From f87363d10451c97a6987d5e729369cd5084d69b7 Mon Sep 17 00:00:00 2001
From: Paul Fultz II <pfultz2@yahoo.com>
Date: Thu, 23 Jul 2026 04:26:30 -0500
Subject: [PATCH 01/59] Fix 14924: FP containerOutOfBounds (copy accessed in
 loop) (#8740)

Co-authored-by: Your Name <you@example.com>
---
 lib/programmemory.cpp | 29 +++++++++++++++++++++++++++--
 test/teststl.cpp      | 12 ++++++++++++
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/lib/programmemory.cpp b/lib/programmemory.cpp
index 013906d00ae..9571e04ea00 100644
--- a/lib/programmemory.cpp
+++ b/lib/programmemory.cpp
@@ -1512,6 +1512,31 @@ namespace {
             return unknown();
         }
 
+        // Get the size of the container. If the container itself is not tracked in the program
+        // memory then check if it is symbolically equal to a container whose size is tracked.
+        ValueFlow::Value executeContainerSize(const Token* containerTok)
+        {
+            ValueFlow::Value v = execute(containerTok);
+            if (v.isContainerSizeValue())
+                return v;
+            for (const ValueFlow::Value& value : containerTok->values()) {
+                if (!value.isSymbolicValue())
+                    continue;
+                if (value.isImpossible())
+                    continue;
+                if (value.intvalue != 0)
+                    continue;
+                if (!value.tokvalue)
+                    continue;
+                if (value.tokvalue->exprId() == 0)
+                    continue;
+                const ValueFlow::Value* sizeValue = pm->getValue(value.tokvalue->exprId());
+                if (sizeValue && sizeValue->isContainerSizeValue())
+                    return *sizeValue;
+            }
+            return unknown();
+        }
+
         ValueFlow::Value executeImpl(const Token* expr)
         {
             const ValueFlow::Value* value = nullptr;
@@ -1540,14 +1565,14 @@ namespace {
                 const Token* containerTok = expr->tokAt(-2)->astOperand1();
                 const Library::Container::Yield yield = containerTok->valueType()->container->getYield(expr->strAt(-1));
                 if (yield == Library::Container::Yield::SIZE) {
-                    ValueFlow::Value v = execute(containerTok);
+                    ValueFlow::Value v = executeContainerSize(containerTok);
                     if (!v.isContainerSizeValue())
                         return unknown();
                     v.valueType = ValueFlow::Value::ValueType::INT;
                     return v;
                 }
                 if (yield == Library::Container::Yield::EMPTY) {
-                    ValueFlow::Value v = execute(containerTok);
+                    ValueFlow::Value v = executeContainerSize(containerTok);
                     if (!v.isContainerSizeValue())
                         return unknown();
                     if (v.isImpossible() && v.intvalue == 0)
diff --git a/test/teststl.cpp b/test/teststl.cpp
index ed9c5503d45..c030fb4c6f6 100644
--- a/test/teststl.cpp
+++ b/test/teststl.cpp
@@ -1003,6 +1003,18 @@ class TestStl : public TestFixture {
                     "}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: error: Out of bounds access in 'v[2]', if 'v' size is 1 and '2' is 2 [containerOutOfBounds]\n",
                       errout_str());
+
+        checkNormal("std::string f(const std::string& str) {\n" // do not warn, the copy has the same size as 'str'
+                    "    std::string outStr = str;\n"
+                    "    if (!outStr.empty())\n"
+                    "        outStr[0] = 'a';\n"
+                    "    for (int i = 0; i < str.size(); ++i) {\n"
+                    "        if (outStr[i] == '_')\n"
+                    "            outStr[i] = ' ';\n"
+                    "    }\n"
+                    "    return outStr;\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void outOfBoundsSymbolic()

From 7aa7114cce28124d409ebf76e0e2a022f21e1553 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Thu, 23 Jul 2026 11:44:22 +0200
Subject: [PATCH 02/59] Fix #14796: FP assertWithSideEffect for member
 functions without definition (#8607)

---
 lib/checkassert.cpp | 6 +++---
 lib/checkassert.h   | 2 +-
 test/testassert.cpp | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/lib/checkassert.cpp b/lib/checkassert.cpp
index 1d0ecde7959..4578f7395ba 100644
--- a/lib/checkassert.cpp
+++ b/lib/checkassert.cpp
@@ -83,7 +83,7 @@ void CheckAssertImpl::assertWithSideEffects()
             if (!scope) {
                 // guess that const method doesn't have side effects
                 if (f->nestedIn->isClassOrStruct() && !f->isConst() && !f->isStatic())
-                    sideEffectInAssertError(tmp, f->name()); // Non-const member function called, assume it has side effects
+                    sideEffectInAssertError(tmp, f->name(), " If there are no side effects, consider declaring the method const."); // Non-const member function called, assume it has side effects
                 continue;
             }
 
@@ -117,12 +117,12 @@ void CheckAssertImpl::assertWithSideEffects()
 //---------------------------------------------------------------------------
 
 
-void CheckAssertImpl::sideEffectInAssertError(const Token *tok, const std::string& functionName)
+void CheckAssertImpl::sideEffectInAssertError(const Token *tok, const std::string& functionName, const std::string &extra)
 {
     reportError(tok, Severity::warning,
                 "assertWithSideEffect",
                 "$symbol:" + functionName + "\n"
-                "Assert statement calls a function which may have desired side effects: '$symbol'.\n"
+                "Assert statement calls a function which may have desired side effects: '$symbol'." + extra + "\n"
                 "Non-pure function: '$symbol' is called inside assert statement. "
                 "Assert statements are removed from release builds so the code inside "
                 "assert statement is not executed. If the code is needed also in release "
diff --git a/lib/checkassert.h b/lib/checkassert.h
index 2db9d804fcb..15f97fb1746 100644
--- a/lib/checkassert.h
+++ b/lib/checkassert.h
@@ -65,7 +65,7 @@ class CPPCHECKLIB CheckAssertImpl : public CheckImpl {
     void checkVariableAssignment(const Token* assignTok, const Scope *assertionScope);
     static bool inSameScope(const Token* returnTok, const Token* assignTok);
 
-    void sideEffectInAssertError(const Token *tok, const std::string& functionName);
+    void sideEffectInAssertError(const Token *tok, const std::string& functionName, const std::string &extra = "");
     void assignmentInAssertError(const Token *tok, const std::string &varname);
 };
 /// @}
diff --git a/test/testassert.cpp b/test/testassert.cpp
index 80bb5d3b827..ea170c43f2d 100644
--- a/test/testassert.cpp
+++ b/test/testassert.cpp
@@ -156,7 +156,7 @@ class TestAssert : public TestFixture {
               "void foo(SquarePack s) {\n"
               "   assert( s.Foo() );\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5:14]: (warning) Assert statement calls a function which may have desired side effects: 'Foo'. [assertWithSideEffect]\n", errout_str());
+        ASSERT_EQUALS("[test.cpp:5:14]: (warning) Assert statement calls a function which may have desired side effects: 'Foo'. If there are no side effects, consider declaring the method const. [assertWithSideEffect]\n", errout_str());
 
         check("struct SquarePack {\n"
               "   int Foo() const;\n"

From d272996589c5d7c75fd6f2e4e4f52d00e5224a36 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Thu, 23 Jul 2026 11:46:18 +0200
Subject: [PATCH 03/59] Fix #14894:  false positive: co_return not recognized
 as return in combination with {}  (#8741)

---
 lib/astutils.cpp         | 20 ++++++++++++++++++++
 lib/astutils.h           |  2 ++
 lib/forwardanalyzer.cpp  |  2 +-
 test/testnullpointer.cpp | 13 +++++++++++++
 4 files changed, 36 insertions(+), 1 deletion(-)

diff --git a/lib/astutils.cpp b/lib/astutils.cpp
index 74d2274ae6c..ea54232b551 100644
--- a/lib/astutils.cpp
+++ b/lib/astutils.cpp
@@ -3918,3 +3918,23 @@ const Token *skipUnreachableBranch(const Token *tok)
 
     return tok;
 }
+
+bool isEscapeKeyword(const Token *tok, const Settings &settings)
+{
+    if (!tok)
+        return false;
+
+    if (tok->str() == "return")
+        return true;
+
+    if (!tok->isCpp())
+        return false;
+
+    if (tok->str() == "throw")
+        return true;
+
+    if (settings.standards.cpp < Standards::CPP20)
+        return false;
+
+    return tok->str() == "co_return";
+}
diff --git a/lib/astutils.h b/lib/astutils.h
index 2c6650068b5..79a607108fd 100644
--- a/lib/astutils.h
+++ b/lib/astutils.h
@@ -463,4 +463,6 @@ bool isUnreachableOperand(const Token *tok);
 
 const Token *skipUnreachableBranch(const Token *tok);
 
+bool isEscapeKeyword(const Token *tok, const Settings &settings);
+
 #endif // astutilsH
diff --git a/lib/forwardanalyzer.cpp b/lib/forwardanalyzer.cpp
index c38d93155ea..3e227873b26 100644
--- a/lib/forwardanalyzer.cpp
+++ b/lib/forwardanalyzer.cpp
@@ -144,7 +144,7 @@ namespace {
                 // If we are in a loop then jump to the end
                 if (out)
                     *out = loopEnds.back();
-            } else if (Token::Match(tok, "return|throw")) {
+            } else if (isEscapeKeyword(tok, settings)) {
                 traverseRecursive(tok->astOperand2(), f, traverseUnknown);
                 traverseRecursive(tok->astOperand1(), f, traverseUnknown);
                 return Break(Analyzer::Terminate::Escape);
diff --git a/test/testnullpointer.cpp b/test/testnullpointer.cpp
index 86b0f4aeeb9..698946b8efa 100644
--- a/test/testnullpointer.cpp
+++ b/test/testnullpointer.cpp
@@ -146,6 +146,7 @@ class TestNullPointer : public TestFixture {
         TEST_CASE(nullpointer106); // #13682
         TEST_CASE(nullpointer107); // #13682 (FP/FN cases around guards that depend on the pointer indirectly)
         TEST_CASE(nullpointer108);
+        TEST_CASE(nullpointer109);
         TEST_CASE(nullpointer_addressOf); // address of
         TEST_CASE(nullpointerSwitch); // #2626
         TEST_CASE(nullpointer_cast); // #4692
@@ -3115,6 +3116,18 @@ class TestNullPointer : public TestFixture {
         ASSERT_EQUALS("[test.cpp:4:10]: (error) Null pointer dereference: r [nullPointer]\n", errout_str());
     }
 
+    void nullpointer109()
+    {
+        check("boost::asio::awaitable<int> test()\n"
+              "{\n"
+              "    const auto *s = getStr();\n"
+              "    if(!s) co_return int{1};\n"
+              "    std::print(\"{}\",*s);\n"
+              "    co_return int{9};\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void nullpointer_addressOf() { // address of
         check("void f() {\n"
               "  struct X *x = 0;\n"

From 55ae8c452452de1214e9598fcc3ac02e651fff26 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Thu, 23 Jul 2026 11:47:05 +0200
Subject: [PATCH 04/59] Fix #14896: false positive: missing co_return in void
 function (#8719)

---
 lib/checkfunctions.cpp |  2 ++
 lib/symboldatabase.cpp | 14 ++++++++++++++
 lib/symboldatabase.h   |  1 +
 test/testfunctions.cpp |  9 +++++++++
 4 files changed, 26 insertions(+)

diff --git a/lib/checkfunctions.cpp b/lib/checkfunctions.cpp
index 23db248816d..1edfdfab6ac 100644
--- a/lib/checkfunctions.cpp
+++ b/lib/checkfunctions.cpp
@@ -329,6 +329,8 @@ void CheckFunctionsImpl::checkMissingReturn()
             continue;
         if (Function::returnsVoid(function, true))
             continue;
+        if (Function::isCoroutine(function, mSettings.standards, *mTokenizer))
+            continue;
         const Token *errorToken = checkMissingReturnScope(scope->bodyEnd, mSettings.library);
         if (errorToken)
             missingReturnError(errorToken);
diff --git a/lib/symboldatabase.cpp b/lib/symboldatabase.cpp
index 4dbd09e98c4..d98c66770e1 100644
--- a/lib/symboldatabase.cpp
+++ b/lib/symboldatabase.cpp
@@ -3407,6 +3407,20 @@ bool Function::returnsVoid(const Function* function, bool unknown)
     });
 }
 
+bool Function::isCoroutine(const Function* function, const Standards &standards, const Tokenizer &tokens)
+{
+    if (!tokens.isCPP() || standards.cpp < Standards::CPP20)
+        return false;
+    if (!function->functionScope)
+        return false;
+    const Scope *scope = function->functionScope;
+    for (const Token *tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
+        if (Token::Match(tok, "co_return|co_await|co_yield"))
+            return true;
+    }
+    return false;
+}
+
 std::vector<const Token*> Function::findReturns(const Function* f)
 {
     std::vector<const Token*> result;
diff --git a/lib/symboldatabase.h b/lib/symboldatabase.h
index 166f228ad99..7d52d0bfb32 100644
--- a/lib/symboldatabase.h
+++ b/lib/symboldatabase.h
@@ -945,6 +945,7 @@ class CPPCHECKLIB Function {
     static bool returnsStandardType(const Function* function, bool unknown = false);
 
     static bool returnsVoid(const Function* function, bool unknown = false);
+    static bool isCoroutine(const Function* function, const Standards &standards, const Tokenizer &tokens);
 
     static std::vector<const Token*> findReturns(const Function* f);
 
diff --git a/test/testfunctions.cpp b/test/testfunctions.cpp
index 788ff7a0d14..f5067bc31dc 100644
--- a/test/testfunctions.cpp
+++ b/test/testfunctions.cpp
@@ -86,6 +86,7 @@ class TestFunctions : public TestFixture {
         TEST_CASE(checkMissingReturn5);
         TEST_CASE(checkMissingReturn6); // #13180
         TEST_CASE(checkMissingReturn7); // #14370 - FN try/catch
+        TEST_CASE(checkMissingReturn8);
         TEST_CASE(checkMissingReturnStdInt); // #14482 - FN std::int32_t
 
         // std::move for locar variable
@@ -1927,6 +1928,14 @@ class TestFunctions : public TestFixture {
         ASSERT_EQUALS("[test.cpp:3:19]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
     }
 
+    void checkMissingReturn8() {
+        const Settings s = settingsBuilder(settings).cpp(Standards::CPP20).build();
+        check("boost::asio::awaitable<void> test() {\n"
+              "        co_return;\n"
+              "}\n",s);
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void checkMissingReturnStdInt() {// #14482 - FN
         check("std::int32_t f() {}\n");
         ASSERT_EQUALS("[test.cpp:1:19]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());

From 354edf03694e7d2d2f91e5cf496356a4c458a73e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Marjam=C3=A4ki?= <daniel.marjamaki@gmail.com>
Date: Fri, 24 Jul 2026 06:01:24 +0200
Subject: [PATCH 05/59] Fixed #14930 (Manual: Document hash value for warnings)
 (#8745)

---
 man/manual-premium.md | 28 ++++++++++++++++++++++++++++
 man/manual.md         | 28 ++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+)

diff --git a/man/manual-premium.md b/man/manual-premium.md
index 4c30dc6d4b3..c8e38666530 100644
--- a/man/manual-premium.md
+++ b/man/manual-premium.md
@@ -572,6 +572,34 @@ The usage of the suppressions file is as follows:
 
     cppcheck --suppress-xml=suppressions.xml src/
 
+### The `<hash>` element
+
+Cppcheck calculates a unique ID for each error, called the hash. The hash depends on the code that
+is related to the error, not on where that code is located. This means that the hash for an error
+stays the same even when unrelated code elsewhere in the file is added, removed or moved, shifting
+the line numbers around. The hash only changes if the related code itself is modified.
+
+This makes hash-based suppressions more robust than line-based suppressions: once you have
+reviewed and suppressed a specific warning, the suppression keeps working even after the file is
+edited, as long as the offending code is not changed.
+
+The hash for an error is included as the `hash` attribute in the [XML output](#the-error-element).
+You can copy that value into a `<hash>` element in a suppressions XML file:
+
+    <?xml version="1.0"?>
+    <suppressions>
+      <suppress>
+        <id>uninitvar</id>
+        <fileName>src/file1.c</fileName>
+        <hash>12345678</hash>
+      </suppress>
+    </suppressions>
+
+A suppression can use `<hash>` on its own, without `<id>`, to suppress a specific error regardless
+of its id. It is also possible to combine `<hash>` with `<id>`, `<fileName>`, `<lineNumber>` and
+`<symbolName>`; when several of these are specified, all of them must match for the suppression to
+apply.
+
 ## Inline suppressions
 
 Suppressions can also be added directly in the code by adding comments that contain special keywords.
diff --git a/man/manual.md b/man/manual.md
index 7db916d4777..93d67e8f402 100644
--- a/man/manual.md
+++ b/man/manual.md
@@ -573,6 +573,34 @@ The usage of the suppressions file is as follows:
 
     cppcheck --suppress-xml=suppressions.xml src/
 
+### The `<hash>` element
+
+Cppcheck calculates a unique ID for each error, called the hash. The hash depends on the code that
+is related to the error, not on where that code is located. This means that the hash for an error
+stays the same even when unrelated code elsewhere in the file is added, removed or moved, shifting
+the line numbers around. The hash only changes if the related code itself is modified.
+
+This makes hash-based suppressions more robust than line-based suppressions: once you have
+reviewed and suppressed a specific warning, the suppression keeps working even after the file is
+edited, as long as the offending code is not changed.
+
+The hash for an error is included as the `hash` attribute in the [XML output](#the-error-element).
+You can copy that value into a `<hash>` element in a suppressions XML file:
+
+    <?xml version="1.0"?>
+    <suppressions>
+      <suppress>
+        <id>uninitvar</id>
+        <fileName>src/file1.c</fileName>
+        <hash>12345678</hash>
+      </suppress>
+    </suppressions>
+
+A suppression can use `<hash>` on its own, without `<id>`, to suppress a specific error regardless
+of its id. It is also possible to combine `<hash>` with `<id>`, `<fileName>`, `<lineNumber>` and
+`<symbolName>`; when several of these are specified, all of them must match for the suppression to
+apply.
+
 ## Inline suppressions
 
 Suppressions can also be added directly in the code by adding comments that contain special keywords.

From 93546a2bcf80347b1fab523c52ecf1db1a0e0d3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Fri, 24 Jul 2026 11:37:17 +0200
Subject: [PATCH 06/59] Fix #14565 xml suppression: add macro attribute for
 specifying macro name (#8749)

---
 lib/suppressions.cpp      |  5 ++-
 test/testsuppressions.cpp | 81 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 85 insertions(+), 1 deletion(-)

diff --git a/lib/suppressions.cpp b/lib/suppressions.cpp
index fe483e347fe..b45ba151914 100644
--- a/lib/suppressions.cpp
+++ b/lib/suppressions.cpp
@@ -136,7 +136,10 @@ std::string SuppressionList::parseXmlFile(const char *filename)
                 s.lineNumber = strToInt<int>(text);
             else if (std::strcmp(name, "symbolName") == 0)
                 s.symbolName = text;
-            else if (*text && std::strcmp(name, "hash") == 0)
+            else if (std::strcmp(name, "macroName") == 0) {
+                s.macroName = text;
+                s.type = SuppressionList::Type::macro;
+            } else if (*text && std::strcmp(name, "hash") == 0)
                 s.hash = strToInt<std::size_t>(text);
             else
                 return std::string("unknown element '") + name + "' in suppressions XML '" + filename + "', expected id/fileName/lineNumber/symbolName/hash.";
diff --git a/test/testsuppressions.cpp b/test/testsuppressions.cpp
index 90c64eb809e..949bad20bb4 100644
--- a/test/testsuppressions.cpp
+++ b/test/testsuppressions.cpp
@@ -119,6 +119,7 @@ class TestSuppressions : public TestFixture {
         TEST_CASE(addSuppressionLineMultiple);
 
         TEST_CASE(suppressionsParseXmlFile);
+        TEST_CASE(xmlMacroSuppressions);
 
         TEST_CASE(toString);
 
@@ -1705,6 +1706,25 @@ class TestSuppressions : public TestFixture {
             ASSERT_EQUALS("sym", suppr.symbolName);
         }
 
+        {
+            ScopedFile file("suppressparsexml.xml",
+                            "<suppressions>\n"
+                            "<suppress>\n"
+                            "<id>uninitvar</id>\n"
+                            "<macroName>MACRO_NAME</macroName>\n"
+                            "</suppress>\n"
+                            "</suppressions>");
+
+            SuppressionList supprList;
+            ASSERT_EQUALS("", supprList.parseXmlFile(file.path().c_str()));
+            const auto& supprs = supprList.getSuppressions();
+            ASSERT_EQUALS(1, supprs.size());
+            const auto& suppr = *supprs.cbegin();
+            ASSERT_EQUALS("uninitvar", suppr.errorId);
+            ASSERT_EQUALS("MACRO_NAME", suppr.macroName);
+            ASSERT_EQUALS_ENUM(SuppressionList::Type::macro, suppr.type);
+        }
+
         // no file specified
         {
             SuppressionList supprList;
@@ -1758,6 +1778,67 @@ class TestSuppressions : public TestFixture {
         }
     }
 
+    #define testXmlSuppressions(...) testXmlSuppressions_(__FILE__,__LINE__,__VA_ARGS__)
+    void testXmlSuppressions_(const char *thisfile,
+                              int thisline,
+                              const std::string &xml,
+                              const std::string &code,
+                              const std::string &expected)
+    {
+        const char *xmlpath = "testsupressions.xml";
+        const char *sourcepath = "test.c";
+
+        Suppressions supprs;
+        const ScopedFile xmlfile(xmlpath, xml);
+        ASSERT_EQUALS_LOC("", supprs.nomsg.parseXmlFile(xmlpath), thisfile, thisline);
+
+        Settings settings;
+        settings.templateFormat = templateFormat;
+        settings.quiet = true;
+
+        const FileWithDetails sourcefile(sourcepath, Standards::Language::C, 0);
+        CppCheck instance(settings, supprs, *this, nullptr, true, nullptr);
+        instance.checkBuffer(sourcefile, code.c_str(), code.size());
+
+        ASSERT_EQUALS_LOC(expected, errout_str(), thisfile, thisline);
+    }
+
+    void xmlMacroSuppressions()
+    {
+        testXmlSuppressions(
+            "<suppressions>\n"
+            "<suppress>\n"
+            "<id>uninitvar</id>\n"
+            "<macroName>VAR</macroName>\n"
+            "</suppress>\n"
+            "</suppressions>",
+
+            "#define VAR x\n"
+            "int f(void) {\n"
+            "    int VAR;\n"
+            "    return VAR;\n"
+            "}\n",
+
+            ""
+            );
+        testXmlSuppressions(
+            "<suppressions>\n"
+            "<suppress>\n"
+            "<id>uninitvar</id>\n"
+            "<macroName>WRONG</macroName>\n"
+            "</suppress>\n"
+            "</suppressions>",
+
+            "#define VAR x\n"
+            "int f(void) {\n"
+            "    int VAR;\n"
+            "    return VAR;\n"
+            "}\n",
+
+            "[test.c:4:12]: (error) Uninitialized variable: x [uninitvar]\n"
+            );
+    }
+
     void addSuppressionDuplicate() const {
         SuppressionList supprs;
 

From 74747650087f9755bc0b8f66a71c76ae3ba3f356 Mon Sep 17 00:00:00 2001
From: Daniel <52839433+DanTheMan2000@users.noreply.github.com>
Date: Fri, 24 Jul 2026 12:41:04 -0500
Subject: [PATCH 07/59] Fix #14371: FP redundantAssignment for nested union
 members (#8748)

---
 lib/checkother.cpp |  6 +++++-
 test/testother.cpp | 42 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/lib/checkother.cpp b/lib/checkother.cpp
index d8f2f6ff6f4..2e6d5eafa4e 100644
--- a/lib/checkother.cpp
+++ b/lib/checkother.cpp
@@ -700,8 +700,12 @@ void CheckOtherImpl::checkRedundantAssignment()
                 // Get next assignment..
                 const Token *nextAssign = fwdAnalysis.reassign(tokenToCheck, start, scope->bodyEnd);
                 // extra check for union
-                if (nextAssign && tokenToCheck != tok->astOperand1())
+                if (nextAssign && tokenToCheck != tok->astOperand1()) {
                     nextAssign = fwdAnalysis.reassign(tok->astOperand1(), start, scope->bodyEnd);
+                    // reading another member of the same union in the rhs is a use through aliasing
+                    if (nextAssign && fwdAnalysis.hasOperand(nextAssign->astOperand2(), tokenToCheck))
+                        nextAssign = nullptr;
+                }
 
                 if (!nextAssign)
                     continue;
diff --git a/test/testother.cpp b/test/testother.cpp
index 92fefb72fd3..1fddea4b536 100644
--- a/test/testother.cpp
+++ b/test/testother.cpp
@@ -11063,6 +11063,48 @@ class TestOther : public TestFixture {
               "    Dst.s->y = Src.s->y;\n"
               "}\n");
         ASSERT_EQUALS("", errout_str());
+
+        // Ticket #14371 "redundantAssignment when using a union"
+        check("union U {\n"
+              "    struct {\n"
+              "        unsigned int abcd;\n"
+              "    } u32;\n"
+              "    struct {\n"
+              "        unsigned short ab;\n"
+              "        unsigned short cd;\n"
+              "    } u16;\n"
+              "};\n"
+              "void f1() {\n"
+              "    U m;\n"
+              "    m.u32.abcd = 1234;\n"
+              "    m.u32.abcd = 5 * m.u16.ab;\n"
+              "}\n"
+              "void f2(unsigned int a, unsigned short b) {\n"
+              "    U m;\n"
+              "    m.u32.abcd = a;\n"
+              "    m.u32.abcd += 0x8000;\n"
+              "    m.u32.abcd = m.u16.ab * b;\n"
+              "}\n"
+              "void f3(unsigned int seed) {\n"
+              "    U m, other;\n"
+              "    other.u32.abcd = seed;\n"
+              "    m.u32.abcd = 1234;\n"
+              "    m.u32.abcd = other.u16.ab * 2;\n"
+              "}\n"
+              "void f4(unsigned short x) {\n"
+              "    U m;\n"
+              "    m.u16.ab = x;\n"
+              "    m.u16.cd = 0;\n"
+              "    m.u16.ab = m.u32.abcd / 53;\n"
+              "}\n"
+              "void f5(unsigned short x, unsigned int y) {\n"
+              "    U m;\n"
+              "    m.u16.ab = x;\n"
+              "    m.u16.cd = 0;\n"
+              "    m.u16.ab = y;\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:24:16] -> [test.cpp:25:16]: (style) Variable 'm.u32.abcd' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:35:14] -> [test.cpp:37:14]: (style) Variable 'm.u16.ab' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
     }
 
     void redundantVarAssignment_7133() {

From 807ce9ff3b9715940fa9a2fcddd633037b2e5421 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Fri, 24 Jul 2026 19:54:03 +0200
Subject: [PATCH 08/59] Refs #14935: Fix index values in function call in for
 loop (#8753)

---
 lib/astutils.cpp       |  2 +-
 test/testvalueflow.cpp | 21 +++++++++++++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/lib/astutils.cpp b/lib/astutils.cpp
index ea54232b551..2a231dccfd5 100644
--- a/lib/astutils.cpp
+++ b/lib/astutils.cpp
@@ -2778,7 +2778,7 @@ bool isVariableChanged(const Token *tok, int indirect, const Settings &settings,
         if (ftok->str() == "(" && Token::simpleMatch(ftok->astOperand1(), "[")) // operator() on array element, bail out
             return true;
         const Token * ptok = tok2;
-        while (Token::Match(ptok->astParent(), ".|::|["))
+        while (Token::Match(ptok->astParent(), ".|::"))
             ptok = ptok->astParent();
         int pindirect = indirect;
         if (indirect == 0 && astIsLHS(tok2) && Token::Match(ptok, ". %var%") && astIsPointer(ptok->next()))
diff --git a/test/testvalueflow.cpp b/test/testvalueflow.cpp
index abeb603b660..45c7f884715 100644
--- a/test/testvalueflow.cpp
+++ b/test/testvalueflow.cpp
@@ -5112,6 +5112,27 @@ class TestValueFlow : public TestFixture {
         ++it;
         ASSERT_EQUALS(0, it->intvalue);
         ASSERT(it->isPossible());
+
+        code = "void g(int*);\n"
+               "void f(int* a) {\n"
+               "    for (int i = 0; i < 5; ++i) {\n"
+               "        g(&a[i]);\n"
+               "    }\n"
+               "}\n";
+        values = tokenValues(code, "i ]");
+        ASSERT_EQUALS(4, values.size());
+        it = values.begin();
+        ASSERT_EQUALS(0, it->intvalue);
+        ASSERT(it->isPossible());
+        ++it;
+        ASSERT_EQUALS(-1, it->intvalue);
+        ASSERT(it->isImpossible());
+        ++it;
+        ASSERT_EQUALS(4, it->intvalue);
+        ASSERT(it->isPossible());
+        ++it;
+        ASSERT_EQUALS(5, it->intvalue);
+        ASSERT(it->isImpossible());
     }
 
     void valueFlowSubFunction() {

From 1ef5ef36c18b7769569ce1a517ce8188a8a058c3 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Fri, 24 Jul 2026 19:54:54 +0200
Subject: [PATCH 09/59] Fix #14928 Duplicate accessMoved in range-based for
 (#8746)

---
 lib/vf_settokenvalue.cpp | 2 +-
 test/testother.cpp       | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/lib/vf_settokenvalue.cpp b/lib/vf_settokenvalue.cpp
index 315f4a40129..aab64170890 100644
--- a/lib/vf_settokenvalue.cpp
+++ b/lib/vf_settokenvalue.cpp
@@ -384,7 +384,7 @@ namespace ValueFlow
             setTokenValueCast(parent, valueType, std::move(value), settings);
         }
 
-        else if (parent->str() == ":") {
+        else if (parent->str() == ":" && Token::simpleMatch(parent->astParent(), "?")) {
             setTokenValue(parent,std::move(value),settings);
         }
 
diff --git a/test/testother.cpp b/test/testother.cpp
index 1fddea4b536..39eb23110a0 100644
--- a/test/testother.cpp
+++ b/test/testother.cpp
@@ -12945,6 +12945,13 @@ class TestOther : public TestFixture {
               "    cif::condition mWhere;\n"
               "};\n");
         ASSERT_EQUALS("", errout_str());
+
+        check("void g(std::string);\n" // #14928
+              "void f(std::string s) {\n"
+              "    g(std::move(s));\n"
+              "    for (char c : s) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:19]: (warning) Access of moved variable 's'. [accessMoved]\n", errout_str());
     }
 
     void moveTernary()

From 3daba5fe546e25ec2a35f1f90a3177d0e2d87561 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Sun, 26 Jul 2026 09:49:18 +0200
Subject: [PATCH 10/59] Fix #14891 FP knownConditionTrueFalse (dereferencing
 pointer to array member) (#8704)

Co-authored-by: chrchr-github <noreply@github.com>
---
 lib/valueflow.cpp      | 3 +++
 test/testvalueflow.cpp | 9 +++++++++
 2 files changed, 12 insertions(+)

diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
index 096e3d56f56..5f6fc1cf622 100644
--- a/lib/valueflow.cpp
+++ b/lib/valueflow.cpp
@@ -3606,6 +3606,9 @@ static void valueFlowSymbolic(const TokenList& tokenlist, const SymbolDatabase&
                 continue;
             if (tok->astOperand2()->exprId() == 0)
                 continue;
+            if (tok->astOperand2()->variable() && tok->astOperand2()->variable()->isArray() &&
+                tok->astOperand1()->valueType() && tok->astOperand1()->valueType()->pointer) // array to pointer decay
+                continue;
             if (!isConstExpression(tok->astOperand2(), settings.library))
                 continue;
             if (tok->astOperand1()->valueType() && tok->astOperand2()->valueType()) {
diff --git a/test/testvalueflow.cpp b/test/testvalueflow.cpp
index 45c7f884715..c98680b8180 100644
--- a/test/testvalueflow.cpp
+++ b/test/testvalueflow.cpp
@@ -9225,6 +9225,15 @@ class TestValueFlow : public TestFixture {
                "    return x;\n"
                "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, "malloc(10)", 0));
+
+        code = "struct S {\n" // #14891
+               "    void f() const {\n"
+               "        const int* p = a;\n"
+               "        if (*p) {}\n"
+               "    }\n"
+               "    int a[3];\n"
+               "};\n";
+        ASSERT(tokenValues(code, "* p )").empty());
     }
 
     void valueFlowSymbolicIdentity()

From 6640862c9381f447f05950b5dd186f83ead9a91d Mon Sep 17 00:00:00 2001
From: Robert Reif <reif@earthlink.net>
Date: Sun, 26 Jul 2026 07:32:28 -0400
Subject: [PATCH 11/59] Fix #14933: Each GUI log entry line should be output on
 a separate line (#8744)

---
 gui/resultsview.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/gui/resultsview.cpp b/gui/resultsview.cpp
index 55f673ab80c..d11cae35bc6 100644
--- a/gui/resultsview.cpp
+++ b/gui/resultsview.cpp
@@ -518,6 +518,7 @@ void ResultsView::logCopyComplete()
         const QListWidgetItem * item = mUI->mListLog->item(i);
         if (nullptr != item) {
             logText += item->text();
+            logText += "\n";
         }
     }
     QClipboard *clipboard = QApplication::clipboard();

From 9c8507f5cea972b85112a71448a117bf4ac99869 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Mon, 27 Jul 2026 08:53:13 +0200
Subject: [PATCH 12/59] Fix #14913 FN duplicateExpression with parenthesized
 subexpression (#8727)

---
 lib/astutils.cpp   |  2 +-
 lib/checkother.cpp | 10 ++++++++++
 test/testother.cpp | 30 ++++++++++++++++++++++++++++++
 3 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/lib/astutils.cpp b/lib/astutils.cpp
index 2a231dccfd5..c99e9b19bd5 100644
--- a/lib/astutils.cpp
+++ b/lib/astutils.cpp
@@ -1700,7 +1700,7 @@ bool isSameExpression(bool macro, const Token *tok1, const Token *tok2, const Se
                     compare = true;
                 }
             }
-            if (compare && astIsBoolLike(varTok1, settings) && astIsBoolLike(varTok2, settings))
+            if (compare && varTok1 != varTok2 && astIsBoolLike(varTok1, settings) && astIsBoolLike(varTok2, settings))
                 return isSameExpression(macro, varTok1, varTok2, settings, pure, followVar, errors);
 
         }
diff --git a/lib/checkother.cpp b/lib/checkother.cpp
index 2e6d5eafa4e..7f22e531230 100644
--- a/lib/checkother.cpp
+++ b/lib/checkother.cpp
@@ -3058,6 +3058,16 @@ void CheckOtherImpl::checkDuplicateExpression()
                                 checkDuplicate(ast1->astOperand1(), tok->astOperand2(), ast1);
                             ast1 = ast1->astOperand1();
                         }
+                        if (tok->str() != "=") {
+                            const Token* par = tok->astParent();
+                            while (par && tok->str() == par->str() && precedes(par->astOperand1(), tok)) { // chain of identical operators with parentheses
+                                checkDuplicate(par->astOperand1(), tok->astOperand1(), par);
+                                checkDuplicate(par->astOperand1(), tok->astOperand2(), par);
+                                checkDuplicate(par->astOperand2(), tok->astOperand1(), par);
+                                checkDuplicate(par->astOperand2(), tok->astOperand2(), par);
+                                par = par->astParent();
+                            }
+                        }
                     }
                 }
             } else if (tok->astOperand1() && tok->astOperand2() && tok->str() == ":" && tok->astParent() && tok->astParent()->str() == "?") {
diff --git a/test/testother.cpp b/test/testother.cpp
index 39eb23110a0..f69c7cae1c2 100644
--- a/test/testother.cpp
+++ b/test/testother.cpp
@@ -201,6 +201,7 @@ class TestOther : public TestFixture {
         TEST_CASE(duplicateExpression19);
         TEST_CASE(duplicateExpression20);
         TEST_CASE(duplicateExpression21);
+        TEST_CASE(duplicateExpression22);
         TEST_CASE(duplicateExpressionLoop);
         TEST_CASE(duplicateValueTernary);
         TEST_CASE(duplicateValueTernarySizeof); // #13773
@@ -8366,6 +8367,35 @@ class TestOther : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void duplicateExpression22() {
+        check("int f() {\n" // #14913
+              "    return 0x1 | (0x2 | 0x4) | 0x1;\n"
+              "}\n"
+              "int g() {\n"
+              "    return 0x1 | (0x2 | 0x1);\n"
+              "}\n"
+              "int h() {\n"
+              "    return 0x1 | (0x1 | 0x2);\n"
+              "}\n"
+              "int i() {\n"
+              "    return 0x2 | (0x4 | 0x1) | 0x1;\n"
+              "}\n"
+              "int j() {\n"
+              "    return 0x2 | (0x1 | 0x4) | 0x1;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:30]: (style) Same expression '0x1' found multiple times in chain of '|' operators. [duplicateExpression]\n"
+                      "[test.cpp:5:23]: (style) Same expression '0x1' found multiple times in chain of '|' operators. [duplicateExpression]\n"
+                      "[test.cpp:8:23]: (style) Same expression '0x1' found multiple times in chain of '|' operators. [duplicateExpression]\n"
+                      "[test.cpp:11:23]: (style) Same expression '0x1' found multiple times in chain of '|' operators. [duplicateExpression]\n"
+                      "[test.cpp:14:23]: (style) Same expression '0x1' found multiple times in chain of '|' operators. [duplicateExpression]\n",
+                      errout_str());
+
+        check("bool f(const int** a, const int** b) {\n"
+              "    return (a[0] != nullptr) != (b[0] != nullptr);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void duplicateExpressionLoop() {
         check("void f() {\n"
               "    int a = 1;\n"

From 422e90c953ae5e825e24f68ff53145a06c4a406f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Mon, 27 Jul 2026 08:53:51 +0200
Subject: [PATCH 13/59] fix #14795: FP unusedStructMember when type is a
 template parameter (#8600)

---
 lib/checkunusedvar.cpp | 21 +++++++++++++++++++++
 test/testunusedvar.cpp | 15 +++++++++++++++
 2 files changed, 36 insertions(+)

diff --git a/lib/checkunusedvar.cpp b/lib/checkunusedvar.cpp
index fe85260fc8d..f4ced7f158d 100644
--- a/lib/checkunusedvar.cpp
+++ b/lib/checkunusedvar.cpp
@@ -1676,6 +1676,27 @@ void CheckUnusedVarImpl::checkStructMemberUsage()
                     if (use)
                         break;
                 }
+                // Class used in template with unknown definition
+                if (Token::Match(tok, "%name% <") && tok->linkAt(1)) {
+                    if (tok->function())
+                        continue;
+                    if (tok->type() && tok->type()->classScope)
+                        continue;
+                    const Token *start = tok;
+                    while (Token::Match(start->tokAt(-2), "%name% ::"))
+                        start = start->tokAt(-2);
+                    if (mSettings.library.detectContainer(start))
+                        continue;
+                    const Token *end = tok->linkAt(1);
+                    for (; tok != end; tok = tok->next()) {
+                        if (tok->type() && tok->type()->classScope == &scope) {
+                            use = true;
+                            break;
+                        }
+                    }
+                    if (use)
+                        break;
+                }
                 if (tok->variable() != &var)
                     continue;
                 if (tok != var.nameToken()) {
diff --git a/test/testunusedvar.cpp b/test/testunusedvar.cpp
index 849d34b49b0..0cf50a5ceb9 100644
--- a/test/testunusedvar.cpp
+++ b/test/testunusedvar.cpp
@@ -80,6 +80,7 @@ class TestUnusedVar : public TestFixture {
         TEST_CASE(structmember32); // #14483
         TEST_CASE(structmember33);
         TEST_CASE(structmember34);
+        TEST_CASE(structmember35);
         TEST_CASE(structmember_macro);
         TEST_CASE(structmember_template_argument); // #13887 - do not report that member used in template argument is unused
         TEST_CASE(classmember);
@@ -2102,6 +2103,20 @@ class TestUnusedVar : public TestFixture {
         ASSERT_EQUALS("[test.cpp:2:24]: (style) struct member 'S::p' is never used. [unusedStructMember]\n", errout_str());
     }
 
+    void structmember35() {
+        checkStructMemberUsage("struct S { int i; };\n"
+                               "int f() { return g<S>(); }\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct S { int i; };\n"
+                               "int f() { A<S> *a = nullptr; (void) a; }\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct S { int i; };\n"
+                               "int f() { const std::vector<S> a {}; (void) a; }\n");
+        ASSERT_EQUALS("[test.cpp:1:16]: (style) struct member 'S::i' is never used. [unusedStructMember]\n", errout_str());
+    }
+
     void structmember_macro() {
         checkStructMemberUsageP("#define S(n) struct n { int a, b, c; };\n"
                                 "S(unused);\n");

From 6d7e1da9dd61ea3ba584caf8b24ddda633fff8bf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Tue, 28 Jul 2026 10:02:37 +0200
Subject: [PATCH 14/59] Fix #14936: Failures to add suppressions are ignored in
 `importCppcheckGuiProject` (#8757)

---
 lib/importproject.cpp            | 13 ++++++++++++-
 test/cli/more-projects_test.py   |  1 -
 test/cli/project-suppressions.py | 33 ++++++++++++++++++++++++++++++++
 test/testimportproject.cpp       | 21 ++++++++++++++++++++
 4 files changed, 66 insertions(+), 2 deletions(-)
 create mode 100644 test/cli/project-suppressions.py

diff --git a/lib/importproject.cpp b/lib/importproject.cpp
index 0e6ca353480..242c1719ba9 100644
--- a/lib/importproject.cpp
+++ b/lib/importproject.cpp
@@ -1653,7 +1653,18 @@ bool ImportProject::importCppcheckGuiProject(std::istream &istr, Settings &setti
 
     for (const std::string &p : paths)
         guiProject.pathNames.push_back(Path::fromNativeSeparators(p));
-    supprs.nomsg.addSuppressions(std::move(suppressions)); // TODO: check result
+
+    bool ok = true;
+    for (const auto &suppression : suppressions) {
+        const std::string addError = supprs.nomsg.addSuppression(suppression);
+        if (!addError.empty()) {
+            errors.emplace_back(addError);
+            ok = false;
+        }
+    }
+    if (!ok)
+        return false;
+
     settings.checkHeaders = temp.checkHeaders;
     settings.checkUnusedTemplates = temp.checkUnusedTemplates;
     settings.maxCtuDepth = temp.maxCtuDepth;
diff --git a/test/cli/more-projects_test.py b/test/cli/more-projects_test.py
index 504a2b14431..98304bbe8aa 100644
--- a/test/cli/more-projects_test.py
+++ b/test/cli/more-projects_test.py
@@ -173,7 +173,6 @@ def test_project_empty_fields(tmpdir):
   </libraries>
   <suppressions/>
   <suppressions>
-    <suppression/>
   </suppressions>
   <vs-configurations/>
   <vs-configurations>
diff --git a/test/cli/project-suppressions.py b/test/cli/project-suppressions.py
new file mode 100644
index 00000000000..e2b6ba5e7d6
--- /dev/null
+++ b/test/cli/project-suppressions.py
@@ -0,0 +1,33 @@
+
+# python -m pytest project-suppressions.py
+
+from testutils import create_gui_project_file, assert_cppcheck
+
+def test_cli_and_project_suppressions(tmp_path):
+    # Uninitvar suppressed in project file
+    suppressions = [{ 'id': 'uninitvar' }]
+    project_path = tmp_path / 'project.cppcheck'
+    create_gui_project_file(project_path, root_path=str(tmp_path), suppressions=suppressions)
+
+    # Uninitvar suppressed on command line before import
+    args = ['--suppress=uninitvar', f'--project={project_path}']
+    out_exp = [
+        "cppcheck: error: suppression 'uninitvar' already exists",
+        f"cppcheck: error: failed to load project '{project_path}'. An error occurred."
+    ]
+    assert_cppcheck(args, ec_exp=1, out_exp=out_exp)
+
+def test_multiple_cli_and_project_suppressions(tmp_path):
+    # Uninitvar and unreadVariable suppressed in project file
+    suppressions = [{ 'id': 'uninitvar' }, { 'id': 'unreadVariable' },]
+    project_path = tmp_path / 'project.cppcheck'
+    create_gui_project_file(project_path, root_path=str(tmp_path), suppressions=suppressions)
+
+    # Uninitvar and unreadVariable suppressed on command line before import
+    args = ['--suppress=uninitvar', '--suppress=unreadVariable', f'--project={project_path}']
+    out_exp = [
+        "cppcheck: error: suppression 'uninitvar' already exists",
+        "cppcheck: error: suppression 'unreadVariable' already exists",
+        f"cppcheck: error: failed to load project '{project_path}'. An error occurred."
+    ]
+    assert_cppcheck(args, ec_exp=1, out_exp=out_exp)
diff --git a/test/testimportproject.cpp b/test/testimportproject.cpp
index c9889445c3c..873272030f6 100644
--- a/test/testimportproject.cpp
+++ b/test/testimportproject.cpp
@@ -79,6 +79,7 @@ class TestImportProject : public TestFixture {
         TEST_CASE(importCompileCommandsDirectoryMissing); // 'directory' field missing
         TEST_CASE(importCompileCommandsDirectoryInvalid); // 'directory' field not a string
         TEST_CASE(importCppcheckGuiProject);
+        TEST_CASE(importCppcheckGuiProjectDuplicateSuppressions);
         TEST_CASE(importCppcheckGuiProjectPremiumMisra);
         TEST_CASE(ignorePaths);
         TEST_CASE(testVcxprojUnicode);
@@ -536,6 +537,26 @@ class TestImportProject : public TestFixture {
         ASSERT_EQUALS(true, s.inlineSuppressions);
     }
 
+    void importCppcheckGuiProjectDuplicateSuppressions() const {
+        REDIRECT;
+        constexpr char xml[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+                               "<project version=\"1\">\n"
+                               "    <root name=\".\"/>\n"
+                               "    <project-name>test test</project-name>\n"
+                               "    <suppressions>\n"
+                               "        <suppression>uninitvar</suppression>\n"
+                               "        <suppression>uninitvar</suppression>\n"
+                               "    </suppressions>\n"
+                               "</project>\n";
+        std::istringstream istr(xml);
+        Settings s;
+        Suppressions supprs;
+        TestImporter project;
+        ASSERT_EQUALS(false, project.importCppcheckGuiProject(istr, s, supprs));
+        ASSERT_EQUALS(1, project.errors.size());
+        ASSERT_EQUALS("suppression 'uninitvar' already exists", project.errors[0]);
+    }
+
     void importCppcheckGuiProjectPremiumMisra() const {
         REDIRECT;
         constexpr char xml[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"

From f26de0cc37b8ebd9142c43346150999c21c2a879 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Tue, 28 Jul 2026 12:55:08 +0200
Subject: [PATCH 15/59] Fix #14941: FN memleak with `_create_locale` (#8758)

---
 cfg/windows.cfg      | 37 +++++++++++++++++++++++++++++++++++++
 test/cfg/windows.cpp | 22 ++++++++++++++++++++++
 2 files changed, 59 insertions(+)

diff --git a/cfg/windows.cfg b/cfg/windows.cfg
index 6a0bd111afa..b2251900d42 100644
--- a/cfg/windows.cfg
+++ b/cfg/windows.cfg
@@ -1331,6 +1331,11 @@
     <alloc init="true" arg="11">AllocateAndInitializeSid</alloc>
     <dealloc>FreeSid</dealloc>
   </memory>
+  <memory>
+    <alloc init="true">_create_locale</alloc>
+    <alloc init="true">_wcreate_locale</alloc>
+    <dealloc>_free_locale</dealloc>
+  </memory>
   <!--SIZE_T RtlCompareMemory(
   _In_ const VOID   *Source1,
   _In_ const VOID   *Source2,
@@ -5591,6 +5596,38 @@ HFONT CreateFont(
       <not-uninit/>
     </arg>
   </function>
+  <!--_locale_t _create_locale(int category, const char *locale);
+      _locale_t _wcreate_locale(int category, const wchar_t *locale);
+      void _free_locale(_locale_t locale);-->
+  <function name="_create_locale">
+    <returnValue type="_locale_t"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <function name="_wcreate_locale">
+    <returnValue type="_locale_t"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <function name="_free_locale">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
   <!--char * strlwr(_Inout_z_ char * _Str);-->
   <function name="strlwr">
     <returnValue type="char *">arg1</returnValue>
diff --git a/test/cfg/windows.cpp b/test/cfg/windows.cpp
index c01e57f6f91..37c580a0134 100644
--- a/test/cfg/windows.cpp
+++ b/test/cfg/windows.cpp
@@ -23,6 +23,7 @@
 #include <wchar.h>
 #include <atlstr.h>
 #include <string>
+#include <locale.h>
 
 bool UpdateTraceACalled(TRACEHANDLE traceHandle, LPCSTR loggerName, EVENT_TRACE_PROPERTIES* pProperties)
 {
@@ -615,6 +616,27 @@ void memleak_malloca()
     // cppcheck-suppress memleak
 }
 
+void memleak_create_locale()
+{
+    // cppcheck-suppress-begin valueFlowBailoutIncompleteVar
+    _locale_t locale = _create_locale(LC_ALL, "C");
+    _locale_t wlocale = _wcreate_locale(LC_ALL, L"C");
+    (void) locale;
+    (void) wlocale;
+    // cppcheck-suppress-end valueFlowBailoutIncompleteVar
+    // cppcheck-suppress memleak
+}
+
+void no_memleak_create_locale()
+{
+    // cppcheck-suppress-begin valueFlowBailoutIncompleteVar
+    _locale_t locale = _create_locale(LC_ALL, "C");
+    _locale_t wlocale = _wcreate_locale(LC_ALL, L"C");
+    _free_locale(locale);
+    _free_locale(wlocale);
+    // cppcheck-suppress-end valueFlowBailoutIncompleteVar
+}
+
 void memleak_AllocateAndInitializeSid()
 {
     PSID pEveryoneSID = NULL;

From bc88becf0b4344dc214a0f93c294f0e602a68dd4 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Tue, 28 Jul 2026 13:47:08 +0200
Subject: [PATCH 16/59] Fix #14935 FN bufferAccessOutOfBounds (memset() in
 loop) (#8754)

---
 lib/checkbufferoverrun.cpp | 16 +++++++++++-----
 test/testbufferoverrun.cpp | 11 +++++++++--
 2 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/lib/checkbufferoverrun.cpp b/lib/checkbufferoverrun.cpp
index 246d428802e..46d8e1c7c6c 100644
--- a/lib/checkbufferoverrun.cpp
+++ b/lib/checkbufferoverrun.cpp
@@ -560,12 +560,18 @@ ValueFlow::Value CheckBufferOverrunImpl::getBufferSize(const Token *bufTok, cons
     if (!bufTok->valueType())
         return ValueFlow::Value(-1);
 
+    MathLib::bigint index = 0;
     if (bufTok->isUnaryOp("&")) {
         bufTok = bufTok->astOperand1();
         if (Token::simpleMatch(bufTok, "[")) {
-            const Token* index = bufTok->astOperand2();
-            if (!(index && index->hasKnownIntValue() && index->getKnownIntValue() == 0))
-                return ValueFlow::Value(-1);
+            if (const Token* indexTok = bufTok->astOperand2()) {
+                if (indexTok->hasKnownIntValue())
+                    index = indexTok->getKnownIntValue();
+                else if (const ValueFlow::Value* maxValue = indexTok->getMaxValue(false))
+                    index = maxValue->intvalue;
+                else
+                    return ValueFlow::Value(-1);
+            }
             bufTok = bufTok->astOperand1();
         }
     }
@@ -600,10 +606,10 @@ ValueFlow::Value CheckBufferOverrunImpl::getBufferSize(const Token *bufTok, cons
     v.valueType = ValueFlow::Value::ValueType::BUFFER_SIZE;
 
     if (var->isPointerArray())
-        v.intvalue = dim * mSettings.platform.sizeof_pointer;
+        v.intvalue = (dim - index) * mSettings.platform.sizeof_pointer;
     else {
         const size_t typeSize = bufTok->valueType()->getSizeOf(mSettings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointee);
-        v.intvalue = dim * typeSize;
+        v.intvalue = (dim - index) * typeSize;
     }
 
     return v;
diff --git a/test/testbufferoverrun.cpp b/test/testbufferoverrun.cpp
index b44fd742ab1..37ab7083902 100644
--- a/test/testbufferoverrun.cpp
+++ b/test/testbufferoverrun.cpp
@@ -3537,7 +3537,7 @@ class TestBufferOverrun : public TestFixture {
               "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3:12]: (error) Buffer is accessed out of bounds: &a[5] [bufferAccessOutOfBounds]\n"
                            "[test.cpp:7:12]: (error) Buffer is accessed out of bounds: &a[0][0] [bufferAccessOutOfBounds]\n",
-                           "",
+                           "[test.cpp:3:12]: (error) Buffer is accessed out of bounds: &a[5] [bufferAccessOutOfBounds]\n",
                            errout_str());
 
         check("void f() {\n" // #14866
@@ -3557,6 +3557,13 @@ class TestBufferOverrun : public TestFixture {
               "    fwrite(&s, 1, 1, fp);\n"
               "}\n");
         ASSERT_EQUALS("", errout_str()); // don't crash
+
+        check("void f() {\n" // #14935
+              "    int a[5];\n"
+              "    for (int i = 0; i < 5; ++i)\n"
+              "        memset(&a[i], 0, sizeof(a));\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:16]: (error) Buffer is accessed out of bounds: &a[i] [bufferAccessOutOfBounds]\n", errout_str());
     }
 
     void buffer_overrun_errorpath() {
@@ -3814,7 +3821,7 @@ class TestBufferOverrun : public TestFixture {
               "  int i[10];\n"
               "  memset(&i[1], 0, 1000);\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:3:10]: (error) Buffer is accessed out of bounds: &i[1] [bufferAccessOutOfBounds]\n", "", errout_str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Buffer is accessed out of bounds: &i[1] [bufferAccessOutOfBounds]\n", errout_str());
 
         check("struct S { int x; };\n" // #8616
               "void f() {\n"

From 8effc6c60d7b135df159a305e23ac95d29b02b1b Mon Sep 17 00:00:00 2001
From: Paul Fultz II <pfultz2@yahoo.com>
Date: Wed, 29 Jul 2026 01:33:02 -0500
Subject: [PATCH 17/59] Fix 14937: False positive: inconclusive
 nullPointerRedundantCheck with thunk (#8755)

---
 lib/symboldatabase.cpp      | 30 +++++++++----
 lib/symboldatabase.h        | 12 +++++-
 test/testnullpointer.cpp    | 19 ++++++++
 test/testsymboldatabase.cpp | 86 +++++++++++++++++++++++++++++++++++++
 4 files changed, 136 insertions(+), 11 deletions(-)

diff --git a/lib/symboldatabase.cpp b/lib/symboldatabase.cpp
index d98c66770e1..e6f676e7a20 100644
--- a/lib/symboldatabase.cpp
+++ b/lib/symboldatabase.cpp
@@ -5861,7 +5861,10 @@ bool Scope::hasInlineOrLambdaFunction(const Token** tokStart, bool onlyInline) c
     });
 }
 
-void Scope::findFunctionInBase(const Token* tok, size_t args, std::vector<const Function *> & matches) const
+void Scope::findFunctionInBase(const std::string& name,
+                               const Token* tok,
+                               size_t args,
+                               std::vector<const Function*>& matches) const
 {
     if (isClassOrStruct() && definedType && !definedType->derivedFrom.empty()) {
         const std::vector<Type::BaseInfo> &derivedFrom = definedType->derivedFrom;
@@ -5871,7 +5874,7 @@ void Scope::findFunctionInBase(const Token* tok, size_t args, std::vector<const
                 if (base->classScope == this) // Ticket #5120, #5125: Recursive class; tok should have been found already
                     continue;
 
-                auto range = base->classScope->functionMap.equal_range(tok->str());
+                auto range = base->classScope->functionMap.equal_range(name);
                 for (auto it = range.first; it != range.second; ++it) {
                     const Function *func = it->second;
                     if (func->isDestructor() && !Token::simpleMatch(tok->tokAt(-1), "~"))
@@ -5882,7 +5885,7 @@ void Scope::findFunctionInBase(const Token* tok, size_t args, std::vector<const
                     }
                 }
 
-                base->classScope->findFunctionInBase(tok, args, matches);
+                base->classScope->findFunctionInBase(name, tok, args, matches);
             }
         }
     }
@@ -6021,8 +6024,10 @@ static bool hasMatchingConstructor(const Scope* classScope, const ValueType* arg
     });
 }
 
-const Function* Scope::findFunction(const Token *tok, bool requireConst, Reference ref) const
+const Function* Scope::findFunction(const Token* tok, bool requireConst, Reference ref, const std::string& funcName) const
 {
+    const std::string& name = funcName.empty() ? tok->str() : funcName;
+
     const bool isCall = Token::Match(tok->next(), "(|{");
 
     const std::vector<const Token *> arguments = getArguments(tok);
@@ -6032,8 +6037,8 @@ const Function* Scope::findFunction(const Token *tok, bool requireConst, Referen
     // find all the possible functions that could match
     const std::size_t args = arguments.size();
 
-    auto addMatchingFunctions = [&](const Scope *scope) {
-        auto range = scope->functionMap.equal_range(tok->str());
+    auto addMatchingFunctions = [&](const Scope* scope) {
+        auto range = scope->functionMap.equal_range(name);
         for (auto it = range.first; it != range.second; ++it) {
             const Function *func = it->second;
             if (ref == Reference::LValue && func->hasRvalRefQualifier())
@@ -6068,7 +6073,7 @@ const Function* Scope::findFunction(const Token *tok, bool requireConst, Referen
     const std::size_t numberOfMatchesNonBase = matches.size();
 
     // check in base classes
-    findFunctionInBase(tok, args, matches);
+    findFunctionInBase(name, tok, args, matches);
 
     // Non-call => Do not match parameters
     if (!isCall) {
@@ -6298,8 +6303,8 @@ const Function* Scope::findFunction(const Token *tok, bool requireConst, Referen
         matches.erase(itPure);
 
     // Only one candidate left
-    if (matches.size() == 1 && std::none_of(functionList.begin(), functionList.end(), [tok](const Function& f) {
-        return startsWith(f.name(), tok->str() + " <");
+    if (matches.size() == 1 && std::none_of(functionList.begin(), functionList.end(), [&name](const Function& f) {
+        return startsWith(f.name(), name + " <");
     }))
         return matches[0];
 
@@ -7792,6 +7797,13 @@ static const Function* getFunction(const Token* tok) {
             lambda = lvar->nameToken()->tokAt(2)->function();
         if (lambda && lambda->retDef)
             return lambda;
+        // calling an object of a class that overloads operator()
+        if (tok != lvar->nameToken() && !lvar->isPointer() && !lvar->isArray() && lvar->typeScope()) {
+            const Function* callOp =
+                lvar->typeScope()->findFunction(tok, lvar->isConst(), Reference::LValue, "operator()");
+            if (callOp && callOp->retDef)
+                return callOp;
+        }
     }
     return nullptr;
 }
diff --git a/lib/symboldatabase.h b/lib/symboldatabase.h
index 7d52d0bfb32..86ce9419999 100644
--- a/lib/symboldatabase.h
+++ b/lib/symboldatabase.h
@@ -1144,9 +1144,14 @@ class CPPCHECKLIB Scope {
      * @brief find a function
      * @param tok token of function call
      * @param requireConst if const refers to a const variable only const methods should be matched
+     * @param ref reference qualification of the object the function is called on
+     * @param funcName name to look up instead of tok->str(), e.g. "operator()" when tok is a variable that is called
      * @return pointer to function if found or NULL if not found
      */
-    const Function *findFunction(const Token *tok, bool requireConst=false, Reference ref=Reference::None) const;
+    const Function* findFunction(const Token* tok,
+                                 bool requireConst = false,
+                                 Reference ref = Reference::None,
+                                 const std::string& funcName = "") const;
 
     const Scope *findRecordInNestedList(const std::string & name, bool isC = false) const;
     Scope *findRecordInNestedList(const std::string & name, bool isC = false);
@@ -1210,7 +1215,10 @@ class CPPCHECKLIB Scope {
      */
     bool isVariableDeclaration(const Token* tok, const Token*& vartok, const Token*& typetok) const;
 
-    void findFunctionInBase(const Token* tok, size_t args, std::vector<const Function *> & matches) const;
+    void findFunctionInBase(const std::string& name,
+                            const Token* tok,
+                            size_t args,
+                            std::vector<const Function*>& matches) const;
 
     /** @brief initialize varlist */
     void getVariableList(const Token *start, const Token *end);
diff --git a/test/testnullpointer.cpp b/test/testnullpointer.cpp
index 698946b8efa..c1bf766b8bb 100644
--- a/test/testnullpointer.cpp
+++ b/test/testnullpointer.cpp
@@ -147,6 +147,7 @@ class TestNullPointer : public TestFixture {
         TEST_CASE(nullpointer107); // #13682 (FP/FN cases around guards that depend on the pointer indirectly)
         TEST_CASE(nullpointer108);
         TEST_CASE(nullpointer109);
+        TEST_CASE(nullpointer110); // #14937
         TEST_CASE(nullpointer_addressOf); // address of
         TEST_CASE(nullpointerSwitch); // #2626
         TEST_CASE(nullpointer_cast); // #4692
@@ -3128,6 +3129,24 @@ class TestNullPointer : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void nullpointer110()
+    { // #14937 - noreturn member function called on operator() result
+        check("struct A {\n"
+              "    [[noreturn]] void g(int);\n"
+              "};\n"
+              "template<class T>\n"
+              "struct Thunk {\n"
+              "    T& operator()() const;\n"
+              "};\n"
+              "void f(Thunk<A> thunk, int* p) {\n"
+              "    if (!p)\n"
+              "        thunk().g(0);\n"
+              "    *p = 1;\n"
+              "}",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void nullpointer_addressOf() { // address of
         check("void f() {\n"
               "  struct X *x = 0;\n"
diff --git a/test/testsymboldatabase.cpp b/test/testsymboldatabase.cpp
index 69d345a1cc5..1ce349cf969 100644
--- a/test/testsymboldatabase.cpp
+++ b/test/testsymboldatabase.cpp
@@ -542,6 +542,8 @@ class TestSymbolDatabase : public TestFixture {
         TEST_CASE(findFunction60);
         TEST_CASE(findFunction61);
         TEST_CASE(findFunction62); // #14272 - pointer passed to function is const
+        TEST_CASE(findFunction63); // #14937 - member function of type returned by operator()
+        TEST_CASE(findFunction64); // overloaded operator()
         TEST_CASE(findFunctionRef1);
         TEST_CASE(findFunctionRef2); // #13328
         TEST_CASE(findFunctionContainer);
@@ -8875,6 +8877,90 @@ class TestSymbolDatabase : public TestFixture {
         ASSERT_EQUALS(2, functionCall->function()->token->linenr());
     }
 
+    void findFunction63()
+    { // #14937
+        GET_SYMBOL_DB("struct A {\n"
+                      "    void g(int);\n"
+                      "};\n"
+                      "template<class T>\n"
+                      "struct Thunk {\n"
+                      "    T& operator()() const;\n"
+                      "};\n"
+                      "void f(Thunk<A> thunk) {\n"
+                      "    thunk().g(0);\n"
+                      "}\n");
+        const Token* g = Token::findsimplematch(tokenizer.tokens(), "g ( 0 )");
+        ASSERT(g);
+        ASSERT(g->function());
+        ASSERT(g->function()->tokenDef);
+        ASSERT_EQUALS(2, g->function()->tokenDef->linenr());
+        const Token* call = Token::findsimplematch(tokenizer.tokens(), "( ) . g");
+        ASSERT(call && call->valueType());
+        ASSERT(call->valueType()->typeScope && call->valueType()->typeScope->className == "A");
+        ASSERT_EQUALS(static_cast<int>(Reference::LValue), static_cast<int>(call->valueType()->reference));
+    }
+
+    void findFunction64()
+    {                                                    // overloaded operator()
+        {
+            GET_SYMBOL_DB("struct A { void g(int); };\n" // overloads distinguished by argument count
+                          "struct B { void h(int); };\n"
+                          "template<class T>\n"
+                          "struct C {\n"
+                          "    A& operator()();\n"
+                          "    B& operator()(int);\n"
+                          "};\n"
+                          "void f(C<int> c) {\n"
+                          "    c().g(1);\n"
+                          "    c(1).h(1);\n"
+                          "}\n");
+            const Token* g = Token::findsimplematch(tokenizer.tokens(), "g ( 1 )");
+            ASSERT(g && g->function());
+            ASSERT_EQUALS(1, g->function()->tokenDef->linenr());
+            const Token* h = Token::findsimplematch(tokenizer.tokens(), "h ( 1 )");
+            ASSERT(h && h->function());
+            ASSERT_EQUALS(2, h->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("struct A { void g(int); };\n" // overloads distinguished by constness of the object
+                          "struct B { void h(int); };\n"
+                          "template<class T>\n"
+                          "struct C {\n"
+                          "    A& operator()();\n"
+                          "    B& operator()() const;\n"
+                          "};\n"
+                          "void f(C<int> c, const C<int>& k) {\n"
+                          "    c().g(1);\n"
+                          "    k().h(1);\n"
+                          "}\n");
+            const Token* g = Token::findsimplematch(tokenizer.tokens(), "g ( 1 )");
+            ASSERT(g && g->function());
+            ASSERT_EQUALS(1, g->function()->tokenDef->linenr());
+            const Token* h = Token::findsimplematch(tokenizer.tokens(), "h ( 1 )");
+            ASSERT(h && h->function());
+            ASSERT_EQUALS(2, h->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("struct A { void g(int); };\n" // overloads distinguished by argument type
+                          "struct B { void h(int); };\n"
+                          "template<class T>\n"
+                          "struct C {\n"
+                          "    A& operator()(int);\n"
+                          "    B& operator()(double);\n"
+                          "};\n"
+                          "void f(C<int> c, int i, double d) {\n"
+                          "    c(i).g(1);\n"
+                          "    c(d).h(1);\n"
+                          "}\n");
+            const Token* g = Token::findsimplematch(tokenizer.tokens(), "g ( 1 )");
+            ASSERT(g && g->function());
+            ASSERT_EQUALS(1, g->function()->tokenDef->linenr());
+            const Token* h = Token::findsimplematch(tokenizer.tokens(), "h ( 1 )");
+            ASSERT(h && h->function());
+            ASSERT_EQUALS(2, h->function()->tokenDef->linenr());
+        }
+    }
+
     void findFunctionRef1() {
         GET_SYMBOL_DB("struct X {\n"
                       "    const std::vector<int> getInts() const & { return mInts; }\n"

From 0911ee6994d6ea0a25580a45672ad51bd5b4c873 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Thu, 30 Jul 2026 09:10:01 +0200
Subject: [PATCH 18/59] Fix #14818 FP returnDanglingLifetime when passing
 c_str() to function (#8750)

Co-authored-by: chrchr-github <noreply@github.com>
---
 lib/valueflow.cpp          | 2 ++
 test/testautovariables.cpp | 9 +++++++++
 2 files changed, 11 insertions(+)

diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
index 5f6fc1cf622..63543e1a8f5 100644
--- a/lib/valueflow.cpp
+++ b/lib/valueflow.cpp
@@ -2542,6 +2542,8 @@ static void valueFlowLifetimeFunction(Token *tok, const TokenList &tokenlist, Er
         for (const Token* returnTok : returns) {
             if (returnTok == tok)
                 continue;
+            if (!ValueFlow::isLifetimeBorrowed(returnTok, settings))
+                return;
             const Variable *returnVar = ValueFlow::getLifetimeVariable(returnTok, settings);
             if (returnVar && returnVar->isArgument() && (returnVar->isConst() || !isVariableChanged(returnVar, settings))) {
                 LifetimeStore ls = LifetimeStore::fromFunctionArg(f, tok, returnVar, tokenlist, settings, errorLogger);
diff --git a/test/testautovariables.cpp b/test/testautovariables.cpp
index df421d6879c..7774d7fa733 100644
--- a/test/testautovariables.cpp
+++ b/test/testautovariables.cpp
@@ -2962,6 +2962,15 @@ class TestAutoVariables : public TestFixture {
               "    int m;\n"
               "}\n");
         ASSERT_EQUALS("", errout_str());
+
+        check("std::string to_string(const char* p) {\n" // #14818
+              "    return p;\n"
+              "}\n"
+              "std::string get() {\n"
+              "    std::string s;\n"
+              "    return to_string(s.c_str());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void danglingLifetimeContainerView()

From 71de6753d64f176e30335b5e4b93bc90464908e4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Thu, 30 Jul 2026 09:39:24 +0200
Subject: [PATCH 19/59] Fix #14914: fuzzing timeout (hang) in
 Tokenizer::simplifyTypedef() (#8762)

---
 lib/tokenize.cpp                              | 29 ++++++++++---------
 ...m-6fd8356f0baeb3bb43463298803b94ac8ea93cac |  1 +
 test/testsimplifytypedef.cpp                  |  6 ++++
 3 files changed, 22 insertions(+), 14 deletions(-)
 create mode 100644 test/cli/fuzz-timeout/oom-6fd8356f0baeb3bb43463298803b94ac8ea93cac

diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index 031ab624bfb..5ebf6c51951 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -563,6 +563,20 @@ namespace {
             if (Token::simpleMatch(start, "typename"))
                 start = start->next();
 
+            const auto checkForRecursion = [this]() {
+                if (Token::Match(mTypedefToken, "typedef %name% %name% ;"))
+                    return;
+                for (const Token *tok = mTypedefToken; tok != mEndToken; tok = tok->next()) {
+                    if (tok == mNameToken)
+                        continue;
+                    if (tok->str() != mNameToken->str())
+                        continue;
+                    if (Token::Match(tok->previous(), "struct|class|enum|union"))
+                        continue;
+                    throw InternalError(tok, "recursive typedef encountered");
+                }
+            };
+
             // TODO handle unnamed structs etc
             if (Token::Match(start, "const| enum|struct|union|class %name%| {")) {
                 const std::pair<const Token*, Token*> rangeBefore(start, Token::findsimplematch(start, "{"));
@@ -585,24 +599,11 @@ namespace {
                     }
                     mNameToken = nameTok;
                     mEndToken = nameTok->next();
+                    checkForRecursion();
                     return;
                 }
             }
 
-            const auto checkForRecursion = [this]() {
-                if (Token::Match(mTypedefToken, "typedef %name% %name% ;"))
-                    return;
-                for (const Token *tok = mTypedefToken; tok != mEndToken; tok = tok->next()) {
-                    if (tok == mNameToken)
-                        continue;
-                    if (tok->str() != mNameToken->str())
-                        continue;
-                    if (Token::Match(tok->previous(), "struct|class|enum|union"))
-                        continue;
-                    throw InternalError(tok, "recursive typedef encountered");
-                }
-            };
-
             for (Token* type = start; Token::Match(type, "%name%|*|&|&&"); type = type->next()) {
                 if (type != start && Token::Match(type, "%name% ;") && !type->isStandardType()) {
                     mRangeType.first = start;
diff --git a/test/cli/fuzz-timeout/oom-6fd8356f0baeb3bb43463298803b94ac8ea93cac b/test/cli/fuzz-timeout/oom-6fd8356f0baeb3bb43463298803b94ac8ea93cac
new file mode 100644
index 00000000000..29e36cf8c55
--- /dev/null
+++ b/test/cli/fuzz-timeout/oom-6fd8356f0baeb3bb43463298803b94ac8ea93cac
@@ -0,0 +1 @@
+typedef struct D{itoftor;}tor tor;
\ No newline at end of file
diff --git a/test/testsimplifytypedef.cpp b/test/testsimplifytypedef.cpp
index 5a14399e406..42718a2f99c 100644
--- a/test/testsimplifytypedef.cpp
+++ b/test/testsimplifytypedef.cpp
@@ -234,6 +234,7 @@ class TestSimplifyTypedef : public TestFixture {
         TEST_CASE(simplifyTypedef161);
         TEST_CASE(simplifyTypedef162);
         TEST_CASE(simplifyTypedef163);
+        TEST_CASE(simplifyTypedef164);
 
         TEST_CASE(simplifyTypedefFunction1);
         TEST_CASE(simplifyTypedefFunction2); // ticket #1685
@@ -3874,6 +3875,11 @@ class TestSimplifyTypedef : public TestFixture {
         ASSERT_THROW_INTERNAL(tok(code), INTERNAL);
     }
 
+    void simplifyTypedef164() {
+        const char code[] = "typedef struct D{x;}y y;";
+        ASSERT_THROW_INTERNAL(tok(code), INTERNAL);
+    }
+
     void simplifyTypedefFunction1() {
         {
             const char code[] = "typedef void (*my_func)();\n"

From a156364fa3f5edbcba3ad7a5bd37310e6ea7d8ae Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Thu, 30 Jul 2026 18:29:55 +0200
Subject: [PATCH 20/59] Partial fix for  #14911 FN knownConditionTrueFalse for
 number literals (regression) (#8737)

Co-authored-by: chrchr-github <noreply@github.com>
---
 lib/checkcondition.cpp | 19 ++++++++++++++-----
 test/testcondition.cpp | 22 ++++++++++++++++++++++
 2 files changed, 36 insertions(+), 5 deletions(-)

diff --git a/lib/checkcondition.cpp b/lib/checkcondition.cpp
index e77641f89e7..4776cbea38f 100644
--- a/lib/checkcondition.cpp
+++ b/lib/checkcondition.cpp
@@ -1575,10 +1575,19 @@ void CheckConditionImpl::alwaysTrueFalse()
                 continue;
             if (Token::simpleMatch(tok->astParent(), "return") && Token::Match(tok, ".|%var%"))
                 continue;
-            if (Token::Match(tok, "%num%|%bool%|%char%"))
-                continue;
-            if (Token::Match(tok, "! %num%|%bool%|%char%"))
-                continue;
+            bool warnForNumber = false;
+            if (Token::Match(tok, "%num%|%bool%|%char%")) {
+                const bool isZeroOrOne = (tok->getKnownIntValue() >> 1) == 0;
+                warnForNumber = !isZeroOrOne && tok->tokType() == Token::eNumber && tok->astParent() == condition->astParent();
+                if (!warnForNumber)
+                    continue;
+            }
+            if (Token::Match(tok, "! %num%|%bool%|%char%")) {
+                const bool isZeroOrOne = tok->next()->hasKnownIntValue() && (tok->next()->getKnownIntValue() >> 1) == 0;
+                warnForNumber = !isZeroOrOne && tok->next()->tokType() == Token::eNumber && tok->astParent() == condition->astParent();
+                if (!warnForNumber)
+                    continue;
+            }
             if (Token::Match(tok, "%oror%|&&")) {
                 bool bail = false;
                 for (const Token* op : { tok->astOperand1(), tok->astOperand2() }) {
@@ -1603,7 +1612,7 @@ void CheckConditionImpl::alwaysTrueFalse()
                                  true))
                 continue;
 
-            if (!pedantic && isConstVarExpression(tok, [](const Token* tok) {
+            if (!pedantic && !warnForNumber && isConstVarExpression(tok, [](const Token* tok) {
                 return Token::Match(tok, "[|(|&|+|-|*|/|%|^|>>|<<") && !Token::simpleMatch(tok, "( )");
             }))
                 continue;
diff --git a/test/testcondition.cpp b/test/testcondition.cpp
index da4ecae43b3..85efa6eab63 100644
--- a/test/testcondition.cpp
+++ b/test/testcondition.cpp
@@ -4949,6 +4949,28 @@ class TestCondition : public TestFixture {
               "    return x ? false : true;\n"
               "}\n");
         ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    if (42) {}\n"
+              "    if (42U) {}\n"
+              "    if (42L) {}\n"
+              "    if (42UL) {}\n"
+              "    if (42LL) {}\n"
+              "    if (042) {}\n"
+              "    if (0x42) {}\n"
+              "    if (0b101010) {}\n"
+              "    if (!42) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Condition '42' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:3:9]: (style) Condition '42U' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:4:9]: (style) Condition '42L' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:5:9]: (style) Condition '42UL' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:6:9]: (style) Condition '42LL' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:7:9]: (style) Condition '042' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:8:9]: (style) Condition '0x42' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:9:9]: (style) Condition '0b101010' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:10:9]: (style) Condition '!42' is always false [knownConditionTrueFalse]\n",
+                      errout_str());
     }
 
     void alwaysTrueSymbolic()

From 8745a78a43281593e755c91c835cc6211ce99ed9 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Thu, 30 Jul 2026 22:28:32 +0200
Subject: [PATCH 21/59] Fix #14945 FN memleak with nested scopes. (#8761)

---
 lib/checkleakautovar.cpp |  2 ++
 test/testleakautovar.cpp | 29 +++++++++++++++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/lib/checkleakautovar.cpp b/lib/checkleakautovar.cpp
index e8271f9eed0..e5220e701a3 100644
--- a/lib/checkleakautovar.cpp
+++ b/lib/checkleakautovar.cpp
@@ -342,6 +342,8 @@ bool CheckLeakAutoVarImpl::checkScope(const Token * const startToken,
             }
         }
 
+        if (tok == tok->scope()->bodyEnd && tok->scope()->type == ScopeType::eUnconditional)
+            ret(tok, varInfo, /*isEndOfScope*/ true);
 
         // look for end of statement
         const bool isInit = Token::Match(tok->tokAt(-1), "%var% {|(") && tok->tokAt(-1)->variable() && tok->tokAt(-1) == tok->tokAt(-1)->variable()->nameToken();
diff --git a/test/testleakautovar.cpp b/test/testleakautovar.cpp
index b7f8b024a8c..6b6397851fb 100644
--- a/test/testleakautovar.cpp
+++ b/test/testleakautovar.cpp
@@ -211,6 +211,7 @@ class TestLeakAutoVar : public TestFixture {
         TEST_CASE(inlineFunction); // #3989
 
         TEST_CASE(smartPtrInContainer); // #8262
+        TEST_CASE(unconditionalScope);
 
         TEST_CASE(functionCallCastConfig); // #9652
         TEST_CASE(functionCallLeakIgnoreConfig); // #7923
@@ -3178,6 +3179,34 @@ class TestLeakAutoVar : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void unconditionalScope() {
+        check("void f() {\n" // #14945
+              "    {\n"
+              "        int* p = new int;\n"
+              "        *p = 1;\n"
+              "    }\n"
+              "    {\n"
+              "        int* q = new int;\n"
+              "        *q = 2;\n"
+              "        delete q;\n"
+              "    }\n"
+              "    int* r = new int;\n"
+              "    *r = 3;\n"
+              "    delete r;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Memory leak: p [memleak]\n", errout_str());
+
+        check("void f() {\n"
+              "    int* p = new int;\n"
+              "    {\n"
+              "        (void)p;\n"
+              "    }\n"
+              "    *p = 1;\n"
+              "    delete p;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void functionCallCastConfig() { // #9652
         constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
                                    "<def format=\"2\">\n"

From da92ba351e39bb86c03879920e8a2de35d435aff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Fri, 31 Jul 2026 11:50:48 +0200
Subject: [PATCH 22/59] Fix #14951: FP unreadVariable with function pointer
 member (#8768)

---
 lib/tokenize.cpp            |  4 +++-
 test/testsymboldatabase.cpp | 17 +++++++++++++++++
 test/testunusedvar.cpp      | 12 ++++++++++++
 3 files changed, 32 insertions(+), 1 deletion(-)

diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index 5ebf6c51951..07ffa4c666c 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -4549,7 +4549,7 @@ static void setVarIdStructMembers(Token *&tok1,
         return;
     }
 
-    while (Token::Match(tok->next(), ")| . %name% !!(")) {
+    while (Token::Match(tok->next(), ")| . %name%")) {
         // Don't set varid for trailing return type
         if (tok->strAt(1) == ")" && Token::Match(tok->linkAt(1)->tokAt(-1), "%name%|]") && !tok->linkAt(1)->tokAt(-1)->isKeyword() &&
             TokenList::isFunctionHead(tok->linkAt(1), "{;")) {
@@ -4571,6 +4571,8 @@ static void setVarIdStructMembers(Token *&tok1,
         std::map<std::string, nonneg int>& members = structMembers[struct_varid];
         const auto it = utils::as_const(members).find(tok->str());
         if (it == members.cend()) {
+            if (Token::Match(tok, "%name% ("))
+                break;
             members[tok->str()] = ++varId;
             tok->varId(varId);
         } else {
diff --git a/test/testsymboldatabase.cpp b/test/testsymboldatabase.cpp
index 1ce349cf969..eeaed0cbf3f 100644
--- a/test/testsymboldatabase.cpp
+++ b/test/testsymboldatabase.cpp
@@ -233,6 +233,7 @@ class TestSymbolDatabase : public TestFixture {
         TEST_CASE(rangeBasedFor);
 
         TEST_CASE(memberVar1);
+        TEST_CASE(memberVar2);
         TEST_CASE(arrayMemberVar1);
         TEST_CASE(arrayMemberVar2);
         TEST_CASE(arrayMemberVar3);
@@ -1864,6 +1865,22 @@ class TestSymbolDatabase : public TestFixture {
         ASSERT(Token::simpleMatch(tok->variable()->typeStartToken(), "int x ;"));
     }
 
+    void memberVar2() {
+        GET_SYMBOL_DB( "struct S { void (*fp)(); };\n"
+                       "void g();\n"
+                       "void f() {\n"
+                       "    S s;\n"
+                       "    s.fp = g;\n"
+                       "    s.fp();\n"
+                       "}\n");
+
+        ASSERT(db != nullptr);
+        const Token *fp1 = Token::findsimplematch(tokenizer.tokens(), "fp =");
+        const Token *fp2 = Token::findsimplematch(tokenizer.tokens(), "fp (");
+        ASSERT(fp1->varId());
+        ASSERT_EQUALS(fp2->varId(), fp1->varId());
+    }
+
     void arrayMemberVar1() {
         GET_SYMBOL_DB("struct Foo {\n"
                       "    int x;\n"
diff --git a/test/testunusedvar.cpp b/test/testunusedvar.cpp
index 0cf50a5ceb9..a56af38c0f5 100644
--- a/test/testunusedvar.cpp
+++ b/test/testunusedvar.cpp
@@ -158,6 +158,7 @@ class TestUnusedVar : public TestFixture {
         TEST_CASE(localvar71);
         TEST_CASE(localvar72);
         TEST_CASE(localvar73);
+        TEST_CASE(localvar74);
         TEST_CASE(localvarloops); // loops
         TEST_CASE(localvaralias1);
         TEST_CASE(localvaralias2); // ticket #1637
@@ -4100,6 +4101,17 @@ class TestUnusedVar : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void localvar74() {
+        functionVariableUsage("struct S { void (*fp)(); };\n"
+                              "void g();\n"
+                              "void f() {\n"
+                              "    S s;\n"
+                              "    s.fp = g;\n"
+                              "    s.fp();\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void localvarloops() {
         // loops
         functionVariableUsage("void fun(int c) {\n"

From cb9f2a2c365f5d9468e99d4c1e5aa5765f0edbc3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Fri, 31 Jul 2026 11:53:12 +0200
Subject: [PATCH 23/59] Fix #14712: FP constVariableReference , taking non
 const reference to member (#8767)

---
 lib/symboldatabase.cpp      |  2 +-
 test/testother.cpp          | 11 +++++++++++
 test/testsymboldatabase.cpp | 12 ++++++++++++
 3 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/lib/symboldatabase.cpp b/lib/symboldatabase.cpp
index e6f676e7a20..a666c15b536 100644
--- a/lib/symboldatabase.cpp
+++ b/lib/symboldatabase.cpp
@@ -5088,7 +5088,7 @@ void Scope::getVariableList()
 void Scope::getVariableList(const Token* start, const Token* end)
 {
     // Variable declared in condition: if (auto x = bar())
-    if (Token::Match(classDef, "if|while ( %type%") && Token::simpleMatch(classDef->next()->astOperand2(), "=")) {
+    if (Token::Match(classDef, "if|while|switch ( %type%") && Token::simpleMatch(classDef->next()->astOperand2(), "=")) {
         checkVariable(classDef->tokAt(2), defaultAccess());
     }
 
diff --git a/test/testother.cpp b/test/testother.cpp
index f69c7cae1c2..b12e26e1ffa 100644
--- a/test/testother.cpp
+++ b/test/testother.cpp
@@ -4155,6 +4155,17 @@ class TestOther : public TestFixture {
               "  return r;\n"
               "}\n");
         ASSERT_EQUALS("", errout_str());
+
+        check("struct Item { int state; };\n"
+              "void foo(std::vector<Item> &items) {\n"
+              "    for (auto &item : items) {\n"
+              "        switch (auto &s = item.state) {\n"
+              "        case 0: s = 1; break;\n"
+              "        default: break;\n"
+              "        }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void constParameterCallback() {
diff --git a/test/testsymboldatabase.cpp b/test/testsymboldatabase.cpp
index eeaed0cbf3f..8fe107080b6 100644
--- a/test/testsymboldatabase.cpp
+++ b/test/testsymboldatabase.cpp
@@ -204,6 +204,7 @@ class TestSymbolDatabase : public TestFixture {
         TEST_CASE(isVariableDeclarationRValueRef);
         TEST_CASE(isVariableDeclarationDoesNotIdentifyCase);
         TEST_CASE(isVariableDeclarationIf);
+        TEST_CASE(isVariableDeclarationSwitch);
         TEST_CASE(isVariableStlType);
         TEST_CASE(isVariablePointerToConstPointer);
         TEST_CASE(isVariablePointerToVolatilePointer);
@@ -1235,6 +1236,17 @@ class TestSymbolDatabase : public TestFixture {
         ASSERT(y->variable());
     }
 
+    void isVariableDeclarationSwitch() {
+        GET_SYMBOL_DB("void foo(void) {\n"
+                      "    int x = 0;\n"
+                      "    switch (auto &s = x) {}\n"
+                      "}\n");
+        const Token *s = Token::findsimplematch(tokenizer.tokens(), "s");
+        ASSERT(s);
+        ASSERT(s->varId());
+        ASSERT(s->variable());
+    }
+
     void VariableValueType1() {
         GET_SYMBOL_DB("typedef uint8_t u8;\n"
                       "static u8 x;");

From cb694dd86322e83fad8caea77ceb8fa687fd0f1f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Mon, 3 Aug 2026 14:57:08 +0200
Subject: [PATCH 24/59] Fix #14954: False negatives: `noCopyConstructor`,
 `noOperatorEq` and `unsafeClassCanLeak` for file descriptor member (#8769)

Co-authored-by: Aaron Danen <aaron.danen@hpe.com>
---
 lib/checkclass.cpp      |  9 ++++++---
 lib/checkmemoryleak.cpp |  2 +-
 test/testclass.cpp      | 32 +++++++++++++++++++++++++++++++-
 test/testmemleak.cpp    | 12 +++++++++++-
 4 files changed, 49 insertions(+), 6 deletions(-)

diff --git a/lib/checkclass.cpp b/lib/checkclass.cpp
index 51d5718159f..d691834097d 100644
--- a/lib/checkclass.cpp
+++ b/lib/checkclass.cpp
@@ -473,7 +473,7 @@ void CheckClassImpl::copyconstructors()
                     if (Token::Match(tok, "%var% ( new") ||
                         (Token::Match(tok, "%var% ( %name% (") && mSettings.library.getAllocFuncInfo(tok->tokAt(2)))) {
                         const Variable* var = tok->variable();
-                        if (var && var->isPointer() && var->scope() == scope)
+                        if (var && var->scope() == scope && var->valueType() && var->valueType()->type != ValueType::SMART_POINTER)
                             allocatedVars[tok->varId()] = tok;
                     }
                 }
@@ -481,7 +481,7 @@ void CheckClassImpl::copyconstructors()
                     if (Token::Match(tok, "%var% = new") ||
                         (Token::Match(tok, "%var% = %name% (") && mSettings.library.getAllocFuncInfo(tok->tokAt(2)))) {
                         const Variable* var = tok->variable();
-                        if (var && var->isPointer() && var->scope() == scope && !var->isStatic())
+                        if (var && var->scope() == scope && !var->isStatic() && var->valueType() && var->valueType()->type != ValueType::SMART_POINTER)
                             allocatedVars[tok->varId()] = tok;
                     }
                 }
@@ -493,7 +493,10 @@ void CheckClassImpl::copyconstructors()
                         (Token::Match(tok, "%name% ( %var%") && mSettings.library.getDeallocFuncInfo(tok))) {
                         const Token *vartok = tok->str() == "delete" ? tok->next() : tok->tokAt(2);
                         const Variable* var = vartok->variable();
-                        if (var && var->isPointer() && var->scope() == scope && !var->isStatic())
+                        if (var && var->scope() == scope && !var->isStatic() &&
+                            var->valueType() && ((var->valueType()->type != ValueType::CONTAINER &&
+                                                  var->valueType()->type != ValueType::RECORD &&
+                                                  var->valueType()->type != ValueType::UNKNOWN_TYPE) || var->valueType()->pointer))
                             deallocatedVars[vartok->varId()] = vartok;
                     }
                 }
diff --git a/lib/checkmemoryleak.cpp b/lib/checkmemoryleak.cpp
index cc8b6853f11..398240b06ab 100644
--- a/lib/checkmemoryleak.cpp
+++ b/lib/checkmemoryleak.cpp
@@ -517,7 +517,7 @@ void CheckMemoryLeakInClassImpl::check()
     // only check classes and structures
     for (const Scope * scope : symbolDatabase->classAndStructScopes) {
         for (const Variable &var : scope->varlist) {
-            if (!var.isStatic() && (var.isPointer() || var.isPointerArray())) {
+            if (!var.isStatic()) {
                 // allocation but no deallocation of private variables in public function..
                 const Token *tok = var.typeStartToken();
                 // Either it is of standard type or a non-derived type
diff --git a/test/testclass.cpp b/test/testclass.cpp
index 1d647eb33a1..457ab5932fe 100644
--- a/test/testclass.cpp
+++ b/test/testclass.cpp
@@ -38,7 +38,7 @@ class TestClass : public TestFixture {
     const Settings settings0_i = settingsBuilder(settings0).certainty(Certainty::inconclusive).build();
     const Settings settings1 = settingsBuilder().severity(Severity::warning).library("std.cfg").build();
     const Settings settings2 = settingsBuilder().severity(Severity::style).library("std.cfg").certainty(Certainty::inconclusive).build();
-    const Settings settings3 = settingsBuilder().severity(Severity::style).library("std.cfg").severity(Severity::warning).build();
+    const Settings settings3 = settingsBuilder().severity(Severity::style).library("std.cfg").severity(Severity::warning).library("posix.cfg").build();
     const Settings settings3_i = settingsBuilder(settings3).certainty(Certainty::inconclusive).build();
     const Settings settings4 = settingsBuilder().severity(Severity::warning).severity(Severity::portability).library("std.cfg").library("posix.cfg").build();
 
@@ -62,6 +62,8 @@ class TestClass : public TestFixture {
         TEST_CASE(copyConstructor4); // base class with private constructor
         TEST_CASE(copyConstructor5); // multiple inheritance
         TEST_CASE(copyConstructor6); // array of pointers
+        TEST_CASE(copyConstructor7); // ticket #14954
+        TEST_CASE(copyConstructor8);
         TEST_CASE(deletedMemberPointer); // deleted member pointer in destructor
         TEST_CASE(noOperatorEq); // class with memory management should have operator eq
         TEST_CASE(noDestructor); // class with memory management should have destructor
@@ -1094,6 +1096,25 @@ class TestClass : public TestFixture {
                            errout_str());
     }
 
+    void copyConstructor7() { // ticket #14954
+        checkCopyConstructor("struct S {\n"
+                             "    explicit S(char *name) { m_fd = mkstemp(name); }\n"
+                             "    ~S() { /* close(m_fd); */ }\n"
+                             "    S &operator =(const S&);\n"
+                             "    int m_fd;\n"
+                             "};\n");
+        ASSERT_EQUALS("[test.cpp:2:30]: (warning) Struct 'S' does not have a copy constructor which is recommended since it has dynamic memory/resource management. [noCopyConstructor]\n", errout_str());
+    }
+
+    void copyConstructor8() {
+        checkCopyConstructor("struct S {\n"
+                             "    S() : m_ptr(new int) {}\n"
+                             "    ~S();\n"
+                             "    std::unique_ptr<int> m_ptr;\n"
+                             "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void deletedMemberPointer() {
 
         // delete ...
@@ -1158,6 +1179,15 @@ class TestClass : public TestFixture {
                              "   ~F();\n"
                              "};");
         ASSERT_EQUALS("", errout_str());
+
+        checkCopyConstructor("struct S {\n"
+                             "    explicit S(char *name) { m_fd = mkstemp(name); }\n"
+                             "    S(const S&);\n"
+                             "    ~S() { /* close(m_fd); */ }\n"
+                             "    int m_fd;\n"
+                             "};\n");
+        ASSERT_EQUALS("[test.cpp:2:30]: (warning) Struct 'S' does not have a operator= which is recommended since it has dynamic memory/resource management. [noOperatorEq]\n", errout_str());
+
     }
 
     void noDestructor() {
diff --git a/test/testmemleak.cpp b/test/testmemleak.cpp
index 783a10ad089..2999fd3f441 100644
--- a/test/testmemleak.cpp
+++ b/test/testmemleak.cpp
@@ -488,7 +488,7 @@ class TestMemleakInClass : public TestFixture {
     TestMemleakInClass() : TestFixture("TestMemleakInClass") {}
 
 private:
-    const Settings settings = settingsBuilder().severity(Severity::warning).severity(Severity::style).library("std.cfg").build();
+    const Settings settings = settingsBuilder().severity(Severity::warning).severity(Severity::style).library("std.cfg").library("posix.cfg").build();
 
     /**
      * Tokenize and execute leak check for given code
@@ -533,6 +533,7 @@ class TestMemleakInClass : public TestFixture {
         TEST_CASE(class25); // ticket #4367 - false positive implementation for destructor is not seen
         TEST_CASE(class26); // ticket #10789
         TEST_CASE(class27); // ticket #8126
+        TEST_CASE(class28); // ticket #14954
 
         TEST_CASE(staticvar);
 
@@ -1484,6 +1485,15 @@ class TestMemleakInClass : public TestFixture {
         ASSERT_EQUALS("[test.cpp:6:11]: (style) Class 'S' is unsafe, 'S::a' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
+    void class28() { // ticket #14954
+        check("struct S {\n"
+              "    explicit S(char *name) { m_fd = mkstemp(name); }\n"
+              "    ~S() { /* close(m_fd); */ }\n"
+              "    int m_fd;\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Class 'S' is unsafe, 'S::m_fd' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
+    }
+
     void staticvar() {
         check("class A\n"
               "{\n"

From 1f1a07f41409747e4a051b9f1f0a02ce6dc97cf5 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Tue, 4 Aug 2026 08:25:50 +0200
Subject: [PATCH 25/59] Fix #11437 FP knownConditionTrueFalse when comparing
 clamped value (#8751)

---
 lib/valueflow.cpp      | 1 +
 test/testcondition.cpp | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
index 63543e1a8f5..766f65e9f32 100644
--- a/lib/valueflow.cpp
+++ b/lib/valueflow.cpp
@@ -4276,6 +4276,7 @@ static void valueFlowAfterAssign(const TokenList &tokenlist,
                         continue;
                     const Token* expr = value.tokvalue;
                     value.intvalue = -value.intvalue;
+                    value.invertBound();
                     value.tokvalue = tok->astOperand1();
 
                     // Skip if it intersects with an already assigned symbol
diff --git a/test/testcondition.cpp b/test/testcondition.cpp
index 85efa6eab63..8567d9b11a7 100644
--- a/test/testcondition.cpp
+++ b/test/testcondition.cpp
@@ -5244,6 +5244,12 @@ class TestCondition : public TestFixture {
               "    if (c) {}\n"
               "}\n");
         ASSERT_EQUALS("", errout_str());
+
+        check("void f(int a, int b) {\n" // #11437
+              "    a = a < b ? b : a;\n"
+              "    if (a != b) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void alwaysTrueInfer() {

From cd55e0888f74053250ad3f2da092f76ce87cf3c8 Mon Sep 17 00:00:00 2001
From: Paul Fultz II <pfultz2@yahoo.com>
Date: Tue, 4 Aug 2026 01:28:16 -0500
Subject: [PATCH 26/59] Fix 14947:  FP algorithmOutOfBounds with array of
 arrays  (#8766)

---
 lib/astutils.cpp           |  11 ++++
 lib/astutils.h             |   3 +
 lib/checkbufferoverrun.cpp |  17 +++--
 lib/checkstl.cpp           |  19 +++++-
 lib/valueflow.cpp          |  52 +++++++++------
 lib/vf_analyzers.cpp       |  19 +++++-
 lib/vf_common.cpp          |   8 ++-
 lib/vf_settokenvalue.cpp   |  22 +++++++
 lib/vfvalue.h              |   4 ++
 test/testbufferoverrun.cpp |  64 +++++++++++++++++++
 test/teststl.cpp           |  15 +++++
 test/testvalueflow.cpp     | 126 +++++++++++++++++++++++++++++++++++++
 12 files changed, 332 insertions(+), 28 deletions(-)

diff --git a/lib/astutils.cpp b/lib/astutils.cpp
index c99e9b19bd5..25249e7be6f 100644
--- a/lib/astutils.cpp
+++ b/lib/astutils.cpp
@@ -1069,6 +1069,17 @@ bool isAliasOf(const Token *tok, nonneg int varid, bool* inconclusive)
     return false;
 }
 
+bool isIteratorOf(const Token* tok, nonneg int exprId)
+{
+    if (!astIsIterator(tok))
+        return false;
+    // An iterator into a subcontainer (e.g. c[0].begin()) aliases the container but iterates
+    // an unrelated range, so require an iterator value recording the container itself
+    return std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {
+        return v.isIteratorValue() && v.container && v.container->exprId() == exprId;
+    });
+}
+
 bool isAliasOf(const Token* tok, const Token* expr, nonneg int* indirect)
 {
     if (indirect)
diff --git a/lib/astutils.h b/lib/astutils.h
index 79a607108fd..578763124ac 100644
--- a/lib/astutils.h
+++ b/lib/astutils.h
@@ -386,6 +386,9 @@ bool isAliasOf(const Token *tok, nonneg int varid, bool* inconclusive = nullptr)
 
 bool isAliasOf(const Token* tok, const Token* expr, nonneg int* indirect = nullptr);
 
+/// If token is an iterator into the container expression with the given expression id
+bool isIteratorOf(const Token* tok, nonneg int exprId);
+
 const Token* getArgumentStart(const Token* ftok);
 
 /** Determines the number of arguments - if token is a function call or macro
diff --git a/lib/checkbufferoverrun.cpp b/lib/checkbufferoverrun.cpp
index 46d8e1c7c6c..8c8912ed06d 100644
--- a/lib/checkbufferoverrun.cpp
+++ b/lib/checkbufferoverrun.cpp
@@ -230,7 +230,8 @@ static bool getDimensionsEtc(const Token * const arrayToken, const Settings &set
         const size_t typeSize = array->valueType()->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, sizeOf);
         if (typeSize == 0)
             return false;
-        dim.num = value->intvalue / typeSize;
+        // a container size counts elements, a buffer size counts bytes
+        dim.num = value->isContainerSizeValue() ? value->intvalue : value->intvalue / typeSize;
         dimensions.emplace_back(dim);
     }
     return !dimensions.empty();
@@ -581,9 +582,17 @@ ValueFlow::Value CheckBufferOverrunImpl::getBufferSize(const Token *bufTok, cons
         if (const ValueFlow::Value *value = getBufferSizeValue(bufTok)) {
             if (value->isBufferSizeValue())
                 return *value;
-            if (value->isContainerSizeValue() && bufTok->valueType() && bufTok->valueType()->containerTypeToken) {
-                const ValueType vtElement = ValueType::parseDecl(bufTok->valueType()->containerTypeToken, settings);
-                const size_t elementSize = vtElement.getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+            if (value->isContainerSizeValue() && bufTok->valueType()) {
+                size_t elementSize = 0;
+                if (bufTok->valueType()->containerTypeToken) {
+                    const ValueType vtElement = ValueType::parseDecl(bufTok->valueType()->containerTypeToken, settings);
+                    elementSize =
+                        vtElement.getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+                } else if (bufTok->valueType()->pointer == 1) {
+                    elementSize = bufTok->valueType()->getSizeOf(settings,
+                                                                 ValueType::Accuracy::ExactOrZero,
+                                                                 ValueType::SizeOf::Pointee);
+                }
                 if (elementSize > 0) {
                     ValueFlow::Value bufSizeVal;
                     bufSizeVal.valueType = ValueFlow::Value::ValueType::BUFFER_SIZE;
diff --git a/lib/checkstl.cpp b/lib/checkstl.cpp
index 500adc08b01..de1d82792ac 100644
--- a/lib/checkstl.cpp
+++ b/lib/checkstl.cpp
@@ -765,6 +765,16 @@ static ValueFlow::Value getLifetimeIteratorValue(const Token* tok, MathLib::bigi
     return ValueFlow::Value{};
 }
 
+// Whether a container size value found on an iterator token belongs to the range of the given
+// iterator value. Both values record the container they belong to when it is known.
+static bool sizeValueAppliesToIterator(const ValueFlow::Value& sizeValue, const ValueFlow::Value& iterValue)
+{
+    if (!sizeValue.container || !iterValue.container)
+        return true; // the container of the size or of the iterator is not known
+    return iterValue.container == sizeValue.container ||
+           (iterValue.container->exprId() != 0 && iterValue.container->exprId() == sizeValue.container->exprId());
+}
+
 bool CheckStlImpl::checkIteratorPair(const Token* tok1, const Token* tok2)
 {
     if (!tok1)
@@ -2526,6 +2536,8 @@ void CheckStlImpl::checkDereferenceInvalidIterator2()
                 auto it = std::find_if(contValues.cbegin(), contValues.cend(), [&](const ValueFlow::Value& c) {
                     if (value.path != c.path)
                         return false;
+                    if (!sizeValueAppliesToIterator(c, value))
+                        return false;
                     if (value.isIteratorStartValue() && value.intvalue >= c.intvalue)
                         return true;
                     if (value.isIteratorEndValue() && -value.intvalue > c.intvalue)
@@ -3448,7 +3460,8 @@ static IteratorPosition getIteratorPosition(const Token* tok, const Settings& se
     if (!position.value)
         return position;
     position.sizeValue = selectPreferredValue(tok, [&](const ValueFlow::Value& value) {
-        return isUsableValue(value, settings) && value.isContainerSizeValue() && value.path == position.value->path;
+        return isUsableValue(value, settings) && value.isContainerSizeValue() && value.path == position.value->path &&
+               sizeValueAppliesToIterator(value, *position.value);
     });
     return position;
 }
@@ -3527,6 +3540,8 @@ static ElementCount findInsufficientSpace(const Token* tok,
         for (const ValueFlow::Value& sizeValue : tok->values()) {
             if (!isUsableValue(sizeValue, settings) || !sizeValue.isContainerSizeValue() || sizeValue.path != value.path)
                 continue;
+            if (!sizeValueAppliesToIterator(sizeValue, value))
+                continue;
             position.sizeValue = &sizeValue;
             consider(getAvailableSpace(position));
         }
@@ -3571,6 +3586,8 @@ static ElementCount findExcessiveDistance(const Token* firstTok,
                 if (!isUsableValue(sizeValue, settings) || !sizeValue.isContainerSizeValue() ||
                     sizeValue.path != endPosition.value->path)
                     continue;
+                if (!sizeValueAppliesToIterator(sizeValue, *endPosition.value))
+                    continue;
                 endPosition.sizeValue = &sizeValue;
                 consider(getIteratorDistance(first, last));
             }
diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
index 766f65e9f32..29eb07bcc90 100644
--- a/lib/valueflow.cpp
+++ b/lib/valueflow.cpp
@@ -401,10 +401,14 @@ void ValueFlow::combineValueProperties(const ValueFlow::Value &value1, const Val
         result.valueType = value2.valueType;
         result.tokvalue = value2.tokvalue;
     }
-    if (value1.isIteratorValue())
+    if (value1.isIteratorValue()) {
         result.valueType = value1.valueType;
-    if (value2.isIteratorValue())
+        result.container = value1.container;
+    }
+    if (value2.isIteratorValue()) {
         result.valueType = value2.valueType;
+        result.container = value2.container;
+    }
     result.condition = value1.condition ? value1.condition : value2.condition;
     result.varId = (value1.varId != 0) ? value1.varId : value2.varId;
     result.varvalue = (result.varId == value1.varId) ? value1.varvalue : value2.varvalue;
@@ -3859,11 +3863,14 @@ static void valueFlowForwardConst(Token* start,
         } else {
             [&] {
                 // Add the container size to iterators of the container (mirrors ContainerExpressionAnalyzer::match)
-                if (hasContainerSizeValue && astIsIterator(tok) && isAliasOf(tok, var->declarationId())) {
+                if (hasContainerSizeValue && isIteratorOf(tok, var->declarationId())) {
                     for (const ValueFlow::Value& value : values) {
                         if (!value.isContainerSizeValue())
                             continue;
-                        setTokenValue(tok, value, settings);
+                        ValueFlow::Value sizeValue = value;
+                        if (!sizeValue.container)
+                            sizeValue.container = var->nameToken();
+                        setTokenValue(tok, std::move(sizeValue), settings);
                     }
                     return;
                 }
@@ -4212,11 +4219,15 @@ static void valueFlowAfterAssign(const TokenList &tokenlist,
             values.remove_if([&](const ValueFlow::Value& value) {
                 return types.count(value.valueType) > 0;
             });
-            // Remove container size if its not a container
-            if (!astIsContainer(tok->astOperand2()))
+            // Remove container size if its not a container - unless the size records its container
+            // and flows into a pointer to the container data (e.g. p = v.data())
+            if (!astIsContainer(tok->astOperand2())) {
+                const bool lhsIsPointer = astIsPointer(tok->astOperand1());
                 values.remove_if([&](const ValueFlow::Value& value) {
-                    return value.valueType == ValueFlow::Value::ValueType::CONTAINER_SIZE;
+                    return value.valueType == ValueFlow::Value::ValueType::CONTAINER_SIZE &&
+                           (!value.container || !lhsIsPointer);
                 });
+            }
             // Remove symbolic values that are the same as the LHS
             values.remove_if([&](const ValueFlow::Value& value) {
                 if (value.isSymbolicValue() && value.tokvalue)
@@ -6447,17 +6458,22 @@ static void valueFlowIterators(TokenList& tokenlist, const Settings& settings)
         const Library::Container::Yield yield = findIteratorYield(tok, ftok, settings.library);
         if (!ftok)
             continue;
-        if (yield == Library::Container::Yield::START_ITERATOR) {
-            ValueFlow::Value v(0);
-            v.setKnown();
-            v.valueType = ValueFlow::Value::ValueType::ITERATOR_START;
-            setTokenValue(const_cast<Token*>(ftok)->next(), std::move(v), settings);
-        } else if (yield == Library::Container::Yield::END_ITERATOR) {
-            ValueFlow::Value v(0);
-            v.setKnown();
-            v.valueType = ValueFlow::Value::ValueType::ITERATOR_END;
-            setTokenValue(const_cast<Token*>(ftok)->next(), std::move(v), settings);
-        }
+        if (yield != Library::Container::Yield::START_ITERATOR && yield != Library::Container::Yield::END_ITERATOR)
+            continue;
+        // The iterator value records the container it iterates. A pointer or a reference only
+        // transports the iterator, so record the container it refers to instead.
+        const Token* containerTok = tok;
+        if (astIsPointer(containerTok) || (containerTok->variable() && containerTok->variable()->isReference())) {
+            const ValueFlow::Value lifetime = ValueFlow::getLifetimeObjValue(containerTok);
+            if (lifetime.tokvalue && astIsContainer(lifetime.tokvalue) && !astIsPointer(lifetime.tokvalue))
+                containerTok = lifetime.tokvalue;
+        }
+        ValueFlow::Value v(0);
+        v.setKnown();
+        v.valueType = yield == Library::Container::Yield::START_ITERATOR ? ValueFlow::Value::ValueType::ITERATOR_START
+                                                                         : ValueFlow::Value::ValueType::ITERATOR_END;
+        v.container = containerTok;
+        setTokenValue(const_cast<Token*>(ftok)->next(), std::move(v), settings);
     }
 }
 
diff --git a/lib/vf_analyzers.cpp b/lib/vf_analyzers.cpp
index cfba7d5f970..cc4a6a820cf 100644
--- a/lib/vf_analyzers.cpp
+++ b/lib/vf_analyzers.cpp
@@ -1299,6 +1299,12 @@ struct ExpressionAnalyzer : SingleValueFlowAnalyzer {
             dependOnThis |= exprDependsOnThis(value.tokvalue);
             setupExprVarIds(value.tokvalue);
         }
+        if (value.isContainerSizeValue() && value.container) {
+            // a container size tracked through another expression (e.g. a pointer obtained from
+            // data()) is invalidated by writes to the container it belongs to
+            dependOnThis |= exprDependsOnThis(value.container);
+            setupExprVarIds(value.container);
+        }
         uniqueExprId =
             expr->isUniqueExprId() && (Token::Match(expr, "%cop%") || !isVariableChanged(expr, 0, s));
     }
@@ -1503,15 +1509,22 @@ ValuePtr<Analyzer> makeMemberExpressionAnalyzer(std::string varname, const Token
 struct ContainerExpressionAnalyzer : ExpressionAnalyzer {
     ContainerExpressionAnalyzer(const Token* expr, ValueFlow::Value val, const Settings& s)
         : ExpressionAnalyzer(expr, std::move(val), s)
-    {}
+    {
+        // The size of a container expression belongs to that expression. Through a pointer the
+        // size keeps belonging to the container the pointer was obtained from.
+        if (astIsContainer(expr) && !astIsPointer(expr))
+            value.container = expr;
+    }
 
     bool match(const Token* tok) const override {
-        return tok->exprId() == expr->exprId() || (astIsIterator(tok) && isAliasOf(tok, expr->exprId()));
+        return tok->exprId() == expr->exprId() || isIteratorOf(tok, expr->exprId());
     }
 
     Action isWritable(const Token* tok, Direction /*d*/) const override
     {
-        if (astIsIterator(tok))
+        // only writes to the container itself change its size - not writes through an iterator
+        // or to a default-inserted element
+        if (tok->exprId() != expr->exprId())
             return Action::None;
         if (!getValue(tok))
             return Action::None;
diff --git a/lib/vf_common.cpp b/lib/vf_common.cpp
index ef48423f38a..f9eecc20fb9 100644
--- a/lib/vf_common.cpp
+++ b/lib/vf_common.cpp
@@ -404,8 +404,12 @@ namespace ValueFlow
             return Token::getStrLength(tok);
         if (astIsGenericChar(tok) || tok->tokType() == Token::eChar)
             return 1;
-        if (const Value* v = tok->getKnownValue(Value::ValueType::CONTAINER_SIZE))
-            return v->intvalue;
+        if (const Value* v = tok->getKnownValue(Value::ValueType::CONTAINER_SIZE)) {
+            // on a pointer the size is the number of elements in the buffer (possibly including
+            // a null terminator), not the length of the string
+            if (!astIsPointer(tok))
+                return v->intvalue;
+        }
         if (const Value* v = tok->getKnownValue(Value::ValueType::TOK)) {
             if (v->tokvalue != tok)
                 return valueFlowGetStrLength(v->tokvalue, library);
diff --git a/lib/vf_settokenvalue.cpp b/lib/vf_settokenvalue.cpp
index aab64170890..9f56b57db0a 100644
--- a/lib/vf_settokenvalue.cpp
+++ b/lib/vf_settokenvalue.cpp
@@ -231,6 +231,11 @@ namespace ValueFlow
         if (!value.isImpossible() && value.isIntValue())
             value = truncateImplicitConversion(tok->astParent(), value, settings);
 
+        // a container size value on a container expression belongs to that expression, while a
+        // pointer or an iterator only transports the size of the container it was obtained from
+        if (value.isContainerSizeValue() && !astIsPointer(tok) && astIsContainer(tok))
+            value.container = tok;
+
         if (settings.debugnormal)
             setSourceLocation(value, loc, tok);
 
@@ -300,15 +305,32 @@ namespace ValueFlow
                     }
                 }
             }
+            // an empty associative container implies that its default-inserted elements are empty as well
+            if (Token::simpleMatch(parent, "[") && astIsLHS(tok) && astIsContainer(parent) &&
+                tok->valueType()->container && tok->valueType()->container->stdAssociativeLike &&
+                !value.isImpossible() && value.intvalue == 0)
+                setTokenValue(parent, value, settings);
             Token* next = nullptr;
             const Library::Container::Yield yields = getContainerYield(parent, settings.library, next);
             if (yields == Library::Container::Yield::SIZE) {
                 value.valueType = Value::ValueType::INT;
+                value.container = nullptr;
+                setTokenValue(next, std::move(value), settings);
+            } else if (contains({Library::Container::Yield::BUFFER,
+                                 Library::Container::Yield::BUFFER_NT,
+                                 Library::Container::Yield::START_ITERATOR,
+                                 Library::Container::Yield::END_ITERATOR,
+                                 Library::Container::Yield::ITERATOR},
+                                yields)) {
+                // The returned pointer or iterator has as many elements available as the container
+                if (yields == Library::Container::Yield::BUFFER_NT)
+                    value.intvalue += 1; // ..plus the null terminator
                 setTokenValue(next, std::move(value), settings);
             } else if (yields == Library::Container::Yield::EMPTY) {
                 const Value::Bound bound = value.bound;
                 const long long intvalue = value.intvalue;
                 value.valueType = Value::ValueType::INT;
+                value.container = nullptr;
                 value.bound = Value::Bound::Point;
                 if (value.isImpossible()) {
                     if (intvalue == 0)
diff --git a/lib/vfvalue.h b/lib/vfvalue.h
index 8a473143b68..ce33f022e58 100644
--- a/lib/vfvalue.h
+++ b/lib/vfvalue.h
@@ -322,6 +322,10 @@ namespace ValueFlow
         /** token value - the token that has the value. this is used for pointer aliases, strings, etc. */
         const Token* tokvalue{};
 
+        /** For CONTAINER_SIZE values: the container the size belongs to, when the value is
+         * attached to a token that is not the container itself (an iterator or a pointer) */
+        const Token* container = nullptr;
+
         /** float value */
         double floatValue{};
 
diff --git a/test/testbufferoverrun.cpp b/test/testbufferoverrun.cpp
index 37ab7083902..8bac50a468c 100644
--- a/test/testbufferoverrun.cpp
+++ b/test/testbufferoverrun.cpp
@@ -197,6 +197,7 @@ class TestBufferOverrun : public TestFixture {
         TEST_CASE(array_index_function_parameter);
         TEST_CASE(array_index_enum_array); // #8439
         TEST_CASE(array_index_container); // #9386
+        TEST_CASE(array_index_container_data); // pointer from data()/c_str() carries the container size
         TEST_CASE(array_index_two_for_loops);
         TEST_CASE(array_index_new); // #7690
 
@@ -2902,6 +2903,69 @@ class TestBufferOverrun : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void array_index_container_data()
+    {
+        check("void f() {\n"
+              "    std::vector<int> v(3);\n"
+              "    int* p = v.data();\n"
+              "    p[2] = 1;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v(3);\n"
+              "    int* p = v.data();\n"
+              "    p[5] = 1;\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:4:6]: (error) Array 'p[3]' accessed at index 5, which is out of bounds. [arrayIndexOutOfBounds]\n",
+            errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v(3);\n"
+              "    memset(v.data(), 0, 12);\n"
+              "    memset(v.data(), 0, 100);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:18]: (error) Buffer is accessed out of bounds: v.data() [bufferAccessOutOfBounds]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v(3);\n"
+              "    int* p = v.data();\n"
+              "    memset(p, 0, 100);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Buffer is accessed out of bounds: p [bufferAccessOutOfBounds]\n",
+                      errout_str());
+
+        // the size is not tracked past changes of the container size
+        check("void f() {\n"
+              "    std::vector<int> v(3);\n"
+              "    v.reserve(100);\n"
+              "    int* p = v.data();\n"
+              "    v.resize(10);\n"
+              "    memset(p, 0, 40);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // ..or when the pointer is reassigned
+        check("void f(int* q) {\n"
+              "    std::vector<int> v(3);\n"
+              "    int* p = v.data();\n"
+              "    p = q;\n"
+              "    memset(p, 0, 100);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // the buffer of c_str() includes the null terminator
+        check("void f(char* dst) {\n"
+              "    std::string s = \"abc\";\n"
+              "    memcpy(dst, s.c_str(), 4);\n"
+              "    memcpy(dst, s.c_str(), 5);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:24]: (error) Buffer is accessed out of bounds: s.c_str() [bufferAccessOutOfBounds]\n",
+                      errout_str());
+    }
+
     void array_index_two_for_loops() {
         check("bool b();\n"
               "void f()\n"
diff --git a/test/teststl.cpp b/test/teststl.cpp
index c030fb4c6f6..2570059c19e 100644
--- a/test/teststl.cpp
+++ b/test/teststl.cpp
@@ -2798,6 +2798,21 @@ class TestStl : public TestFixture {
         ASSERT_EQUALS(
             "[test.cpp:4:24]: (error) The algorithm 'std::fill_n' accesses 10 elements through the iterator 'v.begin()' but only 5 elements are available. [algorithmOutOfBounds]\n",
             errout_str());
+
+        // an iterator into a nested container does not carry the outer container's size
+        check("std::array<std::array<int, 16>, 1> f(const std::array<int, 16>& a) {\n"
+              "    std::array<std::array<int, 16>, 1> res;\n"
+              "    std::copy(a.begin(), a.end(), res[0].begin());\n"
+              "    return res;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    const std::vector<int> v0{1,2,3};\n"
+              "    std::vector<std::vector<int>> v1(1, std::vector<int>(5));\n"
+              "    std::copy(v0.begin(), v0.end(), v1[0].begin());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     // Dereferencing invalid pointer
diff --git a/test/testvalueflow.cpp b/test/testvalueflow.cpp
index c98680b8180..f92ddee3685 100644
--- a/test/testvalueflow.cpp
+++ b/test/testvalueflow.cpp
@@ -517,6 +517,22 @@ class TestValueFlow : public TestFixture {
         return values;
     }
 
+    // The expression of the container recorded by the container size value of the token. The
+    // container token has to be resolved while the tokenizer is alive.
+#define containerOfSizeValue(...) containerOfSizeValue_(__FILE__, __LINE__, __VA_ARGS__)
+    std::string containerOfSizeValue_(const char* file, int line, const char code[], const char tokstr[]) {
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+        const Token* tok = Token::findmatch(tokenizer.tokens(), tokstr);
+        if (!tok)
+            return "";
+        const std::list<ValueFlow::Value>& values = tok->values();
+        const auto it = std::find_if(values.cbegin(), values.cend(), [](const ValueFlow::Value& v) {
+            return v.isContainerSizeValue() && v.container;
+        });
+        return it == values.cend() ? "" : it->container->expressionString();
+    }
+
 #define lifetimeValues(...) lifetimeValues_(__FILE__, __LINE__, __VA_ARGS__)
     template<size_t size>
     std::vector<std::string> lifetimeValues_(const char* file, int line, const char (&code)[size], const char tokstr[]) {
@@ -7682,6 +7698,93 @@ class TestValueFlow : public TestFixture {
                "    if (m.empty()) {}\n"
                "}\n";
         ASSERT(!isKnownContainerSizeValue(tokenValues(code, "m ."), 0).empty());
+
+        // the pointer returned by data() carries the container size
+        code = "int f() {\n"
+               "    std::vector<int> v(3);\n"
+               "    int* p = v.data();\n"
+               "    return p[1];\n"
+               "}";
+        ASSERT_EQUALS("",
+                      isKnownContainerSizeValue(tokenValues(code, "p [", ValueFlow::Value::ValueType::CONTAINER_SIZE), 3));
+
+        // ..which is invalidated when the container size changes
+        code = "int f() {\n"
+               "    std::vector<int> v(3);\n"
+               "    int* p = v.data();\n"
+               "    v.push_back(1);\n"
+               "    return p[1];\n"
+               "}";
+        ASSERT_EQUALS(0U, tokenValues(code, "p [", ValueFlow::Value::ValueType::CONTAINER_SIZE).size());
+
+        // the buffer of c_str() includes the null terminator
+        code = "const char* f() {\n"
+               "    std::string s = \"abc\";\n"
+               "    const char* p = s.c_str();\n"
+               "    return p + 3;\n"
+               "}";
+        ASSERT_EQUALS("",
+                      isKnownContainerSizeValue(tokenValues(code, "p +", ValueFlow::Value::ValueType::CONTAINER_SIZE), 4));
+
+        code = "const char* f() {\n"
+               "    std::string s = \"abc\";\n"
+               "    return s.c_str();\n"
+               "}";
+        ASSERT_EQUALS(
+            "",
+            isKnownContainerSizeValue(tokenValues(code, "( ) ;", ValueFlow::Value::ValueType::CONTAINER_SIZE), 4));
+
+        // the size value of a data() pointer records the container the size belongs to
+        code = "int* f() {\n"
+               "    std::vector<int> v(3);\n"
+               "    return v.data();\n"
+               "}";
+        ASSERT_EQUALS("",
+                      isKnownContainerSizeValue(tokenValues(code, "( ) ;", ValueFlow::Value::ValueType::CONTAINER_SIZE),
+                                                3));
+        ASSERT_EQUALS("v", containerOfSizeValue(code, "( ) ;"));
+
+        // an empty associative container implies that its default-inserted elements are empty as well
+        code = "void f(const std::string& k) {\n"
+               "    std::map<std::string, std::vector<int>> m;\n"
+               "    m[k].front();\n"
+               "}";
+        ASSERT_EQUALS(
+            "",
+            isKnownContainerSizeValue(tokenValues(code, "[ k ] . front", ValueFlow::Value::ValueType::CONTAINER_SIZE),
+                                      0));
+        ASSERT_EQUALS("m[k]", containerOfSizeValue(code, "[ k ] . front"));
+
+        // ..also for nested associative containers..
+        code = "void f(int a, int b) {\n"
+               "    std::map<int, std::map<int, std::vector<int>>> m;\n"
+               "    m[a][b].front();\n"
+               "}";
+        ASSERT_EQUALS(
+            "",
+            isKnownContainerSizeValue(tokenValues(code, "[ b ] . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
+
+        // ..but not for non-associative containers..
+        code = "void f(int i) {\n"
+               "    std::vector<std::vector<int>> v;\n"
+               "    v[i].front();\n"
+               "}";
+        ASSERT_EQUALS(0U, tokenValues(code, "[ i ] . front", ValueFlow::Value::ValueType::CONTAINER_SIZE).size());
+
+        // ..nor when the container is not empty..
+        code = "void f(std::map<std::string, std::vector<int>>& m, const std::string& k) {\n"
+               "    if (m.size() == 1)\n"
+               "        m[k].front();\n"
+               "}";
+        ASSERT_EQUALS(0U, tokenValues(code, "[ k ] . front", ValueFlow::Value::ValueType::CONTAINER_SIZE).size());
+
+        // ..nor when the container was modified
+        code = "void f(const std::string& k) {\n"
+               "    std::map<std::string, std::vector<int>> m;\n"
+               "    m[\"a\"].push_back(1);\n"
+               "    m[k].front();\n"
+               "}";
+        ASSERT_EQUALS(0U, tokenValues(code, "[ k ] . front", ValueFlow::Value::ValueType::CONTAINER_SIZE).size());
     }
 
     void valueFlowContainerSizeIterator() {
@@ -7723,6 +7826,29 @@ class TestValueFlow : public TestFixture {
                "    if (it != w.end()) {}\n"
                "}";
         ASSERT(tokenValues(code, "it !=", ValueFlow::Value::ValueType::CONTAINER_SIZE).empty());
+
+        // iterators created from the container carry the container size
+        code = "bool f() {\n"
+               "    std::vector<int> v(3);\n"
+               "    return v.begin() != v.end();\n"
+               "}";
+        ASSERT_EQUALS(
+            "",
+            isKnownContainerSizeValue(tokenValues(code, "( ) !=", ValueFlow::Value::ValueType::CONTAINER_SIZE), 3));
+        ASSERT_EQUALS(
+            "",
+            isKnownContainerSizeValue(tokenValues(code, "( ) ;", ValueFlow::Value::ValueType::CONTAINER_SIZE), 3));
+
+        // the size value records the container it belongs to
+        code = "void f() {\n"
+               "    std::vector<int> v(3);\n"
+               "    auto it = v.begin();\n"
+               "    if (it != v.end()) {}\n"
+               "}";
+        ASSERT_EQUALS(
+            "",
+            isKnownContainerSizeValue(tokenValues(code, "it !=", ValueFlow::Value::ValueType::CONTAINER_SIZE), 3));
+        ASSERT_EQUALS("v", containerOfSizeValue(code, "it !="));
     }
 
     void valueFlowContainerElement()

From dbde18971103bb5bcf87191c391f75486cd8ca12 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Tue, 4 Aug 2026 16:45:22 +0200
Subject: [PATCH 27/59] Fix #14946: `originalName` in dumpfile missing for
 local typedefs (#8760)

---
 lib/tokenize.cpp                 |  1 +
 test/testincompletestatement.cpp |  2 +-
 test/testsimplifytypedef.cpp     | 16 ++++++++++++++++
 3 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index 07ffa4c666c..610877eec53 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -2044,6 +2044,7 @@ void Tokenizer::simplifyTypedefCpp()
                         tok2->previous()->str("typedef");
                         tok2->insertToken(tok2->str());
                     }
+                    tok2->originalName(tok2->str());
                     tok2->str(typeStart->str());
 
                     // restore qualification if it was removed
diff --git a/test/testincompletestatement.cpp b/test/testincompletestatement.cpp
index da238d304b2..72a13ee6c42 100644
--- a/test/testincompletestatement.cpp
+++ b/test/testincompletestatement.cpp
@@ -492,7 +492,7 @@ class TestIncompleteStatement : public TestFixture {
               "void f(int i) {\n"
               "    (M::N::T)i;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:5:5]: (warning) Redundant code: Found unused cast in expression '(char)i'. [constStatement]\n", errout_str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) Redundant code: Found unused cast in expression '(T)i'. [constStatement]\n", errout_str());
 
         check("void f(int (g)(int a, int b)) {\n" // #10873
               "    int p = 0, q = 1;\n"
diff --git a/test/testsimplifytypedef.cpp b/test/testsimplifytypedef.cpp
index 42718a2f99c..e83be343e01 100644
--- a/test/testsimplifytypedef.cpp
+++ b/test/testsimplifytypedef.cpp
@@ -256,6 +256,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         TEST_CASE(simplifyTypedefOriginalName1);
         TEST_CASE(simplifyTypedefOriginalName2);
+        TEST_CASE(simplifyTypedefOriginalName3);
 
         TEST_CASE(simplifyTypedefTokenColumn1);
         TEST_CASE(simplifyTypedefTokenColumn2);
@@ -4600,6 +4601,21 @@ class TestSimplifyTypedef : public TestFixture {
         ASSERT_EQUALS("A", token->originalName());
     }
 
+    void simplifyTypedefOriginalName3() {
+        const char code[] = "void f(void) {\n"
+                            "    typedef int A;\n"
+                            "    A a;\n"
+                            "}\n";
+        TokenList tokenlist{ settings1, Standards::Language::C };
+        ASSERT(TokenListHelper::createTokensFromString(tokenlist, code, "file.c"));
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        tokenizer.createLinks();
+        tokenizer.simplifyTypedef();
+        ASSERT_NO_THROW(tokenizer.validate());
+        const Token* token = Token::findsimplematch(tokenizer.list.front(), "int");
+        ASSERT_EQUALS("A", token->originalName());
+    }
+
     void simplifyTypedefTokenColumn1() {  // #13155
         const char code[] = "void foo(void) {\n"
                             "    typedef signed int MY_INT;\n"

From 1a96ce880c07919f85dce30fa02ffc3848f74721 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Tue, 4 Aug 2026 16:48:56 +0200
Subject: [PATCH 28/59] Fix #14918: fuzzing crash (stack-overflow) in
 findTokensSkipDeadCodeImpl() (#8732)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Daniel Marjamäki <daniel.marjamaki@gmail.com>
---
 lib/tokenize.cpp                                               | 3 +++
 .../crash-9feb09f580c0cf101456c6c650ab4193b1009d07             | 1 +
 2 files changed, 4 insertions(+)
 create mode 100644 test/cli/fuzz-crash_c/crash-9feb09f580c0cf101456c6c650ab4193b1009d07

diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index 610877eec53..8382c09e785 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -8814,6 +8814,9 @@ void Tokenizer::findGarbageCode() const
             if (!cpp || mSettings.standards.cpp < Standards::CPP20 || !Token::Match(tok->previous(), "%name% : %num% ="))
                 syntaxError(tok, tok->strAt(1) + " " + tok->strAt(2));
         }
+        else if (!cpp && Token::Match(tok, "++|-- ++|--")) {
+            syntaxError(tok, tok->str() + tok->strAt(1));
+        }
         else if (Token::simpleMatch(tok, ") return") && !Token::Match(tok->link()->previous(), "if|while|for (")) {
             if (tok->link()->previous() && tok->link()->previous()->isUpperCaseName())
                 unknownMacroError(tok->link()->previous());
diff --git a/test/cli/fuzz-crash_c/crash-9feb09f580c0cf101456c6c650ab4193b1009d07 b/test/cli/fuzz-crash_c/crash-9feb09f580c0cf101456c6c650ab4193b1009d07
new file mode 100644
index 00000000000..8577d6ccb7f
--- /dev/null
+++ b/test/cli/fuzz-crash_c/crash-9feb09f580c0cf101456c6c650ab4193b1009d07
@@ -0,0 +1 @@
+d(){e?&d=d++++F:a}
\ No newline at end of file

From 933246d2ad5b7972a2886608142be3e69df3f530 Mon Sep 17 00:00:00 2001
From: Paul Fultz II <pfultz2@yahoo.com>
Date: Tue, 4 Aug 2026 10:08:26 -0500
Subject: [PATCH 29/59] Add unit tests for cppcheckdata.py (#8707)

This adds unit tests for cppcheckdata.py which runs with pytest. It will
also run these tests with cmake automatically if python is available, so
this should run on the CI.

The unit tests did surface a couple of problems, but I didnt fix it this
PR to keep the scope smaller. Instead I just marked the test with
`pytest.mark.xfail` for now. I can do a follow up PR to fix these
issues:

1. `Token.isBoolean` is dead code. `Tokenizer::dump`
(lib/tokenize.cpp:6179) checks `tok->isName()` before `isBoolean()`, and
`eBoolean` tokens count as names (lib/token.h:397), so true/false are
always dumped as `type="name"` and the `type="boolean"` branch at
tokenize.cpp:6199 is unreachable for them(I see there is `TODO:
"true"/"false" aren't really a name...`)
2. Line suppressions match every line. The final "other suppression"
fallback in `Suppression.isMatch()` (cppcheckdata.py:1007) doesn't check
that `lineNumber` is unset, so a suppression for line 5 also matches
line 6. The fix would be a one-line `self.lineNumber is None` guard.
3. In C++ `Token::Match`, `!!x` also matches when there is no token at
all (null), but Python `match()` fails when the token list ends:
`match(last_brace, '} !!x')` returns false.

---------

Co-authored-by: Your Name <you@example.com>
---
 test/CMakeLists.txt             |   2 +
 test/addon/CMakeLists.txt       |  41 ++
 test/addon/conftest.py          | 201 +++++++
 test/addon/requirements.txt     |   1 +
 test/addon/test_cppcheckdata.py | 915 ++++++++++++++++++++++++++++++++
 test/cli/performance_test.py    |   2 +-
 6 files changed, 1161 insertions(+), 1 deletion(-)
 create mode 100644 test/addon/CMakeLists.txt
 create mode 100644 test/addon/conftest.py
 create mode 100644 test/addon/requirements.txt
 create mode 100644 test/addon/test_cppcheckdata.py

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 14f3a8eac17..f1e59e17daf 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -47,6 +47,8 @@ if (BUILD_TESTING)
     if (REGISTER_TESTS)
         # CMAKE_MATCH_<n> usage for if (MATCHES) requires CMake 3.9
 
+        add_subdirectory(addon)
+
         find_package(Threads REQUIRED)
         include(ProcessorCount)
         ProcessorCount(N)
diff --git a/test/addon/CMakeLists.txt b/test/addon/CMakeLists.txt
new file mode 100644
index 00000000000..bb04afb6c51
--- /dev/null
+++ b/test/addon/CMakeLists.txt
@@ -0,0 +1,41 @@
+if (NOT Python_Interpreter_FOUND)
+    message(WARNING "Python interpreter not found - skipping addon tests.")
+    return()
+endif()
+
+# creating a virtual environment needs the venv and ensurepip modules - some
+# distributions ship them separately from the interpreter (e.g. the Debian/Ubuntu
+# python3-venv package)
+execute_process(COMMAND ${Python_EXECUTABLE} -c "import venv, ensurepip"
+        RESULT_VARIABLE PYTHON_VENV_RESULT
+        OUTPUT_QUIET
+        ERROR_QUIET)
+if (NOT PYTHON_VENV_RESULT EQUAL 0)
+    message(WARNING "Python venv module not available (e.g. install the python3-venv package) - skipping addon tests.")
+    return()
+endif()
+
+set(VENV_DIR ${CMAKE_CURRENT_BINARY_DIR}/venv)
+if (WIN32)
+    set(VENV_PYTHON ${VENV_DIR}/Scripts/python.exe)
+else()
+    set(VENV_PYTHON ${VENV_DIR}/bin/python)
+endif()
+
+# fixture: create a virtual environment and install the python dependencies into it
+add_test(NAME addon-venv-create
+        COMMAND ${Python_EXECUTABLE} -m venv ${VENV_DIR})
+set_tests_properties(addon-venv-create PROPERTIES
+        FIXTURES_SETUP addon-venv-dir)
+
+add_test(NAME addon-venv-install
+        COMMAND ${VENV_PYTHON} -m pip install -r ${CMAKE_CURRENT_SOURCE_DIR}/requirements.txt)
+set_tests_properties(addon-venv-install PROPERTIES
+        FIXTURES_REQUIRED addon-venv-dir
+        FIXTURES_SETUP addon-venv
+        TIMEOUT 300)
+
+add_test(NAME addon-cppcheckdata
+        COMMAND ${VENV_PYTHON} -m pytest --cppcheck-binary=$<TARGET_FILE:cppcheck> ${CMAKE_CURRENT_SOURCE_DIR})
+set_tests_properties(addon-cppcheckdata PROPERTIES
+        FIXTURES_REQUIRED addon-venv)
diff --git a/test/addon/conftest.py b/test/addon/conftest.py
new file mode 100644
index 00000000000..87012983951
--- /dev/null
+++ b/test/addon/conftest.py
@@ -0,0 +1,201 @@
+"""pytest configuration for the addon tests.
+
+The tests exercise addons/cppcheckdata.py against dump files that are
+generated on the fly with the cppcheck binary given by --cppcheck-binary.
+"""
+import os
+import shutil
+import subprocess
+import sys
+
+import pytest
+
+# Make 'import cppcheckdata' resolve to <repo>/addons/cppcheckdata.py
+_ADDONS_DIR = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', 'addons'))
+if _ADDONS_DIR not in sys.path:
+    sys.path.insert(0, _ADDONS_DIR)
+
+
+def pytest_addoption(parser):
+    parser.addoption('--cppcheck-binary',
+                     default='cppcheck',
+                     help='path to the cppcheck binary used to generate dump files '
+                          '(default: cppcheck found in PATH)')
+
+
+@pytest.fixture(scope='session')
+def cppcheck_binary(request):
+    binary = request.config.getoption('--cppcheck-binary')
+    resolved = shutil.which(binary)
+    if resolved is None:
+        pytest.fail("cppcheck binary '%s' not found - point --cppcheck-binary at a cppcheck executable" % binary)
+    return os.path.abspath(resolved)
+
+
+class DumpFactory:
+    """Runs 'cppcheck --dump' on a source snippet and parses the result."""
+
+    def __init__(self, binary, tmp_path_factory):
+        self.binary = binary
+        self.tmp_path_factory = tmp_path_factory
+
+    def create(self, code, filename='test.c', extra_args=()):
+        """Write the code to a file, dump it and return the dump file path."""
+        directory = self.tmp_path_factory.mktemp('cppcheckdata')
+        path = directory / filename
+        path.write_text(code)
+        cmd = [self.binary, '--dump', '--quiet', str(path)] + list(extra_args)
+        proc = subprocess.run(cmd,
+                              stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE,
+                              check=True,
+                              universal_newlines=True)
+        assert proc.returncode == 0, \
+            'cppcheck failed with exit code %d:\n%s\n%s' % (proc.returncode, proc.stdout, proc.stderr)
+        return str(path) + '.dump'
+
+    def parse(self, code, filename='test.c', extra_args=()):
+        """Write the code to a file, dump it and return the parsed CppcheckData."""
+        import cppcheckdata
+        return cppcheckdata.parsedump(self.create(code, filename, extra_args))
+
+
+@pytest.fixture(scope='session')
+def dump_factory(cppcheck_binary, tmp_path_factory):
+    return DumpFactory(cppcheck_binary, tmp_path_factory)
+
+
+SAMPLE_C = """#define ANSWER 42
+static int add(int a, int b)
+{
+    return a + b;
+}
+
+double half(double d)
+{
+    return d / 2.0;
+}
+
+int main(void)
+{
+    int x = ANSWER;
+    int arr[10];
+    arr[0] = add(x, 1);
+    int neg = -x;
+    return arr[0] + neg;
+}
+"""
+
+SAMPLE_CPP = """namespace ns {
+    int twice(int v) { return 2 * v; }
+}
+
+class Shape {
+public:
+    virtual ~Shape() {}
+    virtual double area() const = 0;
+protected:
+    double mScale;
+};
+
+enum Color { RED, GREEN };
+
+const int limit = 5;
+bool flag = true;
+const char *msg = "hello";
+char ch = 'x';
+
+int run()
+{
+    Color color = RED;
+    if (flag && limit > 1) {
+        return ns::twice(21);
+    }
+    return static_cast<int>(color);
+}
+"""
+
+MULTI_CFG_C = """typedef int myint;
+typedef float myfloat;
+#if defined(FOO) && FOO > 1
+int foo(void) { return 1; }
+#endif
+myint bar(void) { myint y = 3; return y; }
+"""
+
+MATCH_C = """struct Point {
+    int x;
+    int y;
+};
+
+int calc(int a, int b)
+{
+    int bit_or = a | b;
+    int log_or = a || b;
+    int mod = a % b;
+    int mul = a * b;
+    int not_a = !a;
+    int neq = a != b;
+    int arr[3];
+    arr[0] = a;
+    a += 1;
+    if (a > b) {
+        return a;
+    }
+    return calc(a, b);
+}
+"""
+
+MATCH_CPP = """class Widget {};
+
+bool use(int i, int j)
+{
+    std::vector<int> v;
+    bool less = i < j;
+    return less && v.empty();
+}
+"""
+
+
+@pytest.fixture(scope='session')
+def sample_data(dump_factory):
+    """Parsed dump of the canonical C sample."""
+    return dump_factory.parse(SAMPLE_C, filename='sample.c')
+
+
+@pytest.fixture(scope='session')
+def sample_cfg(sample_data):
+    cfgs = sample_data.configurations
+    assert len(cfgs) == 1
+    return cfgs[0]
+
+
+@pytest.fixture(scope='session')
+def sample_cpp_data(dump_factory):
+    """Parsed dump of the canonical C++ sample."""
+    return dump_factory.parse(SAMPLE_CPP, filename='sample.cpp')
+
+
+@pytest.fixture(scope='session')
+def sample_cpp_cfg(sample_cpp_data):
+    cfgs = sample_cpp_data.configurations
+    assert len(cfgs) == 1
+    return cfgs[0]
+
+
+@pytest.fixture(scope='session')
+def multi_cfg_data(dump_factory):
+    """Parsed dump of a file with two preprocessor configurations."""
+    return dump_factory.parse(MULTI_CFG_C, filename='multi.c')
+
+
+@pytest.fixture(scope='session')
+def match_cfg(dump_factory):
+    """Configuration of a C sample covering the match() pattern syntax."""
+    return dump_factory.parse(MATCH_C, filename='match.c').configurations[0]
+
+
+@pytest.fixture(scope='session')
+def match_cpp_cfg(dump_factory):
+    """Configuration of a C++ sample with linked '<' tokens for match()."""
+    return dump_factory.parse(MATCH_CPP, filename='match.cpp').configurations[0]
diff --git a/test/addon/requirements.txt b/test/addon/requirements.txt
new file mode 100644
index 00000000000..e079f8a6038
--- /dev/null
+++ b/test/addon/requirements.txt
@@ -0,0 +1 @@
+pytest
diff --git a/test/addon/test_cppcheckdata.py b/test/addon/test_cppcheckdata.py
new file mode 100644
index 00000000000..0ff3f31a89d
--- /dev/null
+++ b/test/addon/test_cppcheckdata.py
@@ -0,0 +1,915 @@
+"""Unit tests for addons/cppcheckdata.py
+
+Most tests parse dump files generated with the cppcheck binary
+(see conftest.py); tests of pure helper classes construct the
+objects directly from dicts (which provide the same .get() API
+as the XML elements).
+"""
+import json
+import sys
+
+import pytest
+
+import cppcheckdata
+
+
+def find_tokens(cfg, token_str):
+    return [tok for tok in cfg.tokenlist if tok.str == token_str]
+
+
+def find_token(cfg, token_str, skip=0):
+    tokens = find_tokens(cfg, token_str)
+    assert len(tokens) > skip, "token '%s' (skip=%d) not found" % (token_str, skip)
+    return tokens[skip]
+
+
+def find_function(cfg, name):
+    for function in cfg.functions:
+        if function.name == name:
+            return function
+    assert False, "function '%s' not found" % name
+
+
+def find_scope(cfg, scope_type, className=None):
+    for scope in cfg.scopes:
+        if scope.type == scope_type and (className is None or scope.className == className):
+            return scope
+    assert False, "scope '%s' not found" % scope_type
+
+
+def find_variable(cfg, name):
+    for variable in cfg.variables:
+        if variable.nameToken and variable.nameToken.str == name:
+            return variable
+    assert False, "variable '%s' not found" % name
+
+
+class TestCppcheckData:
+    def test_language(self, sample_data, sample_cpp_data):
+        assert sample_data.language == 'c'
+        assert sample_cpp_data.language == 'cpp'
+
+    def test_platform(self, sample_data):
+        platform = sample_data.platform
+        assert platform.name
+        assert platform.char_bit == 8
+        assert platform.short_bit >= 16
+        assert platform.int_bit >= 16
+        assert platform.long_bit >= 32
+        assert platform.long_long_bit >= 64
+        assert platform.pointer_bit > 0
+        assert 'char_bit=8' in repr(platform)
+
+    def test_files(self, sample_data):
+        assert len(sample_data.files) == 1
+        assert sample_data.files[0].endswith('sample.c')
+
+    def test_rawtokens(self, sample_data):
+        raw = sample_data.rawTokens
+        # the not yet preprocessed code contains the directive tokens
+        assert [tok.str for tok in raw[:4]] == ['#', 'define', 'ANSWER', '42']
+        assert raw[-1].str == '}'
+        assert raw[0].file.endswith('sample.c')
+        assert raw[0].linenr == 1
+        # next/previous chain
+        assert raw[0].previous is None
+        assert raw[-1].next is None
+        for i in range(len(raw) - 1):
+            assert raw[i].next is raw[i + 1]
+            assert raw[i + 1].previous is raw[i]
+
+    def test_configurations(self, sample_data):
+        cfgs = sample_data.configurations
+        assert len(cfgs) == 1
+        assert cfgs[0].name == ''
+
+    def test_iterconfigurations(self, multi_cfg_data):
+        it = multi_cfg_data.iterconfigurations()
+        cfgs = list(it)
+        assert len(cfgs) == 2
+        assert cfgs[0].name == ''
+        assert 'FOO' in cfgs[1].name
+        # 'foo()' is only tokenized in the FOO configuration
+        assert not find_tokens(cfgs[0], 'foo')
+        assert find_tokens(cfgs[1], 'foo')
+
+    def test_standards(self, sample_cfg, sample_cpp_cfg):
+        assert sample_cfg.standards.c.startswith('c')
+        assert sample_cpp_cfg.standards.cpp.startswith('c++')
+        assert sample_cfg.standards.posix is False
+        assert 'c=' in repr(sample_cfg.standards)
+
+
+class TestToken:
+    def test_tokenlist(self, sample_cfg):
+        code = ' '.join(tok.str for tok in sample_cfg.tokenlist)
+        assert 'static int add ( int a , int b )' in code
+        # the macro has been expanded
+        assert 'x = 42' in code
+
+    def test_next_previous(self, sample_cfg):
+        tokens = sample_cfg.tokenlist
+        assert tokens[0].previous is None
+        assert tokens[-1].next is None
+        for i in range(len(tokens) - 1):
+            assert tokens[i].next is tokens[i + 1]
+            assert tokens[i + 1].previous is tokens[i]
+
+    def test_location(self, sample_cfg):
+        tok = sample_cfg.tokenlist[0]
+        assert tok.str == 'static'
+        assert tok.file.endswith('sample.c')
+        assert tok.linenr == 2
+        assert tok.column == 1
+
+    def test_link(self, sample_cfg):
+        parenthesis = find_token(sample_cfg, '(')
+        assert parenthesis.link.str == ')'
+        assert parenthesis.link.link is parenthesis
+        bracket = find_token(sample_cfg, '[')
+        assert bracket.link.str == ']'
+        brace = find_token(sample_cfg, '{')
+        assert brace.link.str == '}'
+
+    def test_scope(self, sample_cfg):
+        assert sample_cfg.tokenlist[0].scope.type == 'Global'
+        return_tok = find_token(sample_cfg, 'return')
+        assert return_tok.scope.type == 'Function'
+        assert return_tok.scope.className == 'add'
+
+    def test_name_number_flags(self, sample_cfg):
+        name_tok = find_token(sample_cfg, 'main')
+        assert name_tok.isName
+        assert not name_tok.isNumber
+        num_tok = find_token(sample_cfg, '42')
+        assert num_tok.isNumber
+        assert num_tok.isInt
+        assert not num_tok.isFloat
+        float_tok = find_token(sample_cfg, '2.0')
+        assert float_tok.isNumber
+        assert float_tok.isFloat
+
+    def test_operator_flags(self, sample_cfg, sample_cpp_cfg):
+        plus = find_token(sample_cfg, '+')
+        assert plus.isOp
+        assert plus.isArithmeticalOp
+        assign = find_token(sample_cfg, '=')
+        assert assign.isOp
+        assert assign.isAssignmentOp
+        logical = find_token(sample_cpp_cfg, '&&')
+        assert logical.isOp
+        assert logical.isLogicalOp
+        comparison = find_token(sample_cpp_cfg, '>')
+        assert comparison.isOp
+        assert comparison.isComparisonOp
+
+    def test_string_char(self, sample_cpp_cfg):
+        string_tok = find_token(sample_cpp_cfg, '"hello"')
+        assert string_tok.isString
+        assert string_tok.strlen == 5
+        char_tok = find_token(sample_cpp_cfg, "'x'")
+        assert char_tok.isChar
+
+    @pytest.mark.xfail(strict=False,
+                       reason='Tokenizer::dump checks Token::isName() before Token::isBoolean() and '
+                              'eBoolean tokens are names, so type="boolean" is never dumped')
+    def test_boolean(self, sample_cpp_cfg):
+        bool_tok = find_token(sample_cpp_cfg, 'true')
+        assert bool_tok.isBoolean
+
+    def test_cast(self, sample_cpp_cfg):
+        # static_cast<int>(...) is simplified to a C-style cast
+        assert any(tok.isCast for tok in sample_cpp_cfg.tokenlist)
+
+    def test_macro_expansion(self, sample_cfg):
+        tok = find_token(sample_cfg, '42')
+        assert tok.isExpandedMacro
+        assert tok.macroName == 'ANSWER'
+
+    def test_removed_void_parameter(self, sample_cfg):
+        main_tok = find_token(sample_cfg, 'main')
+        assert main_tok.next.isRemovedVoidParameter
+
+    def test_splitted_var_decl(self, sample_cfg):
+        # 'int x = ANSWER;' is simplified to 'int x ; x = 42 ;'
+        assert any(tok.isSplittedVarDeclEq for tok in sample_cfg.tokenlist)
+
+    def test_variable_and_var_id(self, sample_cfg):
+        x_decl = find_token(sample_cfg, 'x')
+        assert x_decl.varId
+        assert x_decl.variable.nameToken is x_decl
+        # all 'x' tokens refer to the same variable and varId
+        for tok in find_tokens(sample_cfg, 'x'):
+            assert tok.varId == x_decl.varId
+            assert tok.variable is x_decl.variable
+
+    def test_function(self, sample_cfg):
+        add_call = find_token(sample_cfg, 'add', skip=1)
+        assert add_call.function
+        assert add_call.function.name == 'add'
+
+    def test_value_type(self, sample_cfg):
+        x_tok = find_token(sample_cfg, 'x')
+        assert x_tok.valueType.type == 'int'
+        assert x_tok.valueType.sign == 'signed'
+        assert x_tok.valueType.pointer == 0
+        assert x_tok.valueType.isIntegral()
+        assert not x_tok.valueType.isFloat()
+        assert not x_tok.valueType.isEnum()
+        d_tok = find_token(sample_cfg, 'd')
+        assert d_tok.valueType.type == 'double'
+        assert d_tok.valueType.isFloat()
+        # in 'arr[0] = ...' the array decays to a pointer
+        arr_use = find_token(sample_cfg, 'arr', skip=1)
+        assert arr_use.valueType.pointer == 1
+
+    def test_value_type_enum(self, sample_cpp_cfg):
+        color_tok = find_token(sample_cpp_cfg, 'color')
+        assert color_tok.valueType.isEnum()
+        assert color_tok.valueType.typeScope.className == 'Color'
+
+    def test_ast(self, sample_cfg):
+        plus = find_token(sample_cfg, '+')
+        assert plus.astOperand1.str == 'a'
+        assert plus.astOperand2.str == 'b'
+        assert plus.astParent.str == 'return'
+        assert plus.isBinaryOp()
+        assert not plus.isUnaryOp('+')
+
+    def test_ast_unary_op(self, sample_cfg):
+        # the '-' in 'int neg = -x;'
+        minus = find_token(sample_cfg, '-')
+        assert minus.isUnaryOp('-')
+        assert not minus.isBinaryOp()
+        assert minus.astOperand1.str == 'x'
+        assert minus.astOperand2 is None
+
+    def test_ast_parents_top(self, sample_cfg):
+        a_tok = find_token(sample_cfg, 'a', skip=1)  # the 'a' in 'return a + b;'
+        assert [tok.str for tok in a_tok.astParents()] == ['+', 'return']
+        assert a_tok.astTop().str == 'return'
+
+    def test_values(self, sample_cfg):
+        # 'x' has the known value 42 when it is used
+        x_use = find_token(sample_cfg, 'x', skip=2)
+        assert x_use.getKnownIntValue() == 42
+        value = x_use.getValue(42)
+        assert value.intvalue == 42
+        assert value.isKnown()
+        assert not value.isPossible()
+        assert x_use.getValue(43) is None
+        assert 'intvalue=42' in repr(value)
+
+    def test_values_possible(self, sample_cfg):
+        # inside add() the argument 'a' has the possible value 42
+        a_use = find_token(sample_cfg, 'a', skip=1)
+        assert a_use.getKnownIntValue() is None
+        value = a_use.getValue(42)
+        assert value is not None
+        assert value.isPossible()
+
+    def test_impossible_values(self, sample_cfg):
+        # impossible values are separated from the possible/known ones
+        arr_tokens = find_tokens(sample_cfg, 'arr')
+        impossible = [v for tok in arr_tokens for v in tok.impossible_values]
+        assert impossible
+        assert all(v.isImpossible() for v in impossible)
+        possible_or_known = [v for tok in arr_tokens for v in tok.values]
+        assert all(not v.isImpossible() for v in possible_or_known)
+
+    def test_forward_backward(self, sample_cfg):
+        add_def = find_token(sample_cfg, 'add')
+        strs = [tok.str for tok in add_def.forward()]
+        assert strs[:4] == ['add', '(', 'int', 'a']
+        end = add_def.tokAt(2)
+        assert [tok.str for tok in add_def.forward(end=end)] == ['add', '(']
+        strs = [tok.str for tok in add_def.backward()]
+        assert strs[:3] == ['add', 'int', 'static']
+        start = sample_cfg.tokenlist[0]
+        assert [tok.str for tok in add_def.backward(start=start)] == ['add', 'int']
+
+    def test_tokAt_linkAt(self, sample_cfg):
+        add_def = find_token(sample_cfg, 'add')
+        assert add_def.tokAt(0) is add_def
+        assert add_def.tokAt(1).str == '('
+        assert add_def.tokAt(-1).str == 'int'
+        assert add_def.linkAt(1).str == ')'
+
+    def test_repr(self, sample_cfg):
+        tok = sample_cfg.tokenlist[0]
+        assert "str='static'" in repr(tok)
+
+
+class TestScope:
+    def test_scopes(self, sample_cfg):
+        types = [scope.type for scope in sample_cfg.scopes]
+        assert types.count('Global') == 1
+        assert types.count('Function') == 3
+
+    def test_global_scope(self, sample_cfg):
+        global_scope = find_scope(sample_cfg, 'Global')
+        assert global_scope.nestedIn is None
+        assert not global_scope.isExecutable
+        assert len(global_scope.nestedList) == 3
+
+    def test_function_scope(self, sample_cfg):
+        scope = find_scope(sample_cfg, 'Function', className='add')
+        assert scope.bodyStart.str == '{'
+        assert scope.bodyEnd.str == '}'
+        assert scope.bodyStart.link is scope.bodyEnd
+        assert scope.nestedIn.type == 'Global'
+        assert scope.function.name == 'add'
+        assert scope.isExecutable
+
+    def test_varlist(self, sample_cfg):
+        scope = find_scope(sample_cfg, 'Function', className='main')
+        names = [var.nameToken.str for var in scope.varlist]
+        assert names == ['x', 'arr', 'neg']
+
+    def test_cpp_scopes(self, sample_cpp_cfg):
+        types = {scope.type for scope in sample_cpp_cfg.scopes}
+        assert {'Global', 'Namespace', 'Class', 'Enum', 'Function', 'If'} <= types
+        assert find_scope(sample_cpp_cfg, 'Namespace', className='ns')
+        assert find_scope(sample_cpp_cfg, 'Class', className='Shape')
+        if_scope = find_scope(sample_cpp_cfg, 'If')
+        assert if_scope.isExecutable
+        class_scope = find_scope(sample_cpp_cfg, 'Class')
+        assert not class_scope.isExecutable
+
+
+class TestFunction:
+    def test_functions(self, sample_cfg):
+        names = {function.name for function in sample_cfg.functions}
+        assert names == {'add', 'half', 'main'}
+
+    def test_arguments(self, sample_cfg):
+        add = find_function(sample_cfg, 'add')
+        assert sorted(add.argument.keys()) == [1, 2]
+        assert add.argument[1].nameToken.str == 'a'
+        assert add.argument[2].nameToken.str == 'b'
+        main = find_function(sample_cfg, 'main')
+        assert main.argument == {}
+
+    def test_attributes(self, sample_cfg):
+        add = find_function(sample_cfg, 'add')
+        assert add.isStatic
+        assert add.type == 'Function'
+        assert add.tokenDef.str == 'add'
+        assert add.token.str == 'add'
+        assert add.nestedIn.type == 'Global'
+        main = find_function(sample_cfg, 'main')
+        assert not main.isStatic
+
+    def test_virtual(self, sample_cpp_cfg):
+        area = find_function(sample_cpp_cfg, 'area')
+        assert area.hasVirtualSpecifier
+        twice = find_function(sample_cpp_cfg, 'twice')
+        assert not twice.hasVirtualSpecifier
+        assert twice.nestedIn.className == 'ns'
+
+
+class TestVariable:
+    def test_local(self, sample_cfg):
+        x = find_variable(sample_cfg, 'x')
+        assert x.access == 'Local'
+        assert x.isLocal
+        assert not x.isArgument
+        assert not x.isGlobal
+        assert not x.isArray
+        assert x.typeStartToken.str == 'int'
+        assert x.typeEndToken.str == 'int'
+        assert x.scope.className == 'main'
+
+    def test_argument(self, sample_cfg):
+        a = find_variable(sample_cfg, 'a')
+        assert a.access == 'Argument'
+        assert a.isArgument
+        assert not a.isLocal
+
+    def test_array(self, sample_cfg):
+        arr = find_variable(sample_cfg, 'arr')
+        assert arr.isArray
+        assert not arr.isPointer
+
+    def test_global_const(self, sample_cpp_cfg):
+        limit = find_variable(sample_cpp_cfg, 'limit')
+        assert limit.access == 'Global'
+        assert limit.isGlobal
+        assert limit.isConst
+        assert not limit.isStatic
+
+    def test_pointer(self, sample_cpp_cfg):
+        msg = find_variable(sample_cpp_cfg, 'msg')
+        assert msg.isPointer
+        assert not msg.isArray
+
+    def test_class_member(self, sample_cpp_cfg):
+        member = find_variable(sample_cpp_cfg, 'mScale')
+        assert member.access == 'Protected'
+        assert member.isClass is False
+
+
+class TestPreprocessor:
+    def test_directives(self, sample_cfg):
+        directives = sample_cfg.directives
+        assert len(directives) == 1
+        assert directives[0].str == '#define ANSWER 42'
+        assert directives[0].file.endswith('sample.c')
+        assert directives[0].linenr == 1
+        assert "#define ANSWER 42" in repr(directives[0])
+
+    def test_macro_usage(self, sample_cfg):
+        macros = sample_cfg.macro_usage
+        assert len(macros) == 1
+        macro = macros[0]
+        assert macro.name == 'ANSWER'
+        assert macro.usefile.endswith('sample.c')
+        assert int(macro.useline) == 14
+        assert macro.isKnownValue
+        assert "name='ANSWER'" in repr(macro)
+
+    def test_if_conditions(self, multi_cfg_data):
+        cfgs = multi_cfg_data.configurations
+        for cfg in cfgs:
+            assert len(cfg.preprocessor_if_conditions) == 1
+            assert cfg.preprocessor_if_conditions[0].linenr == 3
+        assert cfgs[0].preprocessor_if_conditions[0].result == 0
+        assert cfgs[1].preprocessor_if_conditions[0].result == 1
+        assert 'result=' in repr(cfgs[0].preprocessor_if_conditions[0])
+
+    def test_typedef_info(self, multi_cfg_data):
+        cfg = multi_cfg_data.configurations[0]
+        typedefs = {info.name: info for info in cfg.typedefInfo}
+        assert set(typedefs.keys()) == {'myint', 'myfloat'}
+        assert typedefs['myint'].used
+        assert not typedefs['myfloat'].used
+        assert typedefs['myint'].linenr == 1
+
+
+class TestHelperFunctions:
+    def test_getArguments(self, sample_cfg):
+        add_call = find_token(sample_cfg, 'add', skip=1)
+        args = cppcheckdata.getArguments(add_call)
+        assert [tok.str for tok in args] == ['x', '1']
+
+    def test_getArguments_no_call(self, sample_cfg):
+        int_tok = find_token(sample_cfg, 'int')
+        assert cppcheckdata.getArguments(int_tok) is None
+
+    def test_get_function_call_name_args(self, sample_cfg):
+        add_call = find_token(sample_cfg, 'add', skip=1)
+        name, args = cppcheckdata.get_function_call_name_args(add_call)
+        assert name == 'add'
+        assert [tok.str for tok in args] == ['x', '1']
+
+    def test_get_function_call_name_args_namespace(self, sample_cpp_cfg):
+        twice_call = find_token(sample_cpp_cfg, 'twice', skip=1)
+        name, args = cppcheckdata.get_function_call_name_args(twice_call)
+        assert name == 'ns::twice'
+        assert [tok.str for tok in args] == ['21']
+
+    def test_get_function_call_name_args_not_a_call(self, sample_cfg):
+        # the function definition is not a call
+        add_def = find_token(sample_cfg, 'add')
+        name, args = cppcheckdata.get_function_call_name_args(add_def)
+        assert name is None
+        assert args is None
+
+    def test_astIsFloat(self, sample_cfg):
+        division = find_token(sample_cfg, '/')
+        assert cppcheckdata.astIsFloat(division)
+        plus = find_token(sample_cfg, '+')  # a + b with int operands
+        assert not cppcheckdata.astIsFloat(plus)
+        assert not cppcheckdata.astIsFloat(None)
+
+
+class TestMatch:
+    """Tests for the cppcheckdata.match()/simpleMatch() pattern matching."""
+
+    def test_simpleMatch(self, match_cfg):
+        calc_def = find_token(match_cfg, 'calc')
+        assert cppcheckdata.simpleMatch(calc_def, 'calc')
+        assert cppcheckdata.simpleMatch(calc_def, 'calc ( int a , int b )')
+        assert not cppcheckdata.simpleMatch(calc_def, 'calc ( int b')
+        assert not cppcheckdata.simpleMatch(None, 'calc')
+
+    def test_literal_sequence(self, match_cfg):
+        calc_def = find_token(match_cfg, 'calc')
+        assert cppcheckdata.match(calc_def, 'calc ( int')
+        assert cppcheckdata.match(calc_def, 'calc ( int a , int b )')
+        assert not cppcheckdata.match(calc_def, 'calc ( char')
+        # the match is anchored at the given token
+        assert not cppcheckdata.match(calc_def, 'int calc')
+
+    def test_empty_pattern_and_no_token(self, match_cfg):
+        calc_def = find_token(match_cfg, 'calc')
+        assert not cppcheckdata.match(calc_def, '')
+        assert not cppcheckdata.match(None, 'calc')
+
+    def test_end(self, match_cfg):
+        calc_def = find_token(match_cfg, 'calc')
+        res = cppcheckdata.match(calc_def, 'calc')
+        assert res.end is calc_def
+        res = cppcheckdata.match(calc_def, 'calc ( int')
+        assert res.end.str == 'int'
+
+    # ---- literal operator tokens ----
+
+    def test_literal_bitwise_or(self, match_cfg):
+        # a literal '|' in the pattern matches a '|' token ...
+        bit_or = find_token(match_cfg, '|')
+        assert cppcheckdata.match(bit_or, '|')
+        assert cppcheckdata.match(bit_or.previous, '%var% | %var% ;')
+        # ... but not a '||' token, and it is not an either-or alternation
+        log_or = find_token(match_cfg, '||')
+        assert not cppcheckdata.match(log_or, '|')
+
+    def test_literal_logical_or(self, match_cfg):
+        log_or = find_token(match_cfg, '||')
+        assert cppcheckdata.match(log_or, '||')
+        assert cppcheckdata.match(log_or.previous, '%var% || %var% ;')
+        bit_or = find_token(match_cfg, '|')
+        assert not cppcheckdata.match(bit_or, '||')
+
+    def test_literal_not(self, match_cfg):
+        not_tok = find_token(match_cfg, '!')
+        assert cppcheckdata.match(not_tok, '! %var% ;')
+        assert not cppcheckdata.match(find_token(match_cfg, '!='), '!')
+
+    def test_literal_not_equal(self, match_cfg):
+        neq = find_token(match_cfg, '!=')
+        assert cppcheckdata.match(neq, '!=')
+        assert cppcheckdata.match(neq.previous, '%var% != %var% ;')
+        assert not cppcheckdata.match(find_token(match_cfg, '='), '!=')
+        assert not cppcheckdata.match(neq, '=')
+
+    def test_literal_star(self, match_cfg):
+        mul = find_token(match_cfg, '*')
+        assert cppcheckdata.match(mul, '*')
+        assert cppcheckdata.match(mul.previous, '%var% * %var% ;')
+
+    def test_literal_percent(self, match_cfg):
+        mod = find_token(match_cfg, '%')
+        assert cppcheckdata.match(mod, '%')
+        assert cppcheckdata.match(mod.previous, '%var% % %var% ;')
+
+    def test_literal_parentheses(self, match_cfg):
+        calc_call = find_token(match_cfg, 'calc', skip=1)
+        assert cppcheckdata.match(calc_call, 'calc ( %var% , %var% ) ;')
+
+    # ---- %keyword% patterns ----
+
+    def test_any(self, match_cfg):
+        for token_str in ('calc', '(', '3', ';', '|', '{'):
+            assert cppcheckdata.match(find_token(match_cfg, token_str), '%any%')
+        plus_assign = find_token(match_cfg, '+=')
+        assert cppcheckdata.match(plus_assign, '%assign% %any% ;')
+
+    def test_assign(self, match_cfg):
+        assert cppcheckdata.match(find_token(match_cfg, '='), '%assign%')
+        assert cppcheckdata.match(find_token(match_cfg, '+='), '%assign%')
+        assert not cppcheckdata.match(find_token(match_cfg, '!='), '%assign%')
+        assert not cppcheckdata.match(find_token(match_cfg, '|'), '%assign%')
+
+    def test_comp(self, match_cfg):
+        assert cppcheckdata.match(find_token(match_cfg, '>'), '%comp%')
+        assert cppcheckdata.match(find_token(match_cfg, '!='), '%comp%')
+        assert not cppcheckdata.match(find_token(match_cfg, '='), '%comp%')
+        assert not cppcheckdata.match(find_token(match_cfg, '|'), '%comp%')
+
+    def test_name(self, match_cfg):
+        assert cppcheckdata.match(find_token(match_cfg, 'calc'), '%name%')
+        assert cppcheckdata.match(find_token(match_cfg, 'int'), '%name%')
+        assert not cppcheckdata.match(find_token(match_cfg, '3'), '%name%')
+        assert not cppcheckdata.match(find_token(match_cfg, '('), '%name%')
+
+    def test_op(self, match_cfg):
+        for op in ('|', '||', '*', '%', '!=', '>', '=', '+='):
+            assert cppcheckdata.match(find_token(match_cfg, op), '%op%'), op
+        assert not cppcheckdata.match(find_token(match_cfg, ';'), '%op%')
+        assert not cppcheckdata.match(find_token(match_cfg, 'calc'), '%op%')
+
+    def test_or(self, match_cfg):
+        assert cppcheckdata.match(find_token(match_cfg, '|'), '%or%')
+        assert not cppcheckdata.match(find_token(match_cfg, '||'), '%or%')
+
+    def test_oror(self, match_cfg):
+        assert cppcheckdata.match(find_token(match_cfg, '||'), '%oror%')
+        assert not cppcheckdata.match(find_token(match_cfg, '|'), '%oror%')
+
+    def test_var(self, match_cfg):
+        a_use = find_token(match_cfg, 'a', skip=1)
+        assert cppcheckdata.match(a_use, '%var%')
+        # a function name is a %name% but not a %var%
+        assert not cppcheckdata.match(find_token(match_cfg, 'calc'), '%var%')
+        assert not cppcheckdata.match(find_token(match_cfg, '3'), '%var%')
+
+    # ---- link patterns ----
+
+    def test_link_parentheses(self, match_cfg):
+        calc_call = find_token(match_cfg, 'calc', skip=1)
+        res = cppcheckdata.match(calc_call.next, '(*)')
+        assert res
+        assert res.end.str == ')'
+        assert res.end is calc_call.next.link
+        # the pattern continues after the linked token
+        assert cppcheckdata.match(calc_call, '%name% (*) ;')
+        # '(*)' only matches at a '(' token
+        assert not cppcheckdata.match(calc_call, '(*)')
+
+    def test_link_brackets(self, match_cfg):
+        arr_decl = find_token(match_cfg, 'arr')
+        assert cppcheckdata.match(arr_decl, 'arr [*] ;')
+        arr_use = find_token(match_cfg, 'arr', skip=1)
+        res = cppcheckdata.match(arr_use, '%name% [*] %assign% %var% ;')
+        assert res
+
+    def test_link_braces(self, match_cfg):
+        if_scope = find_scope(match_cfg, 'If')
+        res = cppcheckdata.match(if_scope.bodyStart, '{*}')
+        assert res
+        assert res.end is if_scope.bodyEnd
+
+    def test_link_combined(self, match_cfg):
+        if_tok = find_token(match_cfg, 'if')
+        res = cppcheckdata.match(if_tok, 'if (*) {*}')
+        assert res
+        assert res.end.str == '}'
+
+    def test_link_angle_brackets(self, match_cpp_cfg):
+        # the '<' of 'std::vector<int>' is linked to the '>'
+        template_lt = find_token(match_cpp_cfg, '<')
+        assert template_lt.link
+        res = cppcheckdata.match(template_lt, '<*>')
+        assert res
+        assert res.end.str == '>'
+        assert cppcheckdata.match(template_lt.previous, 'vector <*> %var%')
+        # the '<' in 'i < j' is a comparison without a link
+        comparison_lt = find_token(match_cpp_cfg, '<', skip=1)
+        assert comparison_lt.link is None
+        assert not cppcheckdata.match(comparison_lt, '<*>')
+
+    # ---- either-or alternation ----
+
+    def test_alternatives(self, match_cfg):
+        struct_tok = find_token(match_cfg, 'struct')
+        assert cppcheckdata.match(struct_tok, 'struct|class %name% {')
+        assert not cppcheckdata.match(struct_tok, 'union|enum %name% {')
+
+    def test_alternatives_cpp(self, match_cpp_cfg):
+        class_tok = find_token(match_cpp_cfg, 'class')
+        assert cppcheckdata.match(class_tok, 'struct|class %name% {')
+
+    def test_alternatives_with_keyword(self, match_cfg):
+        struct_tok = find_token(match_cfg, 'struct')
+        assert cppcheckdata.match(struct_tok, '%op%|struct')
+        assert not cppcheckdata.match(struct_tok, '%op%|%comp%')
+
+    # ---- negation ----
+
+    def test_negation(self, match_cfg):
+        struct_tok = find_token(match_cfg, 'struct')
+        assert cppcheckdata.match(struct_tok, 'struct !!;')
+        assert not cppcheckdata.match(struct_tok, 'struct !!Point')
+
+    def test_negation_keyword(self, match_cfg):
+        calc_call = find_token(match_cfg, 'calc', skip=1)
+        assert cppcheckdata.match(calc_call, '%name% !!%op%')
+        assert not cppcheckdata.match(calc_call, '%name% !!(')
+
+    @pytest.mark.xfail(strict=False,
+                       reason='in the C++ Token::Match a negation also matches when there is no token, '
+                              'in match() it does not')
+    def test_negation_no_token(self, match_cfg):
+        last = match_cfg.tokenlist[-1]
+        assert last.str == '}'
+        assert cppcheckdata.match(last, '} !!x')
+
+    # ---- bindings ----
+
+    def test_bindings(self, match_cfg):
+        calc_call = find_token(match_cfg, 'calc', skip=1)
+        res = cppcheckdata.match(calc_call, '%name%@ftok (*)')
+        assert res
+        assert res.ftok is calc_call
+        assert res.ftok.str == 'calc'
+        assert res.end.str == ')'
+
+    def test_multiple_bindings(self, match_cfg):
+        bit_or_lhs = find_token(match_cfg, 'bit_or', skip=1)
+        res = cppcheckdata.match(bit_or_lhs, '%var%@lhs = %var%@op1 | %var%@op2 ;')
+        assert res
+        assert res.lhs.str == 'bit_or'
+        assert res.op1.str == 'a'
+        assert res.op2.str == 'b'
+
+    def test_binding_on_link_pattern(self, match_cfg):
+        calc_call = find_token(match_cfg, 'calc', skip=1)
+        # the binding is the '(' token, end is behind the linked ')'
+        res = cppcheckdata.match(calc_call, '%name% (*)@paren')
+        assert res
+        assert res.paren.str == '('
+        assert res.paren.link is res.end
+
+    def test_bindings_on_failure(self, match_cfg):
+        calc_call = find_token(match_cfg, 'calc', skip=1)
+        res = cppcheckdata.match(calc_call, '%name%@ftok [*]@brackets')
+        assert not res
+        # all bindings (including 'end') read as None on a failed match
+        assert res.ftok is None
+        assert res.brackets is None
+        assert res.end is None
+
+    def test_unknown_binding_raises(self, match_cfg):
+        calc_call = find_token(match_cfg, 'calc', skip=1)
+        res = cppcheckdata.match(calc_call, '%name%@ftok (*)')
+        assert res
+        with pytest.raises(AttributeError):
+            res.nosuchbinding # pylint: disable=W0104
+        res = cppcheckdata.match(calc_call, '%name%@ftok [*]')
+        assert not res
+        with pytest.raises(AttributeError):
+            res.nosuchbinding # pylint: disable=W0104
+
+    # ---- '**' forward search ----
+
+    def test_find_forward(self, match_cfg):
+        calc_def = find_token(match_cfg, 'calc')
+        # '**' searches forward, skipping linked groups: the '{' found here
+        # is the function body, not a '{' inside the parameter list
+        res = cppcheckdata.match(calc_def, 'calc **{')
+        assert res
+        assert res.end.str == '{'
+        assert not cppcheckdata.match(calc_def, 'calc **nosuchtoken')
+
+
+class TestSuppressions:
+    def make_suppression(self, **kwargs):
+        return cppcheckdata.Suppression(kwargs)
+
+    def test_line_suppression(self):
+        supp = self.make_suppression(errorId='zerodiv', lineNumber='5')
+        assert supp.isMatch('a.c', '5', 'msg', 'zerodiv')
+        assert not supp.isMatch('a.c', '5', 'msg', 'nullPointer')
+
+    @pytest.mark.xfail(strict=False,
+                       reason='the "other suppression" fallback in Suppression.isMatch() does not check '
+                              'that lineNumber is unset, so a line suppression matches every line')
+    def test_line_suppression_other_line(self):
+        supp = self.make_suppression(errorId='zerodiv', lineNumber='5')
+        assert not supp.isMatch('a.c', '6', 'msg', 'zerodiv')
+
+    def test_wildcard_errorId(self):
+        supp = self.make_suppression(errorId='*', lineNumber='5')
+        assert supp.isMatch('a.c', '5', 'msg', 'anything')
+
+    def test_file_suppression(self):
+        supp = self.make_suppression(errorId='zerodiv', fileName='a.c', type='file')
+        assert supp.isMatch('a.c', '1', 'msg', 'zerodiv')
+        assert supp.isMatch('a.c', '99', 'msg', 'zerodiv')
+        assert not supp.isMatch('b.c', '1', 'msg', 'zerodiv')
+
+    def test_block_suppression(self):
+        supp = self.make_suppression(errorId='zerodiv', type='block', lineBegin='3', lineEnd='7')
+        assert supp.isMatch('a.c', '5', 'msg', 'zerodiv')
+        assert not supp.isMatch('a.c', '3', 'msg', 'zerodiv')
+        assert not supp.isMatch('a.c', '7', 'msg', 'zerodiv')
+
+    def test_global_suppression(self):
+        supp = self.make_suppression(errorId='zerodiv')
+        assert supp.isMatch('a.c', '1', 'msg', 'zerodiv')
+        assert supp.isMatch('b.c', '99', 'other', 'zerodiv')
+
+    def test_symbolName(self):
+        supp = self.make_suppression(errorId='zerodiv', symbolName='xyz')
+        assert supp.isMatch('a.c', '1', 'error on xyz here', 'zerodiv')
+        assert not supp.isMatch('a.c', '1', 'other message', 'zerodiv')
+
+    def test_dumpfile_suppressions(self, dump_factory):
+        code = ('void f(void)\n'
+                '{\n'
+                '    int a;\n'
+                '    // cppcheck-suppress uninitvar\n'
+                '    a++;\n'
+                '}\n')
+        data = dump_factory.parse(code, extra_args=['--inline-suppr'])
+        assert len(data.suppressions) == 1
+        supp = data.suppressions[0]
+        assert supp.errorId == 'uninitvar'
+        assert supp.fileName.endswith('test.c')
+        assert int(supp.lineNumber) == 5
+        # parsedump() also sets the suppressions used by is_suppressed()
+        location = cppcheckdata.Location({'file': supp.fileName, 'line': '5', 'column': '5'})
+        assert cppcheckdata.is_suppressed(location, 'msg', 'uninitvar')
+        assert not cppcheckdata.is_suppressed(location, 'msg', 'nullPointer')
+        # NOTE: a non-matching line is not checked here - see test_line_suppression_other_line
+
+
+class TestPureHelpers:
+    """Tests that construct objects from dicts and do not need a dump file."""
+
+    def test_location(self):
+        loc = cppcheckdata.Location({'file': 'a.c', 'line': '3', 'column': '7'})
+        assert loc.file == 'a.c'
+        assert loc.linenr == 3
+        assert loc.column == 7
+
+    def test_location_defaults(self):
+        loc = cppcheckdata.Location({'file': 'a.c'})
+        assert loc.linenr == 0
+        assert loc.column == 0
+
+    def test_location_linenr_alias(self):
+        loc = cppcheckdata.Location({'file': 'a.c', 'linenr': '4'})
+        assert loc.linenr == 4
+
+    def test_value_kinds(self):
+        known = cppcheckdata.Value({'intvalue': '42', 'known': 'true'})
+        assert known.intvalue == 42
+        assert known.isKnown()
+        assert not known.isPossible()
+        possible = cppcheckdata.Value({'intvalue': '1', 'possible': 'true'})
+        assert possible.isPossible()
+        impossible = cppcheckdata.Value({'intvalue': '0', 'impossible': 'true'})
+        assert impossible.isImpossible()
+        inconclusive = cppcheckdata.Value({'intvalue': '2', 'inconclusive': 'true'})
+        assert inconclusive.isInconclusive()
+
+    def test_value_condition(self):
+        value = cppcheckdata.Value({'intvalue': '1', 'possible': 'true', 'condition-line': '12'})
+        assert value.condition == 12
+
+    def test_argument_parser(self):
+        parser = cppcheckdata.ArgumentParser()
+        args = parser.parse_args(['a.dump', 'b.ctu-info', '--cli', '-q'])
+        assert args.dumpfile == ['a.dump', 'b.ctu-info']
+        assert args.cli
+        assert args.quiet
+        assert args.file_list is None
+        assert '{severity}' in args.template
+
+    def test_get_files(self, tmp_path):
+        file_list = tmp_path / 'files.txt'
+        file_list.write_text('c.dump\nd.ctu-info\n')
+        parser = cppcheckdata.ArgumentParser()
+        args = parser.parse_args(['a.dump', 'b.ctu-info', '--file-list', str(file_list)])
+        dump_files, ctu_info_files = cppcheckdata.get_files(args)
+        assert dump_files == ['a.dump', 'c.dump']
+        assert ctu_info_files == ['b.ctu-info', 'd.ctu-info']
+
+
+class TestReporting:
+    def test_reportError_cli(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, 'argv', ['myaddon.py', '--cli'])
+        location = cppcheckdata.Location({'file': 'a.c', 'line': '3', 'column': '7'})
+        cppcheckdata.reportError(location, 'error', 'the message', 'myaddon', 'myid', extra='extra info')
+        msg = json.loads(capsys.readouterr().out)
+        assert msg == {'file': 'a.c',
+                       'linenr': 3,
+                       'column': 7,
+                       'severity': 'error',
+                       'message': 'the message',
+                       'addon': 'myaddon',
+                       'errorId': 'myid',
+                       'extra': 'extra info'}
+
+    def test_reportError_cli_column_override(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, 'argv', ['myaddon.py', '--cli'])
+        location = cppcheckdata.Location({'file': 'a.c', 'line': '3', 'column': '7'})
+        cppcheckdata.reportError(location, 'error', 'the message', 'myaddon', 'myid', columnOverride=42)
+        msg = json.loads(capsys.readouterr().out)
+        assert msg['column'] == 42
+
+    def test_reportError_stderr(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, 'argv', ['myaddon.py'])
+        monkeypatch.setattr(cppcheckdata, 'current_dumpfile_suppressions', [])
+        monkeypatch.setattr(cppcheckdata, 'EXIT_CODE', 0)
+        location = cppcheckdata.Location({'file': 'a.c', 'line': '3', 'column': '7'})
+        cppcheckdata.reportError(location, 'style', 'the message', 'myaddon', 'myid')
+        stderr = capsys.readouterr().err
+        assert stderr == '[a.c:3] (style) the message [myaddon-myid]\n'
+        assert cppcheckdata.EXIT_CODE == 1
+
+    def test_reportError_stderr_suppressed(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, 'argv', ['myaddon.py'])
+        suppression = cppcheckdata.Suppression({'errorId': 'myaddon-myid'})
+        monkeypatch.setattr(cppcheckdata, 'current_dumpfile_suppressions', [suppression])
+        monkeypatch.setattr(cppcheckdata, 'EXIT_CODE', 0)
+        location = cppcheckdata.Location({'file': 'a.c', 'line': '3', 'column': '7'})
+        cppcheckdata.reportError(location, 'style', 'the message', 'myaddon', 'myid')
+        assert capsys.readouterr().err == ''
+        assert cppcheckdata.EXIT_CODE == 0
+
+    def test_log_checker_cli(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, 'argv', ['myaddon.py', '--cli'])
+        cppcheckdata.log_checker('SomeChecker', 'myaddon')
+        msg = json.loads(capsys.readouterr().out)
+        assert msg == {'addon': 'myaddon',
+                       'severity': 'none',
+                       'message': 'SomeChecker',
+                       'errorId': 'logChecker'}
+
+    def test_log_checker_no_cli(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, 'argv', ['myaddon.py'])
+        cppcheckdata.log_checker('SomeChecker', 'myaddon')
+        assert capsys.readouterr().out == ''
diff --git a/test/cli/performance_test.py b/test/cli/performance_test.py
index 5be958619fc..67ec3be09f6 100644
--- a/test/cli/performance_test.py
+++ b/test/cli/performance_test.py
@@ -268,7 +268,7 @@ def test_crash_array_in_namespace(tmpdir):
 
 
 @pytest.mark.skipif(sys.platform == 'darwin', reason='GitHub macOS runners are too slow')
-@pytest.mark.timeout(20)
+@pytest.mark.timeout(30)
 def test_crash_array_in_array(tmpdir):
     # 12861
     filename = os.path.join(tmpdir, 'hang.cpp')

From 569f3d6a38aa3afadc2e4791c0fce939a3ee379d Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Tue, 4 Aug 2026 18:14:48 +0200
Subject: [PATCH 30/59] Fix #14952 Stack overflow in
 ValueFlow::isLifetimeBorrowed() (#8770)

---
 lib/token.cpp          |  1 +
 lib/valueflow.cpp      |  2 +-
 test/testvalueflow.cpp | 11 +++++++++++
 3 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/lib/token.cpp b/lib/token.cpp
index d8b438c5073..eac69decee7 100644
--- a/lib/token.cpp
+++ b/lib/token.cpp
@@ -2433,6 +2433,7 @@ std::pair<const Token*, const Token*> Token::typeDecl(const Token* tok, bool poi
                     varTok = varTok->next();
                 while (Token::Match(varTok, "%name% ::"))
                     varTok = varTok->tokAt(2);
+                assert(varTok != tok);
                 std::pair<const Token*, const Token*> r = typeDecl(varTok);
                 if (r.first)
                     return r;
diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
index 29eb07bcc90..5efe698bf61 100644
--- a/lib/valueflow.cpp
+++ b/lib/valueflow.cpp
@@ -3146,7 +3146,7 @@ static void valueFlowLifetime(TokenList &tokenlist, ErrorLogger &errorLogger, co
             valueFlowLifetimeConstructor(tok->next(), tokenlist, errorLogger, settings);
         }
         // Check function calls
-        else if (Token::Match(tok, "%name% (") && !Token::simpleMatch(tok->linkAt(1), ") {")) {
+        else if (tok->scope()->isExecutable() && Token::Match(tok, "%name% (")) {
             valueFlowLifetimeFunction(tok, tokenlist, errorLogger, settings);
         }
         // Unique pointer lifetimes
diff --git a/test/testvalueflow.cpp b/test/testvalueflow.cpp
index f92ddee3685..945555b1b3c 100644
--- a/test/testvalueflow.cpp
+++ b/test/testvalueflow.cpp
@@ -8481,6 +8481,17 @@ class TestValueFlow : public TestFixture {
                "    auto b = a;\n"
                "}\n";
         (void)valueOfTok(code, "b");
+
+        code = "namespace O {}\n" // #14952
+               "namespace N {\n"
+               "    using namespace O;\n"
+               "    enum class E { E0 };\n"
+               "    auto E0 = E::E0;\n"
+               "    struct S {\n"
+               "        E f() const { return E0; }\n"
+               "    };\n"
+               "}\n";
+        (void)valueOfTok(code, "E0");
     }
 
     void valueFlowHang() {

From 9408a1d22dc8c2281d7ce1b370c273b9118cef60 Mon Sep 17 00:00:00 2001
From: Robert Reif <reif@earthlink.net>
Date: Tue, 4 Aug 2026 15:21:45 -0400
Subject: [PATCH 31/59] add support for vcxproj ExcludedFromBuild (#8771)

CMake generates a vcxproj file for the cppcheck GUI that has generated
files for all configurations but adds ExcludedFromBuild so the files
only gets compiled for a specific configuration.
```
<ClCompile Include="C:\Users\Bob\forks\cppcheck\build\gui\cppcheck-gui_autogen\mocs_compilation_Debug.cpp">
  <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
  <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|x64'">true</ExcludedFromBuild>
  <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|x64'">true</ExcludedFromBuild>
</ClCompile>
```
This patch adds support for ExcludedFromBuild so a file only gets
checked for a specific configuration.
---
 lib/importproject.cpp             | 69 +++++++++++++++++------
 test/cli/exclude/DebugX64.cpp     |  8 +++
 test/cli/exclude/ReleaseX64.cpp   |  8 +++
 test/cli/exclude/exclude.cppcheck | 16 ++++++
 test/cli/exclude/exclude.slnx     |  6 ++
 test/cli/exclude/exclude.vcxproj  | 94 +++++++++++++++++++++++++++++++
 test/cli/exclude/foo.h            |  1 +
 test/cli/exclude_test.py          | 20 +++++++
 8 files changed, 206 insertions(+), 16 deletions(-)
 create mode 100644 test/cli/exclude/DebugX64.cpp
 create mode 100644 test/cli/exclude/ReleaseX64.cpp
 create mode 100644 test/cli/exclude/exclude.cppcheck
 create mode 100644 test/cli/exclude/exclude.slnx
 create mode 100644 test/cli/exclude/exclude.vcxproj
 create mode 100644 test/cli/exclude/foo.h
 create mode 100644 test/cli/exclude_test.py

diff --git a/lib/importproject.cpp b/lib/importproject.cpp
index 242c1719ba9..5c9bcaadd3f 100644
--- a/lib/importproject.cpp
+++ b/lib/importproject.cpp
@@ -617,12 +617,13 @@ namespace {
         std::string platformStr;
     };
 
-    struct ConditionalGroup {
-        explicit ConditionalGroup(const tinyxml2::XMLElement *idg){
+    struct Conditional {
+        explicit Conditional(const tinyxml2::XMLElement *idg){
             const char *condAttr = idg->Attribute("Condition");
             if (condAttr)
                 mCondition = condAttr;
         }
+        explicit Conditional(std::string condition) : mCondition(std::move(condition)) {}
 
         static void replaceAll(std::string &c, const std::string &from, const std::string &to) {
             std::string::size_type pos;
@@ -751,8 +752,8 @@ namespace {
         std::string mCondition;
     };
 
-    struct ItemDefinitionGroup : ConditionalGroup {
-        explicit ItemDefinitionGroup(const tinyxml2::XMLElement *idg, std::string includePaths) : ConditionalGroup(idg), additionalIncludePaths(std::move(includePaths)) {
+    struct ItemDefinitionGroup : Conditional {
+        explicit ItemDefinitionGroup(const tinyxml2::XMLElement *idg, std::string includePaths) : Conditional(idg), additionalIncludePaths(std::move(includePaths)) {
             for (const tinyxml2::XMLElement *e1 = idg->FirstChildElement(); e1; e1 = e1->NextSiblingElement()) {
                 const char* name = e1->Name();
                 if (std::strcmp(name, "ClCompile") == 0) {
@@ -802,8 +803,8 @@ namespace {
         Standards::cppstd_t cppstd = Standards::CPPLatest;
     };
 
-    struct ConfigurationPropertyGroup : ConditionalGroup {
-        explicit ConfigurationPropertyGroup(const tinyxml2::XMLElement *idg) : ConditionalGroup(idg) {
+    struct ConfigurationPropertyGroup : Conditional {
+        explicit ConfigurationPropertyGroup(const tinyxml2::XMLElement *idg) : Conditional(idg) {
             for (const tinyxml2::XMLElement *e = idg->FirstChildElement(); e; e = e->NextSiblingElement()) {
                 if (std::strcmp(e->Name(), "UseOfMfc") == 0) {
                     useOfMfc = true;
@@ -816,6 +817,37 @@ namespace {
         bool useOfMfc = false;
         bool useUnicode = false;
     };
+
+    struct ItemGroupClCompile {
+        explicit ItemGroupClCompile(std::string filename) : mFilename(std::move(filename)) {}
+        ItemGroupClCompile(const tinyxml2::XMLElement *element, std::string file) : mFilename(std::move(file)) {
+            for (const tinyxml2::XMLElement* childElement = element->FirstChildElement(); childElement; childElement = childElement->NextSiblingElement()) {
+                const char *name = childElement->Name();
+                if (!name)
+                    continue;
+                if (std::strcmp(name, "ExcludedFromBuild") == 0) {
+                    const char *condition = childElement->Attribute("Condition");
+                    const char *text = childElement->GetText();
+                    if (!condition || !text || std::strcmp(text, "true") != 0)
+                        continue;
+                    mConditions.emplace_back(condition);
+                }
+                // TODO: ForcedIncludeFiles and PrecompiledHeaderFile
+            }
+        }
+        bool exclude(const ProjectConfiguration& p, std::vector<std::string>& errors) const {
+            if (mConditions.empty())
+                return false;
+            for (const std::string& condition : mConditions) {
+                Conditional conditional(condition);
+                if (conditional.conditionIsTrue(p, mFilename, errors))
+                    return true;
+            }
+            return false;
+        }
+        std::string mFilename;
+        std::list<std::string> mConditions;
+    };
 }
 
 static std::list<std::string> toStringList(const std::string &s)
@@ -923,7 +955,7 @@ bool ImportProject::importVcxproj(const std::string &filename, const tinyxml2::X
     variables["ProjectDir"] = Path::simplifyPath(Path::getPathFromFilename(filename));
 
     std::list<ProjectConfiguration> projectConfigurationList;
-    std::list<std::string> compileList;
+    std::list<ItemGroupClCompile> compileList;
     std::list<ItemDefinitionGroup> itemDefinitionGroupList;
     std::vector<ConfigurationPropertyGroup> configurationPropertyGroups;
     std::string includePath;
@@ -954,7 +986,8 @@ bool ImportProject::importVcxproj(const std::string &filename, const tinyxml2::X
                         const char *include = e->Attribute("Include");
                         if (include && Path::acceptFile(include)) {
                             std::string toInclude = Path::simplifyPath(Path::isAbsolute(include) ? include : Path::getPathFromFilename(filename) + include);
-                            compileList.emplace_back(toInclude);
+                            findAndReplace(toInclude, "$(MSBuildThisFileDirectory)", "./");
+                            compileList.emplace_back(e, toInclude);
                         }
                     }
                 }
@@ -1016,7 +1049,7 @@ bool ImportProject::importVcxproj(const std::string &filename, const tinyxml2::X
     for (const auto& sharedProject : sharedItemsProjects) {
         for (const auto &file : sharedProject.sourceFiles) {
             std::string pathToFile = Path::simplifyPath(Path::getPathFromFilename(sharedProject.pathToProjectFile) + file);
-            compileList.emplace_back(std::move(pathToFile));
+            compileList.emplace_back(pathToFile);
         }
         for (const auto &p : sharedProject.includePaths) {
             std::string path = Path::simplifyPath(Path::getPathFromFilename(sharedProject.pathToProjectFile) + p);
@@ -1026,8 +1059,8 @@ bool ImportProject::importVcxproj(const std::string &filename, const tinyxml2::X
 
     // Project files
     PathMatch filtermatcher(fileFilters, Path::getCurrentPath());
-    for (const std::string &cfilename : compileList) {
-        if (!fileFilters.empty() && !filtermatcher.match(cfilename))
+    for (const ItemGroupClCompile& compile : compileList) {
+        if (!fileFilters.empty() && !filtermatcher.match(compile.mFilename))
             continue;
 
         for (const ProjectConfiguration &p : projectConfigurationList) {
@@ -1040,7 +1073,11 @@ bool ImportProject::importVcxproj(const std::string &filename, const tinyxml2::X
                     continue;
             }
 
-            FileSettings fs{cfilename, Standards::Language::None, 0}; // file will be identified later on
+            // check if the file should be excluded for this configuration
+            if (compile.exclude(p, errors))
+                continue;
+
+            FileSettings fs{ compile.mFilename, Standards::Language::None, 0}; // file will be identified later on
             fs.cfg = p.name;
             // TODO: detect actual MSC version
             fs.msc = true;
@@ -1053,7 +1090,7 @@ bool ImportProject::importVcxproj(const std::string &filename, const tinyxml2::X
             }
             std::string additionalIncludePaths;
             for (const ItemDefinitionGroup &i : itemDefinitionGroupList) {
-                if (!i.conditionIsTrue(p, cfilename, errors))
+                if (!i.conditionIsTrue(p, compile.mFilename, errors))
                     continue;
                 fs.standard = Standards::getCPP(i.cppstd);
                 fs.defines += ';' + i.preprocessorDefinitions;
@@ -1071,7 +1108,7 @@ bool ImportProject::importVcxproj(const std::string &filename, const tinyxml2::X
             }
             bool useUnicode = false;
             for (const ConfigurationPropertyGroup &c : configurationPropertyGroups) {
-                if (!c.conditionIsTrue(p, cfilename, errors))
+                if (!c.conditionIsTrue(p, compile.mFilename, errors))
                     continue;
                 // in msbuild the last definition wins
                 useUnicode = c.useUnicode;
@@ -1081,7 +1118,7 @@ bool ImportProject::importVcxproj(const std::string &filename, const tinyxml2::X
                 fs.defines += ";UNICODE=1;_UNICODE=1";
             }
             fsSetDefines(fs, fs.defines);
-            fsSetIncludePaths(fs, Path::getPathFromFilename(filename), toStringList(includePath + ';' + additionalIncludePaths), variables);
+            fsSetIncludePaths(fs, Path::getPathFromFilename(compile.mFilename), toStringList(includePath + ';' + additionalIncludePaths), variables);
             for (const auto &path : sharedItemsIncludePaths) {
                 fs.includePaths.emplace_back(path);
             }
@@ -1754,5 +1791,5 @@ bool cppcheck::testing::evaluateVcxprojCondition(const std::string& condition, c
     ProjectConfiguration p;
     p.configuration = configuration;
     p.platformStr = platform;
-    return ConditionalGroup::evalCondition(condition, p);
+    return Conditional::evalCondition(condition, p);
 }
diff --git a/test/cli/exclude/DebugX64.cpp b/test/cli/exclude/DebugX64.cpp
new file mode 100644
index 00000000000..cfb1fce687a
--- /dev/null
+++ b/test/cli/exclude/DebugX64.cpp
@@ -0,0 +1,8 @@
+#include <iostream>
+
+int foo()
+{
+	std::cout << "DebugX64\n";
+	int x = 3 / 0; (void)x; // ERROR
+	return 0;
+}
diff --git a/test/cli/exclude/ReleaseX64.cpp b/test/cli/exclude/ReleaseX64.cpp
new file mode 100644
index 00000000000..8fa6e6d0f82
--- /dev/null
+++ b/test/cli/exclude/ReleaseX64.cpp
@@ -0,0 +1,8 @@
+#include <iostream>
+
+int foo()
+{
+	std::cout << "ReleaseX64\n";
+	int x = 3 / 0; (void)x; // ERROR
+	return 0;
+}
diff --git a/test/cli/exclude/exclude.cppcheck b/test/cli/exclude/exclude.cppcheck
new file mode 100644
index 00000000000..50d7da84486
--- /dev/null
+++ b/test/cli/exclude/exclude.cppcheck
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="1">
+    <builddir>exclude-cppcheck-build-dir</builddir>
+    <importproject>exclude.slnx</importproject>
+    <analyze-all-vs-configs>false</analyze-all-vs-configs>
+    <check-headers>true</check-headers>
+    <check-unused-templates>true</check-unused-templates>
+    <inline-suppression>true</inline-suppression>
+    <max-ctu-depth>2</max-ctu-depth>
+    <max-template-recursion>100</max-template-recursion>
+    <vs-configurations>
+        <config>Debug</config>
+    </vs-configurations>
+    <check-level-normal/>
+    <project-name>exclude</project-name>
+</project>
diff --git a/test/cli/exclude/exclude.slnx b/test/cli/exclude/exclude.slnx
new file mode 100644
index 00000000000..837662784ac
--- /dev/null
+++ b/test/cli/exclude/exclude.slnx
@@ -0,0 +1,6 @@
+<Solution>
+  <Configurations>
+    <Platform Name="x64" />
+  </Configurations>
+  <Project Path="exclude.vcxproj" Id="c9d1dca1-d8ff-4c05-9159-f00816645319" />
+</Solution>
diff --git a/test/cli/exclude/exclude.vcxproj b/test/cli/exclude/exclude.vcxproj
new file mode 100644
index 00000000000..cc326aaec2f
--- /dev/null
+++ b/test/cli/exclude/exclude.vcxproj
@@ -0,0 +1,94 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>18.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{c9d1dca1-d8ff-4c05-9159-f00816645319}</ProjectGuid>
+    <RootNamespace>exclude</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v145</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v145</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+    <Manifest>
+      <EnableSegmentHeap>true</EnableSegmentHeap>
+    </Manifest>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+    <Manifest>
+      <EnableSegmentHeap>true</EnableSegmentHeap>
+    </Manifest>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="DebugX64.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="ReleaseX64.cpp">
+     <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="foo.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/test/cli/exclude/foo.h b/test/cli/exclude/foo.h
new file mode 100644
index 00000000000..5d5f8f0c9e7
--- /dev/null
+++ b/test/cli/exclude/foo.h
@@ -0,0 +1 @@
+int foo();
diff --git a/test/cli/exclude_test.py b/test/cli/exclude_test.py
new file mode 100644
index 00000000000..4f674aac34e
--- /dev/null
+++ b/test/cli/exclude_test.py
@@ -0,0 +1,20 @@
+
+# python -m pytest exclude_test.py
+
+import os
+
+from testutils import cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+__proj_dir = os.path.join(__script_dir, 'exclude')
+
+def test_exclude():
+    args = [
+        '--template=cppcheck1',
+        '--project=exclude/exclude.cppcheck',
+        '--no-cppcheck-build-dir'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    filename = os.path.join('exclude', 'DebugX64.cpp')
+    assert ret == 0, stdout
+    assert stderr == '[%s:6]: (error) Division by zero.\n' % filename

From 8276218b3da696bf96ff8986b7807aaf48e91ab1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Christoph=20Gr=C3=BCninger?= <foss@grueninger.de>
Date: Wed, 5 Aug 2026 09:11:41 +0200
Subject: [PATCH 32/59] [ci] Update Github actions to latest major release
 (#8756)

---
 .github/workflows/CI-cygwin.yml             |  2 +-
 .github/workflows/CI-mingw.yml              |  2 +-
 .github/workflows/CI-unixish-docker.yml     |  4 ++--
 .github/workflows/CI-unixish.yml            | 22 ++++++++++-----------
 .github/workflows/CI-windows.yml            | 12 +++++------
 .github/workflows/buildman.yml              |  8 ++++----
 .github/workflows/cifuzz.yml                |  2 +-
 .github/workflows/clang-tidy.yml            |  4 ++--
 .github/workflows/codeql-analysis.yml       |  6 +++---
 .github/workflows/corpus.yml                |  4 ++--
 .github/workflows/coverage.yml              |  6 +++---
 .github/workflows/coverity.yml              |  2 +-
 .github/workflows/cppcheck-premium.yml      |  6 +++---
 .github/workflows/format.yml                |  4 ++--
 .github/workflows/iwyu.yml                  | 14 ++++++-------
 .github/workflows/release-windows-mingw.yml |  4 ++--
 .github/workflows/release-windows.yml       | 12 +++++------
 .github/workflows/sanitizers.yml            |  4 ++--
 .github/workflows/scriptcheck.yml           | 12 +++++------
 .github/workflows/selfcheck.yml             |  6 +++---
 .github/workflows/valgrind.yml              |  4 ++--
 21 files changed, 70 insertions(+), 70 deletions(-)

diff --git a/.github/workflows/CI-cygwin.yml b/.github/workflows/CI-cygwin.yml
index bf67967c5f8..6b0ad2cc5bd 100644
--- a/.github/workflows/CI-cygwin.yml
+++ b/.github/workflows/CI-cygwin.yml
@@ -37,7 +37,7 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
diff --git a/.github/workflows/CI-mingw.yml b/.github/workflows/CI-mingw.yml
index 1b0cf3e5672..f308cfa5110 100644
--- a/.github/workflows/CI-mingw.yml
+++ b/.github/workflows/CI-mingw.yml
@@ -33,7 +33,7 @@ jobs:
     timeout-minutes: 19 # max + 3*std of the last 7K runs
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
diff --git a/.github/workflows/CI-unixish-docker.yml b/.github/workflows/CI-unixish-docker.yml
index 16c1615ed04..adf4a74c81b 100644
--- a/.github/workflows/CI-unixish-docker.yml
+++ b/.github/workflows/CI-unixish-docker.yml
@@ -43,7 +43,7 @@ jobs:
       image: ${{ matrix.image }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -96,7 +96,7 @@ jobs:
       image: ${{ matrix.image }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
diff --git a/.github/workflows/CI-unixish.yml b/.github/workflows/CI-unixish.yml
index 8fb5c8d76d6..9bac980c853 100644
--- a/.github/workflows/CI-unixish.yml
+++ b/.github/workflows/CI-unixish.yml
@@ -30,7 +30,7 @@ jobs:
       CCACHE_SLOPPINESS: pch_defines,time_macros
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -85,7 +85,7 @@ jobs:
       CCACHE_SLOPPINESS: pch_defines,time_macros
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -97,7 +97,7 @@ jobs:
       # TODO: move latest compiler to separate step
       # TODO: bail out on warnings with latest GCC
       - name: Set up GCC
-        uses: egor-tensin/setup-gcc@v1
+        uses: egor-tensin/setup-gcc@v2
         if: false  # matrix.os == 'ubuntu-22.04'
         with:
           version: 13
@@ -216,7 +216,7 @@ jobs:
       CCACHE_SLOPPINESS: pch_defines,time_macros
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -265,7 +265,7 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -299,7 +299,7 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -333,7 +333,7 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -361,7 +361,7 @@ jobs:
       CCACHE_SLOPPINESS: pch_defines,time_macros
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -417,7 +417,7 @@ jobs:
       CMAKE_VERSION_FULL: 3.22.6
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -461,7 +461,7 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -712,7 +712,7 @@ jobs:
     runs-on: ubuntu-22.04 # run on the latest image only
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
diff --git a/.github/workflows/CI-windows.yml b/.github/workflows/CI-windows.yml
index a63be4e0ad9..66858c7afbe 100644
--- a/.github/workflows/CI-windows.yml
+++ b/.github/workflows/CI-windows.yml
@@ -31,7 +31,7 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -82,7 +82,7 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -108,7 +108,7 @@ jobs:
       CMAKE_VERSION_FULL: 3.22.6
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -154,13 +154,13 @@ jobs:
       PCRE_VERSION: 8.45
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
       - name: Set up Python
         if: matrix.config == 'release'
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.14'
           check-latest: true
@@ -172,7 +172,7 @@ jobs:
 
       - name: Cache PCRE
         id: cache-pcre
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: |
             externals\pcre.h
diff --git a/.github/workflows/buildman.yml b/.github/workflows/buildman.yml
index b0b399dd851..e84cf4bffd9 100644
--- a/.github/workflows/buildman.yml
+++ b/.github/workflows/buildman.yml
@@ -19,7 +19,7 @@ jobs:
   convert_via_pandoc:
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -38,7 +38,7 @@ jobs:
         with:
           args: --output=output/manual-premium.pdf man/manual-premium.md
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: output
           path: output
@@ -46,7 +46,7 @@ jobs:
   manpage:
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -59,7 +59,7 @@ jobs:
         run: |
           make man
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: cppcheck.1
           path: cppcheck.1
diff --git a/.github/workflows/cifuzz.yml b/.github/workflows/cifuzz.yml
index c54d47da4f1..400fb929786 100644
--- a/.github/workflows/cifuzz.yml
+++ b/.github/workflows/cifuzz.yml
@@ -27,7 +27,7 @@ jobs:
         dry-run: false
         language: c++
     - name: Upload Crash
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v7
       if: failure() && steps.build.outcome == 'success'
       with:
         name: artifacts
diff --git a/.github/workflows/clang-tidy.yml b/.github/workflows/clang-tidy.yml
index 7a5b317693a..4f2db4ab113 100644
--- a/.github/workflows/clang-tidy.yml
+++ b/.github/workflows/clang-tidy.yml
@@ -27,7 +27,7 @@ jobs:
       QT_VERSION: 6.10.0
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -86,7 +86,7 @@ jobs:
         run: |
           cmake --build cmake.output --target run-clang-tidy-csa 2> /dev/null
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         if: success() || failure()
         with:
           name: Compilation Database
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 12e758d2c9e..84d37423d2e 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -33,13 +33,13 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         persist-credentials: false
       
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
+      uses: github/codeql-action/init@v4
       with:
         languages: ${{ matrix.language }}
 
@@ -49,4 +49,4 @@ jobs:
          make -j$(nproc) CXXOPTS="-Werror" HAVE_RULES=yes CPPCHK_GLIBCXX_DEBUG= cppcheck
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
+      uses: github/codeql-action/analyze@v4
diff --git a/.github/workflows/corpus.yml b/.github/workflows/corpus.yml
index 0c1aeda94de..2d9f1424fad 100644
--- a/.github/workflows/corpus.yml
+++ b/.github/workflows/corpus.yml
@@ -16,7 +16,7 @@ jobs:
     if: ${{ github.repository_owner == 'cppcheck-opensource' }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -51,7 +51,7 @@ jobs:
           # print largest size
           ls -l ./store | cut -d' ' -f5 | sort -u -n -r | head -n1
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         if: success()
         with:
           name: corpus
diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index 13f56172a80..b5e496adcf6 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -21,7 +21,7 @@ jobs:
     runs-on: ubuntu-22.04
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -57,12 +57,12 @@ jobs:
           lcov --extract lcov_tmp.info "$(pwd)/*" --output-file lcov.info
           genhtml lcov.info -o coverage_report --frame --legend --demangle-cpp
           
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
          name: Coverage results
          path: coverage_report
          
-      - uses: codecov/codecov-action@v4
+      - uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           # file: ./coverage.xml # optional
diff --git a/.github/workflows/coverity.yml b/.github/workflows/coverity.yml
index 006160c7779..4c62971e4c4 100644
--- a/.github/workflows/coverity.yml
+++ b/.github/workflows/coverity.yml
@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     if: ${{ github.repository_owner == 'cppcheck-opensource' }}
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         persist-credentials: false
     - name: Install missing software on ubuntu
diff --git a/.github/workflows/cppcheck-premium.yml b/.github/workflows/cppcheck-premium.yml
index ed0f2a1bcd5..b99cccd69da 100644
--- a/.github/workflows/cppcheck-premium.yml
+++ b/.github/workflows/cppcheck-premium.yml
@@ -25,7 +25,7 @@ jobs:
   build:
     runs-on: ubuntu-24.04 # run on the latest image only
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -60,13 +60,13 @@ jobs:
           #sed -i 's|"security-severity":.*||' results.sarif
           cat results.sarif
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: results
           path: results.sarif
 
       - name: Upload report
-        uses: github/codeql-action/upload-sarif@v3
+        uses: github/codeql-action/upload-sarif@v4
         with:
           sarif_file: results.sarif
           category: cppcheckpremium
diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
index fd491c0ec0e..4ec72f935fd 100644
--- a/.github/workflows/format.yml
+++ b/.github/workflows/format.yml
@@ -24,12 +24,12 @@ jobs:
       UNCRUSTIFY_VERSION: 0.80.1
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
       - name: Cache uncrustify
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         id: cache-uncrustify
         with:
           path: |
diff --git a/.github/workflows/iwyu.yml b/.github/workflows/iwyu.yml
index de047b8d10a..2e54b92541e 100644
--- a/.github/workflows/iwyu.yml
+++ b/.github/workflows/iwyu.yml
@@ -39,7 +39,7 @@ jobs:
       QT_VERSION: 6.10.0
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -160,13 +160,13 @@ jobs:
           IWYU: include-what-you-use
           IWYU_CLANG_INC: ${{ matrix.clang_inc }}
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         if: success() || failure()
         with:
           name: Compilation Database (include-what-you-use - ${{ matrix.os }} ${{ matrix.stdlib }})
           path: ./cmake.output/compile_commands.json
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         if: ${{ contains(matrix.os, 'macos') && (success() || failure()) }}
         with:
           name: macOS Mappings
@@ -174,7 +174,7 @@ jobs:
             ./iwyu-mapgen-apple-libc.py
             ./macos.imp
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         if: success() || failure()
         with:
           name: Logs (include-what-you-use - ${{ matrix.os }} ${{ matrix.stdlib }})
@@ -199,7 +199,7 @@ jobs:
       QT_VERSION: 6.10.0
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -256,13 +256,13 @@ jobs:
           # TODO: run multi-threaded
           find $PWD/cli $PWD/lib $PWD/test $PWD/gui -maxdepth 1 -name "*.cpp" | xargs -t -n 1 clang-include-cleaner-22 --print=changes --extra-arg=-w --extra-arg=-stdlib=${{ matrix.stdlib }} -p cmake.output > clang-include-cleaner.log 2>&1
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         if: success() || failure()
         with:
           name: Compilation Database (clang-include-cleaner - ${{ matrix.stdlib }})
           path: ./cmake.output/compile_commands.json
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         if: success() || failure()
         with:
           name: Logs (clang-include-cleaner - ${{ matrix.stdlib }})
diff --git a/.github/workflows/release-windows-mingw.yml b/.github/workflows/release-windows-mingw.yml
index 3b9b836347f..8085990e39d 100644
--- a/.github/workflows/release-windows-mingw.yml
+++ b/.github/workflows/release-windows-mingw.yml
@@ -33,7 +33,7 @@ jobs:
     timeout-minutes: 19 # max + 3*std of the last 7K runs
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -63,7 +63,7 @@ jobs:
           cp /mingw64/bin/libstdc*.dll cppcheck-mingw/
           cp /mingw64/bin/libwinpthread-1.dll cppcheck-mingw/
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: cppcheck-mingw
           path: cppcheck-mingw
diff --git a/.github/workflows/release-windows.yml b/.github/workflows/release-windows.yml
index 8d09a55302e..aa467d7b875 100644
--- a/.github/workflows/release-windows.yml
+++ b/.github/workflows/release-windows.yml
@@ -32,7 +32,7 @@ jobs:
       BOOST_MINOR_VERSION: 89
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -95,7 +95,7 @@ jobs:
           del build\bin\Release\cppcheck-gui.ilk || exit /b !errorlevel!
           del build\bin\Release\cppcheck-gui.pdb || exit /b !errorlevel!
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: deploy
           path: build\bin\Release
@@ -109,7 +109,7 @@ jobs:
         env:
           _CL_: /WX
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: bin
           path: bin
@@ -158,7 +158,7 @@ jobs:
           :: copy libcrypto-3-x64.dll and libssl-3-x64.dll
           copy %RUNNER_WORKSPACE%\Qt\Tools\OpenSSLv3\Win_x64\bin\lib*.dll win_installer\files || exit /b !errorlevel!
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: collect
           path: win_installer\files
@@ -173,7 +173,7 @@ jobs:
           @echo ProductVersion="%PRODUCTVER%" || exit /b !errorlevel!
           msbuild -m cppcheck.wixproj -p:Platform=x64,ProductVersion=%PRODUCTVER%.${{ github.run_number }} || exit /b !errorlevel!
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: installer
           path: win_installer/Build/
@@ -209,7 +209,7 @@ jobs:
           del win_installer\files\Qt6Svg.dll || exit /b !errorlevel!
           del win_installer\files\vc_redist.x64.exe || exit /b !errorlevel!
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: portable
           path: win_installer\files
diff --git a/.github/workflows/sanitizers.yml b/.github/workflows/sanitizers.yml
index ea0a0276c99..6021d1237d2 100644
--- a/.github/workflows/sanitizers.yml
+++ b/.github/workflows/sanitizers.yml
@@ -50,7 +50,7 @@ jobs:
       CCACHE_SLOPPINESS: pch_defines,time_macros
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -60,7 +60,7 @@ jobs:
           key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}-${{ matrix.sanitizer }}
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.14'
           check-latest: true
diff --git a/.github/workflows/scriptcheck.yml b/.github/workflows/scriptcheck.yml
index 844b1d5c2f3..8cee3c5a5b4 100644
--- a/.github/workflows/scriptcheck.yml
+++ b/.github/workflows/scriptcheck.yml
@@ -21,7 +21,7 @@ jobs:
     runs-on: ubuntu-22.04
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -31,7 +31,7 @@ jobs:
           key: ${{ github.workflow }}-${{ runner.os }}
 
       - name: Cache Cppcheck
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: cppcheck
           key: ${{ runner.os }}-scriptcheck-cppcheck-${{ github.sha }}
@@ -56,19 +56,19 @@ jobs:
       fail-fast: false
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
       # TODO: bailout on error
       - name: Restore Cppcheck
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: cppcheck
           key: ${{ runner.os }}-scriptcheck-cppcheck-${{ github.sha }}
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
           check-latest: true
@@ -209,7 +209,7 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
diff --git a/.github/workflows/selfcheck.yml b/.github/workflows/selfcheck.yml
index 3517486df31..f16ce8d8332 100644
--- a/.github/workflows/selfcheck.yml
+++ b/.github/workflows/selfcheck.yml
@@ -24,7 +24,7 @@ jobs:
       QT_VERSION: 6.10.0
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -215,7 +215,7 @@ jobs:
         env:
           DISABLE_VALUEFLOW: 1
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: Callgrind Output
           path: ./callgrind.*
@@ -228,7 +228,7 @@ jobs:
         env:
           DISABLE_VALUEFLOW: 1
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: Memcheck Output
           path: ./memcheck.*
diff --git a/.github/workflows/valgrind.yml b/.github/workflows/valgrind.yml
index 3e4a02dbb48..25ef4dd63a2 100644
--- a/.github/workflows/valgrind.yml
+++ b/.github/workflows/valgrind.yml
@@ -21,7 +21,7 @@ jobs:
     runs-on: ubuntu-22.04
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -64,7 +64,7 @@ jobs:
         #env:
         #  DEBUGINFOD_URLS: https://debuginfod.ubuntu.com
           
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         if: success() || failure()
         with:
           name: Logs

From 6a29b12ce24eb507c1cb1d2e6d5d50607655870f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Wed, 5 Aug 2026 11:22:04 +0200
Subject: [PATCH 33/59] Fix #14899:  FP invalidPrintfArgType_float with
 _sprintf_s_l()  (#8729)

---
 lib/checkio.cpp | 36 ++++++++++++++++++++++++++----------
 test/testio.cpp | 12 ++++++++++++
 2 files changed, 38 insertions(+), 10 deletions(-)

diff --git a/lib/checkio.cpp b/lib/checkio.cpp
index 0a0ca70a833..f726cef0cc7 100644
--- a/lib/checkio.cpp
+++ b/lib/checkio.cpp
@@ -666,16 +666,20 @@ void CheckIOImpl::wrongfeofUsage(const Token * tok)
 //    printf("", 1); // Too much arguments
 //---------------------------------------------------------------------------
 
-static bool findFormat(nonneg int arg, const Token *firstArg,
+static bool findFormat(nonneg int arg, nonneg int argc, const Token *firstArg,
                        const Token *&formatStringTok, const Token *&formatArgTok)
 {
+    formatArgTok = firstArg;
+
+    for (int i = 0; i < argc && formatArgTok; ++i)
+        formatArgTok = formatArgTok->nextArgument();
+
     const Token* argTok = firstArg;
 
     for (int i = 0; i < arg && argTok; ++i)
         argTok = argTok->nextArgument();
 
     if (Token::Match(argTok, "%str% [,)]")) {
-        formatArgTok = argTok->nextArgument();
         formatStringTok = argTok;
         return true;
     }
@@ -686,7 +690,6 @@ static bool findFormat(nonneg int arg, const Token *firstArg,
          (argTok->variable()->dimensions().size() == 1 &&
           argTok->variable()->dimensionKnown(0) &&
           argTok->variable()->dimension(0) != 0))) {
-        formatArgTok = argTok->nextArgument();
         if (!argTok->values().empty()) {
             const auto value = std::find_if(
                 argTok->values().cbegin(), argTok->values().cend(), std::mem_fn(&ValueFlow::Value::isTokValue));
@@ -706,6 +709,17 @@ static inline bool typesMatch(const std::string& iToTest, const std::string& iTy
     return (iToTest == iTypename) || (iToTest == iOptionalPrefix + iTypename);
 }
 
+static int getMaxArgNo(const Library::Function *func)
+{
+    const auto &checks = func->argumentChecks;
+    return std::max_element(checks.cbegin(), checks.cend(),
+                            [](const std::pair<int, Library::ArgumentChecks> &lhs,
+                               const std::pair<int, Library::ArgumentChecks> &rhs) {
+        return lhs.first < rhs.first;
+    }
+                            )->first;
+}
+
 void CheckIOImpl::checkWrongPrintfScanfArguments()
 {
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
@@ -723,8 +737,10 @@ void CheckIOImpl::checkWrongPrintfScanfArguments()
             bool scan = false;
             bool scanf_s = false;
             int formatStringArgNo = -1;
+            int argc = -1;
 
             if (tok->strAt(1) == "(" && mSettings.library.formatstr_function(tok)) {
+                argc = getMaxArgNo(mSettings.library.getFunction(tok));
                 formatStringArgNo = mSettings.library.formatstr_argno(tok);
                 scan = mSettings.library.formatstr_scan(tok);
                 scanf_s = mSettings.library.formatstr_secure(tok);
@@ -732,37 +748,37 @@ void CheckIOImpl::checkWrongPrintfScanfArguments()
 
             if (formatStringArgNo >= 0) {
                 // formatstring found in library. Find format string and first argument belonging to format string.
-                if (!findFormat(formatStringArgNo, tok->tokAt(2), formatStringTok, argListTok))
+                if (!findFormat(formatStringArgNo, argc, tok->tokAt(2), formatStringTok, argListTok))
                     continue;
             } else if (Token::simpleMatch(tok, "swprintf (")) {
                 if (Token::Match(tok->tokAt(2)->nextArgument(), "%str%")) {
                     // Find third parameter and format string
-                    if (!findFormat(1, tok->tokAt(2), formatStringTok, argListTok))
+                    if (!findFormat(1, 2, tok->tokAt(2), formatStringTok, argListTok))
                         continue;
                 } else {
                     // Find fourth parameter and format string
-                    if (!findFormat(2, tok->tokAt(2), formatStringTok, argListTok))
+                    if (!findFormat(2, 3, tok->tokAt(2), formatStringTok, argListTok))
                         continue;
                 }
             } else if (isWindows && Token::Match(tok, "sprintf_s|swprintf_s (")) {
                 // template <size_t size> int sprintf_s(char (&buffer)[size], const char *format, ...);
-                if (findFormat(1, tok->tokAt(2), formatStringTok, argListTok)) {
+                if (findFormat(1, 2, tok->tokAt(2), formatStringTok, argListTok)) {
                     if (!formatStringTok)
                         continue;
                 }
                 // int sprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, ...);
-                else if (findFormat(2, tok->tokAt(2), formatStringTok, argListTok)) {
+                else if (findFormat(2, 3, tok->tokAt(2), formatStringTok, argListTok)) {
                     if (!formatStringTok)
                         continue;
                 }
             } else if (isWindows && Token::Match(tok, "_snprintf_s|_snwprintf_s (")) {
                 // template <size_t size> int _snprintf_s(char (&buffer)[size], size_t count, const char *format, ...);
-                if (findFormat(2, tok->tokAt(2), formatStringTok, argListTok)) {
+                if (findFormat(2, 3, tok->tokAt(2), formatStringTok, argListTok)) {
                     if (!formatStringTok)
                         continue;
                 }
                 // int _snprintf_s(char *buffer, size_t sizeOfBuffer, size_t count, const char *format, ...);
-                else if (findFormat(3, tok->tokAt(2), formatStringTok, argListTok)) {
+                else if (findFormat(3, 4, tok->tokAt(2), formatStringTok, argListTok)) {
                     if (!formatStringTok)
                         continue;
                 }
diff --git a/test/testio.cpp b/test/testio.cpp
index 2d191555ba6..16d770bb0bd 100644
--- a/test/testio.cpp
+++ b/test/testio.cpp
@@ -4791,6 +4791,18 @@ class TestIO : public TestFixture {
                       "[test.cpp:17:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
                       "[test.cpp:17:5]: (warning) sprintf_s format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
+        check("int main()\n"
+              "{\n"
+              "    double value = 3.14;\n"
+              "    const size_t buffer_size = 64;\n"
+              "    char buffer[buffer_size];\n"
+              "    int precision = 2;\n"
+              "    _locale_t locale = _create_locale(LC_ALL, \"C\");\n"
+              "    _sprintf_s_l(buffer, buffer_size, \"%.*f\", locale, precision, value);\n"
+              "    _free_locale(locale);\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testMicrosoftSecureScanfArgument() {

From cb6d92e86287d511476b579a9e50a7b08067ebc7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Wed, 5 Aug 2026 11:23:00 +0200
Subject: [PATCH 34/59] AUTHORS: Add aadanen [skip ci] (#8774)

---
 AUTHORS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/AUTHORS b/AUTHORS
index b4917d7d157..cda29aa6ef8 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -1,6 +1,7 @@
 The cppcheck team, in alphabetical order:
 
 0x41head
+Aaron Danen
 Abhijit Sawant
 Abhishek Bharadwaj
 Abigail Buccaneer

From 44b9221a78e6d67f31a70533cea089d74fecf260 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Wed, 5 Aug 2026 12:43:15 +0200
Subject: [PATCH 35/59] Fix #14955: Bad varid for enumerator with using
 namespace (#8773)

---
 lib/tokenize.cpp      | 12 +++++++++++-
 test/testtokenize.cpp | 16 ++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index 8382c09e785..033462ca2e2 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -5270,7 +5270,16 @@ void Tokenizer::setVarIdPass2()
         std::map<const Token *, std::string> endOfScope;
         std::list<std::string> scope;
         std::list<const Token *> usingnamespaces;
+        const Token *enumEnd = nullptr;
         for (Token *tok = list.front(); tok; tok = tok->next()) {
+            if (isEnumStart(tok)) {
+                enumEnd = tok->link();
+                continue;
+            }
+            if (tok == enumEnd) {
+                enumEnd = nullptr;
+                continue;
+            }
             if (!tok->previous() || Token::Match(tok->previous(), "[;{}]")) {
                 if (Token::Match(tok, "using namespace %name% ::|;")) {
                     Token *endtok = tok->tokAt(2);
@@ -5300,7 +5309,8 @@ void Tokenizer::setVarIdPass2()
                 tok = tok->next()->findClosingBracket()->next();
             else if (usingnamespaces.empty() || tok->varId() || !tok->isName() || tok->isStandardType() || tok->tokType() == Token::eKeyword || tok->tokType() == Token::eBoolean ||
                      Token::Match(tok->previous(), ".|namespace|class|struct|&|&&|*|> %name%") || Token::Match(tok->previous(), "%type%| %name% ( %type%|)") || Token::Match(tok, "public:|private:|protected:") ||
-                     (!tok->next() && Token::Match(tok->previous(), "}|; %name%")))
+                     (!tok->next() && Token::Match(tok->previous(), "}|; %name%")) ||
+                     (enumEnd && Token::Match(tok->previous(), "{|, %name% =|,|}")))
                 continue;
 
             if (tok->strAt(-1) == "::" && tok->tokAt(-2) && tok->tokAt(-2)->isName())
diff --git a/test/testtokenize.cpp b/test/testtokenize.cpp
index 79da0177e19..600d457e944 100644
--- a/test/testtokenize.cpp
+++ b/test/testtokenize.cpp
@@ -93,6 +93,7 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(tokenize41);  // #13847
         TEST_CASE(tokenize42);  // #13861
         TEST_CASE(tokenize43);  // #13861
+        TEST_CASE(tokenize44);  // #14955
 
         TEST_CASE(validate);
 
@@ -949,6 +950,21 @@ class TestTokenizer : public TestFixture {
         (void)errout_str();
     }
 
+    void tokenize44() { // #14955
+        const char code[] = "namespace O {}\n"
+                            "namespace N {\n"
+                            "    using namespace O;\n"
+                            "    enum class E { E0 };\n"
+                            "    E E0 = E::E0;\n"
+                            "}\n";
+        const char expected[] = "2: namespace N {\n"
+                                "3: using namespace O ;\n"
+                                "4: enum class E { E0 } ;\n"
+                                "5: E E0@1 ; E0@1 = E :: E0 ;\n"
+                                "6: }\n";
+        ASSERT_EQUALS(expected, tokenizeDebugListing(code));
+    }
+
     void validate() {
         // C++ code in C file
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(";using namespace std;",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);

From b702eade4a164d6739818fc1c560113215cf4929 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Marjam=C3=A4ki?= <daniel.marjamaki@gmail.com>
Date: Wed, 5 Aug 2026 13:26:37 +0200
Subject: [PATCH 36/59] partial fix #14851 (CI: run 'make test' with some old
 gcc versions) (#8663)

---
 .github/workflows/gcc-versions.yml | 39 ++++++++++++++++++++++++++++++
 test/testpath.cpp                  |  3 ++-
 2 files changed, 41 insertions(+), 1 deletion(-)
 create mode 100644 .github/workflows/gcc-versions.yml

diff --git a/.github/workflows/gcc-versions.yml b/.github/workflows/gcc-versions.yml
new file mode 100644
index 00000000000..3402bade743
--- /dev/null
+++ b/.github/workflows/gcc-versions.yml
@@ -0,0 +1,39 @@
+# the purpose of this github action is to test that cppcheck source code can be compiled using old gcc versions.
+# the gcc images we use here are copied from the official gcc images on docker hub
+
+name: gcc-versions
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    strategy:
+      matrix:
+        #image: ["ghcr.io/cppcheck-opensource/gcc:5.4", "ghcr.io/cppcheck-opensource/gcc:6.5", "ghcr.io/cppcheck-opensource/gcc:7.5", "ghcr.io/cppcheck-opensource/gcc:8.5", "ghcr.io/cppcheck-opensource/gcc:9.5"]
+        image: ["ghcr.io/cppcheck-opensource/gcc:5.4"]
+      fail-fast: false
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Build cppcheck
+        run: |
+          # FIXME: simplecpp-1.8.0 can't be compiled with gcc 5.4, so we can't run 'make test' now
+          #docker run --rm -v ${{ github.workspace }}:/cppcheck -w /cppcheck ${{ matrix.image }} make -j$(nproc) CXXOPTS="-Werror" test
+          docker run --rm -v ${{ github.workspace }}:/cppcheck -w /cppcheck ${{ matrix.image }} g++ -fsyntax-only -Iexternals -Iexternals/picojson -Iexternals/simplecpp -Iexternals/tinyxml2 -std=c++11 -Wno-multichar lib/*.cpp
diff --git a/test/testpath.cpp b/test/testpath.cpp
index 69ee91fa391..0ebe343685f 100644
--- a/test/testpath.cpp
+++ b/test/testpath.cpp
@@ -516,7 +516,8 @@ class TestPath : public TestFixture {
         ASSERT_EQUALS(expected, Path::getAbsoluteFilePath(Path::join(cwd, "testabspath.txt")));
 
         std::string cwd_up = Path::getPathFromFilename(cwd);
-        cwd_up.pop_back(); // remove trailing slash
+        if (cwd_up != "/")
+            cwd_up.pop_back(); // remove trailing slash
         ASSERT_EQUALS(cwd_up, Path::getAbsoluteFilePath(Path::join(cwd, "..")));
         ASSERT_EQUALS(cwd_up, Path::getAbsoluteFilePath(Path::join(cwd, "../")));
         ASSERT_EQUALS(cwd_up, Path::getAbsoluteFilePath(Path::join(cwd, "..\\")));

From baf5eaa0780c38dbf2a22740a5c08974d0165546 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Thu, 6 Aug 2026 14:17:46 +0200
Subject: [PATCH 37/59] TestValueFlow: Remove redundant test configuration,
 make settings const (#8776)

Co-authored-by: chrchr-github <noreply@github.com>
---
 test/testvalueflow.cpp | 45 ++++++++++++++++--------------------------
 1 file changed, 17 insertions(+), 28 deletions(-)

diff --git a/test/testvalueflow.cpp b/test/testvalueflow.cpp
index 945555b1b3c..4fc47f63d86 100644
--- a/test/testvalueflow.cpp
+++ b/test/testvalueflow.cpp
@@ -43,16 +43,9 @@ class TestValueFlow : public TestFixture {
     TestValueFlow() : TestFixture("TestValueFlow") {}
 
 private:
-    /*const*/ Settings settings = settingsBuilder().library("std.cfg").build();
+    const Settings settings = settingsBuilder().library("std.cfg").build();
 
     void run() override {
-        // strcpy, abort cfg
-        constexpr char cfg[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"strcpy\"> <arg nr=\"1\"><not-null/></arg> </function>\n"
-                               "  <function name=\"abort\"> <noreturn>true</noreturn> </function>\n" // abort is a noreturn function
-                               "</def>";
-        settings = settingsBuilder(settings).libraryxml(cfg).build();
 
         mNewTemplate = true;
         TEST_CASE(valueFlowNumber);
@@ -437,9 +430,10 @@ class TestValueFlow : public TestFixture {
         return false;
     }
 
-    bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, int value, ValueFlow::Value::ValueType type) {
+    bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, int value, ValueFlow::Value::ValueType type, const Settings* s = nullptr) {
+        const Settings& curSettings = s ? *s : settings;
         // Tokenize..
-        SimpleTokenizer tokenizer(settings, *this);
+        SimpleTokenizer tokenizer(curSettings, *this);
         ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
@@ -5887,21 +5881,19 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(false, value.isKnown());
 
         // #13959
-        const Settings settingsOld = settings;
-        settings.standards.c = Standards::C23;
+        const Settings settingsC23 = settingsBuilder(settings).c(Standards::C23).build();
         code = "void f(int* p) {\n"
                "    if (p == nullptr)\n"
                "        return;\n"
                "    if (p) {}\n"
                "}\n";
-        value = valueOfTok(code, "p ) { }", &settings, /*cpp*/ false);
+        value = valueOfTok(code, "p ) { }", &settingsC23, /*cpp*/ false);
         ASSERT_EQUALS(1, value.intvalue);
         ASSERT_EQUALS(true, value.isKnown());
 
-        settings.standards.c = Standards::C17;
-        value = valueOfTok(code, "p ) { }", &settings, /*cpp*/ false);
+        const Settings settingsC17 = settingsBuilder(settings).c(Standards::C17).build();
+        value = valueOfTok(code, "p ) { }", &settingsC17, /*cpp*/ false);
         ASSERT(value == ValueFlow::Value());
-        settings = settingsOld;
     }
 
     void valueFlowSizeofForwardDeclaredEnum() {
@@ -7880,48 +7872,47 @@ class TestValueFlow : public TestFixture {
     void valueFlowDynamicBufferSize() {
         const char *code;
 
-        const Settings settingsOld = settings; // TODO: get rid of this
-        settings = settingsBuilder(settings).library("posix.cfg").library("bsd.cfg").build();
+        const Settings settingsCfg = settingsBuilder(settings).library("posix.cfg").library("bsd.cfg").build();
 
         code = "void* f() {\n"
                "  void* x = malloc(10);\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3U, 10,  ValueFlow::Value::ValueType::BUFFER_SIZE));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 10, ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "void* f() {\n"
                "  void* x = calloc(4, 5);\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3U, 20,  ValueFlow::Value::ValueType::BUFFER_SIZE));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 20,  ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "void* f() {\n"
                "  const char* y = \"abcd\";\n"
                "  const char* x = strdup(y);\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 4U, 5,  ValueFlow::Value::ValueType::BUFFER_SIZE));
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 5,  ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "void* f() {\n"
                "  void* y = malloc(10);\n"
                "  void* x = realloc(y, 20);\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 4U, 20,  ValueFlow::Value::ValueType::BUFFER_SIZE));
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 20,  ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "void* f() {\n"
                "  void* y = calloc(10, 4);\n"
                "  void* x = reallocarray(y, 20, 5);\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 4U, 100,  ValueFlow::Value::ValueType::BUFFER_SIZE));
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 100,  ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "struct A {};\n" // #14305
                "void* f() {\n"
                "  A* x = new A();\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 4U, 1, ValueFlow::Value::ValueType::BUFFER_SIZE));
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 1, ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "struct A {};\n"
                "void* f() {\n"
@@ -7929,7 +7920,7 @@ class TestValueFlow : public TestFixture {
                "  return x;\n"
                "}";
         {
-            auto values = tokenValues(code, "x ; }");
+            auto values = tokenValues(code, "x ; }", &settingsCfg);
             ASSERT_EQUALS(1, values.size());
             ASSERT(values.front().isSymbolicValue());
             // TODO: add BUFFER_SIZE value = 1
@@ -7940,9 +7931,7 @@ class TestValueFlow : public TestFixture {
                "  B* x = new B();\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 4U, 4, ValueFlow::Value::ValueType::BUFFER_SIZE));
-
-        settings = settingsOld;
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 4, ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
     }
 
     void valueFlowSafeFunctionParameterValues() {

From fecb3496f915944388356346dbab6dd4c08c740c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Marjam=C3=A4ki?= <daniel.marjamaki@gmail.com>
Date: Fri, 7 Aug 2026 07:59:49 +0200
Subject: [PATCH 38/59] Fix #14959 (Warning hash for token-based warnings)
 (#8778)

---
 Makefile               |  2 +-
 lib/errorlogger.cpp    | 65 ++++++++++++++++++++++++++++++++++++++++--
 lib/errorlogger.h      |  2 ++
 oss-fuzz/Makefile      |  2 +-
 test/cli/other_test.py |  2 +-
 5 files changed, 68 insertions(+), 5 deletions(-)

diff --git a/Makefile b/Makefile
index 42b754733ec..a7f3feefba6 100644
--- a/Makefile
+++ b/Makefile
@@ -600,7 +600,7 @@ $(libcppdir)/cppcheck.o: lib/cppcheck.cpp externals/picojson/picojson.h external
 $(libcppdir)/ctu.o: lib/ctu.cpp externals/tinyxml2/tinyxml2.h lib/astutils.h lib/check.h lib/config.h lib/ctu.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h lib/xml.h
 	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/ctu.cpp
 
-$(libcppdir)/errorlogger.o: lib/errorlogger.cpp externals/tinyxml2/tinyxml2.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/token.h lib/tokenlist.h lib/utils.h lib/vfvalue.h lib/xml.h
+$(libcppdir)/errorlogger.o: lib/errorlogger.cpp externals/tinyxml2/tinyxml2.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenlist.h lib/utils.h lib/vfvalue.h lib/xml.h
 	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/errorlogger.cpp
 
 $(libcppdir)/errortypes.o: lib/errortypes.cpp lib/config.h lib/errortypes.h lib/utils.h
diff --git a/lib/errorlogger.cpp b/lib/errorlogger.cpp
index d58c5abcbba..d57ad999734 100644
--- a/lib/errorlogger.cpp
+++ b/lib/errorlogger.cpp
@@ -23,6 +23,7 @@
 #include "path.h"
 #include "settings.h"
 #include "suppressions.h"
+#include "symboldatabase.h"
 #include "token.h"
 #include "tokenlist.h"
 #include "utils.h"
@@ -35,6 +36,7 @@
 #include <cstring>
 #include <fstream>
 #include <iomanip>
+#include <numeric>
 #include <sstream>
 #include <string>
 #include <unordered_map>
@@ -106,6 +108,8 @@ ErrorMessage::ErrorMessage(const std::list<const Token*>& callstack, const Token
         file0 = list->getFiles()[0];
 
     setmsg(msg);
+
+    calculateWarningHash(callstack);
 }
 
 
@@ -126,7 +130,7 @@ ErrorMessage::ErrorMessage(const std::list<const Token*>& callstack, const Token
 
     setmsg(msg);
 
-    // hash = calculateWarningHash(list, hashWarning.str());
+    calculateWarningHash(callstack);
 }
 
 ErrorMessage::ErrorMessage(ErrorPath errorPath, const TokenList *tokenList, Severity severity, const char id[], const std::string &msg, const CWE &cwe, Certainty certainty)
@@ -159,7 +163,12 @@ ErrorMessage::ErrorMessage(ErrorPath errorPath, const TokenList *tokenList, Seve
 
     setmsg(msg);
 
-    // hash = calculateWarningHash(tokenList, hashWarning.str());
+    std::list<const Token*> tokens;
+    std::transform(errorPath.cbegin(), errorPath.cend(), std::back_inserter(tokens),
+                   [](const ErrorPathItem& e) {
+        return e.first;
+    });
+    calculateWarningHash(tokens);
 }
 
 // TODO: improve errorhandling?
@@ -244,6 +253,58 @@ void ErrorMessage::setmsg(const std::string &msg)
     }
 }
 
+void ErrorMessage::calculateWarningHash(const std::list<const Token*>& callstack)
+{
+    if (callstack.empty())
+        return;
+    // Calculate a hash for this warning message
+    std::string hashString;
+    for (const Token* tok: callstack) {
+        if (!tok)
+            continue;
+        if (!tok->scope())
+            return; // might be a syntax error before scope info has been set
+        if (tok->scope()->isExecutable()) {
+            // Executable scope => include all tokens in the function => if the
+            // function is changed the hash is changed
+            for (const Token* t = tok; t; t = t->previous()) {
+                if (!t->scope()->isExecutable())
+                    break;
+                hashString += " " + t->str();
+            }
+            for (const Token* t = tok->next(); t; t = t->next()) {
+                if (!t->scope()->isExecutable())
+                    break;
+                hashString += " " + t->str();
+            }
+        } else {
+            // Non executable scope => include tokens in current statement => if the current statement is changed the hash is changed
+            for (const Token* t = tok; t; t = t->previous()) {
+                if (t->str() == ";")
+                    break;
+                if (t->scope() != tok->scope()) // stop on {} unless its an initializer
+                    break;
+                hashString += " " + t->str();
+            }
+            for (const Token* t = tok->next(); t; t = t->next()) {
+                hashString += " " + t->str();
+                if (t->str() == ";")
+                    break;
+                if (t->scope() != tok->scope()) // stop on {} unless its an initializer
+                    break;
+            }
+        }
+    }
+
+    hashString = id + '\n' + mShortMessage + '\n' + hashString;
+
+    // hash algorithm: sdbm
+    // any hash algorithm can be used but it has to be the same hash on different platforms and compilers
+    hash = std::accumulate(hashString.cbegin(), hashString.cend(), std::size_t{0}, [](std::size_t h, unsigned char c) {
+        return static_cast<std::size_t>(c) + (h << 6) + (h << 16) - h;
+    });
+}
+
 static void serializeString(std::string &oss, const std::string & str)
 {
     oss += std::to_string(str.length());
diff --git a/lib/errorlogger.h b/lib/errorlogger.h
index 97cc3e7f82e..b28fdba244e 100644
--- a/lib/errorlogger.h
+++ b/lib/errorlogger.h
@@ -209,6 +209,8 @@ class CPPCHECKLIB ErrorMessage {
 private:
     static std::string fixInvalidChars(const std::string& raw);
 
+    void calculateWarningHash(const std::list<const Token*>& callstack);
+
     /** Short message */
     std::string mShortMessage;
 
diff --git a/oss-fuzz/Makefile b/oss-fuzz/Makefile
index eeb795bd35c..e6966747958 100644
--- a/oss-fuzz/Makefile
+++ b/oss-fuzz/Makefile
@@ -270,7 +270,7 @@ $(libcppdir)/cppcheck.o: ../lib/cppcheck.cpp ../externals/picojson/picojson.h ..
 $(libcppdir)/ctu.o: ../lib/ctu.cpp ../externals/tinyxml2/tinyxml2.h ../lib/astutils.h ../lib/check.h ../lib/config.h ../lib/ctu.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h ../lib/xml.h
 	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/ctu.cpp
 
-$(libcppdir)/errorlogger.o: ../lib/errorlogger.cpp ../externals/tinyxml2/tinyxml2.h ../lib/check.h ../lib/checkers.h ../lib/color.h ../lib/config.h ../lib/cppcheck.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/standards.h ../lib/suppressions.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h ../lib/xml.h
+$(libcppdir)/errorlogger.o: ../lib/errorlogger.cpp ../externals/tinyxml2/tinyxml2.h ../lib/check.h ../lib/checkers.h ../lib/color.h ../lib/config.h ../lib/cppcheck.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/suppressions.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h ../lib/xml.h
 	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/errorlogger.cpp
 
 $(libcppdir)/errortypes.o: ../lib/errortypes.cpp ../lib/config.h ../lib/errortypes.h ../lib/utils.h
diff --git a/test/cli/other_test.py b/test/cli/other_test.py
index c48a0b50354..f5928c07de5 100644
--- a/test/cli/other_test.py
+++ b/test/cli/other_test.py
@@ -2666,7 +2666,7 @@ def test_xml_output(tmp_path):  # #13391 / #13485
 <results version="2">
     <cppcheck version="{}"/>
     <errors>
-        <error id="nullPointerRedundantCheck" severity="warning" msg="Either the condition &apos;p&apos; is redundant or there is possible null pointer dereference: p." verbose="Either the condition &apos;p&apos; is redundant or there is possible null pointer dereference: p." cwe="476" file0="{}" remark="boom">
+        <error id="nullPointerRedundantCheck" severity="warning" msg="Either the condition &apos;p&apos; is redundant or there is possible null pointer dereference: p." verbose="Either the condition &apos;p&apos; is redundant or there is possible null pointer dereference: p." cwe="476" hash="2884341854190588507" file0="{}" remark="boom">
             <location file="{}" line="5" column="12" info="Null pointer dereference"/>
             <location file="{}" line="4" column="8" info="Assuming that condition &apos;p&apos; is not redundant"/>
             <symbol>p</symbol>

From 5799d47ee5b641fbb962f4dedeff9f3d2a2a368f Mon Sep 17 00:00:00 2001
From: Swasti Shrivastava <37058682+swasti16@users.noreply.github.com>
Date: Fri, 7 Aug 2026 11:41:04 +0530
Subject: [PATCH 39/59] Remove GUI compliance report instructions (feature
 removed) (#8781)

The "Compliance report..." File menu option no longer exists in the
Cppcheck Premium GUI.

Compliance reports are still available via the command-line
`compliance-report` tool, documented in the section immediately below.
---
 man/manual-premium.md | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/man/manual-premium.md b/man/manual-premium.md
index c8e38666530..9175ef47c8a 100644
--- a/man/manual-premium.md
+++ b/man/manual-premium.md
@@ -1384,11 +1384,6 @@ If you want to check all files, you can append `:all` to the coding standard. Ex
 
 ## Compliance report
 
-### Graphical user interface
-
-Run a analysis with some coding standards enabled. After that you can click on
-the `Compliance report...` in the `File` menu.
-
 ### Command line
 
 There is a tool `compliance-report` that is distributed with Cppcheck Premium. To see

From dc9bd7fae838e0f374d89fa786cc5949752dd676 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Fri, 7 Aug 2026 13:10:45 +0200
Subject: [PATCH 40/59] Fix #14966 internalError for valid typedef (#8783)

---
 lib/tokenize.cpp             | 7 +++++++
 test/testsimplifytypedef.cpp | 3 +++
 2 files changed, 10 insertions(+)

diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index 033462ca2e2..0076ce30875 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -566,11 +566,18 @@ namespace {
             const auto checkForRecursion = [this]() {
                 if (Token::Match(mTypedefToken, "typedef %name% %name% ;"))
                     return;
+                int nBraces = 0;
                 for (const Token *tok = mTypedefToken; tok != mEndToken; tok = tok->next()) {
+                    if (tok->str() == "{")
+                        ++nBraces;
+                    else if (tok->str() == "}")
+                        --nBraces;
                     if (tok == mNameToken)
                         continue;
                     if (tok->str() != mNameToken->str())
                         continue;
+                    if (nBraces > 0 && Token::simpleMatch(tok->next(), ";"))
+                        continue;
                     if (Token::Match(tok->previous(), "struct|class|enum|union"))
                         continue;
                     throw InternalError(tok, "recursive typedef encountered");
diff --git a/test/testsimplifytypedef.cpp b/test/testsimplifytypedef.cpp
index e83be343e01..f8e3eb1cdf6 100644
--- a/test/testsimplifytypedef.cpp
+++ b/test/testsimplifytypedef.cpp
@@ -3879,6 +3879,9 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef164() {
         const char code[] = "typedef struct D{x;}y y;";
         ASSERT_THROW_INTERNAL(tok(code), INTERNAL);
+
+        const char code2[] = "typedef struct { int t; } t;"; // #14966
+        ASSERT_EQUALS("struct t { int t ; } ;", tok(code2));
     }
 
     void simplifyTypedefFunction1() {

From 14442692603640cf63098be3387e0f5226bc3faf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Fri, 7 Aug 2026 15:46:02 +0200
Subject: [PATCH 41/59] Fix #14962: False Positive: missingReturn: return
 expression misdiagnosed as missing return path (#8780)

---
 lib/checkfunctions.cpp |  7 ++++++-
 test/testfunctions.cpp | 11 +++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/lib/checkfunctions.cpp b/lib/checkfunctions.cpp
index 1edfdfab6ac..1f17d0bbcdc 100644
--- a/lib/checkfunctions.cpp
+++ b/lib/checkfunctions.cpp
@@ -386,7 +386,12 @@ static const Token *checkMissingReturnScope(const Token *tok, const Library &lib
                 if (!isExhaustiveSwitch(tok->link()))
                     return tok->link();
             } else if (tok->scope()->type == ScopeType::eIf) {
-                const Token *condition = tok->scope()->classDef->next()->astOperand2();
+                const Token *paren = tok->link()->linkAt(-1);
+                if (!paren || !Token::simpleMatch(paren->astOperand1(), "if")) {
+                    tok = tok->link();
+                    continue;
+                }
+                const Token *condition = paren->astOperand2();
                 if (condition && condition->hasKnownIntValue() && condition->getKnownIntValue() == 1)
                     return checkMissingReturnScope(tok, library);
                 return tok;
diff --git a/test/testfunctions.cpp b/test/testfunctions.cpp
index f5067bc31dc..d5a18f7d916 100644
--- a/test/testfunctions.cpp
+++ b/test/testfunctions.cpp
@@ -87,6 +87,7 @@ class TestFunctions : public TestFixture {
         TEST_CASE(checkMissingReturn6); // #13180
         TEST_CASE(checkMissingReturn7); // #14370 - FN try/catch
         TEST_CASE(checkMissingReturn8);
+        TEST_CASE(checkMissingReturn9);
         TEST_CASE(checkMissingReturnStdInt); // #14482 - FN std::int32_t
 
         // std::move for locar variable
@@ -1936,6 +1937,16 @@ class TestFunctions : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void checkMissingReturn9() {
+        check("struct S { int v; };\n"
+              " S operator/(S x, S y) { return { x.v / y.v }; }\n"
+              " S f(int a, int b) {\n"
+              "    if (b) { return S{ a } / S{ b }; }\n"
+              "    else { return {}; }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void checkMissingReturnStdInt() {// #14482 - FN
         check("std::int32_t f() {}\n");
         ASSERT_EQUALS("[test.cpp:1:19]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());

From 4b0c239a321ff12bd34627c0913d8712dd105456 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Sat, 8 Aug 2026 09:45:12 +0200
Subject: [PATCH 42/59] Fix #14017: Missing varid on namespace member (#8784)

---
 lib/tokenize.cpp   | 6 ++++--
 test/testvarid.cpp | 9 +++++++++
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index 0076ce30875..1a6d4a4e53f 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -5172,8 +5172,10 @@ static Token * matchMemberName(const std::list<std::string> &scope, const Token
 
     // Current scope..
     for (auto it = scope.cbegin(); it != scope.cend(); ++it) {
-        if (scopeIt == scopeInfo.cend() || scopeIt->name != *it)
-            return nullptr;
+        if (scopeIt == scopeInfo.cend() || scopeIt->name != *it) {
+            scopeIt = scopeInfo.cbegin();
+            break;
+        }
         ++scopeIt;
     }
 
diff --git a/test/testvarid.cpp b/test/testvarid.cpp
index c8d16bc89a5..e30c613c0bc 100644
--- a/test/testvarid.cpp
+++ b/test/testvarid.cpp
@@ -102,6 +102,7 @@ class TestVarID : public TestFixture {
         TEST_CASE(varid70); // #12660 - function
         TEST_CASE(varid71); // #12676 - wrong varid in uninstantiated templated constructor
         TEST_CASE(varid72);
+        TEST_CASE(varid73);
         TEST_CASE(varid_for_1);
         TEST_CASE(varid_for_2);
         TEST_CASE(varid_for_3);
@@ -1409,6 +1410,14 @@ class TestVarID : public TestFixture {
         ASSERT_EQUALS(expected1, tokenize(code1));
     }
 
+    void varid73() {
+        const char code[] = "namespace a { int x; };\n"
+                            "namespace b { int x = a::x; };\n";
+        const char expected[]  = "1: namespace a { int x@1 ; } ;\n"
+                                 "2: namespace b { int x@2 ; x@2 = a :: x@1 ; } ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
     void varid_for_1() {
         const char code[] = "void foo(int a, int b) {\n"
                             "  for (int a=1,b=2;;) {}\n"

From b1b7e3ccb5e14da331e45e086df3a73101a00513 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Mon, 10 Aug 2026 09:03:31 +0200
Subject: [PATCH 43/59] Fix #14948 FP bufferAccessOutOfBounds after container
 size check (#8763)

Co-authored-by: chrchr-github <noreply@github.com>
---
 lib/checkbufferoverrun.cpp | 11 +++++++++--
 test/testbufferoverrun.cpp | 17 +++++++++++++++++
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/lib/checkbufferoverrun.cpp b/lib/checkbufferoverrun.cpp
index 8c8912ed06d..f0a12efccec 100644
--- a/lib/checkbufferoverrun.cpp
+++ b/lib/checkbufferoverrun.cpp
@@ -68,7 +68,9 @@ static const ValueFlow::Value *getBufferSizeValue(const Token *tok)
     auto it = std::find_if(tokenValues.cbegin(), tokenValues.cend(), std::mem_fn(&ValueFlow::Value::isBufferSizeValue));
     if (it != tokenValues.cend())
         return &*it;
-    it = std::find_if(tokenValues.cbegin(), tokenValues.cend(), std::mem_fn(&ValueFlow::Value::isContainerSizeValue));
+    it = std::find_if(tokenValues.cbegin(), tokenValues.cend(), [](const ValueFlow::Value& v) {
+        return v.isContainerSizeValue() && !v.isImpossible();
+    });
     return it == tokenValues.cend() ? nullptr : &*it;
 }
 
@@ -597,6 +599,8 @@ ValueFlow::Value CheckBufferOverrunImpl::getBufferSize(const Token *bufTok, cons
                     ValueFlow::Value bufSizeVal;
                     bufSizeVal.valueType = ValueFlow::Value::ValueType::BUFFER_SIZE;
                     bufSizeVal.intvalue = value->intvalue * elementSize;
+                    bufSizeVal.valueKind = value->valueKind;
+                    bufSizeVal.errorPath = value->errorPath;
                     return bufSizeVal;
                 }
             }
@@ -730,7 +734,10 @@ void CheckBufferOverrunImpl::bufferOverflow()
 
 void CheckBufferOverrunImpl::bufferOverflowError(const Token *tok, const ValueFlow::Value *value, Certainty certainty)
 {
-    reportError(getErrorPath(tok, value, "Buffer overrun"), Severity::error, "bufferAccessOutOfBounds", "Buffer is accessed out of bounds: " + (tok ? getRealBufferTok(tok)->expressionString() : "buf"), CWE_BUFFER_OVERRUN, certainty);
+    const auto errorPath = getErrorPath(tok, value, "Buffer overrun");
+    const auto severity = !value || value->isKnown() ? Severity::error : Severity::warning;
+    const std::string msg = "Buffer is accessed out of bounds: " + (tok ? getRealBufferTok(tok)->expressionString() : "buf");
+    reportError(errorPath, severity, "bufferAccessOutOfBounds", msg, CWE_BUFFER_OVERRUN, certainty);
 }
 
 //---------------------------------------------------------------------------
diff --git a/test/testbufferoverrun.cpp b/test/testbufferoverrun.cpp
index 8bac50a468c..3914f0ee828 100644
--- a/test/testbufferoverrun.cpp
+++ b/test/testbufferoverrun.cpp
@@ -3628,6 +3628,14 @@ class TestBufferOverrun : public TestFixture {
               "        memset(&a[i], 0, sizeof(a));\n"
               "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (error) Buffer is accessed out of bounds: &a[i] [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("void f(const std::vector<uint8_t>& s) {\n" // #14948
+              "    if (s.size() < 4)\n"
+              "        return;\n"
+              "    uint32_t u = 0;\n"
+              "    std::memcpy(&u, &s[0], sizeof(u));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_errorpath() {
@@ -3642,6 +3650,15 @@ class TestBufferOverrun : public TestFixture {
         ASSERT_EQUALS("[test.cpp:3:12]: error: Buffer is accessed out of bounds: p [bufferAccessOutOfBounds]\n"
                       "[test.cpp:2:13]: note: Assign p, buffer with size 10\n"
                       "[test.cpp:3:12]: note: Buffer overrun\n", errout_str());
+
+        check("void f(const std::vector<uint8_t>& s) {\n"
+              "    if (s.size() == 2) {}\n"
+              "    uint32_t u = 0;\n"
+              "    std::memcpy(&u, &s[0], sizeof(u));\n"
+              "}\n", s);
+        ASSERT_EQUALS("[test.cpp:4:21]: warning: Buffer is accessed out of bounds: &s[0] [bufferAccessOutOfBounds]\n"
+                      "[test.cpp:2:18]: note: Assuming that condition 's.size()==2' is not redundant\n"
+                      "[test.cpp:4:21]: note: Buffer overrun\n", errout_str());
     }
 
     void buffer_overrun_bailoutIfSwitch() {

From dfcec18902c43786c4e1ab5c01c302fbf718c52d Mon Sep 17 00:00:00 2001
From: correctmost <134317971+correctmost@users.noreply.github.com>
Date: Mon, 10 Aug 2026 04:47:39 -0400
Subject: [PATCH 44/59] gtk.cfg: Remove pure annotation from
 g_str_has_prefix/suffix (#8788)

`g_str_has_prefix` and `g_str_has_suffix` are not technically pure
because they can log to the console if a precondition fails.

This partially reverts commit 7cc7c0bb5.

---

Some notes:

The original `gtk.cfg` change hasn't been released yet, so the revert
shouldn't cause any churn for users.

GLib has code like this:

```c
gboolean (g_str_has_prefix) (const gchar *str,
                             const gchar *prefix)
{
  g_return_val_if_fail (str != NULL, FALSE);
  g_return_val_if_fail (prefix != NULL, FALSE);

  return strncmp (str, prefix, strlen (prefix)) == 0;
}
```

Most real-world code is treating this function as safe to call inside of
an assert, even though it could technically have side effects if one of
the preconditions fails.

I removed the pure annotation to err on the side of correctness and
pedantry, even though most projects would view the warnings as "false
positives" from a practical perspective.

Here is example usage from QEMU:

```c
char *qemu_chr_get_filename(Chardev *chr)
{
    ChardevClass *cc = CHARDEV_GET_CLASS(chr);
    const char *typename;

    if (cc->chr_get_filename) {
        return cc->chr_get_filename(chr);
    }

    typename = object_get_typename(OBJECT(chr));
    assert(g_str_has_prefix(typename, "chardev-"));
    return g_strdup(typename + 8);
}
```
---
 cfg/gtk.cfg    | 1 -
 test/cfg/gtk.c | 6 ++++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/cfg/gtk.cfg b/cfg/gtk.cfg
index 5e94a0bbb5c..a1d7763670e 100644
--- a/cfg/gtk.cfg
+++ b/cfg/gtk.cfg
@@ -5221,7 +5221,6 @@
   <!-- gboolean g_str_has_prefix (const gchar* str, const gchar* prefix); -->
   <!-- gboolean g_str_has_suffix (const gchar* str, const gchar* prefix); -->
   <function name="g_str_has_prefix,g_str_has_suffix">
-    <pure/>
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="gboolean"/>
diff --git a/test/cfg/gtk.c b/test/cfg/gtk.c
index 6b48bca2f9e..b923135e2d9 100644
--- a/test/cfg/gtk.c
+++ b/test/cfg/gtk.c
@@ -59,8 +59,14 @@ void validCode(int argInt, GHashTableIter * hash_table_iter, GHashTable * hash_t
     g_string_free(pGStr1, TRUE);
 
     gchar * pGchar1 = g_strconcat("a", "b", NULL);
+
+    // g_str_has_prefix and g_str_has_suffix can have side effects because they use
+    // g_return_val_if_fail, which logs to the console upon failure
+    // cppcheck-suppress assertWithSideEffect
     g_assert_true(g_str_has_prefix(pGchar1, "a"));
+    // cppcheck-suppress assertWithSideEffect
     g_assert_true(g_str_has_suffix(pGchar1, "b"));
+
     printf("%s", pGchar1);
     g_free(pGchar1);
 

From 4184c39b50ab7443ce62ea617ed033cf6812a5df Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Thu, 13 Aug 2026 16:43:27 +0200
Subject: [PATCH 45/59]  Fix #14971 [regression] internalError for valid
 typedef (#8790)

Co-authored-by: chrchr-github <noreply@github.com>
---
 lib/tokenize.cpp             | 2 +-
 test/testsimplifytypedef.cpp | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index 1a6d4a4e53f..27be2e544a2 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -576,7 +576,7 @@ namespace {
                         continue;
                     if (tok->str() != mNameToken->str())
                         continue;
-                    if (nBraces > 0 && Token::simpleMatch(tok->next(), ";"))
+                    if (nBraces > 0 && Token::Match(tok->next(), "[;(]"))
                         continue;
                     if (Token::Match(tok->previous(), "struct|class|enum|union"))
                         continue;
diff --git a/test/testsimplifytypedef.cpp b/test/testsimplifytypedef.cpp
index f8e3eb1cdf6..78d7bd25f3d 100644
--- a/test/testsimplifytypedef.cpp
+++ b/test/testsimplifytypedef.cpp
@@ -3882,6 +3882,9 @@ class TestSimplifyTypedef : public TestFixture {
 
         const char code2[] = "typedef struct { int t; } t;"; // #14966
         ASSERT_EQUALS("struct t { int t ; } ;", tok(code2));
+
+        const char code3[] = "typedef struct S { S() {} } S;"; // #14971
+        ASSERT_EQUALS("struct S { S ( ) { } } ;", tok(code3));
     }
 
     void simplifyTypedefFunction1() {

From b3917652c0205dfa2cea97b868186364a0104ebb Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Fri, 14 Aug 2026 09:27:11 +0200
Subject: [PATCH 46/59] Fix #14725 FP redundantIfRemove when conditional code
 has extra code (#8789)

---
 lib/checkstl.cpp |  3 +++
 test/teststl.cpp | 10 ++++++++++
 2 files changed, 13 insertions(+)

diff --git a/lib/checkstl.cpp b/lib/checkstl.cpp
index de1d82792ac..cf2b671606f 100644
--- a/lib/checkstl.cpp
+++ b/lib/checkstl.cpp
@@ -1867,6 +1867,9 @@ void CheckStlImpl::redundantCondition()
         const Token *var3 = var2->tokAt(7);
         const Token *any2 = var3->tokAt(4);
 
+        if (any2->tokAt(3) != scope.bodyEnd)
+            continue;
+
         // Check if all the "%name%" fields are the same and if all the "%any%" are the same..
         if (var1->str() == var2->str() &&
             var2->str() == var3->str() &&
diff --git a/test/teststl.cpp b/test/teststl.cpp
index 2570059c19e..1cc11029804 100644
--- a/test/teststl.cpp
+++ b/test/teststl.cpp
@@ -4556,6 +4556,16 @@ class TestStl : public TestFixture {
               "        haystack.remove(needle);"
               "}");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Redundant checking of STL container element existence before removing it. [redundantIfRemove]\n", errout_str());
+
+        check("void g(const std::string&);\n" // #14725
+              "std::set<std::string> g_s;\n"
+              "void f(const std::string& k) {\n"
+              "    if (g_s.find(k) != g_s.end()) {\n"
+              "        g_s.erase(k);\n"
+              "        g(k);\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void missingInnerComparison1() {

From 2d75160cada40e58bd54afd77f730259e069f8c9 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Fri, 14 Aug 2026 09:28:22 +0200
Subject: [PATCH 47/59] Fix #14973 FP assertWithSideEffect with function
 pointer comparison (#8792)

---
 lib/checkassert.cpp |  5 +++++
 test/testassert.cpp | 11 +++++++++++
 2 files changed, 16 insertions(+)

diff --git a/lib/checkassert.cpp b/lib/checkassert.cpp
index 4578f7395ba..00bb95e319a 100644
--- a/lib/checkassert.cpp
+++ b/lib/checkassert.cpp
@@ -78,6 +78,11 @@ void CheckAssertImpl::assertWithSideEffects()
                 continue;
             }
 
+            const Token* parent = tmp->astParent();
+            while (Token::Match(parent, ".|::"))
+                parent = parent->astParent();
+            if (!Token::simpleMatch(parent, "("))
+                continue;
             const Function* f = tmp->function();
             const Scope* scope = f->functionScope;
             if (!scope) {
diff --git a/test/testassert.cpp b/test/testassert.cpp
index ea170c43f2d..a76b8207445 100644
--- a/test/testassert.cpp
+++ b/test/testassert.cpp
@@ -147,6 +147,17 @@ class TestAssert : public TestFixture {
               "    assert(g());\n"
               "}\n");
         ASSERT_EQUALS("", errout_str());
+
+        check("int i;\n" // #14973
+              "bool f() {\n"
+              "    i = 0;\n"
+              "    return true;\n"
+              "}\n"
+              "void g() {\n"
+              "    bool (*fp)() = f;\n"
+              "    assert(fp == f);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void memberFunctionCallInAssert() {

From 7d48e00b6da72ff56dbab8fc5c50a89affab237f Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Mon, 17 Aug 2026 09:53:39 +0200
Subject: [PATCH 48/59] Fix  #14976 FP uninitvar (std::size() used on array)
 (#8795)

Co-authored-by: chrchr-github <noreply@github.com>
---
 cfg/std.cfg      | 4 +---
 test/cfg/std.cpp | 5 +++++
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/cfg/std.cfg b/cfg/std.cfg
index 4662d0a4632..6c434b8715c 100644
--- a/cfg/std.cfg
+++ b/cfg/std.cfg
@@ -8343,9 +8343,7 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
     <leak-ignore/>
     <container yields="size"/>
     <returnValue type="size_t"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <arg nr="1" direction="in" indirect="0"/>
   </function>
   <function name="std::ssize">
     <noreturn>false</noreturn>
diff --git a/test/cfg/std.cpp b/test/cfg/std.cpp
index 850dd74b997..e4753a09f7c 100644
--- a/test/cfg/std.cpp
+++ b/test/cfg/std.cpp
@@ -5071,6 +5071,11 @@ int f_constVariable_std_begin() {
     return arr[0];
 }
 
+std::size_t uninitvar_std_size() { // #14976
+    int a[3];
+    return std::size(a);
+}
+
 void smartPtr_get()
 {
     std::unique_ptr<int> p;

From ab9989ca09bc7d5bc573e2e6214c422d998c4f38 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Mon, 17 Aug 2026 14:47:44 +0200
Subject: [PATCH 49/59] Fix #14978: Valueflow: Missing buffer size for
 `::operator new` (#8799)

---
 lib/valueflow.cpp      | 8 +++++++-
 test/testvalueflow.cpp | 7 +++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
index 5efe698bf61..7acf7179723 100644
--- a/lib/valueflow.cpp
+++ b/lib/valueflow.cpp
@@ -7025,6 +7025,12 @@ static void valueFlowDynamicBufferSize(const TokenList& tokenlist, const SymbolD
     auto getBufferSizeFromNew = [&](const Token* newTok) -> MathLib::bigint {
         MathLib::bigint sizeValue = -1, numElem = -1;
 
+        // ::operator new(size_t size)
+        if (Token::Match(newTok->astOperand1(), "::| operatornew")) {
+            const Token *sizeTok = newTok->astOperand2();
+            return sizeTok->hasKnownIntValue() ? sizeTok->getKnownIntValue() : -1;
+        }
+
         if (newTok && newTok->astOperand1()) { // number of elements
             const Token* bracTok = nullptr, *typeTok = nullptr;
             if (newTok->astOperand1()->str() == "[")
@@ -7071,7 +7077,7 @@ static void valueFlowDynamicBufferSize(const TokenList& tokenlist, const SymbolD
             if (!rhs)
                 continue;
 
-            const bool isNew = rhs->isCpp() && rhs->str() == "new";
+            const bool isNew = rhs->isCpp() && (rhs->str() == "new" || Token::Match(rhs->astOperand1(), "::| operatornew"));
             if (!isNew && !Token::Match(rhs->previous(), "%name% ("))
                 continue;
 
diff --git a/test/testvalueflow.cpp b/test/testvalueflow.cpp
index 4fc47f63d86..39916ddeb43 100644
--- a/test/testvalueflow.cpp
+++ b/test/testvalueflow.cpp
@@ -7932,6 +7932,13 @@ class TestValueFlow : public TestFixture {
                "  return x;\n"
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 4, ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
+
+        code = "void f()\n"
+               "{\n"
+               "    void *x = ::operator new(0);\n"
+               "    (void) x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 0, ValueFlow::Value::ValueType::BUFFER_SIZE));
     }
 
     void valueFlowSafeFunctionParameterValues() {

From 777a112d9a8ddd3f77b206807cbbfb2ee1a1d202 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Mon, 17 Aug 2026 15:12:57 +0200
Subject: [PATCH 50/59] Fix #14946: `originalName` in dumpfile missing for
 local typedefs (#8793)

---
 lib/tokenize.cpp             | 103 ++++++++++++++++++-----------------
 test/testsimplifytypedef.cpp |  32 +++++++++++
 2 files changed, 85 insertions(+), 50 deletions(-)

diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index 27be2e544a2..bc50979a04f 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -1187,21 +1187,23 @@ void Tokenizer::simplifyTypedef()
     simplifyTypedefCpp();
 }
 
-static Token* simplifyTypedefCopyTokens(Token* to, const Token* fromStart, const Token* toEnd, const Token* location) {
+static Token* simplifyTypedefCopyTokens(Token* to, const Token* fromStart, const Token* toEnd, const Token* location, const std::string &originalName) {
     Token* ret = TokenList::copyTokens(to, fromStart, toEnd);
     for (Token* tok = to->next(); tok != ret->next(); tok = tok->next()) {
         tok->linenr(location->linenr());
         tok->column(location->column());
         tok->isSimplifiedTypedef(true);
+        tok->originalName(originalName);
     }
     return ret;
 }
 
-static Token* simplifyTypedefInsertToken(Token* tok, const std::string& str, const Token* location) {
+static Token* simplifyTypedefInsertToken(Token* tok, const std::string& str, const Token* location, const std::string &originalName) {
     tok = tok->insertToken(str);
     tok->linenr(location->linenr());
     tok->column(location->column());
     tok->isSimplifiedTypedef(true);
+    tok->originalName(originalName);
     return tok;
 }
 
@@ -2037,12 +2039,13 @@ void Tokenizer::simplifyTypedefCpp()
 
                     // start substituting at the typedef name by replacing it with the type
                     const Token* location = tok2;
+                    const std::string originalName = tok2->str();
                     for (Token* tok3 = typeStart; tok3 && (tok3->str() != ";"); tok3 = tok3->next())
                         tok3->isSimplifiedTypedef(true);
                     if (isPointerTypeCall) {
                         tok2->deleteThis();
-                        tok2 = simplifyTypedefInsertToken(tok2, "0", location);
-                        simplifyTypedefInsertToken(tok2->next(), "0", location);
+                        tok2 = simplifyTypedefInsertToken(tok2, "0", location, originalName);
+                        simplifyTypedefInsertToken(tok2->next(), "0", location, originalName);
                     }
                     if (Token::Match(tok2->tokAt(-1), "class|struct|union") && tok2->strAt(-1) == typeStart->str())
                         tok2->deletePrevious();
@@ -2051,7 +2054,7 @@ void Tokenizer::simplifyTypedefCpp()
                         tok2->previous()->str("typedef");
                         tok2->insertToken(tok2->str());
                     }
-                    tok2->originalName(tok2->str());
+                    tok2->originalName(originalName);
                     tok2->str(typeStart->str());
 
                     // restore qualification if it was removed
@@ -2060,12 +2063,12 @@ void Tokenizer::simplifyTypedefCpp()
                             tok2 = tok2->previous();
 
                         if (globalScope) {
-                            tok2 = simplifyTypedefInsertToken(tok2, "::", location);
+                            tok2 = simplifyTypedefInsertToken(tok2, "::", location, originalName);
                         }
 
                         for (std::size_t i = classLevel; i < spaceInfo.size(); ++i) {
-                            tok2 = simplifyTypedefInsertToken(tok2, spaceInfo[i].className, location);
-                            tok2 = simplifyTypedefInsertToken(tok2, "::", location);
+                            tok2 = simplifyTypedefInsertToken(tok2, spaceInfo[i].className, location, originalName);
+                            tok2 = simplifyTypedefInsertToken(tok2, "::", location, originalName);
                         }
                     }
 
@@ -2082,11 +2085,11 @@ void Tokenizer::simplifyTypedefCpp()
                                 std::string::size_type spaceIdx = 0;
                                 std::string::size_type startIdx = 0;
                                 while ((spaceIdx = removed1.find(' ', startIdx)) != std::string::npos) {
-                                    simplifyTypedefInsertToken(tok2->previous(), removed1.substr(startIdx, spaceIdx - startIdx), location);
+                                    simplifyTypedefInsertToken(tok2->previous(), removed1.substr(startIdx, spaceIdx - startIdx), location, originalName);
                                     startIdx = spaceIdx + 1;
                                 }
-                                simplifyTypedefInsertToken(tok2->previous(), removed1.substr(startIdx), location);
-                                simplifyTypedefInsertToken(tok2->previous(), "::", location);
+                                simplifyTypedefInsertToken(tok2->previous(), removed1.substr(startIdx), location, originalName);
+                                simplifyTypedefInsertToken(tok2->previous(), "::", location, originalName);
                                 break;
                             }
                             idx = removed1.rfind(" ::");
@@ -2098,23 +2101,23 @@ void Tokenizer::simplifyTypedefCpp()
                     }
                     Token* constTok = Token::simpleMatch(tok2->previous(), "const") ? tok2->previous() : nullptr;
                     // add remainder of type
-                    tok2 = simplifyTypedefCopyTokens(tok2, typeStart->next(), typeEnd, location);
+                    tok2 = simplifyTypedefCopyTokens(tok2, typeStart->next(), typeEnd, location, originalName);
 
                     if (!pointers.empty()) {
                         for (const std::string &p : pointers)
                             // cppcheck-suppress useStlAlgorithm
-                            tok2 = simplifyTypedefInsertToken(tok2, p, location);
+                            tok2 = simplifyTypedefInsertToken(tok2, p, location, originalName);
                         if (constTok && !functionPtr) {
-                            tok2 = simplifyTypedefInsertToken(tok2, "const", location);
+                            tok2 = simplifyTypedefInsertToken(tok2, "const", location, originalName);
                             constTok->deleteThis();
                             location = constTok;
                         }
                     }
 
                     if (funcStart && funcEnd) {
-                        tok2 = simplifyTypedefInsertToken(tok2, "(", location);
+                        tok2 = simplifyTypedefInsertToken(tok2, "(", location, originalName);
                         Token *paren = tok2;
-                        tok2 = simplifyTypedefCopyTokens(tok2, funcStart, funcEnd, location);
+                        tok2 = simplifyTypedefCopyTokens(tok2, funcStart, funcEnd, location, originalName);
 
                         if (!inCast)
                             tok2 = processFunc(tok2, inOperator);
@@ -2125,17 +2128,17 @@ void Tokenizer::simplifyTypedefCpp()
                         while (Token::Match(tok2, "%name%|] ["))
                             tok2 = tok2->linkAt(1);
 
-                        tok2 = simplifyTypedefInsertToken(tok2, ")", location);
+                        tok2 = simplifyTypedefInsertToken(tok2, ")", location, originalName);
                         Token::createMutualLinks(tok2, paren);
 
-                        tok2 = simplifyTypedefCopyTokens(tok2, argStart, argEnd, location);
+                        tok2 = simplifyTypedefCopyTokens(tok2, argStart, argEnd, location, originalName);
 
                         if (specStart) {
                             Token *spec = specStart;
-                            tok2 = simplifyTypedefInsertToken(tok2, spec->str(), location);
+                            tok2 = simplifyTypedefInsertToken(tok2, spec->str(), location, originalName);
                             while (spec != specEnd) {
                                 spec = spec->next();
-                                tok2 = simplifyTypedefInsertToken(tok2, spec->str(), location);
+                                tok2 = simplifyTypedefInsertToken(tok2, spec->str(), location, originalName);
                             }
                         }
                     }
@@ -2147,20 +2150,20 @@ void Tokenizer::simplifyTypedefCpp()
                         if (!inTemplate && function && tok2->next() && tok2->strAt(1) != "*")
                             needParen = false;
                         if (needParen) {
-                            tok2 = simplifyTypedefInsertToken(tok2, "(", location);
+                            tok2 = simplifyTypedefInsertToken(tok2, "(", location, originalName);
                         }
                         Token *tok3 = tok2;
                         if (namespaceStart) {
                             const Token *tok4 = namespaceStart;
 
                             while (tok4 != namespaceEnd) {
-                                tok2 = simplifyTypedefInsertToken(tok2, tok4->str(), location);
+                                tok2 = simplifyTypedefInsertToken(tok2, tok4->str(), location, originalName);
                                 tok4 = tok4->next();
                             }
-                            tok2 = simplifyTypedefInsertToken(tok2, namespaceEnd->str(), location);
+                            tok2 = simplifyTypedefInsertToken(tok2, namespaceEnd->str(), location, originalName);
                         }
                         if (functionPtr) {
-                            tok2 = simplifyTypedefInsertToken(tok2, "*", location);
+                            tok2 = simplifyTypedefInsertToken(tok2, "*", location, originalName);
                         }
 
                         if (!inCast)
@@ -2170,35 +2173,35 @@ void Tokenizer::simplifyTypedefCpp()
                             if (!tok2)
                                 syntaxError(nullptr);
 
-                            tok2 = simplifyTypedefInsertToken(tok2, ")", location);
+                            tok2 = simplifyTypedefInsertToken(tok2, ")", location, originalName);
                             Token::createMutualLinks(tok2, tok3);
                         }
                         if (!tok2)
                             syntaxError(nullptr);
 
-                        tok2 = simplifyTypedefCopyTokens(tok2, argStart, argEnd, location);
+                        tok2 = simplifyTypedefCopyTokens(tok2, argStart, argEnd, location, originalName);
                         if (inTemplate) {
                             tok2 = tok2->next();
                         }
 
                         if (specStart) {
                             Token *spec = specStart;
-                            tok2 = simplifyTypedefInsertToken(tok2, spec->str(), location);
+                            tok2 = simplifyTypedefInsertToken(tok2, spec->str(), location, originalName);
                             while (spec != specEnd) {
                                 spec = spec->next();
-                                tok2 = simplifyTypedefInsertToken(tok2, spec->str(), location);
+                                tok2 = simplifyTypedefInsertToken(tok2, spec->str(), location, originalName);
                             }
                         }
                     } else if (functionRetFuncPtr || functionPtrRetFuncPtr) {
-                        tok2 = simplifyTypedefInsertToken(tok2, "(", location);
+                        tok2 = simplifyTypedefInsertToken(tok2, "(", location, originalName);
                         Token *tok3 = tok2;
-                        tok2 = simplifyTypedefInsertToken(tok2, "*", location);
+                        tok2 = simplifyTypedefInsertToken(tok2, "*", location, originalName);
 
                         Token * tok4 = nullptr;
                         if (functionPtrRetFuncPtr) {
-                            tok2 = simplifyTypedefInsertToken(tok2, "(", location);
+                            tok2 = simplifyTypedefInsertToken(tok2, "(", location, originalName);
                             tok4 = tok2;
-                            tok2 = simplifyTypedefInsertToken(tok2, "*", location);
+                            tok2 = simplifyTypedefInsertToken(tok2, "*", location, originalName);
                         }
 
                         // skip over variable name if there
@@ -2211,24 +2214,24 @@ void Tokenizer::simplifyTypedefCpp()
                         }
 
                         if (tok4 && functionPtrRetFuncPtr) {
-                            tok2 = simplifyTypedefInsertToken(tok2,")", location);
+                            tok2 = simplifyTypedefInsertToken(tok2,")", location, originalName);
                             Token::createMutualLinks(tok2, tok4);
                         }
 
-                        tok2 = simplifyTypedefCopyTokens(tok2, argStart, argEnd, location);
+                        tok2 = simplifyTypedefCopyTokens(tok2, argStart, argEnd, location, originalName);
 
-                        tok2 = simplifyTypedefInsertToken(tok2, ")", location);
+                        tok2 = simplifyTypedefInsertToken(tok2, ")", location, originalName);
                         Token::createMutualLinks(tok2, tok3);
 
-                        tok2 = simplifyTypedefCopyTokens(tok2, argFuncRetStart, argFuncRetEnd, location);
+                        tok2 = simplifyTypedefCopyTokens(tok2, argFuncRetStart, argFuncRetEnd, location, originalName);
                     } else if (ptrToArray || refToArray) {
-                        tok2 = simplifyTypedefInsertToken(tok2, "(", location);
+                        tok2 = simplifyTypedefInsertToken(tok2, "(", location, originalName);
                         Token *tok3 = tok2;
 
                         if (ptrToArray)
-                            tok2 = simplifyTypedefInsertToken(tok2, "*", location);
+                            tok2 = simplifyTypedefInsertToken(tok2, "*", location, originalName);
                         else
-                            tok2 = simplifyTypedefInsertToken(tok2, "&", location);
+                            tok2 = simplifyTypedefInsertToken(tok2, "&", location, originalName);
 
                         bool hasName = false;
                         // skip over name
@@ -2247,14 +2250,14 @@ void Tokenizer::simplifyTypedefCpp()
                                 tok2 = tok2->linkAt(1);
                         }
 
-                        simplifyTypedefInsertToken(tok2, ")", location);
+                        simplifyTypedefInsertToken(tok2, ")", location, originalName);
                         Token::createMutualLinks(tok2->next(), tok3);
 
                         if (!hasName)
                             tok2 = tok2->next();
                     } else if (ptrMember) {
                         if (Token::simpleMatch(tok2, "* (")) {
-                            tok2 = simplifyTypedefInsertToken(tok2, "*", location);
+                            tok2 = simplifyTypedefInsertToken(tok2, "*", location, originalName);
                         } else {
                             // This is the case of casting operator.
                             // Name is not available, and () should not be
@@ -2263,7 +2266,7 @@ void Tokenizer::simplifyTypedefCpp()
                             Token *openParenthesis = nullptr;
 
                             if (!castOperator) {
-                                tok2 = simplifyTypedefInsertToken(tok2, "(", location);
+                                tok2 = simplifyTypedefInsertToken(tok2, "(", location, originalName);
 
                                 openParenthesis = tok2;
                             }
@@ -2271,25 +2274,25 @@ void Tokenizer::simplifyTypedefCpp()
                             const Token *tok4 = namespaceStart;
 
                             while (tok4 != namespaceEnd) {
-                                tok2 = simplifyTypedefInsertToken(tok2, tok4->str(), location);
+                                tok2 = simplifyTypedefInsertToken(tok2, tok4->str(), location, originalName);
                                 tok4 = tok4->next();
                             }
-                            tok2 = simplifyTypedefInsertToken(tok2, namespaceEnd->str(), location);
+                            tok2 = simplifyTypedefInsertToken(tok2, namespaceEnd->str(), location, originalName);
 
-                            tok2 = simplifyTypedefInsertToken(tok2, "*", location);
+                            tok2 = simplifyTypedefInsertToken(tok2, "*", location, originalName);
 
                             if (openParenthesis) {
                                 // Skip over name, if any
                                 if (Token::Match(tok2->next(), "%name%"))
                                     tok2 = tok2->next();
 
-                                tok2 = simplifyTypedefInsertToken(tok2, ")", location);
+                                tok2 = simplifyTypedefInsertToken(tok2, ")", location, originalName);
 
                                 Token::createMutualLinks(tok2, openParenthesis);
                             }
                         }
                     } else if (typeOf) {
-                        tok2 = simplifyTypedefCopyTokens(tok2, argStart, argEnd, location);
+                        tok2 = simplifyTypedefCopyTokens(tok2, argStart, argEnd, location, originalName);
                     } else if (Token::Match(tok2, "%name% [")) {
                         while (Token::Match(tok2, "%name%|] [")) {
                             tok2 = tok2->linkAt(1);
@@ -2311,7 +2314,7 @@ void Tokenizer::simplifyTypedefCpp()
                             // reference or pointer to array?
                             if (Token::Match(tok2, "&|*|&&")) {
                                 tok2 = tok2->previous();
-                                Token *tok3 = simplifyTypedefInsertToken(tok2, "(", location);
+                                Token *tok3 = simplifyTypedefInsertToken(tok2, "(", location, originalName);
 
                                 // handle missing variable name
                                 if (Token::Match(tok3, "( *|&|&& *|&|&& %name%"))
@@ -2349,7 +2352,7 @@ void Tokenizer::simplifyTypedefCpp()
                                         tok2 = tok2->tokAt(3);
                                 }
 
-                                tok2 = simplifyTypedefInsertToken(tok2, ")", location);
+                                tok2 = simplifyTypedefInsertToken(tok2, ")", location, originalName);
                                 Token::createMutualLinks(tok2, tok3);
                             }
 
@@ -2360,7 +2363,7 @@ void Tokenizer::simplifyTypedefCpp()
                             while (tok2->strAt(1) == "[")
                                 tok2 = tok2->linkAt(1);
 
-                            tok2 = simplifyTypedefCopyTokens(tok2, arrayStart, arrayEnd, location);
+                            tok2 = simplifyTypedefCopyTokens(tok2, arrayStart, arrayEnd, location, originalName);
                             if (!tok2->next())
                                 syntaxError(tok2);
 
diff --git a/test/testsimplifytypedef.cpp b/test/testsimplifytypedef.cpp
index 78d7bd25f3d..330808b7220 100644
--- a/test/testsimplifytypedef.cpp
+++ b/test/testsimplifytypedef.cpp
@@ -257,6 +257,8 @@ class TestSimplifyTypedef : public TestFixture {
         TEST_CASE(simplifyTypedefOriginalName1);
         TEST_CASE(simplifyTypedefOriginalName2);
         TEST_CASE(simplifyTypedefOriginalName3);
+        TEST_CASE(simplifyTypedefOriginalName4);
+        TEST_CASE(simplifyTypedefOriginalName5);
 
         TEST_CASE(simplifyTypedefTokenColumn1);
         TEST_CASE(simplifyTypedefTokenColumn2);
@@ -4622,6 +4624,36 @@ class TestSimplifyTypedef : public TestFixture {
         ASSERT_EQUALS("A", token->originalName());
     }
 
+    void simplifyTypedefOriginalName4() {
+        const char code[] = "void f(void) {\n"
+                            "    typedef unsigned int A;\n"
+                            "    A a;\n"
+                            "}\n";
+        TokenList tokenlist{ settings1, Standards::Language::C };
+        ASSERT(TokenListHelper::createTokensFromString(tokenlist, code, "file.c"));
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        tokenizer.createLinks();
+        tokenizer.simplifyTypedef();
+        ASSERT_NO_THROW(tokenizer.validate());
+        const Token* token = Token::findsimplematch(tokenizer.list.front(), "int");
+        ASSERT_EQUALS("A", token->originalName());
+    }
+
+    void simplifyTypedefOriginalName5() {
+        const char code[] = "void f(void) {\n"
+                            "    typedef void (*A)(int);\n"
+                            "    A a;\n"
+                            "}\n";
+        TokenList tokenlist{ settings1, Standards::Language::C };
+        ASSERT(TokenListHelper::createTokensFromString(tokenlist, code, "file.c"));
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        tokenizer.createLinks();
+        tokenizer.simplifyTypedef();
+        ASSERT_NO_THROW(tokenizer.validate());
+        const Token* token = Token::findsimplematch(tokenizer.list.front(), "int");
+        ASSERT_EQUALS("A", token->originalName());
+    }
+
     void simplifyTypedefTokenColumn1() {  // #13155
         const char code[] = "void foo(void) {\n"
                             "    typedef signed int MY_INT;\n"

From 2e19539840f28d059b7e9fa2402e81994d9d0d23 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Tue, 18 Aug 2026 17:04:48 +0200
Subject: [PATCH 51/59]  Fix #14977 internalError for valid typedef (operator=)
 (#8798)

Co-authored-by: chrchr-github <noreply@github.com>
---
 lib/tokenize.cpp             | 4 ++--
 test/testsimplifytypedef.cpp | 3 +++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index bc50979a04f..b22658db28c 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -572,12 +572,12 @@ namespace {
                         ++nBraces;
                     else if (tok->str() == "}")
                         --nBraces;
+                    if (nBraces > 0)
+                        continue;
                     if (tok == mNameToken)
                         continue;
                     if (tok->str() != mNameToken->str())
                         continue;
-                    if (nBraces > 0 && Token::Match(tok->next(), "[;(]"))
-                        continue;
                     if (Token::Match(tok->previous(), "struct|class|enum|union"))
                         continue;
                     throw InternalError(tok, "recursive typedef encountered");
diff --git a/test/testsimplifytypedef.cpp b/test/testsimplifytypedef.cpp
index 330808b7220..6e8b8820177 100644
--- a/test/testsimplifytypedef.cpp
+++ b/test/testsimplifytypedef.cpp
@@ -3887,6 +3887,9 @@ class TestSimplifyTypedef : public TestFixture {
 
         const char code3[] = "typedef struct S { S() {} } S;"; // #14971
         ASSERT_EQUALS("struct S { S ( ) { } } ;", tok(code3));
+
+        const char code4[] = "typedef struct S { S& operator=(const S&) = delete; } S;"; // #14977
+        ASSERT_EQUALS("struct S { S & operator= ( const S & ) = delete ; } ;", tok(code4));
     }
 
     void simplifyTypedefFunction1() {

From 9699b99f66bfce37e8d946c18944e2c515549d26 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Fri, 21 Aug 2026 19:07:30 +0200
Subject: [PATCH 52/59] Fix  #14980 Nullptr dereference in
 valueFlowDynamicBufferSize() (#8802)

Co-authored-by: chrchr-github <noreply@github.com>
---
 lib/valueflow.cpp      | 2 +-
 test/testvalueflow.cpp | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
index 7acf7179723..4a41bd90537 100644
--- a/lib/valueflow.cpp
+++ b/lib/valueflow.cpp
@@ -7077,7 +7077,7 @@ static void valueFlowDynamicBufferSize(const TokenList& tokenlist, const SymbolD
             if (!rhs)
                 continue;
 
-            const bool isNew = rhs->isCpp() && (rhs->str() == "new" || Token::Match(rhs->astOperand1(), "::| operatornew"));
+            const bool isNew = rhs->isCpp() && (rhs->str() == "new" || (rhs->str() == "(" && Token::Match(rhs->astOperand1(), "::| operatornew")));
             if (!isNew && !Token::Match(rhs->previous(), "%name% ("))
                 continue;
 
diff --git a/test/testvalueflow.cpp b/test/testvalueflow.cpp
index 39916ddeb43..0762dacfcdb 100644
--- a/test/testvalueflow.cpp
+++ b/test/testvalueflow.cpp
@@ -8488,6 +8488,11 @@ class TestValueFlow : public TestFixture {
                "    };\n"
                "}\n";
         (void)valueOfTok(code, "E0");
+
+        code = "void f() {\n" // #14980
+               "    OpNew *newp = &operator new;\n"
+               "}\n";
+        (void)valueOfTok(code, "&");
     }
 
     void valueFlowHang() {

From 8f7666dd3e07027c7d0325ec835b83818e9fb6d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Marjam=C3=A4ki?= <daniel.marjamaki@gmail.com>
Date: Fri, 21 Aug 2026 19:35:31 +0200
Subject: [PATCH 53/59] Fix #14983 (GUI: exclude file with relative path)
 (#8804)

---
 gui/manualtest/projectfiledialog.md      | 14 +++++++++
 gui/projectfile.cpp                      |  9 ++++++
 gui/projectfile.h                        |  8 +++++
 gui/projectfiledialog.cpp                | 13 ++++----
 gui/test/projectfile/testprojectfile.cpp | 40 ++++++++++++++++++++++++
 gui/test/projectfile/testprojectfile.h   |  6 ++++
 6 files changed, 83 insertions(+), 7 deletions(-)

diff --git a/gui/manualtest/projectfiledialog.md b/gui/manualtest/projectfiledialog.md
index f11b030f246..ce7d39b1df0 100644
--- a/gui/manualtest/projectfiledialog.md
+++ b/gui/manualtest/projectfiledialog.md
@@ -4,6 +4,20 @@
 Some manual testing in the project file dialog interface
 
 
+## Test: Relative paths
+
+Ticket: #14983
+
+1. Configure files/paths in project folder:
+ * import a projectfile
+ * add include paths in project folder
+ * exclude file/folder
+
+2. Save project
+
+EXPECTED: Relative paths should be used in the XML
+
+
 ## Test: Platform file pic8.xml
 
 Ticket: #14489
diff --git a/gui/projectfile.cpp b/gui/projectfile.cpp
index 9144f5a6117..716288d9695 100644
--- a/gui/projectfile.cpp
+++ b/gui/projectfile.cpp
@@ -1193,6 +1193,15 @@ QStringList ProjectFile::getSearchPaths(const QString& projectPath, const QStrin
     return ret;
 }
 
+QString ProjectFile::getRelativePath(const QString &absolutePath) const
+{
+    const QDir dir(QFileInfo(mFilename).absolutePath());
+    const QString relativePath(dir.relativeFilePath(absolutePath));
+    if (relativePath.startsWith("../../..") || absolutePath.length() < relativePath.length())
+        return absolutePath;
+    return relativePath;
+}
+
 QStringList ProjectFile::getSearchPaths(const QString& dir) const {
     const QFileInfo inf(mFilename);
     const QString applicationFilePath = QCoreApplication::applicationFilePath();
diff --git a/gui/projectfile.h b/gui/projectfile.h
index 5a5e0ccb89b..e0b85582c99 100644
--- a/gui/projectfile.h
+++ b/gui/projectfile.h
@@ -447,6 +447,14 @@ class ProjectFile : public QObject {
 
     static QStringList getSearchPaths(const QString& projectPath, const QString& appPath, const QString& datadir, const QString& dir);
 
+    /**
+     * @brief Convert an absolute path to a path relative to this project's directory.
+     * If the relative path would need to walk up more than 2 parent folders
+     * (i.e. "../../...") the absolute path is returned unchanged instead.
+     * @param absolutePath Absolute path to convert.
+     */
+    QString getRelativePath(const QString &absolutePath) const;
+
     /** Set user includes in settings if non-empty */
     void setSettingsUserIncludes(Settings &settings) const;
 
diff --git a/gui/projectfiledialog.cpp b/gui/projectfiledialog.cpp
index 72e3d651471..abb7b343ec1 100644
--- a/gui/projectfiledialog.cpp
+++ b/gui/projectfiledialog.cpp
@@ -571,10 +571,7 @@ QString ProjectFileDialog::getExistingDirectory(const QString &caption, bool tra
 
     // Check if the path is relative to project file's path and if so
     // make it a relative path instead of absolute path.
-    const QDir dir(projectPath);
-    const QString relpath(dir.relativeFilePath(selectedDir));
-    if (!relpath.startsWith("../.."))
-        selectedDir = relpath;
+    selectedDir = mProjectFile->getRelativePath(selectedDir);
 
     // Trailing slash..
     if (trailingSlash && !selectedDir.endsWith('/'))
@@ -631,7 +628,7 @@ void ProjectFileDialog::browseImportProject()
                                                     dir.canonicalPath(),
                                                     toFilterString(filters));
     if (!fileName.isEmpty()) {
-        mUI->mEditImportProject->setText(dir.relativeFilePath(fileName));
+        mUI->mEditImportProject->setText(mProjectFile->getRelativePath(fileName));
         updatePathsAndDefines();
         setProjectConfigurations(getProjectConfigs(fileName));
         for (int row = 0; row < mUI->mListVsConfigs->count(); ++row) {
@@ -652,7 +649,7 @@ void ProjectFileDialog::browseUserInclude()
                                                     dir.canonicalPath(),
                                                     toFilterString(filters));
     if (!fileName.isEmpty()) {
-        mUI->mEditUserInclude->setText(dir.relativeFilePath(fileName));
+        mUI->mEditUserInclude->setText(mProjectFile->getRelativePath(fileName));
     }
 }
 
@@ -891,7 +888,9 @@ void ProjectFileDialog::addExcludeFile()
     QMap<QString,QString> filters;
     filters[tr("Source files")] = "*.c *.cpp";
     filters[tr("All files")] = "*.*";
-    addExcludePath(QFileDialog::getOpenFileName(this, tr("Exclude file"), dir.canonicalPath(), toFilterString(filters)));
+    QString fileName = QFileDialog::getOpenFileName(this, tr("Exclude file"), dir.canonicalPath(), toFilterString(filters));
+    if (!fileName.isEmpty())
+        addExcludePath(mProjectFile->getRelativePath(fileName));
 }
 
 void ProjectFileDialog::editExcludePath()
diff --git a/gui/test/projectfile/testprojectfile.cpp b/gui/test/projectfile/testprojectfile.cpp
index efc1dce6c4f..1a66bd8de23 100644
--- a/gui/test/projectfile/testprojectfile.cpp
+++ b/gui/test/projectfile/testprojectfile.cpp
@@ -214,5 +214,45 @@ void TestProjectFile::emptyUserInclude() const
     QCOMPARE(settings.userIncludes.size(), 0);
 }
 
+// Absolute path is made relative when it does not require walking up more than 3 parent folders
+void TestProjectFile::getRelativePathRelative() const
+{
+    ProjectFile projectFile;
+    projectFile.setFilename("/some/path/sub/123.cppcheck");
+    QCOMPARE(projectFile.getRelativePath("/some/path/externals/foo.cpp"), QString("../externals/foo.cpp"));
+}
+
+// Absolute path is made relative even when it requires walking up 2 parent folders
+void TestProjectFile::getRelativePathTwoUp() const
+{
+    ProjectFile projectFile;
+    projectFile.setFilename("/some/path/sub/123.cppcheck");
+    QCOMPARE(projectFile.getRelativePath("/some/externals/foo.cpp"), QString("../../externals/foo.cpp"));
+}
+
+// Absolute path is kept as-is when making it relative would require walking up more than 3 parent folders
+void TestProjectFile::getRelativePathTooFarUp() const
+{
+    ProjectFile projectFile;
+    projectFile.setFilename("/some/path/sub/123.cppcheck");
+    QCOMPARE(projectFile.getRelativePath("/other/deep/foo.cpp"), QString("/other/deep/foo.cpp"));
+}
+
+// Absolute path in a subfolder of the project path is made relative without walking up at all
+void TestProjectFile::getRelativePathSubfolder() const
+{
+    ProjectFile projectFile;
+    projectFile.setFilename("/some/path/sub/123.cppcheck");
+    QCOMPARE(projectFile.getRelativePath("/some/path/sub/src/file1.c"), QString("src/file1.c"));
+}
+
+// Absolute path is kept as-is when it is shorter than the relative path, even if it does not require walking up 3 or more parent folders
+void TestProjectFile::getRelativePathAbsoluteShorter() const
+{
+    ProjectFile projectFile;
+    projectFile.setFilename("/ab/path/sub/123.cppcheck");
+    QCOMPARE(projectFile.getRelativePath("/ab/foo.cpp"), QString("/ab/foo.cpp"));
+}
+
 QTEST_MAIN(TestProjectFile)
 
diff --git a/gui/test/projectfile/testprojectfile.h b/gui/test/projectfile/testprojectfile.h
index ceda2ff6b96..7203980eb7c 100644
--- a/gui/test/projectfile/testprojectfile.h
+++ b/gui/test/projectfile/testprojectfile.h
@@ -38,4 +38,10 @@ private slots:
     void getCheckingSuppressionsStar() const;
 
     void emptyUserInclude() const;
+
+    void getRelativePathRelative() const;
+    void getRelativePathTwoUp() const;
+    void getRelativePathTooFarUp() const;
+    void getRelativePathSubfolder() const;
+    void getRelativePathAbsoluteShorter() const;
 };

From 5e7baff38ff8fbb87c4a25de33345436386febb5 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Sun, 23 Aug 2026 19:33:03 +0200
Subject: [PATCH 54/59] Fix #14960 Inconsistent bufferAccessOutOfBounds
 (possible values)  (#8779)

After #8763

---------

Co-authored-by: chrchr-github <noreply@github.com>
---
 lib/checkbufferoverrun.cpp | 33 ++++++++++++++++++++++-----------
 test/testbufferoverrun.cpp | 17 +++++++++++++++++
 2 files changed, 39 insertions(+), 11 deletions(-)

diff --git a/lib/checkbufferoverrun.cpp b/lib/checkbufferoverrun.cpp
index f0a12efccec..b3aa09d137c 100644
--- a/lib/checkbufferoverrun.cpp
+++ b/lib/checkbufferoverrun.cpp
@@ -629,7 +629,7 @@ ValueFlow::Value CheckBufferOverrunImpl::getBufferSize(const Token *bufTok, cons
 }
 //---------------------------------------------------------------------------
 
-static bool checkBufferSize(const Token *ftok, const Library::ArgumentChecks::MinSize &minsize, const std::vector<const Token *> &args, const MathLib::bigint bufferSize, const Settings &settings, const Tokenizer* tokenizer)
+static bool checkBufferSize(const Token *ftok, const Library::ArgumentChecks::MinSize &minsize, const std::vector<const Token *> &args, ValueFlow::Value& bufferSize, const Settings &settings, const Tokenizer* tokenizer)
 {
     const Token * const arg = (minsize.arg > 0 && minsize.arg - 1 < args.size()) ? args[minsize.arg - 1] : nullptr;
     const Token * const arg2 = (minsize.arg2 > 0 && minsize.arg2 - 1 < args.size()) ? args[minsize.arg2 - 1] : nullptr;
@@ -637,20 +637,31 @@ static bool checkBufferSize(const Token *ftok, const Library::ArgumentChecks::Mi
     switch (minsize.type) {
     case Library::ArgumentChecks::MinSize::Type::STRLEN:
         if (settings.library.isargformatstr(ftok, minsize.arg)) {
-            return getMinFormatStringOutputLength(args, minsize.arg, settings) < bufferSize;
+            return getMinFormatStringOutputLength(args, minsize.arg, settings) < bufferSize.intvalue;
         } else if (arg) {
             const Token *strtoken = arg->getValueTokenMaxStrLength();
             if (strtoken)
-                return Token::getStrLength(strtoken) < bufferSize;
+                return Token::getStrLength(strtoken) < bufferSize.intvalue;
         }
         break;
     case Library::ArgumentChecks::MinSize::Type::ARGVALUE: {
-        if (arg && arg->hasKnownIntValue()) {
-            MathLib::bigint myMinsize = arg->getKnownIntValue();
+        if (arg) {
+            const ValueFlow::Value* argVal = arg->hasKnownIntValue() ?
+                                             arg->getKnownValue(ValueFlow::Value::ValueType::INT) :
+                                             arg->getMaxValue(/*condition*/ true);
+            if (!argVal)
+                break;
+            MathLib::bigint myMinsize = argVal->intvalue;
             const int baseSize = tokenizer->sizeOfType(minsize.baseType);
             if (baseSize != 0)
                 myMinsize *= baseSize;
-            return myMinsize <= bufferSize;
+            const bool ok = myMinsize <= bufferSize.intvalue;
+            if (!ok) {
+                bufferSize.errorPath.insert(bufferSize.errorPath.end(), argVal->errorPath.begin(), argVal->errorPath.end());
+                if (!bufferSize.condition)
+                    bufferSize.condition = argVal->condition;
+            }
+            return ok;
         }
         break;
     }
@@ -659,14 +670,14 @@ static bool checkBufferSize(const Token *ftok, const Library::ArgumentChecks::Mi
         break;
     case Library::ArgumentChecks::MinSize::Type::MUL:
         if (arg && arg2 && arg->hasKnownIntValue() && arg2->hasKnownIntValue())
-            return (arg->getKnownIntValue() * arg2->getKnownIntValue()) <= bufferSize;
+            return (arg->getKnownIntValue() * arg2->getKnownIntValue()) <= bufferSize.intvalue;
         break;
     case Library::ArgumentChecks::MinSize::Type::VALUE: {
         MathLib::bigint myMinsize = minsize.value;
         const int baseSize = tokenizer->sizeOfType(minsize.baseType);
         if (baseSize != 0)
             myMinsize *= baseSize;
-        return myMinsize <= bufferSize;
+        return myMinsize <= bufferSize.intvalue;
     }
     case Library::ArgumentChecks::MinSize::Type::NONE:
         break;
@@ -704,7 +715,7 @@ void CheckBufferOverrunImpl::bufferOverflow()
                 if (argtok->valueType() && argtok->valueType()->pointer == 0)
                     continue;
                 // TODO: strcpy(buf+10, "hello");
-                const ValueFlow::Value bufferSize = getBufferSize(argtok, mSettings);
+                ValueFlow::Value bufferSize = getBufferSize(argtok, mSettings);
                 if (bufferSize.intvalue <= 0)
                     continue;
                 // buffer size == 1 => do not warn for dynamic memory
@@ -723,7 +734,7 @@ void CheckBufferOverrunImpl::bufferOverflow()
                     }
                 }
                 const bool error = std::none_of(minsizes->begin(), minsizes->end(), [&](const Library::ArgumentChecks::MinSize &minsize) {
-                    return checkBufferSize(tok, minsize, args, bufferSize.intvalue, mSettings, mTokenizer);
+                    return checkBufferSize(tok, minsize, args, bufferSize, mSettings, mTokenizer);
                 });
                 if (error)
                     bufferOverflowError(args[argnr], &bufferSize, Certainty::normal);
@@ -735,7 +746,7 @@ void CheckBufferOverrunImpl::bufferOverflow()
 void CheckBufferOverrunImpl::bufferOverflowError(const Token *tok, const ValueFlow::Value *value, Certainty certainty)
 {
     const auto errorPath = getErrorPath(tok, value, "Buffer overrun");
-    const auto severity = !value || value->isKnown() ? Severity::error : Severity::warning;
+    const auto severity = !value || (value->isKnown() && !value->condition) ? Severity::error : Severity::warning;
     const std::string msg = "Buffer is accessed out of bounds: " + (tok ? getRealBufferTok(tok)->expressionString() : "buf");
     reportError(errorPath, severity, "bufferAccessOutOfBounds", msg, CWE_BUFFER_OVERRUN, certainty);
 }
diff --git a/test/testbufferoverrun.cpp b/test/testbufferoverrun.cpp
index 3914f0ee828..229b2883b9e 100644
--- a/test/testbufferoverrun.cpp
+++ b/test/testbufferoverrun.cpp
@@ -3659,6 +3659,23 @@ class TestBufferOverrun : public TestFixture {
         ASSERT_EQUALS("[test.cpp:4:21]: warning: Buffer is accessed out of bounds: &s[0] [bufferAccessOutOfBounds]\n"
                       "[test.cpp:2:18]: note: Assuming that condition 's.size()==2' is not redundant\n"
                       "[test.cpp:4:21]: note: Buffer overrun\n", errout_str());
+
+        check("void f(int i) {\n" // #14960
+              "    int a[1];\n"
+              "    if (i != 2) return;\n"
+              "    memset(a, 0, i * sizeof(int));\n"
+              "}"
+              "void g(int i) {\n"
+              "    int a[1];\n"
+              "    if (i != 2) {}\n"
+              "    memset(a, 0, i * sizeof(int));\n"
+              "}", s);
+        ASSERT_EQUALS("[test.cpp:4:12]: warning: Buffer is accessed out of bounds: a [bufferAccessOutOfBounds]\n"
+                      "[test.cpp:3:11]: note: Assuming that condition 'i!=2' is not redundant\n"
+                      "[test.cpp:4:12]: note: Buffer overrun\n"
+                      "[test.cpp:8:12]: warning: Buffer is accessed out of bounds: a [bufferAccessOutOfBounds]\n"
+                      "[test.cpp:7:11]: note: Assuming that condition 'i!=2' is not redundant\n"
+                      "[test.cpp:8:12]: note: Buffer overrun\n", errout_str());
     }
 
     void buffer_overrun_bailoutIfSwitch() {

From 518010a753d865caf1d3aab8801737c6be2cfd6c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ludvig=20Gunne=20Lindstr=C3=B6m?=
 <ludviggunnelindstrom@gmail.com>
Date: Mon, 24 Aug 2026 14:37:42 +0200
Subject: [PATCH 55/59] Fix #14984: Valueflow: Buffer size not tracked across
 function calls (#8806)

---
 lib/valueflow.cpp      |  2 +-
 test/cli/other_test.py |  2 ++
 test/testvalueflow.cpp | 11 +++++++++++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
index 4a41bd90537..e956c92c5e0 100644
--- a/lib/valueflow.cpp
+++ b/lib/valueflow.cpp
@@ -7541,6 +7541,7 @@ void ValueFlow::setValues(TokenList& tokenlist,
         VFA(valueFlowInferCondition(tokenlist, settings)),
         VFA(valueFlowSwitchVariable(tokenlist, symboldatabase, errorLogger, settings)),
         VFA(valueFlowForLoop(tokenlist, symboldatabase, errorLogger, settings)),
+        VFA(valueFlowDynamicBufferSize(tokenlist, symboldatabase, errorLogger, settings)),
         VFA(valueFlowSubFunction(tokenlist, symboldatabase, errorLogger, settings)),
         VFA(valueFlowFunctionReturn(tokenlist, errorLogger, settings)),
         VFA(valueFlowLifetime(tokenlist, errorLogger, settings)),
@@ -7557,7 +7558,6 @@ void ValueFlow::setValues(TokenList& tokenlist,
     });
 
     runner.run_once({
-        VFA(valueFlowDynamicBufferSize(tokenlist, symboldatabase, errorLogger, settings)),
         VFA(valueFlowDebug(tokenlist, errorLogger, settings)), // TODO: add option to print it after each step/iteration
     });
 }
diff --git a/test/cli/other_test.py b/test/cli/other_test.py
index f5928c07de5..4d4dbec7b0a 100644
--- a/test/cli/other_test.py
+++ b/test/cli/other_test.py
@@ -210,6 +210,8 @@ def test_progress(tmpdir):
             "progress: ValueFlow::valueFlowSwitchVariable(tokenlist, symboldatabase, errorLogger, settings) 1 100%\n"
             "progress: ValueFlow::valueFlowForLoop(tokenlist, symboldatabase, errorLogger, settings) 1 0%\n"
             "progress: ValueFlow::valueFlowForLoop(tokenlist, symboldatabase, errorLogger, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowDynamicBufferSize(tokenlist, symboldatabase, errorLogger, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowDynamicBufferSize(tokenlist, symboldatabase, errorLogger, settings) 1 100%\n"
             "progress: ValueFlow::valueFlowSubFunction(tokenlist, symboldatabase, errorLogger, settings) 1 0%\n"
             "progress: ValueFlow::valueFlowSubFunction(tokenlist, symboldatabase, errorLogger, settings) 1 100%\n"
             "progress: ValueFlow::valueFlowFunctionReturn(tokenlist, errorLogger, settings) 1 0%\n"
diff --git a/test/testvalueflow.cpp b/test/testvalueflow.cpp
index 0762dacfcdb..98c4271f509 100644
--- a/test/testvalueflow.cpp
+++ b/test/testvalueflow.cpp
@@ -7939,6 +7939,17 @@ class TestValueFlow : public TestFixture {
                "    (void) x;\n"
                "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 0, ValueFlow::Value::ValueType::BUFFER_SIZE));
+
+        code = "void f(int *x)\n"
+               "{\n"
+               "	*x = 1;\n"
+               "}\n"
+               "void g(void)\n"
+               "{\n"
+               "	int *ptr = malloc(1234);\n"
+               "	f(ptr);\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 1234, ValueFlow::Value::ValueType::BUFFER_SIZE));
     }
 
     void valueFlowSafeFunctionParameterValues() {

From ac8c1aadcc153f3ef9bd199d304390b82cd76770 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Tue, 25 Aug 2026 19:11:11 +0200
Subject: [PATCH 56/59] Partial fix for #14982 internalAstError for noexcept
 function with requires clause (#8808)

Co-authored-by: chrchr-github <noreply@github.com>
---
 lib/templatesimplifier.cpp    |  2 +-
 test/testsimplifytemplate.cpp | 17 +++++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/lib/templatesimplifier.cpp b/lib/templatesimplifier.cpp
index 24cc0bcbe1d..a194c0c8793 100644
--- a/lib/templatesimplifier.cpp
+++ b/lib/templatesimplifier.cpp
@@ -3831,7 +3831,7 @@ void TemplateSimplifier::simplifyTemplates(const std::time_t maxtime)
         // Remove concepts/requires
         // TODO concepts are not removed yet
         for (Token *tok = mTokenList.front(); tok; tok = tok->next()) {
-            if (!Token::Match(tok, ")|>|>> requires %name%|("))
+            if (!Token::Match(tok, ")|>|>>|const|noexcept requires %name%|("))
                 continue;
             const Token* end = skipRequires(tok->next());
             if (end)
diff --git a/test/testsimplifytemplate.cpp b/test/testsimplifytemplate.cpp
index 6960b791426..b37ed03db34 100644
--- a/test/testsimplifytemplate.cpp
+++ b/test/testsimplifytemplate.cpp
@@ -314,6 +314,7 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(requires3);
         TEST_CASE(requires4);
         TEST_CASE(requires5);
+        TEST_CASE(requires6);
 
         TEST_CASE(explicitBool1);
         TEST_CASE(explicitBool2);
@@ -6696,6 +6697,22 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT_EQUALS(expected, tok(code));
     }
 
+    void requires6() {
+        const char code[] = "template <int N>\n" // #14982
+                            "struct S {\n"
+                            "  static void f() noexcept\n"
+                            "    requires(N >= 5) {}\n"
+                            "  void g() const\n"
+                            "    requires(N >= 5) {}\n"
+                            "};";
+        const char expected[] = "template < int N > "
+                                "struct S { "
+                                "static void f ( ) noexcept { } "
+                                "void g ( ) const { } "
+                                "} ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
     void explicitBool1() {
         const char code[] = "class Fred { explicit(true) Fred(int); };";
         ASSERT_EQUALS("class Fred { explicit Fred ( int ) ; } ;", tok(code));

From ff4d7ce36a665f57a573f08602fa8faf2b142e15 Mon Sep 17 00:00:00 2001
From: glankk <glankk@users.noreply.github.com>
Date: Wed, 26 Aug 2026 13:42:09 +0200
Subject: [PATCH 57/59] Fix #14987: Update simplecpp to 1.9.1 (#8809)

---
 externals/simplecpp/simplecpp.cpp |  262 +-
 externals/simplecpp/simplecpp.h   |   91 +-
 lib/cppcheck.cpp                  |   34 +-
 lib/importproject.cpp             |    2 +-
 lib/library.cpp                   |    2 +-
 lib/preprocessor.cpp              |    6 +
 lib/programmemory.cpp             |    2 +-
 lib/standards.cpp                 |   12 +
 lib/standards.h                   |    1 +
 lib/symboldatabase.cpp            |    4 +-
 lib/tokenlist.cpp                 |    4 +-
 lib/valueflow.cpp                 |    5 +-
 test/helpers.cpp                  |    6 +-
 test/test64bit.cpp                |   62 +-
 test/testassert.cpp               |   46 +-
 test/testastutils.cpp             |  274 +--
 test/testautovariables.cpp        |  622 ++---
 test/testbool.cpp                 |  330 +--
 test/testbufferoverrun.cpp        |  958 ++++----
 test/testcharvar.cpp              |   40 +-
 test/testclass.cpp                | 1346 +++++-----
 test/testcondition.cpp            | 1134 ++++-----
 test/testconstructors.cpp         |  586 ++---
 test/testcppcheck.cpp             |   16 +-
 test/testerrorlogger.cpp          |    8 +-
 test/testexceptionsafety.cpp      |   72 +-
 test/testfunctions.cpp            |  378 +--
 test/testgarbage.cpp              |  654 ++---
 test/testincompletestatement.cpp  |  100 +-
 test/testio.cpp                   |  498 ++--
 test/testleakautovar.cpp          |  484 ++--
 test/testlibrary.cpp              |   70 +-
 test/testmemleak.cpp              |  386 +--
 test/testnullpointer.cpp          |  684 +++---
 test/testother.cpp                | 2248 ++++++++---------
 test/testpostfixoperator.cpp      |   60 +-
 test/testpreprocessor.cpp         |  156 +-
 test/testprogrammemory.cpp        |    2 +-
 test/testsimplifytemplate.cpp     |  976 ++++----
 test/testsimplifytokens.cpp       |  605 ++---
 test/testsimplifytypedef.cpp      |  566 ++---
 test/testsimplifyusing.cpp        |  118 +-
 test/testsingleexecutor.cpp       |   32 +-
 test/testsizeof.cpp               |  248 +-
 test/teststl.cpp                  |  684 +++---
 test/teststring.cpp               |  254 +-
 test/testsummaries.cpp            |    6 +-
 test/testsuppressions.cpp         |   22 +-
 test/testsymboldatabase.cpp       | 1324 +++++-----
 test/testthreadexecutor.cpp       |   28 +-
 test/testtoken.cpp                |  150 +-
 test/testtokenize.cpp             | 3807 +++++++++++++++--------------
 test/testtokenlist.cpp            |   22 +-
 test/testtokenrange.cpp           |   12 +-
 test/testtype.cpp                 |  124 +-
 test/testuninitvar.cpp            | 1390 +++++------
 test/testunusedfunctions.cpp      |  118 +-
 test/testunusedprivfunc.cpp       |  226 +-
 test/testunusedvar.cpp            | 1148 ++++-----
 test/testvaarg.cpp                |   62 +-
 test/testvalueflow.cpp            | 1216 ++++-----
 test/testvarid.cpp                |  501 ++--
 62 files changed, 12805 insertions(+), 12479 deletions(-)

diff --git a/externals/simplecpp/simplecpp.cpp b/externals/simplecpp/simplecpp.cpp
index d2c398c49e1..8237ac75fab 100644
--- a/externals/simplecpp/simplecpp.cpp
+++ b/externals/simplecpp/simplecpp.cpp
@@ -96,6 +96,8 @@ static const simplecpp::TokenString IFNDEF("ifndef");
 static const simplecpp::TokenString DEFINED("defined");
 static const simplecpp::TokenString ELSE("else");
 static const simplecpp::TokenString ELIF("elif");
+static const simplecpp::TokenString ELIFDEF("elifdef");
+static const simplecpp::TokenString ELIFNDEF("elifndef");
 static const simplecpp::TokenString ENDIF("endif");
 
 static const simplecpp::TokenString PRAGMA("pragma");
@@ -475,26 +477,26 @@ namespace {
 
 simplecpp::TokenList::TokenList(std::vector<std::string> &filenames) : frontToken(nullptr), backToken(nullptr), files(filenames) {}
 
-simplecpp::TokenList::TokenList(std::istream &istr, std::vector<std::string> &filenames, const std::string &filename, OutputList *outputList)
+simplecpp::TokenList::TokenList(std::istream &istr, std::vector<std::string> &filenames, const std::string &filename, const DUI &dui, OutputList *outputList)
     : frontToken(nullptr), backToken(nullptr), files(filenames)
 {
     StdIStream stream(istr);
-    readfile(stream,filename,outputList);
+    readfile(stream,filename,dui,outputList);
 }
 
-simplecpp::TokenList::TokenList(const unsigned char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename, OutputList *outputList, int /*unused*/)
+simplecpp::TokenList::TokenList(const unsigned char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename, const DUI &dui, OutputList *outputList, int /*unused*/)
     : frontToken(nullptr), backToken(nullptr), files(filenames)
 {
     StdCharBufStream stream(data, size);
-    readfile(stream,filename,outputList);
+    readfile(stream,filename,dui,outputList);
 }
 
-simplecpp::TokenList::TokenList(const std::string &filename, std::vector<std::string> &filenames, OutputList *outputList)
+simplecpp::TokenList::TokenList(const std::string &filename, std::vector<std::string> &filenames, const DUI &dui, OutputList *outputList)
     : frontToken(nullptr), backToken(nullptr), files(filenames)
 {
     try {
         FileStream stream(filename, filenames);
-        readfile(stream,filename,outputList);
+        readfile(stream,filename,dui,outputList);
     } catch (const simplecpp::Output & e) {
         outputList->emplace_back(e);
     }
@@ -659,18 +661,24 @@ void simplecpp::TokenList::lineDirective(unsigned int fileIndex_, unsigned int l
 
 static const std::string COMMENT_END("*/");
 
-void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename, OutputList *outputList)
+void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename, const DUI &dui, OutputList *outputList)
 {
     unsigned int multiline = 0U;
+    bool trailing_nl = true;
 
     const Token *oldLastToken = nullptr;
 
+    const cstd_t cstd = getCStd(dui.std);
+    const cppstd_t cppstd = getCppStd(dui.std);
+
     Location location(fileIndex(filename), 1, 1);
     while (stream.good()) {
         unsigned char ch = stream.readChar();
         if (!stream.good())
             break;
 
+        trailing_nl = false;
+
         if (ch >= 0x80) {
             if (outputList) {
                 simplecpp::Output err{
@@ -693,6 +701,7 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
             } else {
                 location.line += multiline + 1;
                 multiline = 0U;
+                trailing_nl = true;
             }
             if (!multiline)
                 location.col = 1;
@@ -723,10 +732,64 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
                 if (ppTok->str() == "line")
                     ppTok = advanceAndSkipComments(ppTok);
 
+                if (ppTok && (ppTok->str()[0] == '-' || ppTok->str()[0] == '+')) {
+                    if (outputList) {
+                        simplecpp::Output err{
+                            simplecpp::Output::SYNTAX_ERROR,
+                            location,
+                            "Invalid character in line directive: '" + ppTok->str() + "'."
+                        };
+                        outputList->emplace_back(std::move(err));
+                    }
+                    clear();
+                    return;
+                }
+
                 if (!ppTok || !ppTok->number)
                     continue;
 
-                const unsigned int line = std::atol(ppTok->str().c_str());
+                constexpr unsigned long line_limit = std::numeric_limits<decltype(Location::line)>::max();
+                unsigned long line;
+                try {
+                    line = std::min(line_limit, std::stoul(ppTok->str()));
+                } catch (...) {
+                    line = line_limit;
+                }
+
+                unsigned long maxline;
+                if ((cstd != CUnknown && cstd < C99) || (cppstd != CPPUnknown && cppstd < CPP11))
+                    maxline = 32767;
+                else
+                    maxline = 2147483647;
+
+                if (line == 0 || line > maxline) {
+                    if (outputList) {
+                        const bool unknown_std = cstd == CUnknown && cppstd == CPPUnknown;
+                        std::string msg = "Line number out of range: " + ppTok->str() + ". ";
+                        if (line == 0) {
+                            msg += "Line number zero is undefined behavior.";
+                        } else {
+                            msg += "Line numbers above " + std::to_string(maxline) + " are ";
+                            if (unknown_std)
+                                msg += "undefined behavior or conditionally supported";
+                            else if (cppstd >= CPP26)
+                                msg += "conditionally supported";
+                            else
+                                msg += "undefined behavior";
+                            if (cstd != CUnknown)
+                                msg += std::string(" in ") + getCStdName(cstd);
+                            else if (cppstd != CPPUnknown)
+                                msg += std::string(" in ") + getCppStdName(cppstd);
+                            msg += ".";
+                        }
+                        simplecpp::Output err{
+                            simplecpp::Output::PORTABILITY_LINE_DIRECTIVE,
+                            location, msg
+                        };
+                        outputList->emplace_back(std::move(err));
+                    }
+                }
+
                 ppTok = advanceAndSkipComments(ppTok);
 
                 unsigned int fileindex;
@@ -961,6 +1024,15 @@ void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename,
             location.adjust(currentToken);
     }
 
+    if ((cstd != CUnknown || cppstd == CPPUnknown) && !trailing_nl && outputList) {
+        Output err{
+            Output::PORTABILITY_NO_EOF_NEWLINE,
+            location,
+            "No newline at end of file is undefined behavior in C."
+        };
+        outputList->emplace_back(std::move(err));
+    }
+
     combineOperators();
 }
 
@@ -1523,7 +1595,7 @@ namespace simplecpp {
          * @throws std::runtime_error thrown on bad macro syntax
          */
         Macro(const std::string &name, const std::string &value, std::vector<std::string> &f) : nameTokDef(nullptr), files(f), tokenListDefine(f), valueDefinedInCode_(false) {
-            const std::string def(name + ' ' + value);
+            const std::string def(name + ' ' + value + '\n');
             StdCharBufStream stream(reinterpret_cast<const unsigned char*>(def.data()), def.size());
             tokenListDefine.readfile(stream);
             if (!parseDefine(tokenListDefine.cfront()))
@@ -1602,7 +1674,7 @@ namespace simplecpp {
                     else if (rawtok->op == ')')
                         --par;
                     else if (rawtok->op == '#' && !sameline(rawtok->previous, rawtok))
-                        throw Error(rawtok->location, "it is invalid to use a preprocessor directive as macro parameter");
+                        throw invalidDirectiveAsMacroParameter(rawtok->location);
                     rawtokens2.push_back(new Token(rawtok->str(), rawtok1->location, rawtok->whitespaceahead));
                     rawtok = rawtok->next;
                 }
@@ -1635,7 +1707,7 @@ namespace simplecpp {
                 if (output2.cfront() != output2.cback() && macro2tok->str() == this->name())
                     break;
                 const MacroMap::const_iterator macro = macros.find(macro2tok->str());
-                if (macro == macros.end() || !macro->second.functionLike())
+                if (macro == macros.end() || !macro->second.functionLike() || macro2tok->isExpandedFrom(&macro->second))
                     break;
                 TokenList rawtokens2(inputFiles);
                 const Location loc(macro2tok->location);
@@ -1698,6 +1770,11 @@ namespace simplecpp {
             const std::string what;
         };
 
+        struct invalidDirectiveAsMacroParameter : public Error {
+            explicit invalidDirectiveAsMacroParameter(const Location &loc)
+                : Error(loc, "it is invalid to use a preprocessor directive as macro parameter") {}
+        };
+
         /** Struct that is thrown when macro is expanded with wrong number of parameters */
         struct wrongNumberOfParameters : public Error {
             wrongNumberOfParameters(const Location &loc, const std::string &macroName) : Error(loc, "Wrong number of parameters for macro \'" + macroName + "\'.") {}
@@ -1917,14 +1994,17 @@ namespace simplecpp {
 
             if (nameTokInst->str() == "__FILE__") {
                 output.push_back(new Token('\"'+output.file(loc)+'\"', loc));
+                output.back()->macro = "__FILE__";
                 return nameTokInst->next;
             }
             if (nameTokInst->str() == "__LINE__") {
                 output.push_back(new Token(toString(loc.line), loc));
+                output.back()->macro = "__LINE__";
                 return nameTokInst->next;
             }
             if (nameTokInst->str() == "__COUNTER__") {
                 output.push_back(new Token(toString(usageList.size()-1U), loc));
+                output.back()->macro = "__COUNTER__";
                 return nameTokInst->next;
             }
 
@@ -2084,39 +2164,37 @@ namespace simplecpp {
             return functionLike() ? parametertokens2.back()->next : nameTokInst->next;
         }
 
-        const Token *recursiveExpandToken(TokenList &output, TokenList &temp, const Location &loc, const Token *tok, const MacroMap &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens) const {
-            if (!temp.cback() || !temp.cback()->name || !tok->next || tok->next->op != '(') {
-                output.takeTokens(temp);
-                return tok->next;
-            }
-
-            if (!sameline(tok, tok->next)) {
-                output.takeTokens(temp);
-                return tok->next;
-            }
-
+        /** Returns the macro to expand when the last token of @p temp is the name of a
+         *  function-like macro and the tokens after @p tok supply its arguments; nullptr otherwise */
+        static const Macro *rescanMacro(const TokenList &temp, const Token *tok, const MacroMap &macros, const std::set<TokenString> &expandedmacros) {
+            if (!temp.cback() || !temp.cback()->name || !sameline(tok, tok->next) || tok->next->op != '(')
+                return nullptr;
             const MacroMap::const_iterator it = macros.find(temp.cback()->str());
-            if (it == macros.end() || expandedmacros.find(temp.cback()->str()) != expandedmacros.end()) {
-                output.takeTokens(temp);
-                return tok->next;
-            }
+            if (it == macros.end() || expandedmacros.find(temp.cback()->str()) != expandedmacros.end())
+                return nullptr;
+            if (!it->second.functionLike() || temp.cback()->isExpandedFrom(&it->second))
+                return nullptr;
+            return &it->second;
+        }
 
-            const Macro &calledMacro = it->second;
-            if (!calledMacro.functionLike()) {
+        const Token *recursiveExpandToken(TokenList &output, TokenList &temp, const Location &loc, const Token *tok, const MacroMap &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens) const {
+            // Expand while the expansion result ends with the name of a function-like
+            // macro whose arguments are supplied by the tokens that follow it. Each round
+            // consumes that macro call from the token stream, so tok always advances.
+            while (const Macro * const calledMacro = rescanMacro(temp, tok, macros, expandedmacros)) {
+                TokenList temp2(files);
+                temp2.push_back(new Token(temp.cback()->str(), tok->location));
+
+                const Token * const tok2 = appendTokens(temp2, loc, tok->next, macros, expandedmacros, parametertokens);
+                if (!tok2)
+                    break;
                 output.takeTokens(temp);
-                return tok->next;
+                output.deleteToken(output.back());
+                calledMacro->expand(temp, loc, temp2.cfront(), macros, expandedmacros);
+                tok = tok2;
             }
-
-            TokenList temp2(files);
-            temp2.push_back(new Token(temp.cback()->str(), tok->location));
-
-            const Token * const tok2 = appendTokens(temp2, loc, tok->next, macros, expandedmacros, parametertokens);
-            if (!tok2)
-                return tok->next;
             output.takeTokens(temp);
-            output.deleteToken(output.back());
-            calledMacro.expand(output, loc, temp2.cfront(), macros, expandedmacros);
-            return tok2->next;
+            return tok->next;
         }
 
         const Token *expandToken(TokenList &output, const Location &loc, const Token *tok, const MacroMap &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens) const {
@@ -3126,8 +3204,8 @@ simplecpp::FileDataCache::FileDataCache()
 {}
 
 simplecpp::FileDataCache::~FileDataCache() = default;
-simplecpp::FileDataCache::FileDataCache(FileDataCache &&) noexcept = default;
-simplecpp::FileDataCache &simplecpp::FileDataCache::operator=(simplecpp::FileDataCache &&) noexcept = default;
+simplecpp::FileDataCache::FileDataCache(FileDataCache &&) SIMPLECPP_NOEXCEPT = default;
+simplecpp::FileDataCache &simplecpp::FileDataCache::operator=(simplecpp::FileDataCache &&) SIMPLECPP_NOEXCEPT = default;
 
 static bool getFileId(const std::string &path, FileID &id);
 
@@ -3145,7 +3223,7 @@ std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::tryload(FileDat
         return {id_it->second, false};
     }
 
-    auto *const data = new FileData {path, TokenList(path, filenames, outputList)};
+    auto *const data = new FileData {path, TokenList(path, filenames, {}, outputList)};
 
     if (dui.removeComments)
         data->tokens.removeComments();
@@ -3154,13 +3232,10 @@ std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::tryload(FileDat
     mImpl->mIdMap.emplace(fileId, data);
     mData.emplace_back(data);
 
-    if (mLoadCallback)
-        mLoadCallback(*data);
-
     return {data, true};
 }
 
-std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::get(const std::string &sourcefile, const std::string &header, const simplecpp::DUI &dui, bool systemheader, std::vector<std::string> &filenames, simplecpp::OutputList *outputList)
+std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::get_private(const std::string &sourcefile, const std::string &header, const simplecpp::DUI &dui, bool systemheader, std::vector<std::string> &filenames, simplecpp::OutputList *outputList)
 {
     if (isAbsolutePath(header)) {
         auto ins = mNameMap.emplace(simplecpp::simplifyPath(header), nullptr);
@@ -3206,6 +3281,16 @@ std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::get(const std::
     return {nullptr, false};
 }
 
+std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::get(const std::string &sourcefile, const std::string &header, const simplecpp::DUI &dui, bool systemheader, std::vector<std::string> &filenames, simplecpp::OutputList *outputList)
+{
+    auto ret = get_private(sourcefile, header, dui, systemheader, filenames, outputList);
+
+    if (mLoadCallback && ret.first)
+        mLoadCallback(*ret.first, ret.second);
+
+    return ret;
+}
+
 void simplecpp::FileDataCache::clear()
 {
     mImpl->clear();
@@ -3336,7 +3421,7 @@ simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens,
     return cache;
 }
 
-static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token *&tok1, simplecpp::MacroMap &macros, std::vector<std::string> &files, simplecpp::OutputList *outputList)
+static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token *&tok1, simplecpp::MacroMap &macros, std::vector<std::string> &files, simplecpp::OutputList *outputList, const simplecpp::DUI &dui)
 {
     const simplecpp::Token * const tok = tok1;
     const simplecpp::MacroMap::const_iterator it = tok->name ? macros.find(tok->str()) : macros.end();
@@ -3344,6 +3429,16 @@ static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token
         simplecpp::TokenList value(files);
         try {
             tok1 = it->second.expand(value, tok, macros, files);
+        } catch (const simplecpp::Macro::invalidDirectiveAsMacroParameter &err) {
+            if (outputList) {
+                simplecpp::Output out{
+                    simplecpp::Output::DIRECTIVE_AS_MACRO_PARAMETER,
+                    err.location,
+                    "failed to expand \'" + tok->str() + "\', " + err.what
+                };
+                outputList->emplace_back(std::move(out));
+            }
+            return false;
         } catch (const simplecpp::Macro::Error &err) {
             if (outputList) {
                 simplecpp::Output out{
@@ -3357,7 +3452,7 @@ static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token
         }
         output.takeTokens(value);
     } else {
-        if (!tok->comment)
+        if (!tok->comment || !dui.removeComments)
             output.push_back(new simplecpp::Token(*tok));
         tok1 = tok->next;
     }
@@ -3552,7 +3647,9 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                 continue;
             }
 
-            if (ifstates.size() <= 1U && (rawtok->str() == ELIF || rawtok->str() == ELSE || rawtok->str() == ENDIF)) {
+            if (ifstates.size() <= 1U && (rawtok->str() == ELIF || rawtok->str() == ELIFDEF ||
+                                          rawtok->str() == ELIFNDEF || rawtok->str() == ELSE ||
+                                          rawtok->str() == ENDIF)) {
                 if (outputList) {
                     simplecpp::Output err{
                         Output::SYNTAX_ERROR,
@@ -3632,7 +3729,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                 TokenList inc2(files);
                 if (!inc1.empty() && inc1.cfront()->name) {
                     const Token *inctok = inc1.cfront();
-                    if (!preprocessToken(inc2, inctok, macros, files, outputList)) {
+                    if (!preprocessToken(inc2, inctok, macros, files, outputList, dui)) {
                         output.clear();
                         return;
                     }
@@ -3693,7 +3790,8 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                     rawtok = filedata->tokens.cfront();
                     continue;
                 }
-            } else if (rawtok->str() == IF || rawtok->str() == IFDEF || rawtok->str() == IFNDEF || rawtok->str() == ELIF) {
+            } else if (rawtok->str() == IF || rawtok->str() == IFDEF || rawtok->str() == IFNDEF || rawtok->str() == ELIF ||
+                       rawtok->str() == ELIFDEF || rawtok->str() == ELIFNDEF) {
                 if (!sameline(rawtok,rawtok->next)) {
                     if (outputList) {
                         simplecpp::Output out{
@@ -3708,15 +3806,28 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                 }
 
                 bool conditionIsTrue;
-                if (ifstates.top() == AlwaysFalse || (ifstates.top() == ElseIsTrue && rawtok->str() != ELIF)) {
+                if (ifstates.top() == AlwaysFalse || (ifstates.top() == ElseIsTrue && rawtok->str() != ELIF &&
+                                                      rawtok->str() != ELIFDEF && rawtok->str() != ELIFNDEF)) {
                     conditionIsTrue = false;
                 }
-                else if (rawtok->str() == IFDEF) {
-                    conditionIsTrue = (macros.find(rawtok->next->str()) != macros.end() || (hasInclude && rawtok->next->str() == HAS_INCLUDE));
-                    maybeUsedMacros[rawtok->next->str()].emplace_back(rawtok->next->location);
-                } else if (rawtok->str() == IFNDEF) {
-                    conditionIsTrue = (macros.find(rawtok->next->str()) == macros.end() && !(hasInclude && rawtok->next->str() == HAS_INCLUDE));
-                    maybeUsedMacros[rawtok->next->str()].emplace_back(rawtok->next->location);
+                else if (rawtok->str() == IFDEF || rawtok->str() == ELIFDEF) {
+                    const std::string &name = rawtok->next->str();
+                    conditionIsTrue = (macros.find(name) != macros.end() || (hasInclude && name == HAS_INCLUDE));
+                    maybeUsedMacros[name].emplace_back(rawtok->next->location);
+                    if (ifCond) {
+                        const std::string E = conditionIsTrue ? "1" : "0";
+                        const long long result = conditionIsTrue ? 1 : 0;
+                        ifCond->emplace_back(rawtok->location, E, result);
+                    }
+                } else if (rawtok->str() == IFNDEF || rawtok->str() == ELIFNDEF) {
+                    const std::string &name = rawtok->next->str();
+                    conditionIsTrue = (macros.find(name) == macros.end() && !(hasInclude && name == HAS_INCLUDE));
+                    maybeUsedMacros[name].emplace_back(rawtok->next->location);
+                    if (ifCond) {
+                        const std::string E = conditionIsTrue ? "1" : "0";
+                        const long long result = conditionIsTrue ? 1 : 0;
+                        ifCond->emplace_back(rawtok->location, E, result);
+                    }
                 } else { /*if (rawtok->str() == IF || rawtok->str() == ELIF)*/
                     TokenList expr(files);
                     for (const Token *tok = rawtok->next; tok && tok->location.sameline(rawtok->location); tok = tok->next) {
@@ -3802,7 +3913,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                         maybeUsedMacros[rawtok->next->str()].emplace_back(rawtok->next->location);
 
                         const Token *tmp = tok;
-                        if (!preprocessToken(expr, tmp, macros, files, outputList)) {
+                        if (!preprocessToken(expr, tmp, macros, files, outputList, dui)) {
                             output.clear();
                             return;
                         }
@@ -3839,7 +3950,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                     }
                 }
 
-                if (rawtok->str() != ELIF) {
+                if (rawtok->str() != ELIF && rawtok->str() != ELIFDEF && rawtok->str() != ELIFNDEF) {
                     // push a new ifstate..
                     if (ifstates.top() != True)
                         ifstates.push(AlwaysFalse);
@@ -3900,7 +4011,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
         const Location loc(rawtok->location);
         TokenList tokens(files);
 
-        if (!preprocessToken(tokens, rawtok, macros, files, outputList)) {
+        if (!preprocessToken(tokens, rawtok, macros, files, outputList, dui)) {
             output.clear();
             return;
         }
@@ -3959,6 +4070,20 @@ simplecpp::cstd_t simplecpp::getCStd(const std::string &std)
     return CUnknown;
 }
 
+const char *simplecpp::getCStdName(cstd_t std)
+{
+    switch (std) {
+    case CUnknown: return "C";
+    case C89: return "C89";
+    case C99: return "C99";
+    case C11: return "C11";
+    case C17: return "C17";
+    case C23: return "C23";
+    case C2Y: return "C2Y";
+    }
+    return "";
+}
+
 std::string simplecpp::getCStdString(cstd_t std)
 {
     switch (std) {
@@ -4011,6 +4136,21 @@ simplecpp::cppstd_t simplecpp::getCppStd(const std::string &std)
     return CPPUnknown;
 }
 
+const char *simplecpp::getCppStdName(cppstd_t std)
+{
+    switch (std) {
+    case CPPUnknown: return "C++";
+    case CPP03: return "C++03";
+    case CPP11: return "C++11";
+    case CPP14: return "C++14";
+    case CPP17: return "C++17";
+    case CPP20: return "C++20";
+    case CPP23: return "C++23";
+    case CPP26: return "C++26";
+    }
+    return "";
+}
+
 std::string simplecpp::getCppStdString(cppstd_t std)
 {
     switch (std) {
diff --git a/externals/simplecpp/simplecpp.h b/externals/simplecpp/simplecpp.h
index 3d6fc5262b9..f4dca18374a 100644
--- a/externals/simplecpp/simplecpp.h
+++ b/externals/simplecpp/simplecpp.h
@@ -60,6 +60,15 @@
 #  endif
 #endif
 
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 9
+// Hack to workaround GCC bug.
+// Details: https://trac.cppcheck.net/ticket/14850
+// seen on g++ before 10.x
+#define  SIMPLECPP_NOEXCEPT
+#else
+#define  SIMPLECPP_NOEXCEPT  noexcept
+#endif
+
 namespace simplecpp {
     /** C code standard */
     enum cstd_t : std::int8_t { CUnknown=-1, C89, C99, C11, C17, C23, C2Y };
@@ -238,7 +247,10 @@ namespace simplecpp {
             MISSING_HEADER,
             INCLUDE_NESTED_TOO_DEEPLY,
             SYNTAX_ERROR,
+            DIRECTIVE_AS_MACRO_PARAMETER,
             PORTABILITY_BACKSLASH,
+            PORTABILITY_LINE_DIRECTIVE,
+            PORTABILITY_NO_EOF_NEWLINE,
             UNHANDLED_CHAR_ERROR,
             EXPLICIT_INCLUDE_NOT_FOUND,
             FILE_NOT_FOUND,
@@ -251,6 +263,21 @@ namespace simplecpp {
 
     using OutputList = std::list<Output>;
 
+    /**
+     * Command line preprocessor settings.
+     * On the command line these are configured by -D, -U, -I, --include, -std
+     */
+    struct SIMPLECPP_LIB DUI {
+        DUI() = default;
+        std::list<std::string> defines;
+        std::set<std::string> undefined;
+        std::list<std::string> includePaths;
+        std::list<std::string> includes;
+        std::string std;
+        bool clearIncludeCache{};
+        bool removeComments{}; /** remove comment tokens from included files */
+    };
+
     /** List of tokens. */
     class SIMPLECPP_LIB TokenList {
     public:
@@ -258,45 +285,45 @@ namespace simplecpp {
 
         explicit TokenList(std::vector<std::string> &filenames);
         /** generates a token list from the given std::istream parameter */
-        TokenList(std::istream &istr, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr);
+        TokenList(std::istream &istr, std::vector<std::string> &filenames, const std::string &filename=std::string(), const DUI &dui = {}, OutputList *outputList = nullptr);
         /** generates a token list from the given buffer */
         template<size_t size>
-        TokenList(const char (&data)[size], std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
-            : TokenList(reinterpret_cast<const unsigned char*>(data), size-1, filenames, filename, outputList, 0)
+        TokenList(const char (&data)[size], std::vector<std::string> &filenames, const std::string &filename=std::string(), const DUI &dui = {}, OutputList *outputList = nullptr)
+            : TokenList(reinterpret_cast<const unsigned char*>(data), size-1, filenames, filename, dui, outputList, 0)
         {}
         /** generates a token list from the given buffer */
         template<size_t size>
-        TokenList(const unsigned char (&data)[size], std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
-            : TokenList(data, size-1, filenames, filename, outputList, 0)
+        TokenList(const unsigned char (&data)[size], std::vector<std::string> &filenames, const std::string &filename=std::string(), const DUI &dui = {}, OutputList *outputList = nullptr)
+            : TokenList(data, size-1, filenames, filename, dui, outputList, 0)
         {}
 #if SIMPLECPP_TOKENLIST_ALLOW_PTR
         /** generates a token list from the given buffer */
-        TokenList(const unsigned char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
-            : TokenList(data, size, filenames, filename, outputList, 0)
+        TokenList(const unsigned char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), const DUI &dui = {}, OutputList *outputList = nullptr)
+            : TokenList(data, size, filenames, filename, dui, outputList, 0)
         {}
         /** generates a token list from the given buffer */
-        TokenList(const char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
-            : TokenList(reinterpret_cast<const unsigned char*>(data), size, filenames, filename, outputList, 0)
+        TokenList(const char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), const DUI &dui = {}, OutputList *outputList = nullptr)
+            : TokenList(reinterpret_cast<const unsigned char*>(data), size, filenames, filename, dui, outputList, 0)
         {}
 #endif // SIMPLECPP_TOKENLIST_ALLOW_PTR
         /** generates a token list from the given buffer */
-        TokenList(View data, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
-            : TokenList(reinterpret_cast<const unsigned char*>(data.data()), data.size(), filenames, filename, outputList, 0)
+        TokenList(View data, std::vector<std::string> &filenames, const std::string &filename=std::string(), const DUI &dui = {}, OutputList *outputList = nullptr)
+            : TokenList(reinterpret_cast<const unsigned char*>(data.data()), data.size(), filenames, filename, dui, outputList, 0)
         {}
 #ifdef __cpp_lib_span
         /** generates a token list from the given buffer */
-        TokenList(std::span<const char> data, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
-            : TokenList(reinterpret_cast<const unsigned char*>(data.data()), data.size(), filenames, filename, outputList, 0)
+        TokenList(std::span<const char> data, std::vector<std::string> &filenames, const std::string &filename=std::string(), const DUI &dui = {}, OutputList *outputList = nullptr)
+            : TokenList(reinterpret_cast<const unsigned char*>(data.data()), data.size(), filenames, filename, dui, outputList, 0)
         {}
 
         /** generates a token list from the given buffer */
-        TokenList(std::span<const unsigned char> data, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
-            : TokenList(data.data(), data.size(), filenames, filename, outputList, 0)
+        TokenList(std::span<const unsigned char> data, std::vector<std::string> &filenames, const std::string &filename=std::string(), const DUI &dui = {}, OutputList *outputList = nullptr)
+            : TokenList(data.data(), data.size(), filenames, filename, dui, outputList, 0)
         {}
 #endif // __cpp_lib_span
 
         /** generates a token list from the given filename parameter */
-        TokenList(const std::string &filename, std::vector<std::string> &filenames, OutputList *outputList = nullptr);
+        TokenList(const std::string &filename, std::vector<std::string> &filenames, const DUI &dui = {}, OutputList *outputList = nullptr);
         TokenList(const TokenList &other);
         TokenList(TokenList &&other);
         ~TokenList();
@@ -312,7 +339,7 @@ namespace simplecpp {
         void dump(bool linenrs = false) const;
         std::string stringify(bool linenrs = false) const;
 
-        void readfile(Stream &stream, const std::string &filename=std::string(), OutputList *outputList = nullptr);
+        void readfile(Stream &stream, const std::string &filename=std::string(), const DUI &dui = {}, OutputList *outputList = nullptr);
         /**
          * @throws std::overflow_error thrown on overflow or division by zero
          * @throws std::runtime_error thrown on invalid expressions
@@ -376,7 +403,7 @@ namespace simplecpp {
         const std::string& file(const Location& loc) const;
 
     private:
-        TokenList(const unsigned char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename, OutputList *outputList, int /*unused*/);
+        TokenList(const unsigned char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename, const DUI &dui, OutputList *outputList, int /*unused*/);
 
         void combineOperators();
 
@@ -425,21 +452,6 @@ namespace simplecpp {
         long long result; // condition result
     };
 
-    /**
-     * Command line preprocessor settings.
-     * On the command line these are configured by -D, -U, -I, --include, -std
-     */
-    struct SIMPLECPP_LIB DUI {
-        DUI() = default;
-        std::list<std::string> defines;
-        std::set<std::string> undefined;
-        std::list<std::string> includePaths;
-        std::list<std::string> includes;
-        std::string std;
-        bool clearIncludeCache{};
-        bool removeComments{}; /** remove comment tokens from included files */
-    };
-
     struct SIMPLECPP_LIB FileData {
         /** The canonical filename associated with this data */
         std::string filename;
@@ -453,10 +465,10 @@ namespace simplecpp {
         ~FileDataCache();
 
         FileDataCache(const FileDataCache &) = delete;
-        FileDataCache(FileDataCache &&) noexcept;
+        FileDataCache(FileDataCache &&) SIMPLECPP_NOEXCEPT;
 
         FileDataCache &operator=(const FileDataCache &) = delete;
-        FileDataCache &operator=(FileDataCache &&) noexcept;
+        FileDataCache &operator=(FileDataCache &&) SIMPLECPP_NOEXCEPT;
 
         /** Get the cached data for a file, or load and then return it if it isn't cached.
          *  returns the file data and true if the file was loaded, false if it was cached. */
@@ -499,7 +511,7 @@ namespace simplecpp {
             return mData.cend();
         }
 
-        using load_callback_type = std::function<void (FileData &)>;
+        using load_callback_type = std::function<void (FileData &, bool)>;
 
         void set_load_callback(load_callback_type cb) {
             mLoadCallback = std::move(cb);
@@ -512,6 +524,7 @@ namespace simplecpp {
         using name_map_type = std::unordered_map<std::string, FileData *>;
 
         std::pair<FileData *, bool> tryload(name_map_type::iterator &name_it, const DUI &dui, std::vector<std::string> &filenames, OutputList *outputList);
+        std::pair<FileData *, bool> get_private(const std::string &sourcefile, const std::string &header, const DUI &dui, bool systemheader, std::vector<std::string> &filenames, OutputList *outputList);
 
         container_type mData;
         name_map_type mNameMap;
@@ -578,9 +591,15 @@ namespace simplecpp {
     /** Returns the C version a given standard */
     SIMPLECPP_LIB cstd_t getCStd(const std::string &std);
 
+    /** Returns the name of a C standard */
+    SIMPLECPP_LIB const char *getCStdName(cstd_t std);
+
     /** Returns the C++ version a given standard */
     SIMPLECPP_LIB cppstd_t getCppStd(const std::string &std);
 
+    /** Returns the name of a C++ standard */
+    SIMPLECPP_LIB const char *getCppStdName(cppstd_t std);
+
     /** Returns the __STDC_VERSION__ value for a given standard */
     SIMPLECPP_LIB std::string getCStdString(const std::string &std);
     SIMPLECPP_LIB std::string getCStdString(cstd_t std);
diff --git a/lib/cppcheck.cpp b/lib/cppcheck.cpp
index 26d98c0c7b4..3c96bec64a3 100644
--- a/lib/cppcheck.cpp
+++ b/lib/cppcheck.cpp
@@ -894,16 +894,20 @@ std::size_t CppCheck::calculateHash(const Preprocessor& preprocessor, const std:
 
 unsigned int CppCheck::checkBuffer(const FileWithDetails &file, const std::string &cfgname, const char* data, std::size_t size)
 {
-    const auto f = [&file, data, size](std::vector<std::string>& files, simplecpp::OutputList* outputList) {
-        return simplecpp::TokenList{{data, size}, files, file.spath(), outputList};
+    const auto f = [&file, data, size, this](std::vector<std::string>& files, simplecpp::OutputList* outputList) {
+        simplecpp::DUI dui;
+        dui.std = mSettings.standards.getStdForLanguage(file.lang());
+        return simplecpp::TokenList{{data, size}, files, file.spath(), dui, outputList};
     };
     return checkInternal(file, cfgname, f);
 }
 
 unsigned int CppCheck::checkFile(const FileWithDetails& file, const std::string &cfgname)
 {
-    const auto f = [&file](std::vector<std::string>& files, simplecpp::OutputList* outputList) {
-        return simplecpp::TokenList{file.spath(), files, outputList};
+    const auto f = [&file, this](std::vector<std::string>& files, simplecpp::OutputList* outputList) {
+        simplecpp::DUI dui;
+        dui.std = mSettings.standards.getStdForLanguage(file.lang());
+        return simplecpp::TokenList{file.spath(), files, dui, outputList};
     };
     return checkInternal(file, cfgname, f);
 }
@@ -1058,16 +1062,18 @@ unsigned int CppCheck::checkInternal(const FileWithDetails& file, const std::str
                        std::inserter(configDefines, configDefines.end()),
                        getDefineName);
 
-        preprocessor.setLoadCallback([&](simplecpp::FileData &data) {
-            // Do preprocessing on included file
-            mLogger->addRemarkComments(preprocessor.getRemarkComments(data.tokens));
-            preprocessor.inlineSuppressions(data.tokens, mSuppressions.nomsg);
-            Preprocessor::removeComments(data.tokens);
-            Preprocessor::createDirectives(data.tokens, directives);
-            Preprocessor::simplifyPragmaAsm(data.tokens);
-            // Discover new configurations from included file
-            if (configurations.size() < maxConfigs)
-                preprocessor.getConfigs(data.filename, data.tokens, configDefines, configurations);
+        preprocessor.setLoadCallback([&](simplecpp::FileData &data, bool loaded) {
+            if (loaded) {
+                // Do preprocessing on included file
+                mLogger->addRemarkComments(preprocessor.getRemarkComments(data.tokens));
+                preprocessor.inlineSuppressions(data.tokens, mSuppressions.nomsg);
+                Preprocessor::removeComments(data.tokens);
+                Preprocessor::createDirectives(data.tokens, directives);
+                Preprocessor::simplifyPragmaAsm(data.tokens);
+                // Discover new configurations from included file
+                if (configurations.size() < maxConfigs)
+                    preprocessor.getConfigs(data.filename, data.tokens, configDefines, configurations);
+            }
         });
 
         preprocessor.setPlatformInfo();
diff --git a/lib/importproject.cpp b/lib/importproject.cpp
index 5c9bcaadd3f..61ef7a2d38a 100644
--- a/lib/importproject.cpp
+++ b/lib/importproject.cpp
@@ -649,7 +649,7 @@ namespace {
         }
 
         static bool evalCondition(const std::string& condition, const ProjectConfiguration &p) {
-            std::string c = '(' + condition + ")";
+            std::string c = '(' + condition + ")\n";
             replaceAll(c, "$(Configuration)", p.configuration);
             replaceAll(c, "$(Platform)", p.platformStr);
 
diff --git a/lib/library.cpp b/lib/library.cpp
index 2a198001d3c..4e542bc55ef 100644
--- a/lib/library.cpp
+++ b/lib/library.cpp
@@ -177,7 +177,7 @@ static std::vector<std::string> getnames(const char *names)
 
 static void gettokenlistfromvalid(const std::string& valid, TokenList& tokenList)
 {
-    const std::string str(valid + ',');
+    const std::string str(valid + ",\n");
     tokenList.createTokensFromBuffer(str.data(), str.size()); // TODO: check result?
     for (Token *tok = tokenList.front(); tok; tok = tok->next()) {
         if (Token::Match(tok,"- %num%")) {
diff --git a/lib/preprocessor.cpp b/lib/preprocessor.cpp
index 3e0b33c7f10..8fe715db864 100644
--- a/lib/preprocessor.cpp
+++ b/lib/preprocessor.cpp
@@ -930,6 +930,8 @@ const simplecpp::Output* Preprocessor::reportOutput(const simplecpp::OutputList
             break;
         case simplecpp::Output::WARNING:
         case simplecpp::Output::PORTABILITY_BACKSLASH:
+        case simplecpp::Output::PORTABILITY_LINE_DIRECTIVE:
+        case simplecpp::Output::PORTABILITY_NO_EOF_NEWLINE:
             break;
         case simplecpp::Output::MISSING_HEADER: {
             // not considered an "error"
@@ -939,6 +941,7 @@ const simplecpp::Output* Preprocessor::reportOutput(const simplecpp::OutputList
                 missingInclude(out.location, out.msg.substr(pos1+1, pos2-pos1-1), out.msg[pos1] == '\"' ? UserHeader : SystemHeader);
         }
         break;
+        case simplecpp::Output::DIRECTIVE_AS_MACRO_PARAMETER:
         case simplecpp::Output::INCLUDE_NESTED_TOO_DEEPLY:
         case simplecpp::Output::SYNTAX_ERROR:
         case simplecpp::Output::UNHANDLED_CHAR_ERROR:
@@ -963,6 +966,7 @@ static std::string simplecppErrToId(simplecpp::Output::Type type)
     case simplecpp::Output::ERROR:
         return "preprocessorErrorDirective";
     case simplecpp::Output::SYNTAX_ERROR:
+    case simplecpp::Output::DIRECTIVE_AS_MACRO_PARAMETER:
         return "syntaxError";
     case simplecpp::Output::UNHANDLED_CHAR_ERROR:
         return "unhandledChar";
@@ -979,6 +983,8 @@ static std::string simplecppErrToId(simplecpp::Output::Type type)
     // no handled at all (warnings)
     case simplecpp::Output::WARNING:
     case simplecpp::Output::PORTABILITY_BACKSLASH:
+    case simplecpp::Output::PORTABILITY_LINE_DIRECTIVE:
+    case simplecpp::Output::PORTABILITY_NO_EOF_NEWLINE:
         throw std::runtime_error("unexpected simplecpp::Output type " + std::to_string(type));
     }
 
diff --git a/lib/programmemory.cpp b/lib/programmemory.cpp
index 9571e04ea00..142385ac641 100644
--- a/lib/programmemory.cpp
+++ b/lib/programmemory.cpp
@@ -1937,7 +1937,7 @@ static std::shared_ptr<Token> createTokenFromExpression(const std::string& retur
 {
     std::shared_ptr<TokenList> tokenList = std::make_shared<TokenList>(settings, cpp ? Standards::Language::CPP : Standards::Language::C);
     {
-        const std::string code = "return " + returnValue + ";";
+        const std::string code = "return " + returnValue + ";\n";
         if (!tokenList->createTokensFromBuffer(code.data(), code.size()))
             return nullptr;
     }
diff --git a/lib/standards.cpp b/lib/standards.cpp
index a0ec72c1580..06b129ab8cf 100644
--- a/lib/standards.cpp
+++ b/lib/standards.cpp
@@ -157,3 +157,15 @@ bool Standards::setStd(const std::string& str)
 {
     return setC(str) || setCPP(str);
 }
+
+std::string Standards::getStdForLanguage(Standards::Language language) const
+{
+    switch (language) {
+    case C:
+        return getC();
+    case CPP:
+        return getCPP();
+    default:
+        return "";
+    }
+}
diff --git a/lib/standards.h b/lib/standards.h
index d2c2a2b8e01..0ab73300a9a 100644
--- a/lib/standards.h
+++ b/lib/standards.h
@@ -58,6 +58,7 @@ struct CPPCHECKLIB Standards {
     static std::string getCPP(cppstd_t std);
     static cppstd_t getCPP(const std::string &std);
     bool setStd(const std::string& str);
+    std::string getStdForLanguage(Language language) const;
 };
 
 /// @}
diff --git a/lib/symboldatabase.cpp b/lib/symboldatabase.cpp
index a666c15b536..7a0148a24a2 100644
--- a/lib/symboldatabase.cpp
+++ b/lib/symboldatabase.cpp
@@ -8093,7 +8093,7 @@ void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings, Token *to
                 if (!typestr.empty()) {
                     ValueType valuetype;
                     TokenList tokenList(mSettings, tok->isCpp() ? Standards::Language::CPP : Standards::Language::C);
-                    const std::string str(typestr+";");
+                    const std::string str(typestr+";\n");
                     tokenList.createTokensFromBuffer(str.data(), str.size()); // TODO: check result?
                     tokenList.simplifyStdType();
                     if (parsedecl(tokenList.front(), &valuetype, mDefaultSignedness, mSettings)) {
@@ -8186,7 +8186,7 @@ void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings, Token *to
                     continue;
                 }
                 TokenList tokenList(mSettings, tok->isCpp() ? Standards::Language::CPP : Standards::Language::C);
-                const std::string str(typestr+";");
+                const std::string str(typestr+";\n");
                 if (tokenList.createTokensFromBuffer(str.data(), str.size())) {
                     ValueType vt;
                     tokenList.simplifyPlatformTypes();
diff --git a/lib/tokenlist.cpp b/lib/tokenlist.cpp
index ca509904db3..384c45e406b 100644
--- a/lib/tokenlist.cpp
+++ b/lib/tokenlist.cpp
@@ -354,7 +354,9 @@ bool TokenList::createTokensFromBufferInternal(const char* data, size_t size, co
 #endif
 
     simplecpp::OutputList outputList;
-    simplecpp::TokenList tokens({data, size}, mFiles, file0, &outputList);
+    simplecpp::DUI dui;
+    dui.std = mSettings.standards.getStdForLanguage(mLang);
+    simplecpp::TokenList tokens({data, size}, mFiles, file0, dui, &outputList);
 
     createTokens(std::move(tokens));
 
diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
index e956c92c5e0..325a55e98e5 100644
--- a/lib/valueflow.cpp
+++ b/lib/valueflow.cpp
@@ -1817,7 +1817,8 @@ static bool isNotEqual(std::pair<const Token*, const Token*> x, std::pair<const
 static bool isNotEqual(std::pair<const Token*, const Token*> x, const std::string& y, bool cpp, const Settings& settings)
 {
     TokenList tokenList(settings, cpp ? Standards::Language::CPP : Standards::Language::C);
-    tokenList.createTokensFromBuffer(y.data(), y.size()); // TODO: check result?
+    const std::string str(y + "\n");
+    tokenList.createTokensFromBuffer(str.data(), str.size()); // TODO: check result?
     return isNotEqual(x, std::make_pair(tokenList.front(), tokenList.back()));
 }
 static bool isNotEqual(std::pair<const Token*, const Token*> x, const ValueType* y, bool cpp, const Settings& settings)
@@ -7101,7 +7102,7 @@ static bool getMinMaxValues(const std::string& typestr,
                             MathLib::bigint& maxvalue)
 {
     TokenList typeTokens(settings, cpp ? Standards::Language::CPP : Standards::Language::C);
-    const std::string str(typestr + ";");
+    const std::string str(typestr + ";\n");
     if (!typeTokens.createTokensFromBuffer(str.data(), str.size()))
         return false;
     typeTokens.simplifyPlatformTypes();
diff --git a/test/helpers.cpp b/test/helpers.cpp
index 70437207a84..95a2dfae24b 100644
--- a/test/helpers.cpp
+++ b/test/helpers.cpp
@@ -113,8 +113,12 @@ ScopedFile::~ScopedFile() {
 
 void SimpleTokenizer2::preprocess(const char* code, std::size_t size, std::vector<std::string> &files, const std::string& file0, Tokenizer& tokenizer, ErrorLogger& errorlogger)
 {
+    const Standards &standards = tokenizer.getSettings().standards;
+    const Standards::Language language = tokenizer.isCPP() ? Standards::CPP : Standards::C;
     simplecpp::OutputList outputList;
-    simplecpp::TokenList tokens1({code, size}, files, file0, &outputList);
+    simplecpp::DUI dui;
+    dui.std = standards.getStdForLanguage(language);
+    simplecpp::TokenList tokens1({code, size}, files, file0, dui, &outputList);
 
     Preprocessor preprocessor(tokens1, tokenizer.getSettings(), errorlogger, Path::identify(tokens1.getFiles()[0], false));
     (void)preprocessor.loadFiles(files); // TODO: check result
diff --git a/test/test64bit.cpp b/test/test64bit.cpp
index cc96da48577..1507f15ec72 100644
--- a/test/test64bit.cpp
+++ b/test/test64bit.cpp
@@ -58,7 +58,7 @@ class Test64BitPortability : public TestFixture {
         check("using CharArray = char[16];\n"
               "void f() {\n"
               "    CharArray foo = \"\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct T { std::vector<int>*a[2][2]; };\n" // #11560
@@ -79,7 +79,7 @@ class Test64BitPortability : public TestFixture {
         check("void foo()\n"
               "{\n"
               "    a = p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -88,65 +88,65 @@ class Test64BitPortability : public TestFixture {
               "{\n"
               "    int a = p;\n"
               "    return a + 4;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (portability) Assigning a pointer to an integer is not portable. [AssignmentAddressToInteger]\n", errout_str());
 
         check("int foo(int p[])\n"
               "{\n"
               "    int a = p;\n"
               "    return a + 4;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (portability) Assigning a pointer to an integer is not portable. [AssignmentAddressToInteger]\n", errout_str());
 
         check("int foo(int p[])\n"
               "{\n"
               "    int *a = p;\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (portability) Returning an address value in a function with integer return type is not portable. [CastAddressToIntegerAtReturn]\n", errout_str());
 
         check("void foo(int x)\n"
               "{\n"
               "    int *p = x;\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (portability) Assigning an integer to a pointer is not portable. [AssignmentIntegerToAddress]\n", errout_str());
 
         check("int f(const char *p) {\n" // #4659
               "    return 6 + p[2] * 256;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int foo(int *p) {\n" // #6096
               "    bool a = p;\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::array<int,2> f();\n"
               "void g() {\n"
               "    std::array<int, 2> a = f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::array<int,2> f(int x);\n"
               "void g(int i) {\n"
               "    std::array<int, 2> a = f(i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("typedef std::array<int, 2> Array;\n"
               "Array f(int x);\n"
               "void g(int i) {\n"
               "    Array a = f(i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("typedef std::array<int, 2> Array;\n"
               "Array f();\n"
               "void g(int i) {\n"
               "    Array a = f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n" // #9951
@@ -174,7 +174,7 @@ class Test64BitPortability : public TestFixture {
         check("struct Foo { int *p; };\n"
               "void f(struct Foo *foo) {\n"
               "    int i = foo->p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (portability) Assigning a pointer to an integer is not portable. [AssignmentAddressToInteger]\n", errout_str());
 
         check("struct S {\n" // #10145
@@ -192,7 +192,7 @@ class Test64BitPortability : public TestFixture {
         // Ticket #2892
         check("void foo(int *p) {\n"
               "    int a = (p != NULL);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -201,74 +201,74 @@ class Test64BitPortability : public TestFixture {
         check("void foo(int *p) {\n"
               "    int x = 10;\n"
               "    int *a = p + x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int *p) {\n"
               "    int x = 10;\n"
               "    int *a = x + p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int *p) {\n"
               "    int x = 10;\n"
               "    int *a = x * x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (portability) Assigning an integer to a pointer is not portable. [AssignmentIntegerToAddress]\n", errout_str());
 
         check("void foo(int *start, int *end) {\n"
               "    int len;\n"
               "    int len = end + 10 - start;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void returnIssues() {
         check("void* foo(int i) {\n"
               "    return i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (portability) Returning an integer in a function with pointer return type is not portable. [CastIntegerToAddressAtReturn]\n", errout_str());
 
         check("void* foo(int* i) {\n"
               "    return i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void* foo() {\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int foo(int i) {\n"
               "    return i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Foo {};\n"
               "\n"
               "int* dostuff(Foo foo) {\n"
               "  return foo;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int foo(char* c) {\n"
               "    return c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (portability) Returning an address value in a function with integer return type is not portable. [CastAddressToIntegerAtReturn]\n", errout_str());
 
         check("int foo(char* c) {\n"
               "    return 1+c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (portability) Returning an address value in a function with integer return type is not portable. [CastAddressToIntegerAtReturn]\n", errout_str());
 
         check("std::string foo(char* c) {\n"
               "    return c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int foo(char *a, char *b) {\n" // #4486
               "    return a + 1 - b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct s {\n" // 4642
@@ -276,13 +276,13 @@ class Test64BitPortability : public TestFixture {
               "};\n"
               "int func(struct s *p) {\n"
               " return 1 + p->i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("static void __iomem *f(unsigned int port_no) {\n"
               "  void __iomem *mmio = hpriv->mmio;\n"
               "  return mmio + (port_no * 0x80);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7247: don't check return statements in nested functions..
@@ -290,7 +290,7 @@ class Test64BitPortability : public TestFixture {
               "  struct {\n"
               "    const char * name() { return \"abc\"; }\n"
               "  } table;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7451: Lambdas
@@ -298,7 +298,7 @@ class Test64BitPortability : public TestFixture {
               "  auto it = std::find_if(outputs.begin(), outputs.end(),\n"
               "     [&](int ele) { return \"test\" == text; });\n"
               "  return nullptr;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n" // #12159
diff --git a/test/testassert.cpp b/test/testassert.cpp
index a76b8207445..c3c271a1bf2 100644
--- a/test/testassert.cpp
+++ b/test/testassert.cpp
@@ -61,7 +61,7 @@ class TestAssert : public TestFixture {
             "   if (b) { a = 1+2 };\n"
             "   return a;\n"
             "}\n"
-            "assert(foo() == 3);");
+            "assert(foo() == 3);\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -69,7 +69,7 @@ class TestAssert : public TestFixture {
             "    int b=a+1;\n"
             "    return b;\n"
             "}\n"
-            "assert(foo(1) == 2);");
+            "assert(foo(1) == 2);\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -80,7 +80,7 @@ class TestAssert : public TestFixture {
             "    a = 1+2;\n"
             "    return a;\n"
             "}\n"
-            "assert(foo() == 3);");
+            "assert(foo() == 3);\n");
         ASSERT_EQUALS("[test.cpp:6:8]: (warning) Assert statement calls a function which may have desired side effects: 'foo'. [assertWithSideEffect]\n", errout_str());
 
         //  Ticket #4937 "false positive: Assert calls a function which may have desired side effects"
@@ -92,7 +92,7 @@ class TestAssert : public TestFixture {
               "};\n"
               "void foo() {\n"
               "   assert( !SquarePack::isRank1Or8(push2) );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct SquarePack {\n"
@@ -103,7 +103,7 @@ class TestAssert : public TestFixture {
               "};\n"
               "void foo() {\n"
               "   assert( !SquarePack::isRank1Or8(push2) );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:25]: (warning) Assert statement calls a function which may have desired side effects: 'isRank1Or8'. [assertWithSideEffect]\n", errout_str());
 
         check("struct SquarePack {\n"
@@ -114,7 +114,7 @@ class TestAssert : public TestFixture {
               "};\n"
               "void foo() {\n"
               "   assert( !SquarePack::isRank1Or8(push2) );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:25]: (warning) Assert statement calls a function which may have desired side effects: 'isRank1Or8'. [assertWithSideEffect]\n", errout_str());
 
         check("struct SquarePack {\n"
@@ -125,7 +125,7 @@ class TestAssert : public TestFixture {
               "};\n"
               "void foo() {\n"
               "   assert( !SquarePack::isRank1Or8(push2) );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Geometry {\n"
@@ -136,7 +136,7 @@ class TestAssert : public TestFixture {
               "\n"
               "void Geometry::ReadGeometry() {\n"
               "    assert(empty());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n" // #4811
@@ -166,7 +166,7 @@ class TestAssert : public TestFixture {
               "};\n"
               "void foo(SquarePack s) {\n"
               "   assert( s.Foo() );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:14]: (warning) Assert statement calls a function which may have desired side effects: 'Foo'. If there are no side effects, consider declaring the method const. [assertWithSideEffect]\n", errout_str());
 
         check("struct SquarePack {\n"
@@ -174,7 +174,7 @@ class TestAssert : public TestFixture {
               "};\n"
               "void foo(SquarePack* s) {\n"
               "   assert( s->Foo() );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct SquarePack {\n"
@@ -182,14 +182,14 @@ class TestAssert : public TestFixture {
               "};\n"
               "void foo(SquarePack* s) {\n"
               "   assert( s->Foo() );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct SquarePack {\n"
               "};\n"
               "void foo(SquarePack* s) {\n"
               "   assert( s->Foo() );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -198,54 +198,54 @@ class TestAssert : public TestFixture {
               "    int a; a = 0;\n"
               "    assert(a = 2);\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (warning) Assert statement modifies 'a'. [assignmentInAssert]\n", errout_str());
 
         check("void f(int a) {\n"
               "    assert(a == 2);\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int a, int b) {\n"
               "    assert(a == 2 && (b = 1));\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:25]: (warning) Assert statement modifies 'b'. [assignmentInAssert]\n", errout_str());
 
         check("void f() {\n"
               "    int a; a = 0;\n"
               "    assert(a += 2);\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (warning) Assert statement modifies 'a'. [assignmentInAssert]\n", errout_str());
 
         check("void f() {\n"
               "    int a; a = 0;\n"
               "    assert(a *= 2);\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (warning) Assert statement modifies 'a'. [assignmentInAssert]\n", errout_str());
 
         check("void f() {\n"
               "    int a; a = 0;\n"
               "    assert(a -= 2);\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (warning) Assert statement modifies 'a'. [assignmentInAssert]\n", errout_str());
 
         check("void f() {\n"
               "    int a = 0;\n"
               "    assert(a--);\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (warning) Assert statement modifies 'a'. [assignmentInAssert]\n", errout_str());
 
         check("void f() {\n"
               "    int a = 0;\n"
               "    assert(--a);\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (warning) Assert statement modifies 'a'. [assignmentInAssert]\n", errout_str());
 
         check("void f() {\n"
@@ -254,19 +254,19 @@ class TestAssert : public TestFixture {
               "                  auto const expected = someOtherValue;\n"
               "                  return tmp == expected;\n"
               "                }));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void crash() {
         check("void foo() {\n"
               "  assert(sizeof(struct { int a[x++]; })==sizeof(int));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n" // #9790
               "  assert(kad_bucket_hash(&(kad_guid) { .bytes = { 0 } }, & (kad_guid){.bytes = { 0 }}) == -1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 };
diff --git a/test/testastutils.cpp b/test/testastutils.cpp
index 6a6e0624587..46dde522338 100644
--- a/test/testastutils.cpp
+++ b/test/testastutils.cpp
@@ -62,29 +62,29 @@ class TestAstUtils : public TestFixture {
     void findLambdaEndTokenTest() {
         const Token* nullTok = nullptr;
         ASSERT(nullptr == (::findLambdaEndToken)(nullTok));
-        ASSERT_EQUALS(false, findLambdaEndToken("void f() { }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[]{ }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[]{ return 0; }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](){ }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[&](){ }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[&, i](){ }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](void) { return -1; }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](int a, int b) { return a + b; }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](int a, int b) mutable { return a + b; }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](int a, int b) constexpr { return a + b; }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](void) -> int { return -1; }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](void) mutable -> int { return -1; }"));
-        ASSERT_EQUALS(false, findLambdaEndToken("[](void) foo -> int { return -1; }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](void) constexpr -> int { return -1; }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](void) constexpr -> int* { return x; }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](void) constexpr -> const * int { return x; }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](void) mutable -> const * int { return x; }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](void) constexpr -> const ** int { return x; }"));
-        ASSERT_EQUALS(true, findLambdaEndToken("[](void) constexpr -> const * const* int { return x; }"));
-        ASSERT_EQUALS(false, findLambdaEndToken("int** a[] { new int*[2] { new int, new int} };", "[ ]"));
-        ASSERT_EQUALS(false, findLambdaEndToken("int** a[] { new int*[2] { new int, new int} };", "[ 2"));
-        ASSERT_EQUALS(false, findLambdaEndToken("shared_ptr<Type *[]> sp{ new Type *[2] {new Type, new Type}, Deleter<Type>{ 2 } };", "[ 2"));
-        ASSERT_EQUALS(true, findLambdaEndToken("int i = 5 * []{ return 7; }();", "[", /*checkNext*/ false));
+        ASSERT_EQUALS(false, findLambdaEndToken("void f() { }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[]{ }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[]{ return 0; }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](){ }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[&](){ }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[&, i](){ }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](void) { return -1; }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](int a, int b) { return a + b; }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](int a, int b) mutable { return a + b; }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](int a, int b) constexpr { return a + b; }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](void) -> int { return -1; }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](void) mutable -> int { return -1; }\n"));
+        ASSERT_EQUALS(false, findLambdaEndToken("[](void) foo -> int { return -1; }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](void) constexpr -> int { return -1; }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](void) constexpr -> int* { return x; }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](void) constexpr -> const * int { return x; }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](void) mutable -> const * int { return x; }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](void) constexpr -> const ** int { return x; }\n"));
+        ASSERT_EQUALS(true, findLambdaEndToken("[](void) constexpr -> const * const* int { return x; }\n"));
+        ASSERT_EQUALS(false, findLambdaEndToken("int** a[] { new int*[2] { new int, new int} };\n", "[ ]"));
+        ASSERT_EQUALS(false, findLambdaEndToken("int** a[] { new int*[2] { new int, new int} };\n", "[ 2"));
+        ASSERT_EQUALS(false, findLambdaEndToken("shared_ptr<Type *[]> sp{ new Type *[2] {new Type, new Type}, Deleter<Type>{ 2 } };\n", "[ 2"));
+        ASSERT_EQUALS(true, findLambdaEndToken("int i = 5 * []{ return 7; }();\n", "[", /*checkNext*/ false));
     }
 
 #define findLambdaStartToken(...) findLambdaStartToken_(__FILE__, __LINE__, __VA_ARGS__)
@@ -98,25 +98,25 @@ class TestAstUtils : public TestFixture {
 
     void findLambdaStartTokenTest() {
         ASSERT(nullptr == (::findLambdaStartToken)(nullptr));
-        ASSERT_EQUALS(false, findLambdaStartToken("void f() { }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[]{ }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[]{ return 0; }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](){ }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[&](){ }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[&, i](){ }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](void) { return -1; }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](int a, int b) { return a + b; }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](int a, int b) mutable { return a + b; }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](int a, int b) constexpr { return a + b; }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](void) -> int { return -1; }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](void) mutable -> int { return -1; }"));
-        ASSERT_EQUALS(false, findLambdaStartToken("[](void) foo -> int { return -1; }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](void) constexpr -> int { return -1; }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](void) constexpr -> int* { return x; }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](void) constexpr -> const * int { return x; }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](void) mutable -> const * int { return x; }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](void) constexpr -> const ** int { return x; }"));
-        ASSERT_EQUALS(true, findLambdaStartToken("[](void) constexpr -> const * const* int { return x; }"));
+        ASSERT_EQUALS(false, findLambdaStartToken("void f() { }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[]{ }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[]{ return 0; }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](){ }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[&](){ }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[&, i](){ }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](void) { return -1; }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](int a, int b) { return a + b; }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](int a, int b) mutable { return a + b; }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](int a, int b) constexpr { return a + b; }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](void) -> int { return -1; }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](void) mutable -> int { return -1; }\n"));
+        ASSERT_EQUALS(false, findLambdaStartToken("[](void) foo -> int { return -1; }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](void) constexpr -> int { return -1; }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](void) constexpr -> int* { return x; }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](void) constexpr -> const * int { return x; }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](void) mutable -> const * int { return x; }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](void) constexpr -> const ** int { return x; }\n"));
+        ASSERT_EQUALS(true, findLambdaStartToken("[](void) constexpr -> const * const* int { return x; }\n"));
     }
 
 #define isNullOperand(...) isNullOperand_(__FILE__, __LINE__, __VA_ARGS__)
@@ -128,16 +128,16 @@ class TestAstUtils : public TestFixture {
     }
 
     void isNullOperandTest() {
-        ASSERT_EQUALS(true, isNullOperand("(void*)0;"));
-        ASSERT_EQUALS(true, isNullOperand("(void*)0U;"));
-        ASSERT_EQUALS(true, isNullOperand("(void*)0x0LL;"));
-        ASSERT_EQUALS(true, isNullOperand("NULL;"));
-        ASSERT_EQUALS(true, isNullOperand("nullptr;"));
-        ASSERT_EQUALS(true, isNullOperand("(void*)NULL;"));
-        ASSERT_EQUALS(true, isNullOperand("static_cast<int*>(0);"));
-        ASSERT_EQUALS(false, isNullOperand("0;"));
-        ASSERT_EQUALS(false, isNullOperand("(void*)0.0;"));
-        ASSERT_EQUALS(false, isNullOperand("(void*)1;"));
+        ASSERT_EQUALS(true, isNullOperand("(void*)0;\n"));
+        ASSERT_EQUALS(true, isNullOperand("(void*)0U;\n"));
+        ASSERT_EQUALS(true, isNullOperand("(void*)0x0LL;\n"));
+        ASSERT_EQUALS(true, isNullOperand("NULL;\n"));
+        ASSERT_EQUALS(true, isNullOperand("nullptr;\n"));
+        ASSERT_EQUALS(true, isNullOperand("(void*)NULL;\n"));
+        ASSERT_EQUALS(true, isNullOperand("static_cast<int*>(0);\n"));
+        ASSERT_EQUALS(false, isNullOperand("0;\n"));
+        ASSERT_EQUALS(false, isNullOperand("(void*)0.0;\n"));
+        ASSERT_EQUALS(false, isNullOperand("(void*)1;\n"));
     }
 
 #define isReturnScope(...) isReturnScope_(__FILE__, __LINE__, __VA_ARGS__)
@@ -152,22 +152,22 @@ class TestAstUtils : public TestFixture {
     }
 
     void isReturnScopeTest() {
-        ASSERT_EQUALS(true, isReturnScope("void f() { if (a) { return; } }", -2));
-        ASSERT_EQUALS(true, isReturnScope("int f() { if (a) { return {}; } }", -2));                        // #8891
-        ASSERT_EQUALS(true, isReturnScope("std::string f() { if (a) { return std::string{}; } }", -2));     // #8891
-        ASSERT_EQUALS(true, isReturnScope("std::string f() { if (a) { return std::string{\"\"}; } }", -2)); // #8891
-        ASSERT_EQUALS(true, isReturnScope("void f() { if (a) { return (ab){0}; } }", -2)); // #7103
-        ASSERT_EQUALS(false, isReturnScope("void f() { if (a) { return (ab){0}; } }", -4)); // #7103
-        ASSERT_EQUALS(true, isReturnScope("void f() { if (a) { {throw new string(x);}; } }", -4)); // #7144
-        ASSERT_EQUALS(true, isReturnScope("void f() { if (a) { {throw new string(x);}; } }", -2)); // #7144
-        ASSERT_EQUALS(false, isReturnScope("void f() { [=]() { return data; }; }", -1));
-        ASSERT_EQUALS(true, isReturnScope("auto f() { return [=]() { return data; }; }", -1));
-        ASSERT_EQUALS(true, isReturnScope("auto f() { return [=]() { return data; }(); }", -1));
-        ASSERT_EQUALS(false, isReturnScope("auto f() { [=]() { return data; }(); }", -1));
-
-        ASSERT_EQUALS(true, isReturnScope("void negativeTokenOffset() { return; }", -1));
-        ASSERT_EQUALS(false, isReturnScope("void zeroTokenOffset() { return; }", 0));
-        ASSERT_EQUALS(true, isReturnScope("void positiveTokenOffset() { return; }", 7));
+        ASSERT_EQUALS(true, isReturnScope("void f() { if (a) { return; } }\n", -2));
+        ASSERT_EQUALS(true, isReturnScope("int f() { if (a) { return {}; } }\n", -2));                        // #8891
+        ASSERT_EQUALS(true, isReturnScope("std::string f() { if (a) { return std::string{}; } }\n", -2));     // #8891
+        ASSERT_EQUALS(true, isReturnScope("std::string f() { if (a) { return std::string{\"\"}; } }\n", -2)); // #8891
+        ASSERT_EQUALS(true, isReturnScope("void f() { if (a) { return (ab){0}; } }\n", -2)); // #7103
+        ASSERT_EQUALS(false, isReturnScope("void f() { if (a) { return (ab){0}; } }\n", -4)); // #7103
+        ASSERT_EQUALS(true, isReturnScope("void f() { if (a) { {throw new string(x);}; } }\n", -4)); // #7144
+        ASSERT_EQUALS(true, isReturnScope("void f() { if (a) { {throw new string(x);}; } }\n", -2)); // #7144
+        ASSERT_EQUALS(false, isReturnScope("void f() { [=]() { return data; }; }\n", -1));
+        ASSERT_EQUALS(true, isReturnScope("auto f() { return [=]() { return data; }; }\n", -1));
+        ASSERT_EQUALS(true, isReturnScope("auto f() { return [=]() { return data; }(); }\n", -1));
+        ASSERT_EQUALS(false, isReturnScope("auto f() { [=]() { return data; }(); }\n", -1));
+
+        ASSERT_EQUALS(true, isReturnScope("void negativeTokenOffset() { return; }\n", -1));
+        ASSERT_EQUALS(false, isReturnScope("void zeroTokenOffset() { return; }\n", 0));
+        ASSERT_EQUALS(true, isReturnScope("void positiveTokenOffset() { return; }\n", 7));
     }
 
 #define isSameExpression(...) isSameExpression_(__FILE__, __LINE__, __VA_ARGS__)
@@ -181,33 +181,33 @@ class TestAstUtils : public TestFixture {
     }
 
     void isSameExpressionTestInternal(bool cpp) {
-        ASSERT_EQUALS(true,  isSameExpression("x = 1 + 1;", "1", "1", cpp));
-        ASSERT_EQUALS(false, isSameExpression("x = 1 + 1u;", "1", "1u", cpp));
-        ASSERT_EQUALS(true,  isSameExpression("x = 1.0 + 1.0;", "1.0", "1.0", cpp));
-        ASSERT_EQUALS(false, isSameExpression("x = 1.0f + 1.0;", "1.0f", "1.0", cpp));
-        ASSERT_EQUALS(false, isSameExpression("x = 1L + 1;", "1L", "1", cpp));
-        ASSERT_EQUALS(true,  isSameExpression("x = 0.0f + 0x0p+0f;", "0.0f", "0x0p+0f", cpp));
-        ASSERT_EQUALS(true,  isSameExpression("x < x;", "x", "x", cpp));
-        ASSERT_EQUALS(false, isSameExpression("x < y;", "x", "y", cpp));
-        ASSERT_EQUALS(true,  isSameExpression("(x + 1) < (x + 1);", "+", "+", cpp));
-        ASSERT_EQUALS(false, isSameExpression("(x + 1) < (x + 1L);", "+", "+", cpp));
-        ASSERT_EQUALS(!cpp,  isSameExpression("(1 + x) < (x + 1);", "+", "+", cpp));
-        ASSERT_EQUALS(false, isSameExpression("(1.0l + x) < (1.0 + x);", "+", "+", cpp));
-        ASSERT_EQUALS(!cpp,  isSameExpression("(0.0 + x) < (x + 0x0p+0);", "+", "+", cpp));
-        ASSERT_EQUALS(true,  isSameExpression("void f() {double y = 1e1; (x + y) < (x + 10.0); } ", "+", "+", cpp));
-        ASSERT_EQUALS(!cpp,  isSameExpression("void f() {double y = 1e1; (x + 10.0) < (y + x); } ", "+", "+", cpp));
-        ASSERT_EQUALS(true,  isSameExpression("void f() {double y = 1e1; double z = 10.0; (x + y) < (x + z); } ", "+", "+", cpp));
-        ASSERT_EQUALS(true,  isSameExpression("A + A", "A", "A", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("x = 1 + 1;\n", "1", "1", cpp));
+        ASSERT_EQUALS(false, isSameExpression("x = 1 + 1u;\n", "1", "1u", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("x = 1.0 + 1.0;\n", "1.0", "1.0", cpp));
+        ASSERT_EQUALS(false, isSameExpression("x = 1.0f + 1.0;\n", "1.0f", "1.0", cpp));
+        ASSERT_EQUALS(false, isSameExpression("x = 1L + 1;\n", "1L", "1", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("x = 0.0f + 0x0p+0f;\n", "0.0f", "0x0p+0f", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("x < x;\n", "x", "x", cpp));
+        ASSERT_EQUALS(false, isSameExpression("x < y;\n", "x", "y", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("(x + 1) < (x + 1);\n", "+", "+", cpp));
+        ASSERT_EQUALS(false, isSameExpression("(x + 1) < (x + 1L);\n", "+", "+", cpp));
+        ASSERT_EQUALS(!cpp,  isSameExpression("(1 + x) < (x + 1);\n", "+", "+", cpp));
+        ASSERT_EQUALS(false, isSameExpression("(1.0l + x) < (1.0 + x);\n", "+", "+", cpp));
+        ASSERT_EQUALS(!cpp,  isSameExpression("(0.0 + x) < (x + 0x0p+0);\n", "+", "+", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("void f() {double y = 1e1; (x + y) < (x + 10.0); } \n", "+", "+", cpp));
+        ASSERT_EQUALS(!cpp,  isSameExpression("void f() {double y = 1e1; (x + 10.0) < (y + x); } \n", "+", "+", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("void f() {double y = 1e1; double z = 10.0; (x + y) < (x + z); } \n", "+", "+", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("A + A\n", "A", "A", cpp));
 
         // the remaining test cases are not valid C code
         if (!cpp)
             return;
 
         //https://trac.cppcheck.net/ticket/9700
-        ASSERT_EQUALS(true, isSameExpression("A::B + A::B;", "::", "::", cpp));
-        ASSERT_EQUALS(false, isSameExpression("A::B + A::C;", "::", "::", cpp));
-        ASSERT_EQUALS(true, isSameExpression("A::B* get() { if(x) return new A::B(true); else return new A::B(true); }", "new", "new", cpp));
-        ASSERT_EQUALS(false, isSameExpression("A::B* get() { if(x) return new A::B(true); else return new A::C(true); }", "new", "new", cpp));
+        ASSERT_EQUALS(true, isSameExpression("A::B + A::B;\n", "::", "::", cpp));
+        ASSERT_EQUALS(false, isSameExpression("A::B + A::C;\n", "::", "::", cpp));
+        ASSERT_EQUALS(true, isSameExpression("A::B* get() { if(x) return new A::B(true); else return new A::B(true); }\n", "new", "new", cpp));
+        ASSERT_EQUALS(false, isSameExpression("A::B* get() { if(x) return new A::B(true); else return new A::C(true); }\n", "new", "new", cpp));
     }
 
     void isSameExpressionCpp() {
@@ -233,7 +233,7 @@ class TestAstUtils : public TestFixture {
         (void)isVariableChanged("void f() {\n"
                                 "  int b;\n"
                                 "  if (b) { (int)((INTOF(8))result >> b); }\n"
-                                "}", "if", "}");
+                                "}\n", "if", "}");
         // #9235
         ASSERT_EQUALS(false,
                       isVariableChanged("void f() {\n"
@@ -242,13 +242,13 @@ class TestAstUtils : public TestFixture {
                                         "= a",
                                         "}"));
 
-        ASSERT_EQUALS(false, isVariableChanged("void f(const A& a) { a.f(); }", "{", "}"));
+        ASSERT_EQUALS(false, isVariableChanged("void f(const A& a) { a.f(); }\n", "{", "}"));
         ASSERT_EQUALS(true,
                       isVariableChanged("void g(int*);\n"
                                         "void f(int x) { g(&x); }\n",
                                         "{",
                                         "}"));
-        ASSERT_EQUALS(false, isVariableChanged("const int A[] = { 1, 2, 3 };", "[", "]"));
+        ASSERT_EQUALS(false, isVariableChanged("const int A[] = { 1, 2, 3 };\n", "[", "]"));
     }
 
 #define isVariableChangedByFunctionCall(...) isVariableChangedByFunctionCall_( __FILE__, __LINE__, __VA_ARGS__)
@@ -267,7 +267,7 @@ class TestAstUtils : public TestFixture {
         { // #8271 - template method
             const char code[] = "void f(int x) {\n"
                                 "  a<int>(x);\n"
-                                "}";
+                                "}\n";
             bool inconclusive = false;
             ASSERT_EQUALS(false, isVariableChangedByFunctionCall(code, "x ) ;", &inconclusive));
             ASSERT_EQUALS(true, inconclusive);
@@ -431,8 +431,8 @@ class TestAstUtils : public TestFixture {
 
     void isExpressionChangedTest()
     {
-        ASSERT_EQUALS(true, isExpressionChanged("void f(std::map<int, int>& m) { m[0]; }", "m [", "{", "}"));
-        ASSERT_EQUALS(false, isExpressionChanged("void f(const A& a) { a.f(); }", "a .", "{", "}"));
+        ASSERT_EQUALS(true, isExpressionChanged("void f(std::map<int, int>& m) { m[0]; }\n", "m [", "{", "}"));
+        ASSERT_EQUALS(false, isExpressionChanged("void f(const A& a) { a.f(); }\n", "a .", "{", "}"));
 
         ASSERT_EQUALS(true,
                       isExpressionChanged("void g(int*);\n"
@@ -459,17 +459,17 @@ class TestAstUtils : public TestFixture {
     }
 
     void nextAfterAstRightmostLeafTest() {
-        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("void f(int a, int b) { int x = a + b; }", "=", "; }"));
-        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a); }", "=", "; }"));
-        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a)[b]; }", "=", "; }"));
-        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(g(a)[b]); }", "=", "; }"));
-        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(g(a)[b] + a); }", "=", "; }"));
-        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a)[b + 1]; }", "=", "; }"));
-        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("void f() { int a; int b; int x = [](int a){}; }", "=", "; }"));
-
-        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = a + b; }", "+", "; }"));
-        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a)[b + 1]; }", "+", "] ; }"));
-        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a + 1)[b]; }", "+", ") ["));
+        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("void f(int a, int b) { int x = a + b; }\n", "=", "; }"));
+        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a); }\n", "=", "; }"));
+        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a)[b]; }\n", "=", "; }"));
+        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(g(a)[b]); }\n", "=", "; }"));
+        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(g(a)[b] + a); }\n", "=", "; }"));
+        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a)[b + 1]; }\n", "=", "; }"));
+        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("void f() { int a; int b; int x = [](int a){}; }\n", "=", "; }"));
+
+        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = a + b; }\n", "+", "; }"));
+        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a)[b + 1]; }\n", "+", "] ; }"));
+        ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a + 1)[b]; }\n", "+", ") ["));
     }
 
     enum class Result : std::uint8_t {False, True, Fail};
@@ -486,37 +486,37 @@ class TestAstUtils : public TestFixture {
     }
 
     void isUsedAsBool() {
-        ASSERT(Result::True == isUsedAsBool("void f() { bool b = true; }", "b"));
-        ASSERT(Result::False ==isUsedAsBool("void f() { int i = true; }", "i"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (i) {} }", "i )"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; while (i) {} }", "i )"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; for (;i;) {} }", "i ; )"));
-        ASSERT(Result::False == isUsedAsBool("void f() { int i; for (;;i) {} }", "i )"));
-        ASSERT(Result::False == isUsedAsBool("void f() { int i; for (i;;) {} }", "i ; ; )"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; for (int j=0; i; ++j) {} }", "i ; ++"));
-        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (i == 2) {} }", "i =="));
-        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (i == true) {} }", "i =="));
-        ASSERT(Result::False == isUsedAsBool("void f() { int i,j; if (i == (j&&f())) {} }", "i =="));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (!i == 0) {} }", "i =="));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (!i) {} }", "i )"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (!!i) {} }", "i )"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (i && f()) {} }", "i &&"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; int j = i && f(); }", "i &&"));
-        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (i & f()) {} }", "i &"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (static_cast<bool>(i)) {} }", "i )"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; if ((bool)i) {} }", "i )"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (1+static_cast<bool>(i)) {} }", "i )"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (1+(bool)i) {} }", "i )"));
-        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (1+static_cast<int>(i)) {} }", "i )"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (1+!static_cast<int>(i)) {} }", "i )"));
-        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (1+(int)i) {} }", "i )"));
-        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (i + 2) {} }", "i +"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int i; bool b = i; }", "i ; }"));
-        ASSERT(Result::True == isUsedAsBool("void f(bool b); void f() { int i; f(i); }","i )"));
-        ASSERT(Result::False == isUsedAsBool("void f() { int *i; if (*i) {} }", "i )"));
-        ASSERT(Result::True == isUsedAsBool("void f() { int *i; if (*i) {} }", "* i )"));
-        ASSERT(Result::True == isUsedAsBool("int g(); void h(bool); void f() { h(g()); }", "( ) )"));
-        ASSERT(Result::True == isUsedAsBool("int g(int); void h(bool); void f() { h(g(0)); }", "( 0 ) )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { bool b = true; }\n", "b"));
+        ASSERT(Result::False ==isUsedAsBool("void f() { int i = true; }\n", "i"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (i) {} }\n", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; while (i) {} }\n", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; for (;i;) {} }\n", "i ; )"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; for (;;i) {} }\n", "i )"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; for (i;;) {} }\n", "i ; ; )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; for (int j=0; i; ++j) {} }\n", "i ; ++"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (i == 2) {} }\n", "i =="));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (i == true) {} }\n", "i =="));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i,j; if (i == (j&&f())) {} }\n", "i =="));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (!i == 0) {} }\n", "i =="));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (!i) {} }\n", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (!!i) {} }\n", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (i && f()) {} }\n", "i &&"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; int j = i && f(); }\n", "i &&"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (i & f()) {} }\n", "i &"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (static_cast<bool>(i)) {} }\n", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if ((bool)i) {} }\n", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (1+static_cast<bool>(i)) {} }\n", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (1+(bool)i) {} }\n", "i )"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (1+static_cast<int>(i)) {} }\n", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (1+!static_cast<int>(i)) {} }\n", "i )"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (1+(int)i) {} }\n", "i )"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (i + 2) {} }\n", "i +"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; bool b = i; }\n", "i ; }"));
+        ASSERT(Result::True == isUsedAsBool("void f(bool b); void f() { int i; f(i); }\n","i )"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int *i; if (*i) {} }\n", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int *i; if (*i) {} }\n", "* i )"));
+        ASSERT(Result::True == isUsedAsBool("int g(); void h(bool); void f() { h(g()); }\n", "( ) )"));
+        ASSERT(Result::True == isUsedAsBool("int g(int); void h(bool); void f() { h(g(0)); }\n", "( 0 ) )"));
     }
 };
 
diff --git a/test/testautovariables.cpp b/test/testautovariables.cpp
index 7774d7fa733..dbec2bae0a0 100644
--- a/test/testautovariables.cpp
+++ b/test/testautovariables.cpp
@@ -180,21 +180,21 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    int num = 2;\n"
               "    *res = &num;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
 
         check("void func1(int **res)\n"
               "{\n"
               "    int num = 2;\n"
               "    res = &num;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it? [uselessAssignmentPtrArg]\n", errout_str());
 
         check("void func1(int **res)\n"
               "{\n"
               "    int num = 2;\n"
               "    foo.res = &num;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -206,7 +206,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    int num = 2;\n"
               "    *res = &num;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
 
         check("class Fred {\n"
@@ -216,7 +216,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    int num = 2;\n"
               "    res = &num;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it? [uselessAssignmentPtrArg]\n", errout_str());
 
         check("class Fred {\n"
@@ -226,7 +226,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    int num = 2;\n"
               "    foo.res = &num;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -235,7 +235,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    int x[100];\n"
               "    *p = x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
@@ -244,7 +244,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    static int x[100];\n"
               "    *p = x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -253,7 +253,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    char a;\n"
               "    ab->a = &a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error, inconclusive) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
@@ -262,14 +262,14 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    char a[10];\n"
               "    x->str = a;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(struct X *x)\n"
               "{\n"
               "    char a[10];\n"
               "    x->str = a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error, inconclusive) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
@@ -279,7 +279,7 @@ class TestAutoVariables : public TestFixture {
               "    struct txt_scrollpane_s * scrollpane;\n"
               "    target->parent = &scrollpane->widget;\n"
               "    return scrollpane;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -287,12 +287,12 @@ class TestAutoVariables : public TestFixture {
         check("void foo(int*& p) {\n"
               "    int i = 0;\n"
               "    p = &i;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
 
         check("void foo(std::string& s) {\n"
               "    s = foo;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -303,7 +303,7 @@ class TestAutoVariables : public TestFixture {
               "    FN fn;\n"
               "    FP fp;\n"
               "    p = &fn.i;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:6:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
 
         check("struct FN {int i;};\n"
@@ -312,7 +312,7 @@ class TestAutoVariables : public TestFixture {
               "    FN fn;\n"
               "    FP fp;\n"
               "    p = &p_fp->i;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("struct FN {int i;};\n"
@@ -321,100 +321,100 @@ class TestAutoVariables : public TestFixture {
               "    FN fn;\n"
               "    FP fp;\n"
               "    p = &fp.f->i;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
     }
 
     void testautovar10() { // #2930 - assignment of function parameter
         check("void foo(char* p) {\n"
               "    p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it? [uselessAssignmentPtrArg]\n", errout_str());
 
         check("void foo(int b) {\n"
               "    b = foo(b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (style) Assignment of function parameter has no effect outside the function. [uselessAssignmentArg]\n", errout_str());
 
         check("void foo(int b) {\n"
               "    b += 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (style) Assignment of function parameter has no effect outside the function. [uselessAssignmentArg]\n", errout_str());
 
         check("void foo(std::string s) {\n"
               "    s = foo(b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (style) Assignment of function parameter has no effect outside the function. [uselessAssignmentArg]\n", errout_str());
 
         check("void foo(char* p) {\n" // don't warn for self assignment, there is another warning for this
               "  p = p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* p) {\n"
               "    if (!p) p = buf;\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* p) {\n"
               "    if (!p) p = buf;\n"
               "    do_something(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* p) {\n"
               "    while (!p) p = buf;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* p) {\n"
               "    p = 0;\n"
               "    asm(\"somecmd\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(Foo* p) {\n"
               "    p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it? [uselessAssignmentPtrArg]\n", errout_str());
 
         check("class Foo {};\n"
               "void foo(Foo p) {\n"
               "    p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Assignment of function parameter has no effect outside the function. [uselessAssignmentArg]\n", errout_str());
 
         check("void foo(Foo p) {\n"
               "    p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int& p) {\n"
               "    p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("double foo(double d) {\n" // #5005
               "    int i = d;\n"
               "    d = i;\n"
-              "    return d;"
-              "}",dinit(CheckOptions, $.inconclusive = false));
+              "    return d;\n"
+              "}\n",dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int* ptr) {\n" // #4793
               "    ptr++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it? [uselessAssignmentPtrArg]\n", errout_str());
 
         check("void foo(int* ptr) {\n" // #3177
               "    --ptr;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it? [uselessAssignmentPtrArg]\n", errout_str());
 
         check("void foo(struct S* const x) {\n" // #7839
               "    ++x->n;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -425,7 +425,7 @@ class TestAutoVariables : public TestFixture {
               "void foo(char** p) {\n"
               "    struct A a = bar();\n"
               "    *p = &(*a.data)[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -434,36 +434,36 @@ class TestAutoVariables : public TestFixture {
               "void foo(char** p) {\n"
               "    struct A a = bar();\n"
               "    *p = &a.data[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
 
         check("void f(char **out) {\n"
               "  struct S *p = glob;\n"
               "  *out = &p->data;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4998
         check("void f(s8**out) {\n"
               "  s8 *p;\n"  // <- p is pointer => no error
               "  *out = &p[1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(s8**out) {\n"
               "  s8 p[10];\n"  // <- p is array => error
               "  *out = &p[1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
     void testautovar12() { // Ticket #5024, #5050 - Crash on invalid input
-        ASSERT_THROW_INTERNAL(check("void f(int* a) { a = }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(check("void f(int* a) { a = }\n"), SYNTAX);
         check("struct custom_type { custom_type(int) {} };\n"
               "void func(int) {}\n"
               "int var;\n"
               "void init() { func(var); }\n"
-              "UNKNOWN_MACRO_EXPANDING_TO_SIGNATURE { custom_type a(var); }");
+              "UNKNOWN_MACRO_EXPANDING_TO_SIGNATURE { custom_type a(var); }\n");
     }
 
     void testautovar13() { // Ticket #5537
@@ -473,7 +473,7 @@ class TestAutoVariables : public TestFixture {
               "  ~FileManager() {\n"
               "    delete &UniqueRealDirs;\n"
               "   }\n"
-              "};");
+              "};\n");
     }
 
     void testautovar14() { // Ticket #4776
@@ -483,7 +483,7 @@ class TestAutoVariables : public TestFixture {
               "    x = x >> 1;\n"
               "    goto label;\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -496,7 +496,7 @@ class TestAutoVariables : public TestFixture {
               "    if (lumdiff > 5.0f)\n"
               "        return &darkOutline;\n"
               "    return 0;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -504,7 +504,7 @@ class TestAutoVariables : public TestFixture {
         check("void f(const void* ptr, bool* result) {\n"
               "  int dummy;\n"
               "  *result = (&dummy < ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -533,7 +533,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    int num=2;"
               "    arr[0]=&num;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
@@ -545,7 +545,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    int num=2;"
               "    arr[0]=&num;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:19]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
@@ -596,7 +596,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    XPoint DropPoint;\n"
               "    ds->location_data = (XtPointer *)&DropPoint;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error, inconclusive) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
@@ -604,7 +604,7 @@ class TestAutoVariables : public TestFixture {
         check("void remove_duplicate_matches (char **matches) {\n"
               "  char dead_slot;\n"
               "  matches[0] = (char *)&dead_slot;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
@@ -613,7 +613,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    int num=2;"
               "    return &num;"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:26] -> [test.cpp:3:9] -> [test.cpp:3:26]: (error) Returning pointer to local variable 'num' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
     }
 
@@ -625,7 +625,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    int num=2;"
               "    return &num;"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:26] -> [test.cpp:6:9] -> [test.cpp:6:26]: (error) Returning pointer to local variable 'num' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
     }
 
@@ -635,7 +635,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    void *&value = tls[id];"
               "    return &value;"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -644,7 +644,7 @@ class TestAutoVariables : public TestFixture {
         check("void foo() {\n"
               "  int cond2;\n"
               "  dostuff([&cond2]() { return &cond2; });\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -681,7 +681,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    extern struct foo f;\n"
               "    return &f;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -691,7 +691,7 @@ class TestAutoVariables : public TestFixture {
               "  pcb->root0 = &root0;\n"
               "  dostuff(pcb);\n"
               "  pcb->root0 = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(cb* pcb) {\n"
@@ -700,7 +700,7 @@ class TestAutoVariables : public TestFixture {
               "  dostuff(pcb);\n"
               "  if (condition) return;\n" // <- not reassigned => error
               "  pcb->root0 = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3]: (error, inconclusive) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
 
         check("void foo(cb* pcb) {\n"
@@ -709,7 +709,7 @@ class TestAutoVariables : public TestFixture {
               "  dostuff(pcb);\n"
               "  if (condition)\n"
               "    pcb->root0 = 0;\n"  // <- conditional reassign => error
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3]: (error, inconclusive) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
 
         check("struct S { int *p; };\n"
@@ -721,7 +721,7 @@ class TestAutoVariables : public TestFixture {
               "void f() {\n"
               "    struct S s;\n"
               "    g(&s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n",
             errout_str());
@@ -739,7 +739,7 @@ class TestAutoVariables : public TestFixture {
               "    delete[] (tmp4);\n"
               "    char tmp5[256];\n"
               "    delete[] tmp5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n"
                       "[test.cpp:5:12]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n"
                       "[test.cpp:7:12]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n"
@@ -748,28 +748,28 @@ class TestAutoVariables : public TestFixture {
 
         check("void func1(char * ptr) {\n"
               "    free(ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void func1() {\n"
               "    char* tmp1[256];\n"
               "    init(tmp1);\n"
               "    delete tmp1[34];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void func1() {\n"
               "    static char tmp1[256];\n"
               "    char *p = tmp1;\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (error) Deallocation of a static variable (tmp1) results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
 
         check("char tmp1[256];\n"
               "void func1() {\n"
               "    char *p; if (x) p = tmp1;\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (error) Deallocation of a global variable (tmp1) results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
 
         check("void f()\n"
@@ -780,7 +780,7 @@ class TestAutoVariables : public TestFixture {
               "        abc(0, psz_title);\n"
               "        free(psz_title);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #2298 new check: passing stack-address to free()
@@ -788,44 +788,44 @@ class TestAutoVariables : public TestFixture {
               "   int *p = malloc(4);\n"
               "   free(&p);\n"
               "   return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
         check("int main() {\n"
               "   int i;\n"
               "   free(&i);\n"
               "   return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
 
         // #5732
         check("int main() {\n"
               "   long (*pKoeff)[256] = new long[9][256];\n"
               "   delete[] pKoeff;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int main() {\n"
               "   long *pKoeff[256];\n"
               "   delete[] pKoeff;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
 
         check("int main() {\n"
               "   long *pKoeff[256];\n"
               "   free (pKoeff);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
 
         check("void foo() {\n"
               "   const intPtr& intref = Getter();\n"
               "   delete intref;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void test() {\n"
               "   MyObj& obj = *new MyObj;\n"
               "   delete &obj;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6506
@@ -837,7 +837,7 @@ class TestAutoVariables : public TestFixture {
               "  F().free(c1);\n"
               "  char *c2 = 0;\n"
               "  F().free(&c2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class foo {\n"
@@ -846,14 +846,14 @@ class TestAutoVariables : public TestFixture {
               "    char **dst_copy = NULL;\n"
               "    free(&dst_copy);\n"
               "  }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6551
         check("bool foo( ) {\n"
               "  SwTxtFld * pTxtFld = GetFldTxtAttrAt();\n"
               "  delete static_cast<SwFmtFld*>(&pTxtFld->GetAttr());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8910
@@ -863,14 +863,14 @@ class TestAutoVariables : public TestFixture {
               "    if (data_size > sizeof (stack)) data = malloc (data_size);\n"
               "    else data = (RGNDATA *)stack;\n"
               "    if ((char *)data != stack) free (data);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8923
         check("void f(char **args1, char *args2[]) {\n"
               "    free((char **)args1);\n"
               "    free((char **)args2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #10097
@@ -985,7 +985,7 @@ class TestAutoVariables : public TestFixture {
         check("void f(EventPtr *eventP, ActionPtr **actionsP) {\n"
               "    EventPtr event = *eventP;\n"
               "    *actionsP = &event->actions;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -993,7 +993,7 @@ class TestAutoVariables : public TestFixture {
         check("static void function(unsigned long **datap) {\n"
               "    struct my_s *mr = global_structure_pointer;\n"
               "    *datap = &mr->value;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1002,7 +1002,7 @@ class TestAutoVariables : public TestFixture {
               "void f() {\n"
               "  int x[10];\n"
               "  p = x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7] -> [test.cpp:3:7] -> [test.cpp:4:3]: (error) Non-local variable 'p' will use pointer to local variable 'x'. [danglingLifetime]\n", errout_str());
 
         check("int *p;\n"
@@ -1010,7 +1010,7 @@ class TestAutoVariables : public TestFixture {
               "  int x[10];\n"
               "  p = x;\n"
               "  p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1019,7 +1019,7 @@ class TestAutoVariables : public TestFixture {
               "void f() {\n"
               "  int x;\n"
               "  p = &x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7] -> [test.cpp:3:7] -> [test.cpp:4:3]: (error) Non-local variable 'p' will use pointer to local variable 'x'. [danglingLifetime]\n", errout_str());
 
         check("int *p;\n"
@@ -1027,7 +1027,7 @@ class TestAutoVariables : public TestFixture {
               "  int x;\n"
               "  p = &x;\n"
               "  p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1038,7 +1038,7 @@ class TestAutoVariables : public TestFixture {
               "    ptr = &x;\n"
               "  }\n"
               "  int *ptr;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:11] -> [test.cpp:3:9] -> [test.cpp:4:5]: (error) Non-local variable 'ptr' will use pointer to local variable 'x'. [danglingLifetime]\n", errout_str());
 
         check("struct A {\n"
@@ -1048,7 +1048,7 @@ class TestAutoVariables : public TestFixture {
               "    ptr = 0;\n"
               "  }\n"
               "  int *ptr;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct R {\n" // #11393
@@ -1072,7 +1072,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    char str[100] = {0};\n"
               "    return str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:12] -> [test.cpp:3:10] -> [test.cpp:4:12]: (error) Returning pointer to local variable 'str' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -1082,7 +1082,7 @@ class TestAutoVariables : public TestFixture {
               "    char str[100] = {0};\n"
               "    char *p = str;\n"
               "    return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:15] -> [test.cpp:3:10] -> [test.cpp:5:12]: (error) Returning pointer to local variable 'str' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -1094,7 +1094,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    char str[100] = {0};\n"
               "    return str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:7:12] -> [test.cpp:6:10] -> [test.cpp:7:12]: (error) Returning pointer to local variable 'str' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -1106,7 +1106,7 @@ class TestAutoVariables : public TestFixture {
               "    char temp[42];\n"
               "    char *tp = temp;\n"
               "    tp = format_reg(tp);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1115,7 +1115,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    char str[100] = {0};\n"
               "    return str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred {\n"
@@ -1125,7 +1125,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    char str[100] = {0};\n"
               "    return str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1135,14 +1135,14 @@ class TestAutoVariables : public TestFixture {
         check("char *foo() {\n"
               "    char q[] = \"AAAAAAAAAAAA\";\n"
               "    return &q[1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12] -> [test.cpp:2:10] -> [test.cpp:3:12]: (error) Returning pointer to local variable 'q' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("char *foo()\n"
               "{\n"
               "    static char q[] = \"AAAAAAAAAAAA\";\n"
               "    return &q[1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("char *foo()\n"
@@ -1151,7 +1151,7 @@ class TestAutoVariables : public TestFixture {
               "char *p;\n"
               "p = &q[1];\n"
               "return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5] -> [test.cpp:3:6] -> [test.cpp:6:8]: (error) Returning pointer to local variable 'q' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
     }
 
@@ -1159,7 +1159,7 @@ class TestAutoVariables : public TestFixture {
         check("char *foo() {\n"
               "    char x[10] = {0};\n"
               "    return x+5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:12] -> [test.cpp:2:10] -> [test.cpp:3:13]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -1167,7 +1167,7 @@ class TestAutoVariables : public TestFixture {
         check("char *foo(int y) {\n"
               "    char x[10] = {0};\n"
               "    return (x+8)-y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:13] -> [test.cpp:2:10] -> [test.cpp:3:17]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -1177,7 +1177,7 @@ class TestAutoVariables : public TestFixture {
         check("char *foo() {\n"
               "    int x[10] = {0};\n"
               "    return (char *)x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:20] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -1188,7 +1188,7 @@ class TestAutoVariables : public TestFixture {
               "    int x = 123;\n"
               "    int p = &x;\n"
               "    return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning object that points to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
     }
 
@@ -1198,35 +1198,35 @@ class TestAutoVariables : public TestFixture {
               "    int s = 0;\n"
               "    int& x = s;\n"
               "    return x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12] -> [test.cpp:5:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("std::string &foo()\n"
               "{\n"
               "    std::string s;\n"
               "    return s;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("std::vector<int> &foo()\n"
               "{\n"
               "    std::vector<int> v;\n"
               "    return v;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("std::vector<int> &foo()\n"
               "{\n"
               "    static std::vector<int> v;\n"
               "    return v;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int> &foo()\n"
               "{\n"
               "    thread_local std::vector<int> v;\n"
               "    return v;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::string hello()\n"
@@ -1237,7 +1237,7 @@ class TestAutoVariables : public TestFixture {
               "std::string &f()\n"
               "{\n"
               "    return hello();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:17]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         // make sure scope is used in function lookup
@@ -1248,7 +1248,7 @@ class TestAutoVariables : public TestFixture {
               "};\n"
               "std::string &f() {\n"
               "    return hello();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::string hello() {\n"
@@ -1257,7 +1257,7 @@ class TestAutoVariables : public TestFixture {
               "\n"
               "std::string &f() {\n"
               "    return hello();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:17]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("std::string hello() {\n"
@@ -1266,7 +1266,7 @@ class TestAutoVariables : public TestFixture {
               "\n"
               "std::string &f() {\n"
               "    return hello().substr(1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:26]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("class Foo;\n"
@@ -1276,7 +1276,7 @@ class TestAutoVariables : public TestFixture {
               "\n"
               "Foo& f() {\n"
               "    return hello();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:17]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         // make sure function overloads are handled properly
@@ -1291,7 +1291,7 @@ class TestAutoVariables : public TestFixture {
               "\n"
               "Foo& f() {\n"
               "    return hello(true);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("Foo hello() {\n"
@@ -1300,7 +1300,7 @@ class TestAutoVariables : public TestFixture {
               "\n"
               "Foo& f() {\n" // Unknown type - might be a reference
               "    return hello();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1312,7 +1312,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    std::string s;\n"
               "    return s;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("class Fred {\n"
@@ -1322,7 +1322,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    std::vector<int> v;\n"
               "    return v;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("class Fred {\n"
@@ -1332,7 +1332,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    static std::vector<int> v;\n"
               "    return v;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred {\n"
@@ -1345,7 +1345,7 @@ class TestAutoVariables : public TestFixture {
               "std::string &Fred::f()\n"
               "{\n"
               "    return hello();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:17]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("class Fred {\n"
@@ -1359,7 +1359,7 @@ class TestAutoVariables : public TestFixture {
               "std::string &Fred::f()\n"
               "{\n"
               "    return hello();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:11:17]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("class Bar;\n"
@@ -1368,7 +1368,7 @@ class TestAutoVariables : public TestFixture {
               "}\n"
               "Bar& bar() {\n"
               "    return foo();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:15]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("std::map<int, string> foo() {\n"
@@ -1376,7 +1376,7 @@ class TestAutoVariables : public TestFixture {
               "}\n"
               "std::map<int, string>& bar() {\n"
               "    return foo();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:15]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("Bar foo() {\n"
@@ -1384,13 +1384,13 @@ class TestAutoVariables : public TestFixture {
               "}\n"
               "Bar& bar() {\n" // Unknown type - might be a typedef to a reference type
               "    return foo();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         // Don't crash with function in unknown scope (#4076)
-        check("X& a::Bar() {}"
+        check("X& a::Bar() {}\n"
               "X& foo() {"
               "    return Bar();"
-              "}");
+              "}\n");
     }
 
     void returnReference3() {
@@ -1398,7 +1398,7 @@ class TestAutoVariables : public TestFixture {
               "    double ret = getValue();\n"
               "    rd = ret;\n"
               "    return rd;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1407,7 +1407,7 @@ class TestAutoVariables : public TestFixture {
         check("double a;\n"
               "double & f() {\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1427,7 +1427,7 @@ class TestAutoVariables : public TestFixture {
               "        const A &ra = pb->a;\n"
               "        return ra;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1435,7 +1435,7 @@ class TestAutoVariables : public TestFixture {
         check("Fred & create() {\n"
               "    Fred &fred(*new Fred);\n"
               "    return fred;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1444,14 +1444,14 @@ class TestAutoVariables : public TestFixture {
               "std::string &a(int);\n"
               "std::string &b() {\n"
               "    return a(12);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::string &a(int);\n"
               "std::string a();\n"
               "std::string &b() {\n"
               "    return a(12);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1460,14 +1460,14 @@ class TestAutoVariables : public TestFixture {
               "    std::vector<int>::iterator it = v.begin();\n"
               "    int& value = *it;\n"
               "    return value;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void returnReference9() {
         check("int& f(bool b, int& x, int& y) {\n"
               "    return b ? x : y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1476,14 +1476,14 @@ class TestAutoVariables : public TestFixture {
               "int& g() {\n"
               "    A a;\n"
               "    return a.f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:15]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("class A { int& f() const; };\n"
               "int& g() {\n"
               "    A a;\n"
               "    return a.f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1491,19 +1491,19 @@ class TestAutoVariables : public TestFixture {
         check("class A { static int f(); };\n"
               "int& g() {\n"
               "    return A::f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("class A { static int& f(); };\n"
               "int& g() {\n"
               "    return A::f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("namespace A { int& f(); }\n"
               "int& g() {\n"
               "    return A::f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1511,14 +1511,14 @@ class TestAutoVariables : public TestFixture {
         check("class A { static int& f(); };\n"
               "auto g() {\n"
               "    return &A::f;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A { static int& f(); };\n"
               "auto g() {\n"
               "    auto x = &A::f;\n"
               "    return x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1527,14 +1527,14 @@ class TestAutoVariables : public TestFixture {
               "void* vp = &v;\n"
               "int& foo(size_t i) {\n"
               "    return ((std::vector<int>*)vp)->at(i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int> v;\n"
               "void* vp = &v;\n"
               "int& foo(size_t i) {\n"
               "    return static_cast<std::vector<int>*>(vp)->at(i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1547,7 +1547,7 @@ class TestAutoVariables : public TestFixture {
               "}\n"
               "void* &A::f() {\n"
               "    return g()->m;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1560,7 +1560,7 @@ class TestAutoVariables : public TestFixture {
               "template <class T>\n"
               "const int& f(const T&) {\n"
               "    return f<T>();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template <class T>\n"
@@ -1568,19 +1568,19 @@ class TestAutoVariables : public TestFixture {
               "template <class T>\n"
               "const int& f(const T&) {\n"
               "    return g<T>();\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
     void returnReference16() {
         check("int& f(std::tuple<int>& x) {\n"
               "    return std::get<0>(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int& f(int x) {\n"
               "    return std::get<0>(std::make_tuple(x));\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
@@ -1588,7 +1588,7 @@ class TestAutoVariables : public TestFixture {
         check("auto g() -> int&;\n"
               "int& f() {\n"
               "    return g();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1597,7 +1597,7 @@ class TestAutoVariables : public TestFixture {
               "auto f(T& x) -> decltype(x);\n"
               "int& g(int* x) {\n"
               "    return f(*x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1605,7 +1605,7 @@ class TestAutoVariables : public TestFixture {
     void returnReference19() {
         check("struct C : B {\n"
               "    const B &f() const { return (const B &)*this; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1616,7 +1616,7 @@ class TestAutoVariables : public TestFixture {
               "};\n"
               "int& b() {\n"
               "    return a()();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("auto a() {\n"
@@ -1627,13 +1627,13 @@ class TestAutoVariables : public TestFixture {
               "}\n"
               "const int& c() {\n"
               "    return a()();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::function<int&()> a();\n"
               "int& b() {\n"
               "    return a()();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9889
@@ -1779,7 +1779,7 @@ class TestAutoVariables : public TestFixture {
               "int& hello() {\n"
               "    int x = 0;\n"
               "    return f(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:1:14] -> [test.cpp:2:12] -> [test.cpp:6:12] -> [test.cpp:6:13]: (error) Reference to local variable returned. [returnReference]\n",
             errout_str());
@@ -1790,7 +1790,7 @@ class TestAutoVariables : public TestFixture {
               "int* hello() {\n"
               "    int x = 0;\n"
               "    return &f(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:1:14] -> [test.cpp:2:12] -> [test.cpp:6:13] -> [test.cpp:6:12] -> [test.cpp:5:9] -> [test.cpp:6:12]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -1800,7 +1800,7 @@ class TestAutoVariables : public TestFixture {
               "}\n"
               "int * g(int x) {\n"
               "    return f(&x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:14] -> [test.cpp:5:14] -> [test.cpp:4:13] -> [test.cpp:5:13]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("int* f(int * x) {\n"
@@ -1809,7 +1809,7 @@ class TestAutoVariables : public TestFixture {
               "}\n"
               "int * g(int x) {\n"
               "    return f(&x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int& a) {\n"
@@ -1818,7 +1818,7 @@ class TestAutoVariables : public TestFixture {
               "int& hello() {\n"
               "    int x = 0;\n"
               "    return f(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:13]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("int& f(int a) {\n"
@@ -1827,7 +1827,7 @@ class TestAutoVariables : public TestFixture {
               "int& hello() {\n"
               "    int x = 0;\n"
               "    return f(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("int f(int a) {\n"
@@ -1836,14 +1836,14 @@ class TestAutoVariables : public TestFixture {
               "int& hello() {\n"
               "    int x = 0;\n"
               "    return f(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:13]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("template<class T>\n"
               "int& f(int& x, T y) {\n"
               "    x += y;\n"
               "    return x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1851,31 +1851,31 @@ class TestAutoVariables : public TestFixture {
         check("auto& f() {\n"
               "    std::vector<int> x;\n"
               "    return x[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("auto& f() {\n"
               "    std::vector<int> x;\n"
               "    return x.front();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14] -> [test.cpp:3:19]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("std::vector<int> g();\n"
               "auto& f() {\n"
               "    return g().front();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:3:21]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("auto& f() {\n"
               "    return std::vector<int>{1}.front();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:32] -> [test.cpp:2:37]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("struct A { int foo; };\n"
               "int& f(std::vector<A> v) {\n"
               "    auto it = v.begin();\n"
               "    return it->foo;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:22] -> [test.cpp:4:14]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("template <class T, class K, class V>\n"
@@ -1909,7 +1909,7 @@ class TestAutoVariables : public TestFixture {
               "int& f(std::vector<A>& v) {\n"
               "    auto it = v.begin();\n"
               "    return it->foo;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("static std::vector<int> A[2];\n"
@@ -1923,18 +1923,18 @@ class TestAutoVariables : public TestFixture {
     void returnReferenceLiteral() {
         check("const std::string &a() {\n"
               "    return \"foo\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("const std::string a() {\n"
               "    return \"foo\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("const std::string& f(const std::string& x) { return x; }\n"
               "const std::string &a() {\n"
               "    return f(\"foo\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:1:42] -> [test.cpp:1:53] -> [test.cpp:3:12] -> [test.cpp:3:13]: (error) Reference to temporary returned. [returnTempReference]\n",
             errout_str());
@@ -1942,59 +1942,59 @@ class TestAutoVariables : public TestFixture {
         check("const char * f(const char * x) { return x; }\n"
               "const std::string &a() {\n"
               "    return f(\"foo\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
     }
 
     void returnReferenceCalculation() {
         check("const std::string &a(const std::string& str) {\n"
               "    return \"foo\" + str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("int& operator<<(int out, int path) {\n"
               "    return out << path;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("std::ostream& operator<<(std::ostream& out, const std::string& path) {\n"
               "    return out << path;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::ostream& operator<<(std::ostream* out, const std::string& path) {\n"
               "    return *out << path;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("Unknown1& operator<<(Unknown1 out, Unknown2 path) {\n"
               "    return out << path;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int& a(int b) {\n"
               "    return 2*(b+1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("const std::string &a(const std::string& str) {\n"
               "    return str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("const std::string &a(int bar) {\n"
               "    return foo(bar + 1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("const std::string a(const std::string& str) {\n"
               "    return \"foo\" + str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int& incValue(int& value) {\n"
               "    return ++value;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2005,7 +2005,7 @@ class TestAutoVariables : public TestFixture {
               "    [](const Item& lhs, const Item& rhs) {\n"
               "        return false;\n"
               "    });\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5844
@@ -2015,13 +2015,13 @@ class TestAutoVariables : public TestFixture {
               "    return var;\n"
               "  }();\n"
               "return s_var;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7583
         check("Command& foo() {\n"
               "  return f([]() -> int { return 1; });\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2034,16 +2034,16 @@ class TestAutoVariables : public TestFixture {
               "        }\n"
               "    };\n"
               "    return _make(_Wrapper::call, pmf);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void returnReferenceRecursive() {
-        check("int& f() { return f(); }");
+        check("int& f() { return f(); }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int& g(int& i) { return i; }\n"
-              "int& f() { return g(f()); }");
+              "int& f() { return g(f()); }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2053,7 +2053,7 @@ class TestAutoVariables : public TestFixture {
               "auto f() {\n"
               "    const int& x = h();\n"
               "    return [&] { return x; };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18] -> [test.cpp:5:25] -> [test.cpp:4:16] -> [test.cpp:5:12]: (error) Returning lambda that captures local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("void g(int*);\n"
@@ -2061,7 +2061,7 @@ class TestAutoVariables : public TestFixture {
               "int* f() {\n"
               "    const int& x = h();\n"
               "    return &x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18] -> [test.cpp:5:12] -> [test.cpp:4:16] -> [test.cpp:5:12]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("void g(int*);\n"
@@ -2069,7 +2069,7 @@ class TestAutoVariables : public TestFixture {
               "void f() {\n"
               "    int& x = h();\n"
               "    g(&x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:12] -> [test.cpp:5:7] -> [test.cpp:4:15] -> [test.cpp:5:7]: (error) Using pointer that is a temporary. [danglingTemporaryLifetime]\n"
             "[test.cpp:4:12] -> [test.cpp:5:8]: (error) Using reference to dangling temporary. [danglingTempReference]\n",
@@ -2080,7 +2080,7 @@ class TestAutoVariables : public TestFixture {
               "void f() {\n"
               "    const int& x = h();\n"
               "    g(&x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Data {\n"
@@ -2089,7 +2089,7 @@ class TestAutoVariables : public TestFixture {
               "const char* foo() {\n"
               "    const Data& data = getData();\n"
               "    return data.path.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2098,7 +2098,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    static int &r = k;\n"
               "    return r;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:19] -> [test.cpp:3:17]: (error) Non-local reference variable 'r' to local variable 'k' [danglingReference]\n",
                       errout_str());
 
@@ -2106,7 +2106,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    static int &r = k;\n"
               "    return r;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2274,7 +2274,7 @@ class TestAutoVariables : public TestFixture {
               "   {\n"
               "      pNum = apNum;\n"
               "   }\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -2283,28 +2283,28 @@ class TestAutoVariables : public TestFixture {
         check("int* foo(int y)\n"
               "{\n"
               "  return &y;\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:1:14] -> [test.cpp:3:10]: (error) Returning pointer to local variable 'y' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("int ** foo(int * y)\n"
               "{\n"
               "  return &y;\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:1:18] -> [test.cpp:3:10]: (error) Returning pointer to local variable 'y' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("const int * foo(const int & y)\n"
               "{\n"
               "  return &y;\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
         check("int * foo(int * y)\n"
               "{\n"
               "  return y;\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -2314,7 +2314,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    struct s *r = f();\n"
               "    *q = &r->p;\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -2325,7 +2325,7 @@ class TestAutoVariables : public TestFixture {
               "  const_tree_iterator& parent() {\n"
               "    return const_tree_iterator(foo);\n"
               "  }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:31]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
     }
 
@@ -2336,7 +2336,7 @@ class TestAutoVariables : public TestFixture {
               "}\n"
               "void opened_cb () {\n"
               "	g_signal_connect (G_CALLBACK (removed_cb));\n"
-              "}");
+              "}\n");
     }
 
     void danglingLifetimeLambda() {
@@ -2344,30 +2344,30 @@ class TestAutoVariables : public TestFixture {
               "    int a = 1;\n"
               "    auto l = [&](){ return a; };\n"
               "    return l;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:28] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f() {\n"
               "    int a = 1;\n"
               "    return [&](){ return a; };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:26] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f(int a) {\n"
               "    return [&](){ return a; };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:26] -> [test.cpp:1:12] -> [test.cpp:2:12]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f(int a) {\n"
               "    auto p = &a;\n"
               "    return [=](){ return p; };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14] -> [test.cpp:3:26] -> [test.cpp:1:12] -> [test.cpp:3:12]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto g(int& a) {\n"
               "    int p = a;\n"
               "    return [&](){ return p; };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:26] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning lambda that captures local variable 'p' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f() {\n"
@@ -2375,7 +2375,7 @@ class TestAutoVariables : public TestFixture {
               "        int a = 1;\n"
               "        return [&](){ return a; };\n"
               "    };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:30] -> [test.cpp:3:13] -> [test.cpp:4:16]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f(int b) {\n"
@@ -2383,30 +2383,30 @@ class TestAutoVariables : public TestFixture {
               "        a += b;\n"
               "        return [&](){ return a; };\n"
               "    };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:30] -> [test.cpp:2:20] -> [test.cpp:4:16]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto g(int& a) {\n"
               "    return [&](){ return a; };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("auto g(int a) {\n"
               "    auto p = a;\n"
               "    return [=](){ return p; };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("auto g(int& a) {\n"
               "    auto p = a;\n"
               "    return [=](){ return p; };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("auto g(int& a) {\n"
               "    int& p = a;\n"
               "    return [&](){ return p; };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template<class F>\n"
@@ -2414,7 +2414,7 @@ class TestAutoVariables : public TestFixture {
               "auto f() {\n"
               "    int x;\n"
               "    return g([&]() { return x; });\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("auto f() {\n"
@@ -2487,28 +2487,28 @@ class TestAutoVariables : public TestFixture {
         check("auto f(const std::vector<int>& x) {\n"
               "    auto it = x.begin();\n"
               "    return it;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int>::iterator f() {\n"
               "    std::vector<int> x;\n"
               "    auto it = x.begin();\n"
               "    return it;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:22] -> [test.cpp:2:22] -> [test.cpp:4:12]: (error) Returning iterator to local container 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f() {\n"
               "    std::vector<int> x;\n"
               "    auto it = std::begin(x);\n"
               "    return it;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:25] -> [test.cpp:2:22] -> [test.cpp:4:12]: (error) Returning iterator to local container 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("int* f() {\n"
               "    std::vector<int> x;\n"
               "    auto p = x.data();\n"
               "    return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:20] -> [test.cpp:2:22] -> [test.cpp:4:12]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -2517,7 +2517,7 @@ class TestAutoVariables : public TestFixture {
               "    std::vector<int> x;\n"
               "    auto p = &x[0];\n"
               "    return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:14] -> [test.cpp:2:22] -> [test.cpp:4:12]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -2526,7 +2526,7 @@ class TestAutoVariables : public TestFixture {
               "int* f(std::vector<A> v) {\n"
               "    auto it = v.begin();\n"
               "    return &it->foo;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:22] -> [test.cpp:4:12] -> [test.cpp:2:23] -> [test.cpp:4:12]: (error) Returning pointer to local variable 'v' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -2534,14 +2534,14 @@ class TestAutoVariables : public TestFixture {
         check("std::vector<int>::iterator f(std::vector<int> x) {\n"
               "    auto it = x.begin();\n"
               "    return it;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22] -> [test.cpp:1:47] -> [test.cpp:3:12]: (error) Returning iterator to local container 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f() {\n"
               "    std::vector<int> x;\n"
               "    auto it = x.begin();\n"
               "    return std::next(it);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:22] -> [test.cpp:2:22] -> [test.cpp:4:21]: (error) Returning iterator to local container 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -2550,7 +2550,7 @@ class TestAutoVariables : public TestFixture {
               "    std::vector<int> x;\n"
               "    auto it = x.begin();\n"
               "    return it + 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:22] -> [test.cpp:2:22] -> [test.cpp:4:15]: (error) Returning iterator to local container 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -2559,7 +2559,7 @@ class TestAutoVariables : public TestFixture {
               "    std::vector<int> x;\n"
               "    auto it = x.begin();\n"
               "    return std::next(it + 1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:22] -> [test.cpp:4:25] -> [test.cpp:2:22] -> [test.cpp:4:21]: (error) Returning object that points to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -2569,7 +2569,7 @@ class TestAutoVariables : public TestFixture {
               "    std::vector<int*> v;\n"
               "    v.push_back(&i);\n"
               "    return v;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:17] -> [test.cpp:4:17] -> [test.cpp:2:9] -> [test.cpp:5:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -2581,7 +2581,7 @@ class TestAutoVariables : public TestFixture {
               "    v.push_back(&i);\n"
               "    r.assign(v.begin(), v.end());\n"
               "    return r;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:5:17] -> [test.cpp:5:17] -> [test.cpp:5:5] -> [test.cpp:3:9] -> [test.cpp:7:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -2592,7 +2592,7 @@ class TestAutoVariables : public TestFixture {
               "        int i;\n"
               "        v.push_back(&i);\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS(
             "[test.cpp:5:21] -> [test.cpp:5:21] -> [test.cpp:4:13] -> [test.cpp:5:9]: (error) Non-local variable 'v' will use object that points to local variable 'i'. [danglingLifetime]\n",
             errout_str());
@@ -2604,7 +2604,7 @@ class TestAutoVariables : public TestFixture {
               "        int * p = &i;\n"
               "        v.push_back(p);\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS(
             "[test.cpp:5:19] -> [test.cpp:6:21] -> [test.cpp:4:13] -> [test.cpp:6:9]: (error) Non-local variable 'v' will use object that points to local variable 'i'. [danglingLifetime]\n",
             errout_str());
@@ -2617,7 +2617,7 @@ class TestAutoVariables : public TestFixture {
               "        v.push_back(&x);\n"
               "        m.insert(m.end(), v.begin(), v.end());\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS(
             "[test.cpp:6:21] -> [test.cpp:6:21] -> [test.cpp:6:9] -> [test.cpp:4:13] -> [test.cpp:7:9]: (error) Non-local variable 'm' will use object that points to local variable 'x'. [danglingLifetime]\n"
             "[test.cpp:6:21] -> [test.cpp:6:21] -> [test.cpp:6:9] -> [test.cpp:4:13] -> [test.cpp:7:18]: (error) Non-local variable 'm' will use object that points to local variable 'x'. [danglingLifetime]\n", // duplicate
@@ -2628,7 +2628,7 @@ class TestAutoVariables : public TestFixture {
               "        return it;\n"
               "    }\n"
               "    return {};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:26] -> [test.cpp:1:47] -> [test.cpp:3:16]: (error) Returning iterator to local container 'v' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -2636,7 +2636,7 @@ class TestAutoVariables : public TestFixture {
         check("const char * f() {\n"
               "   std::string ba(\"hello\");\n"
               "   return ba.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:19] -> [test.cpp:2:16] -> [test.cpp:3:19]: (error) Returning pointer to local variable 'ba' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -2658,7 +2658,7 @@ class TestAutoVariables : public TestFixture {
         check("std::vector<int> g();\n"
               "auto f() {\n"
               "    return g().begin();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:21] -> [test.cpp:3:21]: (error) Returning iterator that will be invalid when returning. [returnDanglingLifetime]\n",
                       errout_str());
 
@@ -2666,14 +2666,14 @@ class TestAutoVariables : public TestFixture {
               "std::vector<int>::iterator f() {\n"
               "    auto it = g().begin();\n"
               "    return it;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:24] -> [test.cpp:3:16] -> [test.cpp:4:5]: (error) Using iterator that is a temporary. [danglingTemporaryLifetime]\n",
                       errout_str());
 
         check("std::vector<int> g();\n"
               "int& f() {\n"
               "    return *g().begin();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:22] -> [test.cpp:3:12]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("struct A {\n"
@@ -2682,7 +2682,7 @@ class TestAutoVariables : public TestFixture {
               "        char s[3];\n"
               "        v.push_back(s);\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<std::string> f() {\n"
@@ -2690,46 +2690,46 @@ class TestAutoVariables : public TestFixture {
               "    std::vector<std::string> v;\n"
               "    v.push_back(s);\n"
               "    return v;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("auto f() {\n"
               "  static std::vector<int> x;\n"
               "  return x.begin();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::string g() {\n"
               "    std::vector<char> v;\n"
               "    return v.data();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int>::iterator f(std::vector<int>* v) {\n"
               "    return v->begin();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int>::iterator f(std::vector<int>* v) {\n"
               "    std::vector<int>* v = new std::vector<int>();\n"
               "    return v->begin();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(std::vector<int> v) {\n"
               "    return *v.begin();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(std::vector<int> v) {\n"
               "    return v.end() - v.begin();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("auto g() {\n"
               "    std::vector<char> v;\n"
               "    return {v, [v]() { return v.data(); }};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template<class F>\n"
@@ -2737,7 +2737,7 @@ class TestAutoVariables : public TestFixture {
               "auto f() {\n"
               "    std::vector<char> v;\n"
               "    return g([&]() { return v.data(); });\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int> g();\n"
@@ -2747,7 +2747,7 @@ class TestAutoVariables : public TestFixture {
               "        std::vector<int> v = g();\n"
               "        m.insert(m.end(), v.begin(), v.end());\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b) {\n"
@@ -2757,7 +2757,7 @@ class TestAutoVariables : public TestFixture {
               "        v.insert(a, a+1);\n"
               "    }\n"
               "    return v.back() == 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"
@@ -2768,7 +2768,7 @@ class TestAutoVariables : public TestFixture {
               "    struct B {};\n"
               "    std::map< S, B > m1;\n"
               "    std::map< S, B > m2;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -2777,33 +2777,33 @@ class TestAutoVariables : public TestFixture {
               "    void f() {\n"
               "        v.push_back(&x);\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("size_t f(const std::string& x) {\n"
               "    std::string y = \"x\";\n"
               "    return y.find(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::string* f();\n"
               "const char* g() {\n"
               "    std::string* var = f();\n"
               "    return var->c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::string f() {\n"
               "    std::vector<char> data{};\n"
               "    data.push_back('a');\n"
               "    return std::string{ data.data(), data.size() };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<char*> f() {\n"
               "    char a = 0;\n"
               "    return std::vector<char*>{&a};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:31] -> [test.cpp:3:31] -> [test.cpp:2:10] -> [test.cpp:3:30]: (error) Returning object that points to local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("std::vector<int>* g();\n"
@@ -3246,20 +3246,20 @@ class TestAutoVariables : public TestFixture {
               "    std::vector<int> a;\n"
               "    auto it = a.begin();\n"
               "    return [=](){ return it; };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:22] -> [test.cpp:4:26] -> [test.cpp:2:22] -> [test.cpp:4:12]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f(std::vector<int> a) {\n"
               "    auto it = a.begin();\n"
               "    return [=](){ return it; };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22] -> [test.cpp:3:26] -> [test.cpp:1:25] -> [test.cpp:3:12]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("struct e {};\n"
               "e * j() {\n"
               "    e c[20];\n"
               "    return c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:12] -> [test.cpp:3:7] -> [test.cpp:4:12]: (error) Returning pointer to local variable 'c' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -3267,12 +3267,12 @@ class TestAutoVariables : public TestFixture {
         check("auto f(std::vector<int>& a) {\n"
               "    auto it = a.begin();\n"
               "    return [=](){ return it; };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int * f(int a[]) {\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -3280,14 +3280,14 @@ class TestAutoVariables : public TestFixture {
               "        uint32_t f[6];\n"
               "    } d;\n"
               "    uint32_t *a = d.f;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Don't decay std::array
         check("std::array<char, 1> f() {\n"
               "    std::array<char, 1> x;\n"
               "    return x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Make sure we don't hang
@@ -3295,7 +3295,7 @@ class TestAutoVariables : public TestFixture {
               "void f() {\n"
               "    using T = A[3];\n"
               "    A &&a = T{1, 2, 3}[1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Make sure we don't hang
@@ -3303,7 +3303,7 @@ class TestAutoVariables : public TestFixture {
               "void f() {\n"
               "    using T = A[3];\n"
               "    A &&a = T{1, 2, 3}[1]();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Make sure we don't hang
@@ -3311,7 +3311,7 @@ class TestAutoVariables : public TestFixture {
               "void f() {\n"
               "    using T = A[3];\n"
               "    A &&a = T{1, 2, 3}[1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Make sure we don't hang
@@ -3319,7 +3319,7 @@ class TestAutoVariables : public TestFixture {
               "void f() {\n"
               "    using T = A[3];\n"
               "    A &&a = T{1, 2, 3}[1]();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Crash #8872
@@ -3327,14 +3327,14 @@ class TestAutoVariables : public TestFixture {
               "  void operator()(b c) override {\n"
               "    d(c, [&] { c->e });\n"
               "  }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct a {\n"
               "  void operator()(b c) override {\n"
               "    d(c, [=] { c->e });\n"
               "  }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct a {\n"
@@ -3343,7 +3343,7 @@ class TestAutoVariables : public TestFixture {
               "a f() {\n"
               "    char c[20];\n"
               "    return c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct a {\n"
@@ -3353,7 +3353,7 @@ class TestAutoVariables : public TestFixture {
               "    char c[20];\n"
               "    a d = c;\n"
               "    return d;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -3361,14 +3361,14 @@ class TestAutoVariables : public TestFixture {
               "        std::vector<int> v;\n"
               "        auto g() { return v.end(); }\n"
               "    };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int * f(std::vector<int>& v) {\n"
               "    for(int & x : v)\n"
               "        return &x;\n"
               "    return nullptr;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9275
@@ -3380,7 +3380,7 @@ class TestAutoVariables : public TestFixture {
               "    char buf[1024];\n"
               "    const char* msg = buf;\n"
               "    m = msg;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9201
@@ -3388,14 +3388,14 @@ class TestAutoVariables : public TestFixture {
               "    struct a { int m; };\n"
               "    static a b{0};\n"
               "    return &b.m;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9453
         check("int *ptr;\n"
               "void foo(int arr[]) {\n"
               "    ptr = &arr[2];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9639
@@ -3406,7 +3406,7 @@ class TestAutoVariables : public TestFixture {
               "const char * f() {\n"
               "  const Fred &fred = getFred();\n"
               "  return fred.s.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9534
@@ -3416,14 +3416,14 @@ class TestAutoVariables : public TestFixture {
               "int* f(int i, std::vector<A>& v) {\n"
               "    A& y = v[i];\n"
               "    return &y.x[i];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9712
         check("std::string f(const char *str) {\n"
               "    char value[256];\n"
               "    return value;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9770
@@ -3597,7 +3597,7 @@ class TestAutoVariables : public TestFixture {
         check("auto f() {\n"
               "    int a;\n"
               "    return std::ref(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:21] -> [test.cpp:2:9] -> [test.cpp:3:20]: (error) Returning object that points to local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -3605,7 +3605,7 @@ class TestAutoVariables : public TestFixture {
         check("auto f() {\n"
               "    int a;\n"
               "    return std::make_tuple(std::ref(a));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:37] -> [test.cpp:3:36] -> [test.cpp:2:9] -> [test.cpp:3:27]: (error) Returning object that points to local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -3617,7 +3617,7 @@ class TestAutoVariables : public TestFixture {
               "auto g() {\n"
               "    std::vector<int> v;\n"
               "    return by_value(v.begin());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:7:28] -> [test.cpp:7:28] -> [test.cpp:3:12] -> [test.cpp:3:25] -> [test.cpp:6:22] -> [test.cpp:7:20]: (error) Returning object that points to local variable 'v' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -3640,7 +3640,7 @@ class TestAutoVariables : public TestFixture {
               "auto f() {\n"
               "    int i = 0;\n"
               "    return by_ref(i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:12] -> [test.cpp:1:19] -> [test.cpp:2:25] -> [test.cpp:6:19] -> [test.cpp:5:9] -> [test.cpp:6:18]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -3658,7 +3658,7 @@ class TestAutoVariables : public TestFixture {
               "    int a;\n"
               "    std::tie(a) = x;\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::pair<std::string, std::string>\n"
@@ -3907,7 +3907,7 @@ class TestAutoVariables : public TestFixture {
               "A f() {\n"
               "    int i = 0;\n"
               "    return A{i, i};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:7:14] -> [test.cpp:6:9] -> [test.cpp:7:13]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -3919,7 +3919,7 @@ class TestAutoVariables : public TestFixture {
               "A f() {\n"
               "    int i = 0;\n"
               "    return {i, i};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:7:13] -> [test.cpp:6:9] -> [test.cpp:7:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -3932,7 +3932,7 @@ class TestAutoVariables : public TestFixture {
               "    int i = 0;\n"
               "    A r{i, i};\n"
               "    return r;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:7:9] -> [test.cpp:6:9] -> [test.cpp:8:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -3945,7 +3945,7 @@ class TestAutoVariables : public TestFixture {
               "    int i = 0;\n"
               "    A r = {i, i};\n"
               "    return r;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:7:12] -> [test.cpp:6:9] -> [test.cpp:8:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -3957,7 +3957,7 @@ class TestAutoVariables : public TestFixture {
               "A f(int& x) {\n"
               "    int i = 0;\n"
               "    return A{i, x};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:7:14] -> [test.cpp:6:9] -> [test.cpp:7:13]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
             errout_str());
@@ -3969,7 +3969,7 @@ class TestAutoVariables : public TestFixture {
               "A f(int& x) {\n"
               "    int i = 0;\n"
               "    return A{x, i};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -3978,14 +3978,14 @@ class TestAutoVariables : public TestFixture {
               "};\n"
               "A f(int& x) {\n"
               "    return A{x, x};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { int i; const int& j; };\n"
               "A f(int& x) {\n"
               "    int y = 0;\n"
               "    return A{y, x};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct a {\n"
@@ -4086,7 +4086,7 @@ class TestAutoVariables : public TestFixture {
               "    int i = 0;\n"
               "    std::vector<int*> v = {&i, &i};\n"
               "    return v;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:28] -> [test.cpp:3:28] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n"
             "[test.cpp:3:32] -> [test.cpp:3:32] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
@@ -4096,7 +4096,7 @@ class TestAutoVariables : public TestFixture {
               "    int i = 0;\n"
               "    std::vector<int*> v{&i, &i};\n"
               "    return v;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:25] -> [test.cpp:3:25] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n"
             "[test.cpp:3:29] -> [test.cpp:3:29] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
@@ -4105,7 +4105,7 @@ class TestAutoVariables : public TestFixture {
         check("std::vector<int*> f() {\n"
               "    int i = 0;\n"
               "    return {&i, &i};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:13] -> [test.cpp:3:13] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n"
             "[test.cpp:3:17] -> [test.cpp:3:17] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
@@ -4113,7 +4113,7 @@ class TestAutoVariables : public TestFixture {
 
         check("std::vector<int*> f(int& x) {\n"
               "    return {&x, &x};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<std::string> f() {\n"
@@ -4121,7 +4121,7 @@ class TestAutoVariables : public TestFixture {
               "    x.insert(\"1\");\n"
               "    x.insert(\"2\");\n"
               "    return { x.begin(), x.end() };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4130,7 +4130,7 @@ class TestAutoVariables : public TestFixture {
               "A f() {\n"
               "   std::string ba(\"hello\");\n"
               "   return ba.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { A(const char *a); };\n"
@@ -4138,7 +4138,7 @@ class TestAutoVariables : public TestFixture {
               "   std::string ba(\"hello\");\n"
               "   A bp = ba.c_str();\n"
               "   return bp;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { A(const char *a); };\n"
@@ -4147,7 +4147,7 @@ class TestAutoVariables : public TestFixture {
               "   std::vector<A> v;\n"
               "   v.push_back(ba.c_str());\n"
               "   return v;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::string f(const std::string& x) {\n"
@@ -4155,7 +4155,7 @@ class TestAutoVariables : public TestFixture {
               "  if (!x.empty())\n"
               "    return x + c;\n"
               "  return \"\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::string f(const std::string& x) {\n"
@@ -4163,7 +4163,7 @@ class TestAutoVariables : public TestFixture {
               "  if (!x.empty())\n"
               "    return c + 1;\n"
               "  return \"\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4186,7 +4186,7 @@ class TestAutoVariables : public TestFixture {
               "void f(int& i) {\n"
               "    int* x = &g(0);\n"
               "    i += *x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:1:26] -> [test.cpp:2:12] -> [test.cpp:5:15] -> [test.cpp:5:14] -> [test.cpp:5:17] -> [test.cpp:6:11]: (error) Using pointer that is a temporary. [danglingTemporaryLifetime]\n",
             errout_str());
@@ -4196,7 +4196,7 @@ class TestAutoVariables : public TestFixture {
               "    const char* b = a.toStdString().c_str();\n"
               "    QString c = b;\n"
               "    return c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:42] -> [test.cpp:3:34] -> [test.cpp:4:15]: (error) Using pointer that is a temporary. [danglingTemporaryLifetime]\n",
                       errout_str());
 
@@ -4204,7 +4204,7 @@ class TestAutoVariables : public TestFixture {
               "    const char *x = s.substr(1,2).c_str();\n"
               "    auto i = s.substr(4,5).begin();\n"
               "    return *i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:33] -> [test.cpp:3:22] -> [test.cpp:4:13]: (error) Using iterator that is a temporary. [danglingTemporaryLifetime]\n",
                       errout_str());
 
@@ -4212,7 +4212,7 @@ class TestAutoVariables : public TestFixture {
               "    std::stringstream tmp;\n"
               "    const std::string &str = tmp.str();\n"
               "    return std::string(str.c_str(), 1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int get_value();\n"
@@ -4682,7 +4682,7 @@ class TestAutoVariables : public TestFixture {
               "        f = [&]{ return b; };\n"
               "    }\n"
               "    f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:25] -> [test.cpp:4:13] -> [test.cpp:7:5]: (error) Using lambda that captures local variable 'b' that is out of scope. [invalidLifetime]\n", errout_str());
 
         check("void f(bool b)  {\n"
@@ -4692,7 +4692,7 @@ class TestAutoVariables : public TestFixture {
               "    x = y;\n"
               "  }\n"
               "  x[3];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:5:9] -> [test.cpp:4:9] -> [test.cpp:7:3]: (error) Using pointer to local variable 'y' that is out of scope. [invalidLifetime]\n",
             errout_str());
@@ -4704,7 +4704,7 @@ class TestAutoVariables : public TestFixture {
               "        f = [&]{ return b; };\n"
               "        f();\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct a {\n"
@@ -4713,7 +4713,7 @@ class TestAutoVariables : public TestFixture {
               "};\n"
               "void a::b() {\n"
               "  c.end()\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void b(char f[], char c[]) {\n"
@@ -4721,7 +4721,7 @@ class TestAutoVariables : public TestFixture {
               "    std::string e;\n"
               "    b(f, e.c_str())\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b) {\n"
@@ -4731,11 +4731,11 @@ class TestAutoVariables : public TestFixture {
               "        s = buf;\n"
               "    }\n"
               "    std::cout << s;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int &a[];\n"
-              "void b(){int *c = a};");
+              "void b(){int *c = a};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -4749,7 +4749,7 @@ class TestAutoVariables : public TestFixture {
               "            return y.x;\n"
               "        };\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("namespace test {\n"
@@ -4883,7 +4883,7 @@ class TestAutoVariables : public TestFixture {
               "    p = &x;\n"
               "  }\n"
               "  *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9] -> [test.cpp:7:4]: (error) Using pointer to local variable 'x' that is out of scope. [invalidLifetime]\n", errout_str());
 
         // FP: don't warn in subfunction
@@ -4900,7 +4900,7 @@ class TestAutoVariables : public TestFixture {
               "  } else {\n"
               "  }\n"
               "  f(tmp);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Don't warn about references (#6399)
@@ -4912,7 +4912,7 @@ class TestAutoVariables : public TestFixture {
               "    }\n"
               "    if (former_hover != pitem)\n"
               "        dosth();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -4923,7 +4923,7 @@ class TestAutoVariables : public TestFixture {
               "    }\n"
               "    if (former_hover != pitem)\n"
               "        dosth();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:5:24] -> [test.cpp:3:47] -> [test.cpp:4:26] -> [test.cpp:7:9]: (error) Using pointer to local variable 'item' that is out of scope. [invalidLifetime]\n",
             errout_str());
@@ -4936,7 +4936,7 @@ class TestAutoVariables : public TestFixture {
               "    };\n"
               "    EventReport * rep = &repData;\n"
               "    rep->setEventType(NDB_LE_Connected);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8785
@@ -4949,7 +4949,7 @@ class TestAutoVariables : public TestFixture {
               "    if(b && a)\n"
               "        return *iPtr;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:5:16] -> [test.cpp:7:10] -> [test.cpp:4:13] -> [test.cpp:8:17]: (error) Using pointer to local variable 'x' that is out of scope. [invalidLifetime]\n",
             errout_str());
diff --git a/test/testbool.cpp b/test/testbool.cpp
index 6074bbab46a..46365c11af3 100644
--- a/test/testbool.cpp
+++ b/test/testbool.cpp
@@ -96,28 +96,28 @@ class TestBool : public TestFixture {
     void assignBoolToPointer() {
         check("void foo(bool *p) {\n"
               "    p = false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         check("void foo(bool *p) {\n"
               "    p = (x<y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         check("void foo(bool *p) {\n"
               "    p = (x||y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         check("void foo(bool *p) {\n"
               "    p = (x&&y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         // check against potential false positives
         check("void foo(bool *p) {\n"
               "    *p = false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #5046 - false positive: Boolean value assigned to pointer
@@ -127,7 +127,7 @@ class TestBool : public TestFixture {
               "void f() {\n"
               "    S s = {0};\n"
               "    *s.p = true;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -136,13 +136,13 @@ class TestBool : public TestFixture {
               "void f() {\n"
               "    S s = {0};\n"
               "    s.p = true;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:9]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         // ticket #5627 - false positive: template
         check("void f() {\n"
               "    X *p = new ::std::pair<int,int>[rSize];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #6588 (c mode)
@@ -152,7 +152,7 @@ class TestBool : public TestFixture {
               "  const int *rmat = n < 4 ? " /* OK */
               "                       ctx->q_intra_matrix :"
               "                       ctx->q_chroma_intra_matrix;\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:3:19]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         // ticket #6588 (c++ mode)
@@ -162,7 +162,7 @@ class TestBool : public TestFixture {
               "  const int *rmat = n < 4 ? " /* OK */
               "                       ctx->q_intra_matrix :"
               "                       ctx->q_chroma_intra_matrix;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         // ticket #6665
@@ -171,37 +171,37 @@ class TestBool : public TestFixture {
               "  char* m1 = compare(a, b) < 0\n"
               "      ? (compare(b, c) < 0 ? b : (compare(a, c) < 0 ? c : a))\n"
               "      : (compare(a, c) < 0 ? a : (compare(b, c) < 0 ? c : b));\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         // #7381
         check("void foo(bool *p, bool b) {\n"
               "    p = b;\n"
               "    p = &b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
     }
 
     void assignBoolToFloat() {
         check("void foo1() {\n"
               "    double d = false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (style) Boolean value assigned to floating point variable. [assignBoolToFloat]\n", errout_str());
 
         check("void foo2() {\n"
               "    float d = true;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Boolean value assigned to floating point variable. [assignBoolToFloat]\n", errout_str());
 
         check("void foo3() {\n"
               "    long double d = (2>1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:19]: (style) Boolean value assigned to floating point variable. [assignBoolToFloat]\n", errout_str());
 
         // stability - don't crash:
         check("void foo4() {\n"
               "    unknown = false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -210,7 +210,7 @@ class TestBool : public TestFixture {
               "void f() {\n"
               "    S s = {0};\n"
               "    s.p = true;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:9]: (style) Boolean value assigned to floating point variable. [assignBoolToFloat]\n", errout_str());
 
         check("struct S {\n"
@@ -219,7 +219,7 @@ class TestBool : public TestFixture {
               "void f() {\n"
               "    S s = {0};\n"
               "    *s.p[0] = true;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:13]: (style) Boolean value assigned to floating point variable. [assignBoolToFloat]\n", errout_str());
     }
 
@@ -227,50 +227,50 @@ class TestBool : public TestFixture {
         check("void f(int x) {\n"
               "    if ((x && 0x0f)==6)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x && 0x0f)==0)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x || 0x0f)==6)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x || 0x0f)==0)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x & 0x0f)==6)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x | 0x0f)==6)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
         check("void f(int x) {\n"
               "    if ((5 && x)==3)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((5 && x)==3 || (8 && x)==9)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:17]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n"
             "[test.cpp:2:32]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n",
@@ -279,39 +279,39 @@ class TestBool : public TestFixture {
         check("void f(int x) {\n"
               "    if ((5 && x)!=3)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
 
         check("void f(int x) {\n"
               "    if ((5 && x) > 3)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((5 && x) > 0)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((5 && x) < 0)\n"
               "        a++;\n"
-              "}"
+              "}\n"
               );
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Comparison of a boolean expression with an integer. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((5 && x) < 1)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((5 && x) > 1)\n"
               "        a++;\n"
-              "}"
+              "}\n"
               );
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Comparison of a boolean expression with an integer. [compareBoolExpressionWithInt]\n", errout_str());
 
@@ -319,91 +319,91 @@ class TestBool : public TestFixture {
         check("void f(int x) {\n"
               "    if (0 < (5 && x))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (0 > (5 && x))\n"
               "        a++;\n"
-              "}"
+              "}\n"
               );
         ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of a boolean expression with an integer. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (1 > (5 && x))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (1 < (5 && x))\n"
               "        a++;\n"
-              "}"
+              "}\n"
               );
         ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of a boolean expression with an integer. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( x > false )\n"
               "      a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( false < x )\n"
               "      a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( x < false )\n"
               "      a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( false > x )\n"
               "      a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( x >= false )\n"
               "      a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( false >= x )\n"
               "      a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( x <= false )\n"
               "      a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( false <= x )\n"
               "      a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("typedef int (*func)(bool invert);\n"
               "void x(int, func f);\n"
               "void foo(int error) {\n"
               "  if (error == ABC) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int f() { return !a+b<c; }"); // #5072
+        check("int f() { return !a+b<c; }\n"); // #5072
         ASSERT_EQUALS("",errout_str());
 
-        check("int f() { return (!a+b<c); }");
+        check("int f() { return (!a+b<c); }\n");
         ASSERT_EQUALS("",errout_str());
 
-        check("int f() { return (a+(b<5)<=c); }");
+        check("int f() { return (a+(b<5)<=c); }\n");
         ASSERT_EQUALS("",errout_str());
     }
 
@@ -412,85 +412,85 @@ class TestBool : public TestFixture {
               "    if (!x == 10) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (!x != 10) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x != 10) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (10 == !x) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (10 != !x) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if (y != !x) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, bool y) {\n"
               "    if (y != !x) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (10 != x) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "    return (!y == !x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int a) {\n"
               "  return (x()+1 == !a);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
-        check("void f() { if (!!a+!!b+!!c>1){} }");
+        check("void f() { if (!!a+!!b+!!c>1){} }\n");
         ASSERT_EQUALS("",errout_str());
 
-        check("void f(int a, int b, int c) { if (a != !b || c) {} }");
+        check("void f(int a, int b, int c) { if (a != !b || c) {} }\n");
         ASSERT_EQUALS("",errout_str());
 
-        check("void f(int a, int b, int c) { if (1 < !!a + !!b + !!c) {} }");
+        check("void f(int a, int b, int c) { if (1 < !!a + !!b + !!c) {} }\n");
         ASSERT_EQUALS("",errout_str());
 
-        check("void f(int a, int b, int c) { if (1 < !(a+b)) {} }");
+        check("void f(int a, int b, int c) { if (1 < !(a+b)) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:37]: (warning) Comparison of a boolean expression with an integer. [compareBoolExpressionWithInt]\n",errout_str());
     }
 
     void comparisonOfBoolExpressionWithInt3() {
         check("int f(int x) {\n"
               "    return t<0>() && x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -498,48 +498,48 @@ class TestBool : public TestFixture {
         // #5016
         check("void f() {\n"
               "  for(int i = 4; i > -1 < 5 ; --i) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:25]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int a, int b, int c) {\n"
               "  return (a > b) < c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int a, int b, int c) {\n"
               "  return x(a > b) < c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int a, int b, int c) {\n"
               "  return a > b == c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // templates
         check("struct Tokenizer { TokenList list; };\n"
               "void Tokenizer::f() {\n"
               "  std::list<Token*> locationList;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5063 - or
         check("void f() {\n"
               "  return a > b or c < d;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "  return (a < b) != 0U;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("int f() {\n"
               "  return (a < b) != 0x0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("int f() {\n"
               "  return (a < b) != 42U;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
     }
 
@@ -563,7 +563,7 @@ class TestBool : public TestFixture {
               "     }\n"
               "     else\n"
               "         return true;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style) Comparison of two functions returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfTwoFuncsReturningBoolError]\n", errout_str());
     }
 
@@ -588,7 +588,7 @@ class TestBool : public TestFixture {
               "  }\n"
               "    else\n"
               "     return false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfFuncReturningBoolError]\n"
                       "[test.cpp:11:7]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfFuncReturningBoolError]\n", errout_str());
     }
@@ -600,7 +600,7 @@ class TestBool : public TestFixture {
               "         printf(\"foo\");\n"
               "   }\n"
               "}\n"
-              "bool compare(int temp);");
+              "bool compare(int temp);\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n"
                       "[test.cpp:3:12]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfFuncReturningBoolError]\n", errout_str());
     }
@@ -626,7 +626,7 @@ class TestBool : public TestFixture {
               " }\n"
               " else\n"
               "     return false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfFuncReturningBoolError]\n", errout_str());
     }
 
@@ -650,7 +650,7 @@ class TestBool : public TestFixture {
               "     }\n"
               "     else\n"
               "         return true;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style) Comparison of two functions returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfTwoFuncsReturningBoolError]\n", errout_str());
     }
 
@@ -664,7 +664,7 @@ class TestBool : public TestFixture {
               "    if(compare1(temp) > compare2(temp)){\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("namespace Foo {\n"
@@ -676,7 +676,7 @@ class TestBool : public TestFixture {
               "    if(compare1(temp) > compare2(temp)){\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int compare1(int temp);\n"
@@ -688,7 +688,7 @@ class TestBool : public TestFixture {
               "            printf(\"foo\");\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:20]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfFuncReturningBoolError]\n", errout_str());
 
         check("int compare1(int temp);\n"
@@ -700,7 +700,7 @@ class TestBool : public TestFixture {
               "            printf(\"foo\");\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool compare1(int temp);\n"
@@ -709,7 +709,7 @@ class TestBool : public TestFixture {
               "    if(foo.compare1(temp) > compare2(temp)){\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -739,7 +739,7 @@ class TestBool : public TestFixture {
               "    if(b > a){ \n"                             // here warning should be displayed
               "        ;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (style) Comparison of a variable having boolean value using relational (<, >, <= or >=) operator. [comparisonOfBoolWithBoolError]\n", errout_str());
         // op: <
         check("int main(void){\n"
@@ -748,7 +748,7 @@ class TestBool : public TestFixture {
               "    if(b < a){ \n"                             // here warning should be displayed
               "        ;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (style) Comparison of a variable having boolean value using relational (<, >, <= or >=) operator. [comparisonOfBoolWithBoolError]\n", errout_str());
         // op: >=
         check("int main(void){\n"
@@ -757,7 +757,7 @@ class TestBool : public TestFixture {
               "    if(b >= a){ \n"                             // here warning should be displayed
               "        ;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (style) Comparison of a variable having boolean value using relational (<, >, <= or >=) operator. [comparisonOfBoolWithBoolError]\n", errout_str());
         // op: <=
         check("int main(void){\n"
@@ -766,7 +766,7 @@ class TestBool : public TestFixture {
               "    if(b <= a){ \n"                             // here warning should be displayed
               "        ;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (style) Comparison of a variable having boolean value using relational (<, >, <= or >=) operator. [comparisonOfBoolWithBoolError]\n", errout_str());
     }
 
@@ -778,7 +778,7 @@ class TestBool : public TestFixture {
               "  if ( eval(argv[1]) > eval(argv[2]) )\n"
               "    return 1;\n"
               "  return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -812,96 +812,96 @@ class TestBool : public TestFixture {
     void bitwiseOnBoolean() { // 3062
         check("void f(_Bool a, _Bool b) {\n"
               "    if(a & b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(_Bool a, _Bool b) {\n"
               "    if(a | b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "    if(a & !b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "    if(a | !b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
 
         check("bool a, b;\n"
               "void f() {\n"
               "    if(a & b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
 
         check("bool a, b;\n"
               "void f() {\n"
               "    if(a & !b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
 
         check("bool a, b;\n"
               "void f() {\n"
               "    if(a | b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
 
         check("bool a, b;\n"
               "void f() {\n"
               "    if(a | !b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(bool a, int b) {\n"
               "    if(a & b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(int a, bool b) {\n"
               "    if(a & b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'b' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(int a, int b) {\n"
               "    if((a > 0) & (b < 0)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (style, inconclusive) Boolean expression 'a>0' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(bool a, int b) {\n"
               "    if(a | b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(int a, bool b) {\n"
               "    if(a | b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'b' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
 
         check("int f(bool a, int b) {\n"
               "    return a | b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(bool a, int b) {\n"
               "    return a | b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(int a, int b) {\n"
               "    if(a & b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b) {\n"
               "    foo(bar, &b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b) {\n" // #9405
               "    class C { void foo(bool &b) {} };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f();\n"
@@ -970,27 +970,27 @@ class TestBool : public TestFixture {
 
     void incrementBoolean() {
         check("bool bValue = true;\n"
-              "void f() { bValue++; }");
+              "void f() { bValue++; }\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (style) Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead. [incrementboolean]\n", errout_str());
 
         check("void f(bool test){\n"
               "    test++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (style) Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead. [incrementboolean]\n", errout_str());
 
         check("void f(bool* test){\n"
               "    (*test)++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:6]: (style) Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead. [incrementboolean]\n", errout_str());
 
         check("void f(bool* test){\n"
               "    test[0]++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead. [incrementboolean]\n", errout_str());
 
         check("void f(int test){\n"
               "    test++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -999,51 +999,51 @@ class TestBool : public TestFixture {
               "    if (x < 10) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(bool x) {\n"
               "    if (10 >= x) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(bool x) {\n"
               "    if (x != 0) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool x) {\n"  // #3356
               "    if (x == 1) {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool x) {\n"
               "    if (x != 10) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(bool x) {\n"
               "    if (x == 10) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(bool x) {\n"
               "    if (x == 0) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("DensePropertyMap<int, true> visited;"); // #4075
+        check("DensePropertyMap<int, true> visited;\n"); // #4075
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1052,28 +1052,28 @@ class TestBool : public TestFixture {
               "    if (x == y) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, bool y) {\n"
               "    if (x == y) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool x, bool y) {\n"
               "    if (x == y) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool x, fooClass y) {\n"
               "    if (x == y) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1082,35 +1082,35 @@ class TestBool : public TestFixture {
               "    if (y > false) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(int y) {\n"
               "    if (true == y) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool y) {\n"
               "    if (y == true) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool y) {\n"
               "    if (false < 5) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
     }
 
     void comparisonOfBoolWithInt4() {
         check("void f(int x) {\n"
               "    if (!x == 1) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1118,21 +1118,21 @@ class TestBool : public TestFixture {
         check("void SetVisible(int index, bool visible) {\n"
               "    bool (SciTEBase::*ischarforsel)(char ch);\n"
               "    if (visible != GetVisible(index)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void comparisonOfBoolWithInt6() { // #4224 - integer is casted to bool
         check("void SetVisible(bool b, int i) {\n"
               "    if (b == (bool)i) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void comparisonOfBoolWithInt7() { // #4846 - (!x==true)
         check("void f(int x) {\n"
               "    if (!x == true) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1142,7 +1142,7 @@ class TestBool : public TestFixture {
               "    auto res = Fun();\n"
               "    if (expectedResult == res)\n"
               "        throw 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int Fun();\n"
@@ -1150,7 +1150,7 @@ class TestBool : public TestFixture {
               "    auto res = Fun();\n"
               "    if (expectedResult == res)\n"
               "        throw 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool Fun();\n"
@@ -1158,7 +1158,7 @@ class TestBool : public TestFixture {
               "    auto res = Fun();\n"
               "    if (5 + expectedResult == res)\n"
               "        throw 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int Fun();\n"
@@ -1166,7 +1166,7 @@ class TestBool : public TestFixture {
               "    auto res = Fun();\n"
               "    if (5 + expectedResult == res)\n"
               "        throw 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int Fun();\n"
@@ -1174,7 +1174,7 @@ class TestBool : public TestFixture {
               "    auto res = Fun();\n"
               "    if (expectedResult == res + 5)\n"
               "        throw 2;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
@@ -1185,7 +1185,7 @@ class TestBool : public TestFixture {
               "        b = !b;\n"
               "    }\n"
               "    return b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1210,76 +1210,76 @@ class TestBool : public TestFixture {
     void pointerArithBool1() { // #5126
         check("void f(char *p) {\n"
               "    if (p+1){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour. [pointerArithBool]\n", errout_str());
 
         check("void f(char *p) {\n"
               "    do {} while (p+1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:19]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour. [pointerArithBool]\n", errout_str());
 
         check("void f(char *p) {\n"
               "    while (p-1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour. [pointerArithBool]\n", errout_str());
 
         check("void f(char *p) {\n"
               "    for (int i = 0; p+1; i++) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour. [pointerArithBool]\n", errout_str());
 
         check("void f(char *p) {\n"
               "    if (p && p+1){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour. [pointerArithBool]\n", errout_str());
 
         check("void f(char *p) {\n"
               "    if (p+2 || p) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour. [pointerArithBool]\n", errout_str());
     }
 
     void returnNonBool() {
         check("bool f(void) {\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
               "    return 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
               "    return 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    return -1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    return 1 + 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    int x = 0;\n"
               "    return x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
               "    int x = 10;\n"
               "    return x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    return 2 < 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
@@ -1287,7 +1287,7 @@ class TestBool : public TestFixture {
               "    if (a)\n"
               "        ret = 1;\n"
               "    return ret;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
@@ -1295,20 +1295,20 @@ class TestBool : public TestFixture {
               "    if (a)\n"
               "        ret = 3;\n"
               "    return ret;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    if (a)\n"
               "        return 3;\n"
               "    return 4;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n"
                       "[test.cpp:4:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1316,42 +1316,42 @@ class TestBool : public TestFixture {
         check("bool f(void) {\n"
               "    auto x = [](void) { return -1; };\n"
               "    return false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
               "    auto x = [](void) { return -1; };\n"
               "    return 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    auto x = [](void) -> int { return -1; };\n"
               "    return false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
               "    auto x = [](void) -> int { return -1; };\n"
               "    return 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
     }
 
     void returnNonBoolLogicalOp() {
         check("bool f(int x) {\n"
               "    return x & 0x4;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(int x, int y) {\n"
               "    return x | y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(int x) {\n"
               "    return (x & 0x2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1359,7 +1359,7 @@ class TestBool : public TestFixture {
         check("class X {\n"
               "    public:\n"
               "        bool f() { return -1;}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:20]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f() {\n"
@@ -1368,7 +1368,7 @@ class TestBool : public TestFixture {
               "            int f() { return -1;}\n"
               "    };\n"
               "    return false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f() {\n"
@@ -1377,7 +1377,7 @@ class TestBool : public TestFixture {
               "            int f() { return -1;}\n"
               "    };\n"
               "    return false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f() {\n"
@@ -1386,7 +1386,7 @@ class TestBool : public TestFixture {
               "            bool f() { return -1;}\n"
               "    };\n"
               "    return -1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n"
                       "[test.cpp:4:24]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
     }
diff --git a/test/testbufferoverrun.cpp b/test/testbufferoverrun.cpp
index 229b2883b9e..7b36dbac035 100644
--- a/test/testbufferoverrun.cpp
+++ b/test/testbufferoverrun.cpp
@@ -327,7 +327,7 @@ class TestBufferOverrun : public TestFixture {
               "    {\n"
               "        char str[50];\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -349,7 +349,7 @@ class TestBufferOverrun : public TestFixture {
               "void f4(const char str[])\n"
               "{\n"
               "    strcpy(buf, str);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -360,7 +360,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    char data[1];\n"
               "    return abc.data[1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -370,7 +370,7 @@ class TestBufferOverrun : public TestFixture {
         check("static void f() {\n"
               "    char data[100];\n"
               "    const char *p = data + 100;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -382,7 +382,7 @@ class TestBufferOverrun : public TestFixture {
               "    snprintf(group, 32, \"%u\", 0);\n"
               "    struct group *gr;\n"
               "    snprintf(group, 32, \"%u\", gr->gr_gid);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -392,14 +392,14 @@ class TestBufferOverrun : public TestFixture {
               "    char str[0x10] = {0};\n"
               "    str[15] = 0;\n"
               "    str[16] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:8]: (error) Array 'str[16]' accessed at index 16, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("char f()\n"
               "{\n"
               "    char str[16] = {0};\n"
               "    return str[16];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:15]: (error) Array 'str[16]' accessed at index 16, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // test stack array
@@ -409,7 +409,7 @@ class TestBufferOverrun : public TestFixture {
               "   int y;\n"
               "   y = x[ 4 ];\n"
               "   return y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9]: (error) Array 'x[3]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("int f()\n"
@@ -418,15 +418,15 @@ class TestBufferOverrun : public TestFixture {
               "   int y;\n"
               "   y = x[ 2 ];\n"
               "   return y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int x[5] = {0};\n"
-              "int a = x[10];");
+              "int a = x[10];\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (error) Array 'x[5]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("int x[5] = {0};\n"
-              "int a = (x)[10];");
+              "int a = (x)[10];\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (error) Array 'x[5]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -437,21 +437,21 @@ class TestBufferOverrun : public TestFixture {
               "    char *str = new char[0x10];\n"
               "    str[i] = 0;\n"
               "}\n"
-              "void b() { a(16); }");
+              "void b() { a(16); }\n");
         ASSERT_EQUALS("[test.cpp:4:8]: (error) Array 'str[16]' accessed at index 16, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_4() {
-        check("char c = \"abc\"[4];");
+        check("char c = \"abc\"[4];\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (error) Array '\"abc\"[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
-        check("p = &\"abc\"[4];");
+        check("p = &\"abc\"[4];\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("char c = \"\\0abc\"[2];");
+        check("char c = \"\\0abc\"[2];\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("char c = L\"abc\"[4];");
+        check("char c = L\"abc\"[4];\n");
         ASSERT_EQUALS("[test.cpp:1:16]: (error) Array 'L\"abc\"[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -462,7 +462,7 @@ class TestBufferOverrun : public TestFixture {
               "    int i, sum=0;\n"
               "    for (i = 0; i < 100; i++)\n"
               "        sum += val[i];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:19]: (error) Array 'val[50]' accessed at index 99, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
@@ -471,7 +471,7 @@ class TestBufferOverrun : public TestFixture {
               "    int i, sum=0;\n"
               "    for (i = 1; i < 100; i++)\n"
               "        sum += val[i];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:19]: (error) Array 'val[50]' accessed at index 99, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f(int a)\n"
@@ -480,7 +480,7 @@ class TestBufferOverrun : public TestFixture {
               "    int i, sum=0;\n"
               "    for (i = a; i < 100; i++)\n"
               "        sum += val[i];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:19]: (error) Array 'val[50]' accessed at index 99, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("typedef struct g g2[3];\n"
@@ -490,21 +490,21 @@ class TestBufferOverrun : public TestFixture {
               "  {\n"
               "    a[i]=0;\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int argc)\n"
               "{\n"
               "  char a[2];\n"
               "  for (int i = 4; i < argc; i++){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a[10]) {\n"
               "    for (int i=0;i<50;++i) {\n"
               "        a[i] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (error) Array 'a[10]' accessed at index 49, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -518,7 +518,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    struct ABC abc;\n"
               "    abc.str[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:12]: (error) Array 'abc.str[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct ABC\n"
@@ -530,7 +530,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    struct ABC abc;\n"
               "    return abc.str[10];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:19]: (error) Array 'abc.str[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // This is not out of bounds because it is a variable length array
@@ -543,7 +543,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    struct ABC* x = malloc(sizeof(struct ABC) + 10);\n"
               "    x->str[1] = 0;"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // This is not out of bounds because it is not a variable length array
@@ -557,7 +557,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    struct ABC* x = malloc(sizeof(struct ABC) + 10);\n"
               "    x->str[1] = 0;"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         // This is not out of bounds because it is a variable length array
@@ -571,8 +571,8 @@ class TestBufferOverrun : public TestFixture {
               "static void f()\n"
               "{\n"
               "    struct ABC* x = malloc(sizeof(struct ABC) + 10);\n"
-              "    x->str[10] = 0;"
-              "}");
+              "    x->str[10] = 0;\n"
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // This is out of bounds because it is outside the memory allocated.
@@ -585,8 +585,8 @@ class TestBufferOverrun : public TestFixture {
               "static void f()\n"
               "{\n"
               "    struct ABC* x = malloc(sizeof(struct ABC) + 10);\n"
-              "    x->str[11] = 0;"
-              "}");
+              "    x->str[11] = 0;\n"
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:9]: (error) Array 'str[1]' accessed at index 11, which is out of bounds.\n", "", errout_str());
 
         // This is out of bounds if 'sizeof(ABC)' is 1 (No padding)
@@ -598,8 +598,8 @@ class TestBufferOverrun : public TestFixture {
               "static void f()\n"
               "{\n"
               "    struct ABC* x = malloc(sizeof(ABC) + 10);\n"
-              "    x->str[11] = 0;"
-              "}");
+              "    x->str[11] = 0;\n"
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         // This is out of bounds because it is outside the memory allocated
@@ -612,8 +612,8 @@ class TestBufferOverrun : public TestFixture {
               "static void f()\n"
               "{\n"
               "    struct ABC* x = malloc(sizeof(struct ABC));\n"
-              "    x->str[1] = 0;"
-              "}");
+              "    x->str[1] = 0;\n"
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:9]: (error) Array 'str[1]' accessed at index 1, which is out of bounds.\n", "", errout_str());
 
         // This is out of bounds because it is outside the memory allocated
@@ -626,8 +626,8 @@ class TestBufferOverrun : public TestFixture {
               "static void f()\n"
               "{\n"
               "    struct ABC* x = malloc(sizeof(ABC));\n"
-              "    x->str[1] = 0;"
-              "}");
+              "    x->str[1] = 0;\n"
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         // This is out of bounds because it is not a variable array
@@ -639,8 +639,8 @@ class TestBufferOverrun : public TestFixture {
               "static void f()\n"
               "{\n"
               "    struct ABC x;\n"
-              "    x.str[1] = 0;"
-              "}");
+              "    x.str[1] = 0;\n"
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:10]: (error) Array 'x.str[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct foo\n"
@@ -653,19 +653,19 @@ class TestBufferOverrun : public TestFixture {
               "    foo f;\n"
               "    for ( unsigned int i = 0; i < 64; ++i )\n"
               "        f.str[i] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:14]: (error) Array 'f.str[10]' accessed at index 63, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct AB { char a[NUM]; char b[NUM]; }\n"
               "void f(struct AB *ab) {\n"
               "    ab->a[0] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("union { char a[1]; int b; } ab;\n"
               "void f() {\n"
               "    ab.a[2] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Array 'ab.a[1]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -679,7 +679,7 @@ class TestBufferOverrun : public TestFixture {
               "static void f(struct ABC *abc)\n"
               "{\n"
               "    abc->str[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:13]: (error) Array 'abc->str[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -698,7 +698,7 @@ class TestBufferOverrun : public TestFixture {
               "    {\n"
               "        abc->str[10] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:13:17]: (error) Array 'abc->str[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -713,7 +713,7 @@ class TestBufferOverrun : public TestFixture {
               "Fred::Fred()\n"
               "{\n"
               "    str[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:8]: (error) Array 'str[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("class Fred\n"
@@ -726,7 +726,7 @@ class TestBufferOverrun : public TestFixture {
               "char Fred::c()\n"
               "{\n"
               "    return str[10];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:15]: (error) Array 'str[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -739,7 +739,7 @@ class TestBufferOverrun : public TestFixture {
               "        if (i < 10)\n"
               "            int x = buf[i];\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -749,7 +749,7 @@ class TestBufferOverrun : public TestFixture {
               "    int a[10];\n"
               "    for (int i = 0; i < 10; i++)\n"
               "        a[i+10] = i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[10]' accessed at index 19, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -759,7 +759,7 @@ class TestBufferOverrun : public TestFixture {
               "    int a[10];\n"
               "    for (int i = 0; i < 10; i++)\n"
               "        a[10+i] = i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[10]' accessed at index 19, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -769,7 +769,7 @@ class TestBufferOverrun : public TestFixture {
               "    int a[10];\n"
               "    for (int i = 0; i < 10; i++)\n"
               "        a[i+1] = i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -779,7 +779,7 @@ class TestBufferOverrun : public TestFixture {
               "    int a[10];\n"
               "    for (int i = 0; i < 10; i++)\n"
               "        a[i*2] = i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[10]' accessed at index 18, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
@@ -787,7 +787,7 @@ class TestBufferOverrun : public TestFixture {
               "    int a[12];\n"
               "    for (int i = 0; i < 12; i+=6)\n"
               "        a[i+5] = i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -795,21 +795,21 @@ class TestBufferOverrun : public TestFixture {
               "    int a[12];\n"
               "    for (int i = 0; i < 12; i+=6)\n"
               "        a[i+6] = i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[12]' accessed at index 12, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"  // #4398
               "    int a[2];\n"
               "    for (int i = 0; i < 4; i+=2)\n"
               "        a[i] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"  // #4398
               "    int a[2];\n"
               "    for (int i = 0; i < 4; i+=2)\n"
               "        do_stuff(a+i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -822,7 +822,7 @@ class TestBufferOverrun : public TestFixture {
               "        a[i] = i;\n"
               "        i+=1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -833,7 +833,7 @@ class TestBufferOverrun : public TestFixture {
               "        a[i] = i;\n"
               "        i++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -844,7 +844,7 @@ class TestBufferOverrun : public TestFixture {
               "        a[i] = i;\n"
               "        ++i;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -855,7 +855,7 @@ class TestBufferOverrun : public TestFixture {
               "        a[i] = i;\n"
               "        i=4;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:10]: (error) Array 'a[5]' accessed at index 5, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
@@ -866,7 +866,7 @@ class TestBufferOverrun : public TestFixture {
               "        a[i] = i;\n"
               "        i+=1;\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Buffer overrun\n", "", errout_str());
     }
 
@@ -876,7 +876,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "  char a[2];\n"
               "  char *end = &(a[2]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Getting more than one past the end is not legal
@@ -884,7 +884,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "  char a[2];\n"
               "  char *end = &(a[3]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (error) Array 'a[2]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -895,7 +895,7 @@ class TestBufferOverrun : public TestFixture {
               " int b[10];\n"
               " for ( int i = 0; i < 9; i++ )\n"
               "  b[i] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -909,7 +909,7 @@ class TestBufferOverrun : public TestFixture {
               " for(int j=0; j<3; ++j) {\n"
               "  int b = indices[j];\n"
               " }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -917,7 +917,7 @@ class TestBufferOverrun : public TestFixture {
         check("int main() {\n"
               "  size_t indices[2];\n"
               "  int b = indices[2];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:18]: (error) Array 'indices[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -926,7 +926,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    char c[10];\n"
               "    c[1<<23]='a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 'c[10]' accessed at index 8388608, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -945,7 +945,7 @@ class TestBufferOverrun : public TestFixture {
               "    int a[n];\n"     // n <= SCHAR_MAX
               "    a[-1] = 0;\n"    // negative index
               "    a[128] = 0;\n"   // 128 > SCHAR_MAX
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[128]' accessed at index -1, which is out of bounds. [negativeIndex]\n"
                       "[test.cpp:4:6]: (error) Array 'a[128]' accessed at index 128, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
@@ -953,7 +953,7 @@ class TestBufferOverrun : public TestFixture {
               "    int a[n];\n"     // n <= UCHAR_MAX
               "    a[-1] = 0;\n"    // negative index
               "    a[256] = 0;\n"   // 256 > UCHAR_MAX
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[256]' accessed at index -1, which is out of bounds. [negativeIndex]\n"
                       "[test.cpp:4:6]: (error) Array 'a[256]' accessed at index 256, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
@@ -961,7 +961,7 @@ class TestBufferOverrun : public TestFixture {
               "    int a[n];\n"     // n <= SHRT_MAX
               "    a[-1] = 0;\n"    // negative index
               "    a[32768] = 0;\n" // 32768 > SHRT_MAX
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[32768]' accessed at index -1, which is out of bounds. [negativeIndex]\n"
                       "[test.cpp:4:6]: (error) Array 'a[32768]' accessed at index 32768, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
@@ -969,7 +969,7 @@ class TestBufferOverrun : public TestFixture {
               "    int a[n];\n"     // n <= USHRT_MAX
               "    a[-1] = 0;\n"    // negative index
               "    a[65536] = 0;\n" // 65536 > USHRT_MAX
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[65536]' accessed at index -1, which is out of bounds. [negativeIndex]\n"
                       "[test.cpp:4:6]: (error) Array 'a[65536]' accessed at index 65536, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
@@ -977,26 +977,26 @@ class TestBufferOverrun : public TestFixture {
               "    int a[n];\n"     // n <= SHRT_MAX
               "    a[-1] = 0;\n"    // negative index
               "    a[32768] = 0;\n" // 32768 > SHRT_MAX
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[32768]' accessed at index -1, which is out of bounds. [negativeIndex]\n"
                       "[test.cpp:4:6]: (error) Array 'a[32768]' accessed at index 32768, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f(int n) {\n"
               "    int a[n];\n"     // n <= INT_MAX
               "    a[-1] = 0;\n"    // negative index
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[2147483648]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
 
         check("void f(unsigned int n) {\n"
               "    int a[n];\n"     // n <= UINT_MAX
               "    a[-1] = 0;\n"    // negative index
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[4294967296]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
 
         check("void f(signed int n) {\n"
               "    int a[n];\n"     // n <= INT_MAX
               "    a[-1] = 0;\n"    // negative index
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[2147483648]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
@@ -1004,7 +1004,7 @@ class TestBufferOverrun : public TestFixture {
         check("void foo()\n"
               "{\n"
               "   long l[SOME_SIZE];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1014,7 +1014,7 @@ class TestBufferOverrun : public TestFixture {
               "    int a[3];\n"
               "    for (int i = 3; 0 <= i; i--)\n"
               "        a[i] = i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[3]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
@@ -1022,7 +1022,7 @@ class TestBufferOverrun : public TestFixture {
               "    int a[4];\n"
               "    for (int i = 3; 0 <= i; i--)\n"
               "        a[i] = i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1032,7 +1032,7 @@ class TestBufferOverrun : public TestFixture {
               "    int a[10];\n"
               "    for (int i = 0; i < 10; i++)\n"
               "        a[i-1] = a[i];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[10]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
@@ -1043,7 +1043,7 @@ class TestBufferOverrun : public TestFixture {
               "    int i[2];\n"
               "    int *ip = i + 1;\n"
               "    ip[-10] = 1;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Array ip[-10] out of bounds.\n", "", errout_str());
     }
 
@@ -1055,7 +1055,7 @@ class TestBufferOverrun : public TestFixture {
               "    int *i = iBuf + 9;"
               "    int *ii = i + -5;"
               "    ii[10] = 0;"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Array ii[10] out of bounds.\n", "", errout_str());
     }
 
@@ -1065,7 +1065,7 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "    UINT8 x[2];\n"
               "    x[5] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'x[2]' accessed at index 5, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -1082,7 +1082,7 @@ class TestBufferOverrun : public TestFixture {
               "void y() {\n"
               "    struct s1 obj;\n"
               "    x(obj.delay, 123);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct s1 {\n"
@@ -1096,7 +1096,7 @@ class TestBufferOverrun : public TestFixture {
               "void y() {\n"
               "    struct s1 obj;\n"
               "    x(obj.delay, 123);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:11] -> [test.cpp:6]: (error) Array 'obj.delay[3]' accessed at index 4, which is out of bounds.\n",
                            "",
                            errout_str());
@@ -1107,7 +1107,7 @@ class TestBufferOverrun : public TestFixture {
               "\n"
               "void f() {\n"
               "    struct s1 *obj;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1121,14 +1121,14 @@ class TestBufferOverrun : public TestFixture {
               "       m_x[1] = 0;\n"
               "    }\n"
               "    int m_x[1];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:7:11]: (error) Array 'm_x[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_33() {
         check("void foo(char bar[][4]) {\n"
               "    baz(bar[5]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1137,7 +1137,7 @@ class TestBufferOverrun : public TestFixture {
               "    int y[2][2][2];\n"
               "    y[0][2][0] = 0;\n"
               "    y[0][0][2] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'y[2][2][2]' accessed at index y[0][2][0], which is out of bounds. [arrayIndexOutOfBounds]\n"
                       "[test.cpp:4:6]: (error) Array 'y[2][2][2]' accessed at index y[0][0][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
@@ -1157,7 +1157,7 @@ class TestBufferOverrun : public TestFixture {
               "    ptest->a[10] = 3;\n"
               "    ptest->b[10][2] = 4;\n"
               "    ptest->b[0][19] = 4;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:11]: (error) Array 'test.a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n"
                       "[test.cpp:10:11]: (error) Array 'test.b[10][5]' accessed at index test.b[10][2], which is out of bounds. [arrayIndexOutOfBounds]\n"
                       "[test.cpp:11:11]: (error) Array 'test.b[10][5]' accessed at index test.b[0][19], which is out of bounds. [arrayIndexOutOfBounds]\n"
@@ -1178,7 +1178,7 @@ class TestBufferOverrun : public TestFixture {
               "    ptest = &test;\n"
               "    ptest->a[9][5] = 4;\n"
               "    ptest->a[0][50] = 4;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:11]: (error) Array 'test.a[10][5]' accessed at index test.a[9][5], which is out of bounds. [arrayIndexOutOfBounds]\n"
                       "[test.cpp:9:11]: (error) Array 'test.a[10][5]' accessed at index test.a[0][50], which is out of bounds. [arrayIndexOutOfBounds]\n"
                       "[test.cpp:12:13]: (error) Array 'ptest->a[10][5]' accessed at index ptest->a[9][5], which is out of bounds. [arrayIndexOutOfBounds]\n"
@@ -1189,21 +1189,21 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "    struct Struct { unsigned m_Var[1]; } s;\n"
               "    s.m_Var[1] = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Array 's.m_Var[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct Struct { unsigned m_Var[1]; };\n"
               "void f() {\n"
               "    struct Struct s;\n"
               "    s.m_Var[1] = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (error) Array 's.m_Var[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct Struct { unsigned m_Var[1]; };\n"
               "void f() {\n"
               "    struct Struct * s = calloc(40);\n"
               "    s->m_Var[1] = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1215,7 +1215,7 @@ class TestBufferOverrun : public TestFixture {
               "};\n"
               "Fred::Fred(const Fred & rhs) {\n"
               "    m_b[2] = rhs.m_b[2];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:8]: (error) Array 'm_b[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n"
                       "[test.cpp:7:21]: (error) Array 'rhs.m_b[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
@@ -1227,7 +1227,7 @@ class TestBufferOverrun : public TestFixture {
               "        for (unsigned int i = 0; i < 15; i++)\n"
               "            i;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1246,7 +1246,7 @@ class TestBufferOverrun : public TestFixture {
               "            }\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1255,7 +1255,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    char a[10];\n"
               "    a[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 'a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -1264,7 +1264,7 @@ class TestBufferOverrun : public TestFixture {
               "    char a[10];\n"
               "    for (int i = 0; i < 10; ++i)\n"
               "        f2(&a[i + 1]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1277,7 +1277,7 @@ class TestBufferOverrun : public TestFixture {
               "\n"
               "void b() {\n"
               "    struct Fred { char data[3]; } fred;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void a() {\n"
@@ -1288,7 +1288,7 @@ class TestBufferOverrun : public TestFixture {
               "void b() {\n"
               "    struct Fred { char data[3]; } fred;\n"
               "    fred.data[4] = 0;\n"  // <- error
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:14]: (error) Array 'fred.data[3]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -1299,7 +1299,7 @@ class TestBufferOverrun : public TestFixture {
               "  char *p; p = (char *)malloc(10);\n"
               "  p[10] = 7;\n"
               "  free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'p[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
@@ -1307,7 +1307,7 @@ class TestBufferOverrun : public TestFixture {
               "  float *p; p = (float *)malloc(10 * sizeof(float));\n"
               "  p[10] = 7;\n"
               "  free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'p[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
@@ -1316,7 +1316,7 @@ class TestBufferOverrun : public TestFixture {
               "  p[0] = 0;\n"
               "  p[9] = 9;\n"
               "  free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -1325,7 +1325,7 @@ class TestBufferOverrun : public TestFixture {
               "  p[0] = 0;\n"
               "  p[9] = 9;\n"
               "  delete [] p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -1334,7 +1334,7 @@ class TestBufferOverrun : public TestFixture {
               "  p[0] = 0;\n"
               "  p[9] = 9;\n"
               "  delete [] p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -1345,11 +1345,11 @@ class TestBufferOverrun : public TestFixture {
               "  }\n"
               "  catch(...){\n"
               "  return;\n"
-              "  }"
+              "  }\n"
               "  p[0] = 0;\n"
               "  p[9] = 9;\n"
               "  delete [] p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1366,7 +1366,7 @@ class TestBufferOverrun : public TestFixture {
               "   var[ 0 ].arr[ 2 ] = 2;\n"
               "   y = var[ 0 ].arr[ 3 ];\n" // <-- array access out of bounds
               "   return y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:20]: (error) Array 'var[0].arr[3]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("int f( )\n"
@@ -1380,7 +1380,7 @@ class TestBufferOverrun : public TestFixture {
               "   var[ 0 ].arr[ 2 ] = 2;\n"
               "   y = var[ 0 ].arr[ 2 ];\n"
               "   return y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -1396,7 +1396,7 @@ class TestBufferOverrun : public TestFixture {
               "var.arr[ 3 ] = 3;\n" // <-- array access out of bounds
               "y=var.arr[ 3 ];\n"   // <-- array access out of bounds
               "return y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:8]: (error) Array 'var.arr[3]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n"
                       "[test.cpp:11:10]: (error) Array 'var.arr[3]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
@@ -1410,7 +1410,7 @@ class TestBufferOverrun : public TestFixture {
               "var[0].var[ 1 ] = 1;\n"
               "var[0].var[ 2 ] = 2;\n"
               "var[0].var[ 4 ] = 4;\n" // <-- array access out of bounds
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:11]: (error) Array 'var[0].var[3]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f( ) {\n"
@@ -1421,7 +1421,7 @@ class TestBufferOverrun : public TestFixture {
               "var[0].var[ 0 ] = 0;\n"
               "var[0].var[ 1 ] = 1;\n"
               "var[0].var[ 2 ] = 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // avoid FPs (modified examples taken from #3838)
@@ -1430,7 +1430,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct AB ab;\n"
               "    int * p = &ab.a[10];\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct AB { int a[10]; int b[10]; };\n"
@@ -1438,7 +1438,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct AB ab[1];\n"
               "    int * p = &ab[0].a[10];\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct AB { int a[10]; int b[10]; };\n"
@@ -1446,7 +1446,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct AB ab[1];\n"
               "    int * p = &ab[10].a[0];\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (error) Array 'ab[1]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -1460,7 +1460,7 @@ class TestBufferOverrun : public TestFixture {
               "    {\n"
               "        buf[i] = 1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -1470,7 +1470,7 @@ class TestBufferOverrun : public TestFixture {
               "    {\n"
               "        buf[i] = 2.;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1483,7 +1483,7 @@ class TestBufferOverrun : public TestFixture {
               "void test() {\n"
               "    CHAR buffer[1024];\n"
               "    f(\"%s\", buffer);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Unnamed argument
@@ -1493,7 +1493,7 @@ class TestBufferOverrun : public TestFixture {
               "void test() {\n"
               "    char buffer[1024];\n"
               "    f(buffer);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1505,7 +1505,7 @@ class TestBufferOverrun : public TestFixture {
               "    for(int i=3; i--;) {\n"
               "        printf(\"files(%i): %s\", 3-i, buffer[3-i]);\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Array 'buffer[3]' accessed at index 3, which is out of bounds.\n", "", errout_str());
 
         check("void f() {\n"
@@ -1514,7 +1514,7 @@ class TestBufferOverrun : public TestFixture {
               "    for(i=10; i--;) {\n"
               "        buffer[i] = i;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:15]: (error) Array 'buffer[9]' accessed at index 9, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // Correct access limits -> i from 9 to 0
@@ -1523,7 +1523,7 @@ class TestBufferOverrun : public TestFixture {
               "    for(unsigned long int i=10; i--;) {\n"
               "        buffer[i] = i;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1533,7 +1533,7 @@ class TestBufferOverrun : public TestFixture {
               "void f() {\n"
               "    for (int i = 2; i < 0; i++)\n"
               "        s[i] = 5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1546,7 +1546,7 @@ class TestBufferOverrun : public TestFixture {
               "        printf(\" %i\", i);\n"
               "        array[i] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:14]: (error) Array 'array[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void test(void)\n"
@@ -1556,7 +1556,7 @@ class TestBufferOverrun : public TestFixture {
               "        scanf(\"%i\", &i);\n"
               "        array[i] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1570,7 +1570,7 @@ class TestBufferOverrun : public TestFixture {
               "        i++;\n"
               "    }\n"
               "    arr[k];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1582,7 +1582,7 @@ class TestBufferOverrun : public TestFixture {
               "void g() {\n"
               "    f(\"12345678\");\n"
               "    f(\"12345\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1590,7 +1590,7 @@ class TestBufferOverrun : public TestFixture {
         check("void f(void){\n"
               "    int k=0, dd, d[1U] = {1};\n"
               "    for (dd=d[k]; k<10; dd=d[++k]){;}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:29]: (error) Array 'd[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -1601,7 +1601,7 @@ class TestBufferOverrun : public TestFixture {
               "    for(int i = 0, j= 11; i < j; ++i)\n"
               "       buf[i] = 0;\n"
               "    return buf[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:11]: (error) Array 'buf[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -1613,7 +1613,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i=0; i < 3; i++)\n"
               "        for (int j = 0; j < 3; j++)\n"
               "             M[i][j]=0.0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:15]: (error) Array 'M[3][1]' accessed at index M[*][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -2017,87 +2017,87 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "  char a[2][2];\n"
               "  a[1][1] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2][2];\n"
               "  a[1][1][1] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2];\n"
               "  a[2][1] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[2][2]' accessed at index a[2][1], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2];\n"
               "  a[1][2] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[2][2]' accessed at index a[1][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2][2];\n"
               "  a[2][1][1] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[2][2][2]' accessed at index a[2][1][1], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2][2];\n"
               "  a[1][2][1] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[2][2][2]' accessed at index a[1][2][1], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2][2][2];\n"
               "  a[1][2][1][1] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[2][2][2][2]' accessed at index a[1][2][1][1], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2][2];\n"
               "  a[1][1][2] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[2][2][2]' accessed at index a[1][1][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[10][10][10];\n"
               "  a[2*3][4*3][2] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[10][10][10]' accessed at index a[6][12][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "  char a[10][10][10];\n"
               "  a[6][40][10] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:4]: (error) Array 'a[10][10][10]' accessed at index a[6][40][10], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "  char a[1][1][1];\n"
               "  a[2][2][2] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:4]: (error) Array 'a[1][1][1]' accessed at index a[2][2][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "  char a[6][6][6];\n"
               "  a[6][6][2] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:4]: (error) Array 'a[6][6][6]' accessed at index a[6][6][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "  int a[2][2];\n"
               "  p = &a[2][0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // unknown dim..
@@ -2105,7 +2105,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "  int a[2][countof(x)] = {{1,2},{3,4}};\n"
               "  a[0][0] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void draw_quad(float z)  {\n"
@@ -2127,7 +2127,7 @@ class TestBufferOverrun : public TestFixture {
               "        vertices[i][1][2] = 4.0;\n"
               "        vertices[i][1][3] = 5.0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         {
@@ -2136,7 +2136,7 @@ class TestBufferOverrun : public TestFixture {
                   "  const size_t B = 2;\n"
                   "  extern int stuff[A][B];\n"
                   "  return stuff[0][1];\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("", errout_str());
 
             // TODO: better handling of VLAs in symboldatabase. should be
@@ -2146,7 +2146,7 @@ class TestBufferOverrun : public TestFixture {
                   "  const size_t B = 2;\n"
                   "  extern int stuff[A][B];\n"
                   "  return stuff[0][1];\n"
-                  "}");
+                  "}\n");
             TODO_ASSERT_EQUALS("error", "", errout_str());
         }
     }
@@ -2167,7 +2167,7 @@ class TestBufferOverrun : public TestFixture {
               "    break;\n"
               "  };\n"
               " }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -2185,7 +2185,7 @@ class TestBufferOverrun : public TestFixture {
               "    break;\n"
               "  };\n"
               " }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:12]: (error) Array index out of bounds.\n", "", errout_str());
     }
 
@@ -2197,7 +2197,7 @@ class TestBufferOverrun : public TestFixture {
               "            a[i] = 0;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2207,7 +2207,7 @@ class TestBufferOverrun : public TestFixture {
               "void f(int i) {\n"
               "  if (i >= 0 && i < 10) {}\n"
               "  a[i] = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:19] -> [test.cpp:4:4]: (warning) Either the condition 'i<10' is redundant or the array 'a[10]' is accessed at index 10, which is out of bounds. [arrayIndexOutOfBoundsCond]\n"
                       "[test.cpp:3:9] -> [test.cpp:4:4]: (warning) Either the condition 'i>=0' is redundant or the array 'a[10]' is accessed at index -1, which is out of bounds. [negativeIndex]\n",
                       errout_str());
@@ -2221,7 +2221,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 19; i < 36; ++i) {\n"
               "        data[i/2] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:13]: (error) Array 'data[8]' accessed at index 17, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // #2199 - false negative: array out of bounds in loop when there is calculation
@@ -2231,7 +2231,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i < 5; ++i) {\n"
               "        arr[i + 7] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (error) Array 'arr[5]' accessed at index 11, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -2241,21 +2241,21 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    char data[8];\n"
               "    data[-1] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Array 'data[8]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    char data[8][4];\n"
               "    data[5][-1] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Array 'data[8][4]' accessed at index data[*][-1], which is out of bounds. [negativeIndex]\n", errout_str());
 
         // #1614 - negative index is ok for pointers
         check("void foo(char *p)\n"
               "{\n"
               "    p[-1] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -2263,14 +2263,14 @@ class TestBufferOverrun : public TestFixture {
               "    char s[] = \"abc\";\n"
               "    char *p = s + strlen(s);\n"
               "    if (p[-1]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #1850
         check("int f(const std::map<int, std::map<int,int> > &m)\n"
               "{\n"
               "    return m[0][-1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2279,7 +2279,7 @@ class TestBufferOverrun : public TestFixture {
               "void foo() {\n"
               "    TEST test;\n"
               "    test.a[-1] = 3;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (error) Array 'test.a[10]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
@@ -2295,7 +2295,7 @@ class TestBufferOverrun : public TestFixture {
               "void g(int i) {\n"
               "    if( i == 0 )\n"
               "        return f(i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2402,7 +2402,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 10; i > 0; --i) {\n"
               "        data[i] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:13]: (error) Array 'data[8]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
@@ -2411,7 +2411,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (unsigned int i = 3; i < 5; --i) {\n"
               "        val[i+1] = val[i];\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -2420,7 +2420,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 3; i < 5; --i) {\n"
               "        val[i+1] = val[i];\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (error) Array 'val[5]' accessed at index -9994, which is out of bounds. [negativeIndex]\n"
                       "[test.cpp:5:23]: (error) Array 'val[5]' accessed at index -9995, which is out of bounds. [negativeIndex]\n", errout_str());
     }
@@ -2438,7 +2438,7 @@ class TestBufferOverrun : public TestFixture {
               "    A a;\n"
               "    a.data[3] = 0;\n"
               "    a.b.data[2] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #1586
@@ -2453,7 +2453,7 @@ class TestBufferOverrun : public TestFixture {
               "    A a;\n"
               "    a.data[4] = 0;\n"
               "    a.b.data[3] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:11]: (error) Array 'a.data[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n"
                       "[test.cpp:11:13]: (error) Array 'a.b.data[3]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
@@ -2467,7 +2467,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (x = 0; x < 10 && y; x++) {\n"
               "        data[x] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:13]: (error) Array 'data[2]' accessed at index 9, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
@@ -2476,7 +2476,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (x = 0; x < 10 || y; x++) {\n"
               "        data[x] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:13]: (error) Array 'data[2]' accessed at index 9, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
@@ -2485,7 +2485,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (x = 0; x <= 10 && y; x++) {\n"
               "        data[x] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:13]: (error) Array 'data[2]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
@@ -2494,7 +2494,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (x = 0; y && x <= 10; x++) {\n"
               "        data[x] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:13]: (error) Array 'data[2]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("int f() {\n" // #9126
@@ -2506,7 +2506,7 @@ class TestBufferOverrun : public TestFixture {
               "            c++;\n"
               "     }\n"
               "    return c;\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2520,7 +2520,7 @@ class TestBufferOverrun : public TestFixture {
               "        }\n"
               "        a[i - 1] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // extracttests.start: int maybe();
@@ -2532,7 +2532,7 @@ class TestBufferOverrun : public TestFixture {
               "        }\n"
               "        a[i - 1] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:10]: (error) Array 'a[2]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
@@ -2545,7 +2545,7 @@ class TestBufferOverrun : public TestFixture {
               "        }\n"
               "        a[i] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:10]: (error) Array 'a[10]' accessed at index 19, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // Ticket #2385 - No false positive
@@ -2557,7 +2557,7 @@ class TestBufferOverrun : public TestFixture {
               "            a[i-10] = 0;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #3893 - start value out of bounds
@@ -2567,7 +2567,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 10; maybe(); dostuff()) {\n"
               "        a[i] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // #7686
@@ -2601,7 +2601,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i != 10; ++i) {\n"
               "        a[i] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'a[5]' accessed at index 9, which is out of bounds. [arrayIndexOutOfBounds]\n",
                       errout_str());
     }
@@ -2613,7 +2613,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i != 10; ++i) {\n"
               "        i == 0 ? 0 : a[i-1];\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -2621,7 +2621,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i != 10; ++i) {\n"
               "        some_condition ? 0 : a[i-1];\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:31]: (error) Array 'a[10]' accessed at index -1, which is out of bounds. [negativeIndex]\n",
                       errout_str());
 
@@ -2631,7 +2631,7 @@ class TestBufferOverrun : public TestFixture {
               "        i==0 ? 0 : a[i-1];\n"
               "        a[i-1] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[10]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
@@ -2639,7 +2639,7 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "   char a[10];\n"
               "   for (i=0; i<10; i++);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2650,14 +2650,14 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i=0; i<7; ++i) {\n"
               "        a[0] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_extern() {
         // Ticket #1684. FP when using 'extern'.
         check("extern char arr[15];\n"
-              "char arr[15] = \"abc\";");
+              "char arr[15] = \"abc\";\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2671,7 +2671,7 @@ class TestBufferOverrun : public TestFixture {
               "void f2() {\n"
               "    int x[2];\n"
               "    f1(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Same type => error
@@ -2681,7 +2681,7 @@ class TestBufferOverrun : public TestFixture {
               "void f2() {\n"
               "    char x[2];\n"
               "    f1(x);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:2]: (error) Array 'x[2]' accessed at index 4, which is out of bounds.\n",
                            "",
                            errout_str());
@@ -2691,41 +2691,41 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "    const char *str = \"abc\";\n"
               "    bar(str[10]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Array 'str[4]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    const char *str = \"abc\";\n"
               "    bar(str[4]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (error) Array 'str[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    const char *str = \"abc\";\n"
               "    bar(str[3]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "    const char *str = \"a\tc\";\n"
               "    bar(str[4]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (error) Array 'str[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n" // #6973
               "    const char *name = \"\";\n"
               "    if ( name[0] == 'U' ? name[1] : 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int main(int argc, char **argv) {\n"
               "    char str[6] = \"\\0\";\n"
               "    unsigned short port = 65535;\n"
               "    snprintf(str, sizeof(str), \"%hu\", port);\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int x) {\n" // #11020
@@ -2747,7 +2747,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    struct tt *tt=x;\n"
               "    tt->name;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // detect error
@@ -2758,7 +2758,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    struct tt *tt=x;\n"
               "    tt->name[22] = 123;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:13]: (error) Array 'tt->name[21]' accessed at index 22, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -2767,7 +2767,7 @@ class TestBufferOverrun : public TestFixture {
               "    char str[3];\n"
               "    str[i] = 0;\n"
               "    if (i==10) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10] -> [test.cpp:3:8]: (warning) Either the condition 'i==10' is redundant or the array 'str[3]' is accessed at index 10, which is out of bounds. [arrayIndexOutOfBoundsCond]\n", errout_str());
 
         check("void f(int i) {\n"
@@ -2776,31 +2776,31 @@ class TestBufferOverrun : public TestFixture {
               "    switch (i) {\n"
               "    case 10: break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5] -> [test.cpp:3:8]: (warning) Either the switch case 'case 10' is redundant or the array 'str[3]' is accessed at index 10, which is out of bounds. [arrayIndexOutOfBoundsCond]\n", errout_str());
 
         check("void f() {\n"
               "    char str[3];\n"
               "    str[((unsigned char)3) - 1] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"  // #5416 FP
               "    char *str[3];\n"
               "    do_something(&str[0][5]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class X { static const int x[100]; };\n" // #6070
-              "const int X::x[100] = {0};");
+              "const int X::x[100] = {0};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("namespace { class X { static const int x[100]; };\n" // #6232
-              "const int X::x[100] = {0}; }");
+              "const int X::x[100] = {0}; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class ActorSprite { static ImageSet * targetCursorImages[2][10]; };\n"
-              "ImageSet *ActorSprite::targetCursorImages[2][10];");
+              "ImageSet *ActorSprite::targetCursorImages[2][10];\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(const std::size_t s) {\n" // #10130
@@ -2832,7 +2832,7 @@ class TestBufferOverrun : public TestFixture {
               "  int a[10];\n"
               "  int *p = a;\n"
               "  p[20] = 0;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (error) Array 'a[10]' accessed at index 20, which is out of bounds.\n", "", errout_str());
 
         {
@@ -2841,14 +2841,14 @@ class TestBufferOverrun : public TestFixture {
                   "  int a[10];\n"
                   "  int *p = a;\n"
                   "  p[10] = 0;\n"
-                  "}");
+                  "}\n");
             TODO_ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4:6]: (error) Array 'a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", "", errout_str());
 
             check("void f() {\n"
                   "  int a[10];\n"
                   "  int *p = a;\n"
                   "  dostuff(&p[10]);\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("", errout_str());
         }
 
@@ -2856,33 +2856,33 @@ class TestBufferOverrun : public TestFixture {
               "  int a[X];\n" // unknown size
               "  int *p = a;\n"
               "  p[20] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int a[2];\n"
               "  char *p = (char *)a;\n" // cast
               "  p[4] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_function_parameter() {
         check("void f(char a[10]) {\n"
               "  a[20] = 0;\n" // <- cppcheck warn here even though it's not a definite access out of bounds
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:4]: (error) Array 'a[10]' accessed at index 20, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f(char a[10]) {\n" // #6353 - reassign 'a'
               "  a += 4;\n"
               "  a[-1] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char a[10]) {\n"
               "  a[0] = 0;\n"
               "  a[-1] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:4]: (error) Array 'a[10]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
@@ -2891,7 +2891,7 @@ class TestBufferOverrun : public TestFixture {
               "void f() {\n"
               "    E arrE[] = { e1, e2 };\n"
               "    arrE[sizeof(arrE)] = e1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Array 'arrE[2]' accessed at index 8, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -2899,7 +2899,7 @@ class TestBufferOverrun : public TestFixture {
         check("constexpr int blockLen = 10;\n"
               "void foo(std::array<uint8_t, blockLen * 2>& a) {\n"
               "    a[2] = 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2909,14 +2909,14 @@ class TestBufferOverrun : public TestFixture {
               "    std::vector<int> v(3);\n"
               "    int* p = v.data();\n"
               "    p[2] = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    std::vector<int> v(3);\n"
               "    int* p = v.data();\n"
               "    p[5] = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:6]: (error) Array 'p[3]' accessed at index 5, which is out of bounds. [arrayIndexOutOfBounds]\n",
             errout_str());
@@ -2925,7 +2925,7 @@ class TestBufferOverrun : public TestFixture {
               "    std::vector<int> v(3);\n"
               "    memset(v.data(), 0, 12);\n"
               "    memset(v.data(), 0, 100);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (error) Buffer is accessed out of bounds: v.data() [bufferAccessOutOfBounds]\n",
                       errout_str());
 
@@ -2933,7 +2933,7 @@ class TestBufferOverrun : public TestFixture {
               "    std::vector<int> v(3);\n"
               "    int* p = v.data();\n"
               "    memset(p, 0, 100);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (error) Buffer is accessed out of bounds: p [bufferAccessOutOfBounds]\n",
                       errout_str());
 
@@ -2944,7 +2944,7 @@ class TestBufferOverrun : public TestFixture {
               "    int* p = v.data();\n"
               "    v.resize(10);\n"
               "    memset(p, 0, 40);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ..or when the pointer is reassigned
@@ -2953,7 +2953,7 @@ class TestBufferOverrun : public TestFixture {
               "    int* p = v.data();\n"
               "    p = q;\n"
               "    memset(p, 0, 100);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // the buffer of c_str() includes the null terminator
@@ -2961,7 +2961,7 @@ class TestBufferOverrun : public TestFixture {
               "    std::string s = \"abc\";\n"
               "    memcpy(dst, s.c_str(), 4);\n"
               "    memcpy(dst, s.c_str(), 5);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:24]: (error) Buffer is accessed out of bounds: s.c_str() [bufferAccessOutOfBounds]\n",
                       errout_str());
     }
@@ -2976,7 +2976,7 @@ class TestBufferOverrun : public TestFixture {
               "        sum += val[i];\n"
               "    if (i < 50)\n"
               "        sum -= val[i];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool b();\n"
@@ -2990,7 +2990,7 @@ class TestBufferOverrun : public TestFixture {
               "        sum -= val[i];\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool b();\n"
@@ -3002,7 +3002,7 @@ class TestBufferOverrun : public TestFixture {
               "        sum += val[i];\n"
               "    for (; i < 50; i++)\n"
               "        sum -= val[i];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3089,7 +3089,7 @@ class TestBufferOverrun : public TestFixture {
               "static void f(struct ABC *abc)\n"
               "{\n"
               "    strcpy( abc->str, \"abcdef\" );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:16]: (error) Buffer is accessed out of bounds: abc->str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("struct ABC\n"
@@ -3101,7 +3101,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    struct ABC abc;\n"
               "    strcpy( abc.str, \"abcdef\" );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:16]: (error) Buffer is accessed out of bounds: abc.str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("struct ABC\n"
@@ -3112,7 +3112,7 @@ class TestBufferOverrun : public TestFixture {
               "static void f(struct ABC &abc)\n"
               "{\n"
               "    strcpy( abc.str, \"abcdef\" );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:16]: (error) Buffer is accessed out of bounds: abc.str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("static void f()\n"
@@ -3122,7 +3122,7 @@ class TestBufferOverrun : public TestFixture {
               "        char str[5];\n"
               "    } abc;\n"
               "    strcpy( abc.str, \"abcdef\" );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:16]: (error) Buffer is accessed out of bounds: abc.str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("static void f()\n"
@@ -3134,7 +3134,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct ABC *abc = malloc(sizeof(struct ABC));\n"
               "    strcpy( abc->str, \"abcdef\" );\n"
               "    free(abc);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:16]: (error) Buffer is accessed out of bounds: abc->str [bufferAccessOutOfBounds]\n", errout_str());
     }
 
@@ -3147,7 +3147,7 @@ class TestBufferOverrun : public TestFixture {
               "    int i;\n"
               "    for (i = 0; i <= 10; ++i)\n"
               "        a[i] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:10]: (error) Array 'a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct S { int b; } static e[1];\n" // #11052
@@ -3162,7 +3162,7 @@ class TestBufferOverrun : public TestFixture {
               "    const char *p[2];\n"
               "    for (int i = 0; i < 8; ++i)\n"
               "        p[i] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'p[2]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // No false positive
@@ -3171,7 +3171,7 @@ class TestBufferOverrun : public TestFixture {
               "    const char *p[2];\n"
               "    const char *s = y + p[1];\n"
               "    p[1] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // There is no error here
@@ -3183,7 +3183,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "  char s[3];\n"
               "  f1(s,20);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:3]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
 
         check("void f1(char *s,int size)\n"
@@ -3204,7 +3204,7 @@ class TestBufferOverrun : public TestFixture {
               "    char n[5];\n"
               "    sprintf(n, \"d\");\n"
               "    printf(\"hello!\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3214,21 +3214,21 @@ class TestBufferOverrun : public TestFixture {
               "   char n[5];\n"
               "   strcat(n, \"abc\");\n"
               "   strcat(n, \"def\");\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Buffer is accessed out of bounds: n\n", "", errout_str());
 
         check("void f()\n" // #12489
               "{\n"
               "   char d[3] = {};\n"
               "   strcat(d, \"12345678\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (error) Buffer is accessed out of bounds: d [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   char d[3] = \"ab\"; \n"
               "   strcat(d, \"c\");\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4:11]: (error) Buffer is accessed out of bounds: d [bufferAccessOutOfBounds]\n", "", errout_str());
     }
 
@@ -3238,7 +3238,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    char a[2];\n"
               "    strcpy(a, \"a\\0\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3251,7 +3251,7 @@ class TestBufferOverrun : public TestFixture {
               "    {\n"
               "        a[i] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -3261,7 +3261,7 @@ class TestBufferOverrun : public TestFixture {
               "    {\n"
               "        a[i] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3275,7 +3275,7 @@ class TestBufferOverrun : public TestFixture {
               "        a[i] = 0;\n"
               "        i += 100;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3288,7 +3288,7 @@ class TestBufferOverrun : public TestFixture {
               "    {\n"
               "        char b = a[i];\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3299,7 +3299,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (float i=0; i<10.0;i=i+0.1)\n"
               "    {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -3308,7 +3308,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (float i=0; i<10.0;i=0.1+i)\n"
               "    {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3320,7 +3320,7 @@ class TestBufferOverrun : public TestFixture {
               "void A::f(int i, int ii)\n"
               "{\n"
               "    strcpy(val, \"ab\") ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:12]: (error) Buffer is accessed out of bounds: val [bufferAccessOutOfBounds]\n", errout_str());
     }
 
@@ -3329,20 +3329,20 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "    struct Foo foo[5];\n"
               "    memset(foo, 0, sizeof(foo));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"  // ticket #2093
               "    gchar x[3];\n"
               "    strcpy(x, \"12\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("extern char a[10];\n"
               "void f() {\n"
               "    char b[25] = {0};\n"
               "    std::memcpy(b, a, 10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3356,7 +3356,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i=0; i<6; i++) {\n"
               "        b[i] = b[i+1];\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"
@@ -3368,7 +3368,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i=0; i<7; i++) {\n"
               "        b[i] = b[i+1];\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:17]: (error) Array 'b[7]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -3381,7 +3381,7 @@ class TestBufferOverrun : public TestFixture {
               "\n"
               "A::A() {\n"
               "    memset(buf, 0, 10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3392,7 +3392,7 @@ class TestBufferOverrun : public TestFixture {
               "    const char *src = \"AAAAAAAAAAAAAAAAAAAAA\";\n"
               "    for (size_t i = 0; i <= 4; i++)\n"
               "        dst[i] = src[i];\n"
-              "} } }");
+              "} } }\n");
         ASSERT_EQUALS("[test.cpp:6:12]: (error) Array 'dst[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -3404,7 +3404,7 @@ class TestBufferOverrun : public TestFixture {
               "   for( int i = 0; i<6; ) {\n"
               "      x += array[i];\n"
               "       i++;  }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         // ticket #4096
@@ -3414,7 +3414,7 @@ class TestBufferOverrun : public TestFixture {
               "   for( int i = 0; i<6; ) {\n"
               "      x += array[i++];\n"
               "   }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
@@ -3424,7 +3424,7 @@ class TestBufferOverrun : public TestFixture {
               "    char inbuf[1000];\n"
               "    char *f[10];\n"
               "    split(inbuf, f, 10, \"\t\t\");\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3434,7 +3434,7 @@ class TestBufferOverrun : public TestFixture {
               "void main() {\n"
               "struct foobar x[5];\n"
               "abc(x);\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3445,7 +3445,7 @@ class TestBufferOverrun : public TestFixture {
               "int main(){\n"
               "  testChar tc1 = \"\";\n"
               "  tc1[5]='a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3455,14 +3455,14 @@ class TestBufferOverrun : public TestFixture {
         check("struct S { int m[9]; };\n"
               "int f(S * s) {\n"
               "    return s->m[sizeof(s->m)];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Array 's->m[9]' accessed at index 36, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void buffer_overrun_31() {
         check("void f(WhereInfo *pWInfo, int *aiCur) {\n"
               "  memcpy(aiCur, pWInfo->aiCurOnePass, sizeof(int)*2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3473,7 +3473,7 @@ class TestBufferOverrun : public TestFixture {
               "    char dest[1] = \"a\";\n"
               "    (void)strxfrm(dest,src,1);\n"
               "    (void)strxfrm(dest,src,2);\n"// <<
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:19]: (error) Buffer is accessed out of bounds: dest [bufferAccessOutOfBounds]\n", errout_str());
         // destination size is too small
         check("void f(void) {\n"
@@ -3482,7 +3482,7 @@ class TestBufferOverrun : public TestFixture {
               "    (void)strxfrm(dest,src,1);\n"
               "    (void)strxfrm(dest,src,2);\n"
               "    (void)strxfrm(dest,src,3);\n" // <<
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:19]: (error) Buffer is accessed out of bounds: dest [bufferAccessOutOfBounds]\n", errout_str());
         // source size is too small
         check("void f(void) {\n"
@@ -3491,7 +3491,7 @@ class TestBufferOverrun : public TestFixture {
               "    (void)strxfrm(dest,src,1);\n"
               "    (void)strxfrm(dest,src,2);\n"
               "    (void)strxfrm(dest,src,3);\n" // <<
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:24]: (error) Buffer is accessed out of bounds: src [bufferAccessOutOfBounds]\n", errout_str());
         // source size is too small
         check("void f(void) {\n"
@@ -3499,7 +3499,7 @@ class TestBufferOverrun : public TestFixture {
               "    char dest[3] = \"abc\";\n"
               "    (void)strxfrm(dest,src,1);\n"
               "    (void)strxfrm(dest,src,2);\n" // <<
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:24]: (error) Buffer is accessed out of bounds: src [bufferAccessOutOfBounds]\n", errout_str());
     }
 
@@ -3510,7 +3510,7 @@ class TestBufferOverrun : public TestFixture {
               "      for (int j=0; j<20; j++)\n"
               "          z[i] = 0;\n"
               "   return z[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (error) Array 'z[16]' accessed at index 19, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -3641,12 +3641,12 @@ class TestBufferOverrun : public TestFixture {
     void buffer_overrun_errorpath() {
         setMultiline();
         Settings s = settings0;
-        s.templateLocation = "{file}:{line}:note:{info}";
+        s.templateLocation = "{file}:{line}:note:{info}\n";
 
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    memset(p, 0, 20);\n"
-              "}", s);
+              "}\n", s);
         ASSERT_EQUALS("[test.cpp:3:12]: error: Buffer is accessed out of bounds: p [bufferAccessOutOfBounds]\n"
                       "[test.cpp:2:13]: note: Assign p, buffer with size 10\n"
                       "[test.cpp:3:12]: note: Buffer overrun\n", errout_str());
@@ -3687,7 +3687,7 @@ class TestBufferOverrun : public TestFixture {
               "void f2() {\n"
               "    char a[10];\n"
               "    f1(a);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // No false positive
@@ -3699,7 +3699,7 @@ class TestBufferOverrun : public TestFixture {
               "void f2() {\n"
               "    char a[10];\n"
               "    f1(a);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // No false negative
@@ -3711,7 +3711,7 @@ class TestBufferOverrun : public TestFixture {
               "void f2() {\n"
               "    char a[10];\n"
               "    f1(a);"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:3]: (error) Array 'a[10]' accessed at index 100, which is out of bounds.\n", "", errout_str());
     }
 
@@ -3722,7 +3722,7 @@ class TestBufferOverrun : public TestFixture {
               "void g() {\n"
               "    char a[2];\n"
               "    f(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: warning: Buffer 'a' is too small, the function 'f' expects a bigger buffer in 1st argument [argumentSize]\n"
                       "[test.cpp:4:5]: note: Function 'f' is called\n"
                       "[test.cpp:1:13]: note: Declaration of 1st function argument.\n"
@@ -3733,7 +3733,7 @@ class TestBufferOverrun : public TestFixture {
               "void g() {\n"
               "    float a[2][3];\n"
               "    f(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: warning: Buffer 'a' is too small, the function 'f' expects a bigger buffer in 1st argument [argumentSize]\n"
                       "[test.cpp:4:5]: note: Function 'f' is called\n"
                       "[test.cpp:1:14]: note: Declaration of 1st function argument.\n"
@@ -3744,7 +3744,7 @@ class TestBufferOverrun : public TestFixture {
               "void g() {\n"
               "    int a[2];\n"
               "    f(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: warning: Buffer 'a' is too small, the function 'f' expects a bigger buffer in 1st argument [argumentSize]\n"
                       "[test.cpp:4:5]: note: Function 'f' is called\n"
                       "[test.cpp:1:12]: note: Declaration of 1st function argument.\n"
@@ -3766,7 +3766,7 @@ class TestBufferOverrun : public TestFixture {
               "void foo() {\n"
               "  unsigned char(* tree)[2048][4] = new unsigned char[256][2048][4];\n"
               "  CreateLeafTex(tree);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int a[10]) {\n" // #10069
@@ -3794,7 +3794,7 @@ class TestBufferOverrun : public TestFixture {
               "    memset(src, 'C', 99);\n"
               "    src[99] = '\\0';\n"
               "    strcat(data, src);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6]: (warning) Possible buffer overflow if strlen(src) is larger than sizeof(data)-strlen(data).\n", "", errout_str());
 
         check("void foo() {\n"
@@ -3803,19 +3803,19 @@ class TestBufferOverrun : public TestFixture {
               "    memset(src, 'C', 99);\n"
               "    src[99] = '\\0';\n"
               "    strcat(data, src);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char src[100]) {\n"
               "    char * data = (char *)alloca(50);\n"
               "    strcat(data, src);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3]: (warning) Possible buffer overflow if strlen(src) is larger than sizeof(data)-strlen(data).\n", "", errout_str());
 
         check("void foo(char src[100]) {\n"
               "    char * data = (char *)alloca(100);\n"
               "    strcat(data, src);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -3824,7 +3824,7 @@ class TestBufferOverrun : public TestFixture {
               "    memset(src, 'C', 99);\n"
               "    src[99] = '\\0';\n"
               "    strcpy(data, src);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6]: (warning) Possible buffer overflow if strlen(src) is larger than or equal to sizeof(data).\n", "", errout_str());
 
         check("void foo() {\n"
@@ -3833,19 +3833,19 @@ class TestBufferOverrun : public TestFixture {
               "    memset(src, 'C', 99);\n"
               "    src[99] = '\\0';\n"
               "    strcpy(data, src);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char src[100]) {\n"
               "    char * data = (char *)alloca(50);\n"
               "    strcpy(data, src);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3]: (warning) Possible buffer overflow if strlen(src) is larger than or equal to sizeof(data).\n", "", errout_str());
 
         check("void foo(char src[100]) {\n"
               "    char * data = (char *)alloca(100);\n"
               "    strcpy(data, src);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3867,26 +3867,26 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "  u8 str[256];\n"
               "  mystrcpy(str, \"abcd\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  u8 str[2];\n"
               "  mystrcpy(str, \"abcd\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
 
         // The same for structs, where the message comes from a different check
         check("void f() {\n"
               "    struct { u8 str[256]; } ms;\n"
               "    mystrcpy(ms.str, \"abcd\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    struct { u8 str[2]; } ms;\n"
               "    mystrcpy(ms.str, \"abcd\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Buffer is accessed out of bounds: ms.str [bufferAccessOutOfBounds]\n", errout_str());
     }
 
@@ -3894,31 +3894,31 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "  int i;\n"
               "  memset(i, 0, 1000);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int i;\n"
               "  memset(&i, 0, 1000);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (error) Buffer is accessed out of bounds: &i [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "  int i[2];\n"
               "  memset(&i, 0, 1000);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (error) Buffer is accessed out of bounds: i [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "  int i;\n"
               "  memset(&i, 0, sizeof(i));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int i[10];\n"
               "  memset(&i[1], 0, 1000);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (error) Buffer is accessed out of bounds: &i[1] [bufferAccessOutOfBounds]\n", errout_str());
 
         check("struct S { int x; };\n" // #8616
@@ -3947,7 +3947,7 @@ class TestBufferOverrun : public TestFixture {
               "  const char *x = s;\n"
               "  if (cond) x = \"abcde\";\n"
               "  return x[20];\n" // <- array index out of bounds when x is "abcde"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (error) Array 'x[6]' accessed at index 20, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -3957,40 +3957,40 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "    char a[10];\n"
               "    char *p = a + 100;\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("[test.cpp:3:17]: (portability) Undefined behaviour, pointer arithmetic 'a+100' is out of bounds. [pointerOutOfBounds]\n", errout_str());
 
         check("char *f() {\n"
               "    char a[10];\n"
               "    return a + 100;\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("[test.cpp:3:14]: (portability) Undefined behaviour, pointer arithmetic 'a+100' is out of bounds. [pointerOutOfBounds]\n", errout_str());
 
         check("void f(int i) {\n"
               "    char x[10];\n"
               "    if (i == 123) {}\n"
               "    dostuff(x+i);\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:4:14]: (portability) Undefined behaviour, when 'i' is 123 the pointer arithmetic 'x+i' is out of bounds. [pointerOutOfBoundsCond]\n", errout_str());
 
         check("void f(int i) {\n"
               "    char x[10];\n"
               "    if (i == -1) {}\n"
               "    dostuff(x+i);\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:4:14]: (portability) Undefined behaviour, when 'i' is -1 the pointer arithmetic 'x+i' is out of bounds. [pointerOutOfBoundsCond]\n", errout_str());
 
         check("void f() {\n" // #6350 - fp when there is cast of buffer
               "  wchar_t buf[64];\n"
               "  p = (unsigned char *) buf + sizeof (buf);\n"
-              "}", settings0_p, false);
+              "}\n", settings0_p, false);
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    const char   d[] = \"0123456789\";\n"
               "    char *cp = d + 3;\n"
               "    return cp - d;\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3999,7 +3999,7 @@ class TestBufferOverrun : public TestFixture {
               "    char *p = malloc(10);\n"
               "    p += 100;\n"
               "    free(p);"
-              "}", settings0_p);
+              "}\n", settings0_p);
         TODO_ASSERT_EQUALS("[test.cpp:3]: (portability) Undefined behaviour, pointer arithmetic 'p+100' is out of bounds.\n", "", errout_str());
 
         check("void f() {\n"
@@ -4007,7 +4007,7 @@ class TestBufferOverrun : public TestFixture {
               "    p += 10;\n"
               "    *p = 0;\n"
               "    free(p);"
-              "}", settings0_p);
+              "}\n", settings0_p);
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) p is out of bounds.\n", "", errout_str());
 
         check("void f() {\n"
@@ -4016,7 +4016,7 @@ class TestBufferOverrun : public TestFixture {
               "    p -= 10;\n"
               "    *p = 0;\n"
               "    free(p);"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -4025,7 +4025,7 @@ class TestBufferOverrun : public TestFixture {
               "    p = p - 1;\n"
               "    *p = 0;\n"
               "    free(p);"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4033,7 +4033,7 @@ class TestBufferOverrun : public TestFixture {
         check("struct S { int a[10]; };\n"
               "void f(struct S *s) {\n"
               "    int *p = s->a + 100;\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("[test.cpp:3:19]: (portability) Undefined behaviour, pointer arithmetic 's->a+100' is out of bounds. [pointerOutOfBounds]\n", errout_str());
 
         check("template <class T> class Vector\n"
@@ -4056,22 +4056,22 @@ class TestBufferOverrun : public TestFixture {
     void pointer_out_of_bounds_4() {
         check("const char* f() {\n"
               "    g(\"Hello\" + 6);\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("", errout_str());
 
         check("const char* f() {\n"
               "    g(\"Hello\" + 7);\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("[test.cpp:2:15]: (portability) Undefined behaviour, pointer arithmetic '\"Hello\"+7' is out of bounds. [pointerOutOfBounds]\n", errout_str());
 
         check("const char16_t* f() {\n"
               "    g(u\"Hello\" + 6);\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("", errout_str());
 
         check("const char16_t* f() {\n"
               "    g(u\"Hello\" + 7);\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("[test.cpp:2:16]: (portability) Undefined behaviour, pointer arithmetic 'u\"Hello\"+7' is out of bounds. [pointerOutOfBounds]\n", errout_str());
 
         check("void f() {\n" // #4647
@@ -4118,26 +4118,26 @@ class TestBufferOverrun : public TestFixture {
         check("char *f() {\n"
               "    char x[10];\n"
               "    return x-1;\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("[test.cpp:3:13]: (portability) Undefined behaviour, pointer arithmetic 'x-1' is out of bounds. [pointerOutOfBounds]\n", errout_str());
 
         check("void f(int i) {\n"
               "    char x[10];\n"
               "    if (i == 123) {}\n"
               "    dostuff(x-i);\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:4:14]: (portability) Undefined behaviour, when 'i' is 123 the pointer arithmetic 'x-i' is out of bounds. [pointerOutOfBoundsCond]\n", errout_str());
 
         check("void f(int i) {\n"
               "    char x[10];\n"
               "    if (i == -20) {}\n"
               "    dostuff(x-i);\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         TODO_ASSERT_EQUALS("[test.cpp:4]: (portability) Undefined behaviour, when 'i' is -20 the pointer arithmetic 'x-i' is out of bounds.\n", "", errout_str());
 
         check("void f(const char *x[10]) {\n"
               "    return x-4;\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4147,7 +4147,7 @@ class TestBufferOverrun : public TestFixture {
               "  struct Foo x = {0};\n"
               "  strcat(x.a, \"aa\");\n"
               "  strcat(x.a, \"aa\");\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
     }
 
@@ -4160,7 +4160,7 @@ class TestBufferOverrun : public TestFixture {
               "        char str[50];\n"
               "        str[30] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4168,7 +4168,7 @@ class TestBufferOverrun : public TestFixture {
         check("struct foo {\n"
               "  void bar() { return; }\n"
               "  type<> member[1];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4178,7 +4178,7 @@ class TestBufferOverrun : public TestFixture {
               "void foo()\n"
               "{\n"
               "    str[3] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:8]: (error) Array 'str[3]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -4187,7 +4187,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    char *s; s = new char[10];\n"
               "    s[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 's[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // ticket #1670 - false negative when using return
@@ -4195,7 +4195,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    int *s; s = new int[10];\n"
               "    return s[10];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Array 's[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct Fred { char c[10]; };\n"
@@ -4203,12 +4203,12 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    Fred *f; f = new Fred;\n"
               "    return f->c[10];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:16]: (error) Array 'f->c[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("static const size_t MAX_SIZE = UNAVAILABLE_TO_CPPCHECK;\n"
               "struct Thing { char data[MAX_SIZE]; };\n"
-              "char f4(const Thing& t) { return !t.data[0]; }");
+              "char f4(const Thing& t) { return !t.data[0]; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -4218,7 +4218,7 @@ class TestBufferOverrun : public TestFixture {
               "  buf = new char[9];\n"
               "  buf[8] = 0;\n"
               "  delete [] buf;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -4228,7 +4228,7 @@ class TestBufferOverrun : public TestFixture {
               "  buf = new char[9];\n"
               "  buf[9] = 0;\n"
               "  delete [] buf;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:6]: (error) Array 'buf[9]' accessed at index 9, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void foo()\n"
@@ -4236,7 +4236,7 @@ class TestBufferOverrun : public TestFixture {
               "    enum E { Size = 10 };\n"
               "    char *s; s = new char[Size];\n"
               "    s[Size] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:6]: (error) Array 's[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void foo()\n"
@@ -4244,7 +4244,7 @@ class TestBufferOverrun : public TestFixture {
               "    enum E { ZERO };\n"
               "    E *e; e = new E[10];\n"
               "    e[10] = ZERO;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:6]: (error) Array 'e[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -4254,14 +4254,14 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    char *s; s = (char *)malloc(10);\n"
               "    s[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 's[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // ticket #842
         check("void f() {\n"
               "    int *tab4 = (int *)malloc(20 * sizeof(int));\n"
               "    tab4[20] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Array 'tab4[20]' accessed at index 20, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // ticket #1478
@@ -4270,7 +4270,7 @@ class TestBufferOverrun : public TestFixture {
               "    free(p);\n"
               "    p = (char *)malloc(10);\n"
               "    p[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:6]: (error) Array 'p[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // ticket #1134
@@ -4278,7 +4278,7 @@ class TestBufferOverrun : public TestFixture {
               "    int *x, i;\n"
               "    x = (int *)malloc(10 * sizeof(int));\n"
               "    x[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 'x[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
@@ -4288,7 +4288,7 @@ class TestBufferOverrun : public TestFixture {
               "  tab4 = malloc(21 * sizeof(int));\n"
               "  tab4[20] = 0;\n"
               "  free(tab4);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -4297,49 +4297,49 @@ class TestBufferOverrun : public TestFixture {
               "  tab4 = realloc(tab4,21 * sizeof(int));\n"
               "  tab4[20] = 0;\n"
               "  free(tab4);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    enum E { Size = 20 };\n"
               "    E *tab4 = (E *)malloc(Size * 4);\n"
               "    tab4[Size] = Size;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Array 'tab4[20]' accessed at index 20, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "    enum E { Size = 20 };\n"
               "    E *tab4 = (E *)malloc(4 * Size);\n"
               "    tab4[Size] = Size;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Array 'tab4[20]' accessed at index 20, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "    enum E { ZERO };\n"
               "    E *tab4 = (E *)malloc(20 * sizeof(E));\n"
               "    tab4[20] = ZERO;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Array 'tab4[20]' accessed at index 20, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n" // #8721
               "  unsigned char **cache = malloc(32);\n"
               "  cache[i] = malloc(65536);\n"
               "  cache[i][0xFFFF] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int **a = malloc(2 * sizeof(int*));\n"
               "  for (int i = 0; i < 3; i++)\n"
               "    a[i] = NULL;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "  int **a = new int*[2];\n"
               "  for (int i = 0; i < 3; i++)\n"
               "    a[i] = NULL;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f(const uint8_t* a) {\n" // 10421
@@ -4358,21 +4358,21 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    const char *s = \"123\";\n"
               "    s[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 's[4]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    char *s; s = \"\";\n"
               "    s[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 's[1]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void foo() {\n"
               "    const char *s = \"\";\n"
               "    s = y();\n"
               "    s[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n" // #7718
@@ -4380,7 +4380,7 @@ class TestBufferOverrun : public TestFixture {
               "    std::string s = \"123\";\n"
               "    s.resize(100);\n"
               "    s[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4390,7 +4390,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    char *s = (char *)alloca(10);\n"
               "    s[10] = 0;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 's[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", "", errout_str());
     }
     /*
@@ -4487,13 +4487,13 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "    char c[10];\n"
               "    mymemset(c, 0, 10);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char c[10];\n"
               "    mymemset(c, 0, 11);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:14]: (error) Buffer is accessed out of bounds: c [bufferAccessOutOfBounds]\n", errout_str());
 
         check("struct S {\n"
@@ -4502,13 +4502,13 @@ class TestBufferOverrun : public TestFixture {
               "void f() {\n"
               "    S s;\n"
               "    mymemset(s.a, 0, 10);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:6:15]: (error) Buffer is accessed out of bounds: s.a [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void foo() {\n"
               "    char s[10];\n"
               "    mymemset(s, 0, '*');\n"
-              "}", settings);
+              "}\n", settings);
         TODO_ASSERT_EQUALS("[test.cpp:3]: (warning) The size argument is given as a char constant.\n"
                            "[test.cpp:3:14]: (error) Buffer is accessed out of bounds: s [bufferAccessOutOfBounds]\n", "[test.cpp:3:14]: (error) Buffer is accessed out of bounds: s [bufferAccessOutOfBounds]\n", errout_str());
 
@@ -4516,65 +4516,65 @@ class TestBufferOverrun : public TestFixture {
         check("void f(void) {\n"
               "  char a[10];\n"
               "  mymemset(a+5, 0, 10);\n"
-              "}", settings);
+              "}\n", settings);
         TODO_ASSERT_EQUALS("[test.cpp:3:13]: (error) Buffer is accessed out of bounds: a [bufferAccessOutOfBounds]\n", "", errout_str());
 
         // Ticket #909
         check("void f(void) {\n"
               "    char str[] = \"abcd\";\n"
               "    mymemset(str, 0, 6);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:14]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f(void) {\n"
               "    char str[] = \"abcd\";\n"
               "    mymemset(str, 0, 5);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void f(void) {\n"
               "    wchar_t str[] = L\"abcd\";\n"
               "    mymemset(str, 0, 21);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:14]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f(void) {\n"
               "    wchar_t str[] = L\"abcd\";\n"
               "    mymemset(str, 0, 20);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         // ticket #1659 - overflowing variable when using memcpy
         check("void f(void) {\n"
               "  char c;\n"
               "  mymemset(&c, 0, 4);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Buffer is accessed out of bounds: &c [bufferAccessOutOfBounds]\n", errout_str());
 
         // ticket #2121 - buffer access out of bounds when using uint32_t
         check("void f(void) {\n"
               "    unknown_type_t buf[4];\n"
               "    mymemset(buf, 0, 100);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         // #3124 - multidimensional array
         check("int main() {\n"
               "    char b[5][6];\n"
               "    mymemset(b, 0, 5 * 6);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("int main() {\n"
               "    char b[5][6];\n"
               "    mymemset(b, 0, 6 * 6);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:14]: (error) Buffer is accessed out of bounds: b [bufferAccessOutOfBounds]\n", errout_str());
 
         check("int main() {\n"
               "    char b[5][6];\n"
               "    mymemset(b, 0, 31);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:14]: (error) Buffer is accessed out of bounds: b [bufferAccessOutOfBounds]\n", errout_str());
 
         // #4968 - not standard function
@@ -4583,26 +4583,26 @@ class TestBufferOverrun : public TestFixture {
               "    foo.mymemset(str, 0, 100);\n"
               "    foo::mymemset(str, 0, 100);\n"
               "    std::mymemset(str, 0, 100);\n"
-              "}", settings);
+              "}\n", settings);
         TODO_ASSERT_EQUALS("[test.cpp:5:15]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", "", errout_str());
 
         // #5257 - check strings
         check("void f() {\n"
               "  mymemset(\"abc\", 0, 20);\n"
-              "}", settings);
+              "}\n", settings);
         TODO_ASSERT_EQUALS("[test.cpp:2]: (error) Buffer is accessed out of bounds.\n",
                            "",
                            errout_str());
 
         check("void f() {\n"
               "  mymemset(temp, \"abc\", 4);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #6816 - fp when array has known string value
               "    char c[10] = \"c\";\n"
               "    mymemset(c, 0, 10);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4624,43 +4624,43 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "    char c[7];\n"
               "    mystrncpy(c, \"hello\", 7);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               " char c[6];\n"
               " mystrncpy(c,\"hello\",6);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               " char c[5];\n"
               " mystrncpy(c,\"hello\",6);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Buffer is accessed out of bounds: c [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "    char c[6];\n"
               "    mystrncpy(c,\"hello!\",7);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:15]: (error) Buffer is accessed out of bounds: c [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f(unsigned int addr) {\n"
               "    memset((void *)addr, 0, 1000);\n"
-              "}", settings0); // TODO: use settings?
+              "}\n", settings0); // TODO: use settings?
         ASSERT_EQUALS("", errout_str());
 
         check("struct AB { char a[10]; };\n"
               "void foo(AB *ab) {\n"
               "    mystrncpy(x, ab->a, 100);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void a(char *p) { mystrncpy(p,\"hello world!\",10); }\n" // #3168
               "void b() {\n"
               "    char buf[5];\n"
               "    a(buf);"
-              "}", settings);
+              "}\n", settings);
         TODO_ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:1]: (error) Buffer is accessed out of bounds: buf\n",
                            "",
                            errout_str());
@@ -4686,13 +4686,13 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "    char str[3];\n"
               "    mysprintf(str, \"test\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:15]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "    char str[5];\n"
               "    mysprintf(str, \"%s\", \"abcde\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:15]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("int getnumber();\n"
@@ -4700,51 +4700,51 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    char str[5];\n"
               "    mysprintf(str, \"%d: %s\", getnumber(), \"abcde\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:5:15]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "    char str[5];\n"
               "    mysprintf(str, \"test%s\", \"\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char *str = new char[5];\n"
               "    mysprintf(str, \"abcde\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:15]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f(int condition) {\n"
               "    char str[5];\n"
               "    mysprintf(str, \"test%s\", condition ? \"12\" : \"34\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int condition) {\n"
               "    char str[5];\n"
               "    mysprintf(str, \"test%s\", condition ? \"12\" : \"345\");\n"
-              "}", settings);
+              "}\n", settings);
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         check("struct Foo { char a[1]; };\n"
               "void f() {\n"
               "  struct Foo x;\n"
               "  mysprintf(x.a, \"aa\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:4:14]: (error) Buffer is accessed out of bounds: x.a [bufferAccessOutOfBounds]\n", errout_str());
 
         // ticket #900
         check("void f() {\n"
               "  char *a = new char(30);\n"
               "  mysprintf(a, \"a\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Buffer is accessed out of bounds: a [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f(char value) {\n"
               "  char *a = new char(value);\n"
               "  mysprintf(a, \"a\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Buffer is accessed out of bounds: a [bufferAccessOutOfBounds]\n", errout_str());
 
         // This is out of bounds if 'sizeof(ABC)' is 1 (No padding)
@@ -4752,21 +4752,21 @@ class TestBufferOverrun : public TestFixture {
               "void f() {\n"
               "  struct Foo *x = malloc(sizeof(Foo));\n"
               "  mysprintf(x->a, \"aa\");\n"
-              "}", settings);
+              "}\n", settings);
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error, inconclusive) Buffer is accessed out of bounds: x.a\n", "", errout_str());
 
         check("struct Foo { char a[1]; };\n"
               "void f() {\n"
               "  struct Foo *x = malloc(sizeof(Foo) + 10);\n"
               "  mysprintf(x->a, \"aa\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("struct Foo { char a[1]; };\n"
               "void f() {\n"
               "  struct Foo x;\n"
               "  mysprintf(x.a, \"aa\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:4:14]: (error) Buffer is accessed out of bounds: x.a [bufferAccessOutOfBounds]\n", errout_str());
 
         check("struct Foo {\n" // #6668 - unknown size
@@ -4775,7 +4775,7 @@ class TestBufferOverrun : public TestFixture {
               "};"
               "void Foo::f() {\n"
               "  mysprintf(a, \"abcd\");\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #901
@@ -4831,13 +4831,13 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "    char c[5];\n"
               "    myfread(c, 1, 5, stdin);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char c[5];\n"
               "    myfread(c, 1, 6, stdin);\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Buffer is accessed out of bounds: c [bufferAccessOutOfBounds]\n", errout_str());
     }
 
@@ -4847,7 +4847,7 @@ class TestBufferOverrun : public TestFixture {
         check("void f()\n"
               "{\n"
               " UnknownType *a = malloc(4);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
     // extracttests.disable
@@ -4859,26 +4859,26 @@ class TestBufferOverrun : public TestFixture {
               "    baz[99] = 0;\n"
               "    strncpy(baz, bar, 100);\n"
               "    baz[99] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo ( char *bar ) {\n"
               "    char baz[100];\n"
               "    strncpy(baz, bar, 100);\n"
               "    baz[99] = '\\0';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo ( char *bar ) {\n"
               "    char baz[100];\n"
               "    strncpy(baz, bar, 100);\n"
               "    baz[x+1] = '\\0';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Test with invalid code that there is no segfault
         check("char baz[100];\n"
-              "strncpy(baz, \"var\", 100)");
+              "strncpy(baz, \"var\", 100)\n");
         ASSERT_EQUALS("", errout_str());
 
         // Test that there are no duplicate error messages
@@ -4887,7 +4887,7 @@ class TestBufferOverrun : public TestFixture {
               "    strncpy(baz, bar, 100);\n"
               "    foo(baz);\n"
               "    foo(baz);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) The buffer 'baz' may not be null-terminated after the call to strncpy(). [terminateStrncpy]\n", errout_str());
     }
 
@@ -4897,7 +4897,7 @@ class TestBufferOverrun : public TestFixture {
               "    strncpy(baz, bar, 100);\n"
               "    bar[99] = 0;\n"
               "    return strdup(baz);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) The buffer 'baz' may not be null-terminated after the call to strncpy(). [terminateStrncpy]\n", errout_str());
     }
 
@@ -4920,13 +4920,13 @@ class TestBufferOverrun : public TestFixture {
         check("void bar() {\n"
               "    char buf[4];\n"
               "    strncpy(buf, \"ab\", 4);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void bar() {\n"
               "    char buf[4];\n"
               "    strncpy(buf, \"abcde\", 4);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) The buffer 'buf' may not be null-terminated after the call to strncpy(). [terminateStrncpy]\n", errout_str());
     }
 
@@ -4952,13 +4952,13 @@ class TestBufferOverrun : public TestFixture {
         check("void foo() {\n"
               "  char c[6];\n"
               "  strncpy(&c, \"hello!\", 6);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3]: (warning, inconclusive) The buffer 'c' may not be null-terminated after the call to strncpy(). [terminateStrncpy]\n", errout_str());
 
         check("void foo() {\n"
               "  char c[6];\n"
               "  strncpy(&c, \"hello\\0\", 6);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4986,7 +4986,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    char a[10];\n"
               "    f2(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5002,7 +5002,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    struct A *str;\n"
               "    str = malloc(4);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5014,12 +5014,12 @@ class TestBufferOverrun : public TestFixture {
               "void b() {\n"
               "    char arr[64];\n"
               "    a(arr);\n"
-              "}");
+              "}\n");
     }
 
     void crash3() {
         check("struct b { unknown v[0]; };\n"
-              "void d() { struct b *f; f = malloc(108); }");
+              "void d() { struct b *f; f = malloc(108); }\n");
     }
 
     void crash4() { // #8679
@@ -5027,13 +5027,13 @@ class TestBufferOverrun : public TestFixture {
               "int main() { "
               "  thread_local_var = malloc(1337); "
               "  return 0; "
-              "}");
+              "}\n");
 
         check("thread_local void *thread_local_var; "
               "int main() { "
               "  thread_local_var = malloc(1337); "
               "  return 0; "
-              "}");
+              "}\n");
     }
 
     void crash5() { // 8644 - token has varId() but variable() is null
@@ -5041,19 +5041,19 @@ class TestBufferOverrun : public TestFixture {
               "    void b(char **dst) {\n"
               "        *dst = malloc(50);\n"
               "    }\n"
-              "}");
+              "}\n");
     }
 
     void crash6() {
         check("void start(char* name) {\n"
               "char snapname[64] = { 0 };\n"
               "strncpy(snapname, \"snapshot\", arrayLength(snapname));\n"
-              "}");
+              "}\n");
     }
 
     void crash7() { // 9073 - [ has no astParent
         check("char x[10];\n"
-              "void f() { x[10]; }");
+              "void f() { x[10]; }\n");
     }
 
     void insecureCmdLineArgs() {
@@ -5067,7 +5067,7 @@ class TestBufferOverrun : public TestFixture {
               "        free(p);\n"
               "    }\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:7]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char *argv[])\n"
@@ -5080,112 +5080,112 @@ class TestBufferOverrun : public TestFixture {
               "        free(p);\n"
               "    }\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:7]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(const int argc, char* argv[])\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, const char* argv[])\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(const int argc, const char* argv[])\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char* argv[])\n"
               "{\n"
               "    char prog[10] = {'\\0'};\n"
               "    strcat(prog, argv[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **argv, char **envp)\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, const char *const *const argv, char **envp)\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(const int argc, const char *const *const argv, const char *const *const envp)\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **argv, char **envp)\n"
               "{\n"
               "    char prog[10] = {'\\0'};\n"
               "    strcat(prog, argv[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(const int argc, const char **argv, char **envp)\n"
               "{\n"
               "    char prog[10] = {'\\0'};\n"
               "    strcat(prog, argv[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, const char **argv, char **envp)\n"
               "{\n"
               "    char prog[10] = {'\\0'};\n"
               "    strcat(prog, argv[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(const int argc, char **argv, char **envp)\n"
               "{\n"
               "    char prog[10] = {'\\0'};\n"
               "    strcat(prog, argv[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **options)\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, options[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **options)\n"
               "{\n"
               "    char prog[10] = {'\\0'};\n"
               "    strcat(prog, options[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **options)\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, *options);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **options)\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog+3, *options);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **argv, char **envp)\n"
@@ -5193,7 +5193,7 @@ class TestBufferOverrun : public TestFixture {
               "    char prog[10];\n"
               "    if (strlen(argv[0]) < 10)\n"
               "        strcpy(prog, argv[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int main(int argc, char **argv, char **envp)\n"
@@ -5201,7 +5201,7 @@ class TestBufferOverrun : public TestFixture {
               "    char prog[10] = {'\\0'};\n"
               "    if (10 > strlen(argv[0]))\n"
               "        strcat(prog, argv[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int main(int argc, char **argv, char **envp)\n"
@@ -5209,7 +5209,7 @@ class TestBufferOverrun : public TestFixture {
               "    char prog[10];\n"
               "    argv[0][0] = '\\0';\n"
               "    strcpy(prog, argv[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5835
@@ -5217,18 +5217,18 @@ class TestBufferOverrun : public TestFixture {
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
               "    strcpy(prog, argv[0]);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Buffer overrun possible for long command line arguments.\n"
                            "[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         // #7964
         check("int main(int argc, char *argv[]) {\n"
               "  char *strcpy();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("int main(int argc, char *argv[]) {\n"
               "  char *strcat();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5236,33 +5236,33 @@ class TestBufferOverrun : public TestFixture {
         check("void f(char *a) {\n"
               "  char *b = new char[strlen(a)];\n"
               "  strcpy(b, a);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
 
         check("void f(char *a) {\n"
               "  char *b = new char[strlen(a) + 1];\n"
               "  strcpy(b, a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char *a) {\n"
               "  char *b = new char[strlen(a)];\n"
               "  a[0] = '\\0';\n"
               "  strcpy(b, a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char *a) {\n"
               "  char *b = (char *)malloc(strlen(a));\n"
               "  b = realloc(b, 10000);\n"
               "  strcpy(b, a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char *a) {\n"
               "  char *b = (char *)malloc(strlen(a));\n"
               "  strcpy(b, a);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
 
         check("void f(char *a) {\n"
@@ -5270,31 +5270,31 @@ class TestBufferOverrun : public TestFixture {
               "  {\n"
               "    strcpy(b, a);\n"
               "  }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
 
         check("void f(char *a) {\n"
               "  char *b = (char *)malloc(strlen(a) + 1);\n"
               "  strcpy(b, a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char *a, char *c) {\n"
               "  char *b = (char *)realloc(c, strlen(a));\n"
               "  strcpy(b, a);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
 
         check("void f(char *a, char *c) {\n"
               "  char *b = (char *)realloc(c, strlen(a) + 1);\n"
               "  strcpy(b, a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char *a) {\n"
               "  char *b = (char *)malloc(strlen(a));\n"
               "  strcpy(b, a);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
     }
 
@@ -5308,7 +5308,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    X x;\n"
               "    x.buf[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"
@@ -5320,7 +5320,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    A::X x;\n"
               "    x.buf[10] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:10]: (error) Array 'x.buf[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
@@ -5339,68 +5339,68 @@ class TestBufferOverrun : public TestFixture {
         check("void f(const char s[]) {\n"
               "    if (s[i] == 'x' && i < y) {\n"
               "    }"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // No message because i is unknown and thus gets no varid. Avoid an internalError here.
 
         check("void f(const char s[], int i) {\n"
               "    if (s[i] == 'x' && i < y) {\n"
               "    }"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) Array index 'i' is used before limits check. [arrayIndexThenCheck]\n", errout_str());
 
         check("void f(const char s[]) {\n"
               "    for (int i = 0; s[i] == 'x' && i < y; ++i) {\n"
               "    }"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (style) Array index 'i' is used before limits check. [arrayIndexThenCheck]\n", errout_str());
 
         check("void f(const int a[], unsigned i) {\n"
               "    if((a[i] < 2) && (i <= 42)) {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) Array index 'i' is used before limits check. [arrayIndexThenCheck]\n", errout_str());
 
         check("void f(const int a[], unsigned i) {\n"
               "    if((a[i] < 2) && (42 >= i)) {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) Array index 'i' is used before limits check. [arrayIndexThenCheck]\n", errout_str());
 
         // extracttests.start: int elen;
         check("void f(char* e, int y) {\n"
               "    if (e[y] == '/' && elen > y + 1 && e[y + 1] == '?') {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // extracttests.start: int foo(int); int func(int);
         check("void f(const int a[], unsigned i) {\n"
               "    if(a[i] < func(i) && i <= 42) {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Array index 'i' is used before limits check. [arrayIndexThenCheck]\n", errout_str());
 
         check("void f(const int a[], unsigned i) {\n"
               "    if (i <= 42 && a[i] < func(i)) {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const int a[], unsigned i) {\n"
               "    if (foo(a[i] + 3) < func(i) && i <= 42) {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (style) Array index 'i' is used before limits check. [arrayIndexThenCheck]\n", errout_str());
 
         check("void f(int i) {\n" // sizeof
               "  sizeof(a)/sizeof(a[i]) && i < 10;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // extracttests.start: extern int buf[];
         check("void f(int i) {\n" // ?:
               "  if ((i < 10 ? buf[i] : 1) && (i < 5 ? buf[i] : 5)){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5423,19 +5423,19 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "    char c[6];\n"
               "    strncpy(c,\"hello!\",6);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) The buffer 'c' may not be null-terminated after the call to strncpy(). [terminateStrncpy]\n", errout_str());
 
         check("void f() {\n"
               "    char c[6];\n"
               "    memcpy(c,\"hello!\",6);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) The buffer 'c' may not be null-terminated after the call to memcpy().\n", "", errout_str());
 
         check("void f() {\n"
               "    char c[6];\n"
               "    memmove(c,\"hello!\",6);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) The buffer 'c' may not be null-terminated after the call to memmove().\n", "", errout_str());
     }
 
@@ -5445,7 +5445,7 @@ class TestBufferOverrun : public TestFixture {
               "   int *a;\n"
               "   a = new int[-1];\n"
               "   delete [] a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:8]: (error) Memory allocation size is negative. [negativeMemoryAllocationSize]\n", errout_str());
 
         check("void f()\n"
@@ -5453,7 +5453,7 @@ class TestBufferOverrun : public TestFixture {
               "   int *a;\n"
               "   a = (int *)malloc( -10 );\n"
               "   free(a);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4:8]: (error) Memory allocation size is negative. [negativeMemoryAllocationSize]\n", "", errout_str());
 
         check("void f()\n"
@@ -5461,14 +5461,14 @@ class TestBufferOverrun : public TestFixture {
               "   int *a;\n"
               "   a = (int *)malloc( -10);\n"
               "   free(a);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4:8]: (error) Memory allocation size is negative. [negativeMemoryAllocationSize]\n", "", errout_str());
 
         check("void f()\n"
               "{\n"
               "   int *a;\n"
               "   a = (int *)alloca( -10 );\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4:8]: (error) Memory allocation size is negative. [negativeMemoryAllocationSize]\n", "", errout_str());
 
         check("int* f(int n) {\n" // #11145
@@ -5485,14 +5485,14 @@ class TestBufferOverrun : public TestFixture {
         check("void f(int sz) {\n" // #1760 - VLA
               "   int a[sz];\n"
               "}\n"
-              "void x() { f(-100); }");
+              "void x() { f(-100); }\n");
         ASSERT_EQUALS("[test.cpp:2:8]: (error) Declaration of array 'a' with negative size is undefined behaviour [negativeArraySize]\n", errout_str());
 
         // don't warn for constant sizes -> this is a compiler error so this is used for static assertions for instance
         check("int x, y;\n"
               "int a[-1];\n"
               "int b[x?1:-1];\n"
-              "int c[x?y:-1];");
+              "int c[x?y:-1];\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5500,7 +5500,7 @@ class TestBufferOverrun : public TestFixture {
         check("void f() {\n"
               "    char arr[10];\n"
               "    char *p = arr + 20;\n"
-              "}", settings0_p);
+              "}\n", settings0_p);
         ASSERT_EQUALS("[test.cpp:3:19]: (portability) Undefined behaviour, pointer arithmetic 'arr+20' is out of bounds. [pointerOutOfBounds]\n", errout_str());
 
         check("char(*g())[1];\n" // #7950
@@ -5540,7 +5540,7 @@ class TestBufferOverrun : public TestFixture {
             "int main() {\n"
             "  char *s = malloc(4);\n"
             "  dostuff(s);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:6:11] -> [test.cpp:7:10] -> [test.cpp:2:3]: (error) Array index out of bounds; buffer 'p' is accessed at offset -3. [ctuArrayIndex]\n", errout_str());
 
         ctu("void dostuff(char *p) {\n"
@@ -5550,7 +5550,7 @@ class TestBufferOverrun : public TestFixture {
             "int main() {\n"
             "  char *s = malloc(4);\n"
             "  dostuff(s);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:6:11] -> [test.cpp:7:10] -> [test.cpp:2:3]: (error) Array index out of bounds; 'p' buffer size is 4 and it is accessed at offset 4. [ctuArrayIndex]\n", errout_str());
 
         ctu("void f(int* p) {\n" // #10415
@@ -5582,7 +5582,7 @@ class TestBufferOverrun : public TestFixture {
             "int main() {\n"
             "  char str[4];\n"
             "  dostuff(str);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:6:10] -> [test.cpp:2:5]: (error) Array index out of bounds; 'p' buffer size is 4 and it is accessed at offset 10. [ctuArrayIndex]\n", errout_str());
 
         ctu("static void memclr( char *data )\n"
@@ -5594,7 +5594,7 @@ class TestBufferOverrun : public TestFixture {
             "{\n"
             "    char str[5];\n"
             "    memclr( str );\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:9:11] -> [test.cpp:3:5]: (error) Array index out of bounds; 'data' buffer size is 5 and it is accessed at offset 10. [ctuArrayIndex]\n", errout_str());
 
         ctu("static void memclr( int i, char *data )\n"
@@ -5606,7 +5606,7 @@ class TestBufferOverrun : public TestFixture {
             "{\n"
             "    char str[5];\n"
             "    memclr( 0, str );\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:9:11] -> [test.cpp:3:5]: (error) Array index out of bounds; 'data' buffer size is 5 and it is accessed at offset 10. [ctuArrayIndex]\n", errout_str());
 
         ctu("static void memclr( int i, char *data )\n"
@@ -5618,7 +5618,7 @@ class TestBufferOverrun : public TestFixture {
             "{\n"
             "    char str[5];\n"
             "    memclr( 10, str );\n"
-            "}");
+            "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:3]: (possible error) Array index out of bounds.\n",
                            "", errout_str());
 
@@ -5633,7 +5633,7 @@ class TestBufferOverrun : public TestFixture {
             "{\n"
             "    char str[5];\n"
             "    memclr( str, 5 );\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #2097
@@ -5647,7 +5647,7 @@ class TestBufferOverrun : public TestFixture {
             "{\n"
             "    int p[3];\n"
             "    foo(p+1);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9112
@@ -5660,7 +5660,7 @@ class TestBufferOverrun : public TestFixture {
             "{\n"
             "    u8 macstrbuf[17] = { 0 };\n"
             "    get_mac_address(macstrbuf);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9788
@@ -5717,7 +5717,7 @@ class TestBufferOverrun : public TestFixture {
             "int main() {\n"
             "  int x = 4;\n"
             "  dostuff(&x);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:6:10] -> [test.cpp:2:5]: (error) Array index out of bounds; 'p' buffer size is 4 and it is accessed at offset 40. [ctuArrayIndex]\n", errout_str());
     }
 
@@ -5726,7 +5726,7 @@ class TestBufferOverrun : public TestFixture {
             "int main() {\n"
             "  int x[3];\n"
             "  dostuff(x);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:4:10] -> [test.cpp:1:28]: (error) Pointer arithmetic overflow; 'p' buffer size is 12 [ctuPointerArith]\n", errout_str());
 
         ctu("void f(const char *p) {\n" // #11361
@@ -5745,7 +5745,7 @@ class TestBufferOverrun : public TestFixture {
             "void f() {\n"
             "    char a[10] = {};\n"
             "    g(a);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: error: Pointer arithmetic overflow; 'p' buffer size is 10 [ctuPointerArith]\n"
                       "[test.cpp:6:6]: note: Calling function g, 1st argument is accessed out of bounds\n"
                       "[test.cpp:2:12]: note: Using argument p\n",
@@ -5756,7 +5756,7 @@ class TestBufferOverrun : public TestFixture {
         check("int f() {\n"
               "    int i;\n"
               "    return (&i)[1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:13] -> [test.cpp:3:16]: (error) The address of variable 'i' is accessed at non-zero index. [objectIndex]\n",
             errout_str());
@@ -5764,7 +5764,7 @@ class TestBufferOverrun : public TestFixture {
         check("int f(int j) {\n"
               "    int i;\n"
               "    return (&i)[j];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:13] -> [test.cpp:3:16]: (warning) The address of variable 'i' might be accessed at non-zero index. [objectIndex]\n",
             errout_str());
@@ -5772,34 +5772,34 @@ class TestBufferOverrun : public TestFixture {
         check("int f() {\n"
               "    int i;\n"
               "    return (&i)[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int * i) {\n"
               "    return i[1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(std::vector<int> i) {\n"
               "    return i[1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(std::vector<int> i) {\n"
               "    return i.data()[1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int* f(std::vector<int>& i) {\n"
               "    return &(i[1]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { int i; int j; };\n"
               "int f() {\n"
               "    A x;\n"
               "    return (&x.i)[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { int i; int j; };\n"
@@ -5807,7 +5807,7 @@ class TestBufferOverrun : public TestFixture {
               "    A x;\n"
               "    int * i = &x.i;\n"
               "    return i[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -5815,7 +5815,7 @@ class TestBufferOverrun : public TestFixture {
               "  std::map<int, int*> m;\n"
               "  m[0] = &x;\n"
               "  m[1] = &x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
@@ -5823,7 +5823,7 @@ class TestBufferOverrun : public TestFixture {
               "  std::map<int, int*> m;\n"
               "  m[0] = &x;\n"
               "  return m[0][1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:10] -> [test.cpp:5:14]: (error) The address of variable 'x' is accessed at non-zero index. [objectIndex]\n",
             errout_str());
@@ -5833,7 +5833,7 @@ class TestBufferOverrun : public TestFixture {
               "  std::map<int, int*> m;\n"
               "  m[0] = &x;\n"
               "  return m[0][1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:10] -> [test.cpp:5:14]: (error) The address of variable 'x' is accessed at non-zero index. [objectIndex]\n",
             errout_str());
@@ -5844,7 +5844,7 @@ class TestBufferOverrun : public TestFixture {
               "  m[0] = &x;\n"
               "  m[1] = y;\n"
               "  return m[1][1];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void print(char** test);\n"
@@ -5914,7 +5914,7 @@ class TestBufferOverrun : public TestFixture {
               "void h() {\n"
               "    const uint8_t u = 4;\n"
               "    f(&u, N);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("uint32_t f(uint32_t u) {\n" // #10154
@@ -6008,7 +6008,7 @@ class TestBufferOverrun : public TestFixture {
               "if (pipe(pipefd) == -1) {\n"
               "    return;\n"
               "  }\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:10]: (error) Buffer is accessed out of bounds: pipefd [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f(){\n"
@@ -6016,7 +6016,7 @@ class TestBufferOverrun : public TestFixture {
               "if (pipe(pipefd) == -1) {\n"
               "    return;\n"
               "  }\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
 
         check("void f(){\n"
@@ -6024,7 +6024,7 @@ class TestBufferOverrun : public TestFixture {
               "if (pipe((int*)pipefd) == -1) {\n"
               "    return;\n"
               "  }\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("[test.cpp:3:10]: (error) Buffer is accessed out of bounds: (int*)pipefd [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f(){\n"
@@ -6032,7 +6032,7 @@ class TestBufferOverrun : public TestFixture {
               "if (pipe((int*)pipefd) == -1) {\n"
               "    return;\n"
               "  }\n"
-              "}", settings);
+              "}\n", settings);
         ASSERT_EQUALS("", errout_str());
     }
 };
diff --git a/test/testcharvar.cpp b/test/testcharvar.cpp
index 7d4a17489fc..0c9c8dd4b5b 100644
--- a/test/testcharvar.cpp
+++ b/test/testcharvar.cpp
@@ -57,7 +57,7 @@ class TestCharVar : public TestFixture {
               "{\n"
               "    unsigned char ch = 0x80;\n"
               "    buf[ch] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int buf[256];\n"
@@ -65,7 +65,7 @@ class TestCharVar : public TestFixture {
               "{\n"
               "    char ch = 0x80;\n"
               "    buf[ch] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (portability) 'char' type used as array index. [unknownSignCharArrayIndex]\n", errout_str());
 
         check("int buf[256];\n"
@@ -73,7 +73,7 @@ class TestCharVar : public TestFixture {
               "{\n"
               "    char ch = 0;\n"
               "    buf[ch] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int buf[256];\n"
@@ -81,7 +81,7 @@ class TestCharVar : public TestFixture {
               "{\n"
               "    signed char ch = 0;\n"
               "    buf[ch] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int buf[256];\n"
@@ -89,67 +89,67 @@ class TestCharVar : public TestFixture {
               "{\n"
               "    char ch = 0x80;\n"
               "    buf[ch] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (portability) 'char' type used as array index. [unknownSignCharArrayIndex]\n", errout_str());
 
         check("int buf[256];\n"
               "void foo(signed char ch)\n"
               "{\n"
               "    buf[ch] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int buf[256];\n"
               "void foo(char ch)\n"
               "{\n"
               "    buf[ch] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* buf)\n"
               "{\n"
               "    char ch = 0x80;"
               "    buf[ch] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:24]: (portability) 'char' type used as array index. [unknownSignCharArrayIndex]\n", errout_str());
 
         check("void foo(char* buf)\n"
               "{\n"
               "    char ch = 0;"
               "    buf[ch] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* buf)\n"
               "{\n"
               "    buf['A'] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* buf, char ch)\n"
               "{\n"
               "    buf[ch] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int flags[256];\n"
               "void foo(const char* str)\n"
               "{\n"
               "    flags[*str] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int flags[256];\n"
               "void foo(const char* str)\n"
               "{\n"
               "    flags[(unsigned char)*str] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(const char str[])\n"
               "{\n"
               "    map[str] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -159,7 +159,7 @@ class TestCharVar : public TestFixture {
               "void bar(int i) {\n"
               "    const char *s = \"abcde\";\n"
               "    foo(s[i]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -167,32 +167,32 @@ class TestCharVar : public TestFixture {
         check("void foo(int *result) {\n"
               "    signed char ch = -1;\n"
               "    *result = a | ch;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (warning) When using 'char' variables in bit operations, sign extension can generate unexpected results. [charBitOp]\n", errout_str());
 
         check("void foo(int *result) {\n"
               "    unsigned char ch = -1;\n"
               "    *result = a | ch;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char *result) {\n"
               "    signed char ch = -1;\n"
               "    *result = a | ch;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // 0x03 & ..
         check("void foo(int *result) {\n"
               "    signed char ch = -1;\n"
               "    *result = 0x03 | ch;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:20]: (warning) When using 'char' variables in bit operations, sign extension can generate unexpected results. [charBitOp]\n", errout_str());
 
         check("void foo(int *result) {\n"
               "    signed char ch = -1;\n"
               "    *result = 0x03 & ch;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 };
diff --git a/test/testclass.cpp b/test/testclass.cpp
index 457ab5932fe..451502c2164 100644
--- a/test/testclass.cpp
+++ b/test/testclass.cpp
@@ -282,25 +282,25 @@ class TestClass : public TestFixture {
                                    "{\n"
                                    "    A(const A& other) { }\n"
                                    "    A& operator=(const A& other) { return *this; }\n"
-                                   "};");
+                                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
 
         checkCopyCtorAndEqOperator("class A\n"
                                    "{\n"
-                                   "};");
+                                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyCtorAndEqOperator("class A\n"
                                    "{\n"
                                    "    A(const A& other) { }\n"
-                                   "};");
+                                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyCtorAndEqOperator("class A\n"
                                    "{\n"
                                    "    A& operator=(const A& other) { return *this; }\n"
-                                   "};");
+                                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -308,7 +308,7 @@ class TestClass : public TestFixture {
                                    "{\n"
                                    "    A(const A& other) { }\n"
                                    "    int x;\n"
-                                   "};");
+                                   "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:1]: (warning) The class 'A' has 'copy constructor' but lack of 'operator='.\n", "", errout_str());
         // TODO the error message should be clarified. It should say something like 'copy constructor is empty and will not assign i and therefore the behaviour is different to the default assignment operator'
 
@@ -316,7 +316,7 @@ class TestClass : public TestFixture {
                                    "{\n"
                                    "    A& operator=(const A& other) { return *this; }\n"
                                    "    int x;\n"
-                                   "};");
+                                   "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:1]: (warning) The class 'A' has 'operator=' but lack of 'copy constructor'.\n", "", errout_str());
         // TODO the error message should be clarified. It should say something like 'assignment operator does not assign i and therefore the behaviour is different to the default copy constructor'
 
@@ -324,7 +324,7 @@ class TestClass : public TestFixture {
                                    "{\n"
                                    "    A& operator=(const int &x) { this->x = x; return *this; }\n"
                                    "    int x;\n"
-                                   "};");
+                                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyCtorAndEqOperator("class A {\n"
@@ -344,7 +344,7 @@ class TestClass : public TestFixture {
                                    "    B(const B & b) :A(b) { }\n"
                                    "private:\n"
                                    "    static int i;\n"
-                                   "};");
+                                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7987 - Don't show warning when there is a move constructor
@@ -355,14 +355,14 @@ class TestClass : public TestFixture {
                                    "    test = std::move(s.test);\n"
                                    "    return *this;\n"
                                    "  }\n"
-                                   "};");
+                                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8337 - False positive in copy constructor detection
         checkCopyCtorAndEqOperator("struct StaticListNode {\n"
                                    "  StaticListNode(StaticListNode*& prev) : m_next(0) {}\n"
                                    "  StaticListNode* m_next;\n"
-                                   "};");
+                                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -386,7 +386,7 @@ class TestClass : public TestFixture {
                                   "    explicit Class(int i) { }\n"
                                   "    explicit Class(const std::string&) { }\n"
                                   "    Class(int a, int b) { }\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkExplicitConstructors("class Class {\n"
@@ -394,7 +394,7 @@ class TestClass : public TestFixture {
                                   "    explicit Class(const Class& other) { }\n"
                                   "    explicit Class(Class&& other) { }\n"
                                   "    virtual int i() = 0;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkExplicitConstructors("class Class {\n"
@@ -402,37 +402,37 @@ class TestClass : public TestFixture {
                                   "    Class(const Class& other) = delete;\n"
                                   "    Class(Class&& other) = delete;\n"
                                   "    virtual int i() = 0;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkExplicitConstructors("class Class {\n"
                                   "    Class(int i) { }\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (style) Class 'Class' has a constructor with 1 argument that is not explicit. [noExplicitConstructor]\n", errout_str());
 
         checkExplicitConstructors("class Class {\n"
                                   "    Class(const Class& other) { }\n"
                                   "    virtual int i() = 0;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkExplicitConstructors("class Class {\n"
                                   "    Class(Class&& other) { }\n"
                                   "    virtual int i() = 0;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6585
         checkExplicitConstructors("class Class {\n"
                                   "    private: Class(const Class&);\n"
                                   "    virtual int i() = 0;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkExplicitConstructors("class Class {\n"
                                   "    public: Class(const Class&);\n"
                                   "    virtual int i() = 0;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7465: Error properly reported in templates
@@ -443,7 +443,7 @@ class TestClass : public TestFixture {
                                   "int main() {\n"
                                   "  Test <int> test;\n"
                                   "  return 0;\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: (style) Struct 'Test < int >' has a constructor with 1 argument that is not explicit. [noExplicitConstructor]\n", errout_str());
 
         // #7465: No error for copy or move constructors
@@ -456,7 +456,7 @@ class TestClass : public TestFixture {
                                   "int main() {\n"
                                   "  Test <int> test;\n"
                                   "  return 0;\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8600
@@ -464,12 +464,12 @@ class TestClass : public TestFixture {
                                   "struct A::B {\n"
                                   "    B() = default;\n"
                                   "    B(const B&) {}\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkExplicitConstructors("struct A{"
-                                  "    A(int, int y=2) {}"
-                                  "};");
+                                  "    A(int, int y=2) {}\n"
+                                  "};\n");
         ASSERT_EQUALS("[test.cpp:1:14]: (style) Struct 'A' has a constructor with 1 argument that is not explicit. [noExplicitConstructor]\n", errout_str());
 
         checkExplicitConstructors("struct Foo {\n" // #10515
@@ -541,7 +541,7 @@ class TestClass : public TestFixture {
                                   "};\n"
                                   "struct Derived : Base {\n"
                                   "   int x;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkDuplInheritedMembers("class Base {\n"
@@ -550,7 +550,7 @@ class TestClass : public TestFixture {
                                   "};\n"
                                   "struct Derived : Base {\n"
                                   "   int x;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:6:8]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base'. [duplInheritedMember]\n", errout_str());
 
         checkDuplInheritedMembers("class Base {\n"
@@ -559,7 +559,7 @@ class TestClass : public TestFixture {
                                   "};\n"
                                   "struct Derived : public Base {\n"
                                   "   int x;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:6:8]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base'. [duplInheritedMember]\n", errout_str());
 
         checkDuplInheritedMembers("class Base0 {\n"
@@ -570,7 +570,7 @@ class TestClass : public TestFixture {
                                   "};\n"
                                   "struct Derived : Base0, Base1 {\n"
                                   "   int x;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkDuplInheritedMembers("class Base0 {\n"
@@ -582,7 +582,7 @@ class TestClass : public TestFixture {
                                   "};\n"
                                   "struct Derived : Base0, Base1 {\n"
                                   "   int x;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:9:8]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base0'. [duplInheritedMember]\n", errout_str());
 
         checkDuplInheritedMembers("class Base0 {\n"
@@ -595,7 +595,7 @@ class TestClass : public TestFixture {
                                   "};\n"
                                   "struct Derived : Base0, Base1 {\n"
                                   "   int x;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:10:8]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base0'. [duplInheritedMember]\n"
                       "[test.cpp:7:8] -> [test.cpp:10:8]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base1'. [duplInheritedMember]\n", errout_str());
 
@@ -604,7 +604,7 @@ class TestClass : public TestFixture {
                                   "};\n"
                                   "struct Derived : Base {\n"
                                   "   int y;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkDuplInheritedMembers("class A {\n"
@@ -612,20 +612,20 @@ class TestClass : public TestFixture {
                                   "};\n"
                                   "struct B {\n"
                                   "   int x;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // Unknown 'Base' class
         checkDuplInheritedMembers("class Derived : public UnknownBase {\n"
                                   "  int x;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkDuplInheritedMembers("class Base {\n"
                                   "   int x;\n"
                                   "};\n"
                                   "class Derived : public Base {\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6692
@@ -637,7 +637,7 @@ class TestClass : public TestFixture {
                                   "   struct SWibble : public test1::wibble {\n"
                                   "   int Value;\n"
                                   "   };\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9957
@@ -651,12 +651,12 @@ class TestClass : public TestFixture {
                                   "};\n"
                                   "class Derived2 : public Derived1 {\n"
                                   "    int i;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("[test.cpp:3:13] -> [test.cpp:10:9]: (warning) The class 'Derived2' defines member variable with name 'i' also defined in its parent class 'Base'. [duplInheritedMember]\n", errout_str());
 
         // don't crash on recursive template
         checkDuplInheritedMembers("template<size_t N>\n"
-                                  "struct BitInt : public BitInt<N+1> { };");
+                                  "struct BitInt : public BitInt<N+1> { };\n");
         ASSERT_EQUALS("", errout_str());
 
         // don't crash on recursive template
@@ -671,7 +671,7 @@ class TestClass : public TestFixture {
                                   "    template <typename T>\n"
                                   "    struct fn_traits<decltype(void(&T::operator())), T>\n"
                                   "        : public fn_traits<void, decltype(&T::operator())> {};\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #10594
@@ -776,7 +776,7 @@ class TestClass : public TestFixture {
                              "   }\n"
                              "   F&operator=(const F&);\n"
                              "   ~F();\n"
-                             "};");
+                             "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n", "", errout_str());
 
         checkCopyConstructor("class F {\n"
@@ -789,7 +789,7 @@ class TestClass : public TestFixture {
                              "   }\n"
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
-                             "};");
+                             "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:4:7]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory. [copyCtorPointerCopying]\n"
                            "[test.cpp:3] -> [test.cpp:7]: (warning) Copy constructor does not allocate memory for member 'p' although memory has been allocated in other constructors.\n",
                            "[test.cpp:4:7]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory. [copyCtorPointerCopying]\n"
@@ -809,7 +809,7 @@ class TestClass : public TestFixture {
                              "   }\n"
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
-                             "};");
+                             "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n"
                            "[test.cpp:5] -> [test.cpp:10]: (warning) Copy constructor does not allocate memory for member 'p' although memory has been allocated in other constructors.\n",
                            ""
@@ -839,7 +839,7 @@ class TestClass : public TestFixture {
                              "   }\n"
                              "   ~kalci();\n"
                              "   kalci& operator=(const kalci&kalci);\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class F\n"
@@ -864,7 +864,7 @@ class TestClass : public TestFixture {
                              "   }\n"
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
-                             "};");
+                             "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:14] -> [test.cpp:11]: (warning) Copy constructor does not allocate memory for member 'd' although memory has been allocated in other constructors.\n", "", errout_str());
 
         checkCopyConstructor("class F {\n"
@@ -878,7 +878,7 @@ class TestClass : public TestFixture {
                              "   }\n"
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class F {\n"
@@ -892,7 +892,7 @@ class TestClass : public TestFixture {
                              "   }\n"
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
-                             "};");
+                             "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:4]: (warning) Copy constructor does not allocate memory for member 'd' although memory has been allocated in other constructors.\n", "", errout_str());
 
         checkCopyConstructor("class F\n"
@@ -907,7 +907,7 @@ class TestClass : public TestFixture {
                              "   }\n"
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
-                             "};");
+                             "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:8]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource management.\n", "", errout_str());
 
         checkCopyConstructor("class F\n"
@@ -931,7 +931,7 @@ class TestClass : public TestFixture {
                              "   }\n"
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class F : E\n"
@@ -942,7 +942,7 @@ class TestClass : public TestFixture {
                              "   }\n"
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class E { E(E&); };\n" // non-copyable
@@ -954,7 +954,7 @@ class TestClass : public TestFixture {
                              "   }\n"
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class E {};\n"
@@ -965,7 +965,7 @@ class TestClass : public TestFixture {
                              "   }\n"
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:5:7]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource management. [noCopyConstructor]\n", errout_str());
 
         checkCopyConstructor("class F {\n"
@@ -976,7 +976,7 @@ class TestClass : public TestFixture {
                              "   F(F& f);\n"
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class F {\n"
@@ -984,7 +984,7 @@ class TestClass : public TestFixture {
                              "   F() : p(malloc(100)) {}\n"
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource management. [noCopyConstructor]\n", errout_str());
 
         // #7198
@@ -993,7 +993,7 @@ class TestClass : public TestFixture {
                              "   F() {\n"
                              "      p = malloc(100);\n"
                              "   }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1010,7 +1010,7 @@ class TestClass : public TestFixture {
                              "     ~Vector();\n"
                              "     Vector& operator=(const Vector&v);\n"
                              "    _Tp* _M_finish;\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1021,7 +1021,7 @@ class TestClass : public TestFixture {
                              "   F(const F &f) = delete;\n"
                              "   F&operator=(const F &f);\n"
                              "   ~F();\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("struct F {\n"
@@ -1030,7 +1030,7 @@ class TestClass : public TestFixture {
                              "   F(const F &f) = default;\n"
                              "   F&operator=(const F &f);\n"
                              "   ~F();\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (warning) Struct 'F' has dynamic memory/resource allocation(s). The copy constructor is explicitly defaulted but the default copy constructor does not work well. It is recommended to define or delete the copy constructor. [noCopyConstructor]\n", errout_str());
     }
 
@@ -1053,7 +1053,7 @@ class TestClass : public TestFixture {
                              "    ~Foo() { delete m_ptr; }\n"
                              "private:\n"
                              "    int* m_ptr;\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1066,7 +1066,7 @@ class TestClass : public TestFixture {
                              "    ~Foo() { delete m_ptr; }\n"
                              "private:\n"
                              "    int* m_ptr;\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class Copyable {};\n"
@@ -1077,7 +1077,7 @@ class TestClass : public TestFixture {
                              "    ~Foo() { delete m_ptr; }\n"
                              "private:\n"
                              "    int* m_ptr;\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1148,7 +1148,7 @@ class TestClass : public TestFixture {
                              "   F() { c = malloc(100); }\n"
                              "   F(const F &f);\n"
                              "   ~F();\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (warning) Struct 'F' does not have a operator= which is recommended since it has dynamic memory/resource management. [noOperatorEq]\n", errout_str());
 
         // defaulted operator=
@@ -1158,7 +1158,7 @@ class TestClass : public TestFixture {
                              "   F(const F &f);\n"
                              "   F &operator=(const F &f) = default;\n"
                              "   ~F();\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (warning) Struct 'F' has dynamic memory/resource allocation(s). The operator= is explicitly defaulted but the default operator= does not work well. It is recommended to define or delete the operator=. [noOperatorEq]\n", errout_str());
 
         // deleted operator=
@@ -1168,7 +1168,7 @@ class TestClass : public TestFixture {
                              "   F(const F &f);\n"
                              "   F &operator=(const F &f) = delete;\n"
                              "   ~F();\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // base class deletes operator=
@@ -1177,7 +1177,7 @@ class TestClass : public TestFixture {
                              "   F() { c = malloc(100); }\n"
                              "   F(const F &f);\n"
                              "   ~F();\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("struct S {\n"
@@ -1196,7 +1196,7 @@ class TestClass : public TestFixture {
                              "   F() { c = malloc(100); }\n"
                              "   F(const F &f);\n"
                              "   F&operator=(const F&);"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (warning) Struct 'F' does not have a destructor which is recommended since it has dynamic memory/resource management. [noDestructor]\n", errout_str());
 
         checkCopyConstructor("struct F {\n"
@@ -1204,7 +1204,7 @@ class TestClass : public TestFixture {
                              "   F() { c = new C; }\n"
                              "   F(const F &f);\n"
                              "   F&operator=(const F&);"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("struct F {\n"
@@ -1212,7 +1212,7 @@ class TestClass : public TestFixture {
                              "   F() { i = new int(); }\n"
                              "   F(const F &f);\n"
                              "   F& operator=(const F&);"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (warning) Struct 'F' does not have a destructor which is recommended since it has dynamic memory/resource management. [noDestructor]\n", errout_str());
 
         checkCopyConstructor("struct Data { int x; int y; };\n"
@@ -1221,7 +1221,7 @@ class TestClass : public TestFixture {
                              "   F() { c = new Data; }\n"
                              "   F(const F &f);\n"
                              "   F&operator=(const F&);"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (warning) Struct 'F' does not have a destructor which is recommended since it has dynamic memory/resource management. [noDestructor]\n", errout_str());
 
         // defaulted destructor
@@ -1231,7 +1231,7 @@ class TestClass : public TestFixture {
                              "   F(const F &f);\n"
                              "   F &operator=(const F &f);\n"
                              "   ~F() = default;\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (warning) Struct 'F' has dynamic memory/resource allocation(s). The destructor is explicitly defaulted but the default destructor does not work well. It is recommended to define the destructor. [noDestructor]\n", errout_str());
 
         // deleted destructor
@@ -1241,7 +1241,7 @@ class TestClass : public TestFixture {
                              "   F(const F &f);\n"
                              "   F &operator=(const F &f);\n"
                              "   ~F() = delete;\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1264,7 +1264,7 @@ class TestClass : public TestFixture {
             "{\n"
             "public:\n"
             "    A & operator=(const A &a) { return *this; }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1272,7 +1272,7 @@ class TestClass : public TestFixture {
             "{\n"
             "public:\n"
             "    A & operator=(const A &a) { return a; }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1281,7 +1281,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &);\n"
             "};\n"
-            "A & A::operator=(const A &a) { return *this; }");
+            "A & A::operator=(const A &a) { return *this; }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1290,7 +1290,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &a);\n"
             "};\n"
-            "A & A::operator=(const A &a) { return *this; }");
+            "A & A::operator=(const A &a) { return *this; }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1299,7 +1299,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &);\n"
             "};\n"
-            "A & A::operator=(const A &a) { return a; }");
+            "A & A::operator=(const A &a) { return a; }\n");
         ASSERT_EQUALS("[test.cpp:6:8]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1308,7 +1308,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &a);\n"
             "};\n"
-            "A & A::operator=(const A &a) { return a; }");
+            "A & A::operator=(const A &a) { return a; }\n");
         ASSERT_EQUALS("[test.cpp:6:8]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1320,7 +1320,7 @@ class TestClass : public TestFixture {
             "    public:\n"
             "        B & operator=(const B &b) { return *this; }\n"
             "    };\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1332,7 +1332,7 @@ class TestClass : public TestFixture {
             "    public:\n"
             "        B & operator=(const B &b) { return b; }\n"
             "    };\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:7:13]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1345,7 +1345,7 @@ class TestClass : public TestFixture {
             "        B & operator=(const B &);\n"
             "    };\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B &b) { return *this; }");
+            "A::B & A::B::operator=(const A::B &b) { return *this; }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1358,7 +1358,7 @@ class TestClass : public TestFixture {
             "        B & operator=(const B &);\n"
             "    };\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B &b) { return b; }");
+            "A::B & A::B::operator=(const A::B &b) { return b; }\n");
         ASSERT_EQUALS("[test.cpp:10:14]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1368,7 +1368,7 @@ class TestClass : public TestFixture {
             "class A::B\n"
             "{\n"
             "  B & operator=(const B & b) { return b; }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:6:7]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1379,7 +1379,7 @@ class TestClass : public TestFixture {
             "{\n"
             "  B & operator=(const B &);\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B & b) { return b; }");
+            "A::B & A::B::operator=(const A::B & b) { return b; }\n");
         ASSERT_EQUALS("[test.cpp:8:14]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1389,7 +1389,7 @@ class TestClass : public TestFixture {
             "class A::B\n"
             "{\n"
             "  A::B & operator=(const A::B & b) { return b; }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:6:10]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1400,7 +1400,7 @@ class TestClass : public TestFixture {
             "{\n"
             "  A::B & operator=(const A::B &);\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B & b) { return b; }");
+            "A::B & A::B::operator=(const A::B & b) { return b; }\n");
         ASSERT_EQUALS("[test.cpp:8:14]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1410,7 +1410,7 @@ class TestClass : public TestFixture {
             "class A::B\n"
             "{\n"
             "  B & operator=(const B & b) { return b; }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:6:7]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1421,7 +1421,7 @@ class TestClass : public TestFixture {
             "{\n"
             "  B & operator=(const B &);\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B & b) { return b; }");
+            "A::B & A::B::operator=(const A::B & b) { return b; }\n");
         ASSERT_EQUALS("[test.cpp:8:14]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1431,7 +1431,7 @@ class TestClass : public TestFixture {
             "class A::B\n"
             "{\n"
             "  A::B & operator=(const A::B & b) { return b; }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:6:10]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1442,7 +1442,7 @@ class TestClass : public TestFixture {
             "{\n"
             "  A::B & operator=(const A::B &);\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B & b) { return b; }");
+            "A::B & A::B::operator=(const A::B & b) { return b; }\n");
         ASSERT_EQUALS("[test.cpp:8:14]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis( // #11380
@@ -1462,7 +1462,7 @@ class TestClass : public TestFixture {
             "class szp\n"
             "{\n"
             "  szp &operator =(int *other) {}\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:3:8]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1470,7 +1470,7 @@ class TestClass : public TestFixture {
             "{\n"
             "  szp &operator =(int *other);\n"
             "};\n"
-            "szp &szp::operator =(int *other) {}");
+            "szp &szp::operator =(int *other) {}\n");
         ASSERT_EQUALS("[test.cpp:5:11]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1480,7 +1480,7 @@ class TestClass : public TestFixture {
             "class NS::szp\n"
             "{\n"
             "  szp &operator =(int *other) {}\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:6:8]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1491,7 +1491,7 @@ class TestClass : public TestFixture {
             "{\n"
             "  szp &operator =(int *other);\n"
             "};\n"
-            "NS::szp &NS::szp::operator =(int *other) {}");
+            "NS::szp &NS::szp::operator =(int *other) {}\n");
         ASSERT_EQUALS("[test.cpp:8:19]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1501,7 +1501,7 @@ class TestClass : public TestFixture {
             "class NS::szp\n"
             "{\n"
             "  NS::szp &operator =(int *other) {}\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:6:12]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1512,7 +1512,7 @@ class TestClass : public TestFixture {
             "{\n"
             "  NS::szp &operator =(int *other);\n"
             "};\n"
-            "NS::szp &NS::szp::operator =(int *other) {}");
+            "NS::szp &NS::szp::operator =(int *other) {}\n");
         ASSERT_EQUALS("[test.cpp:8:19]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1522,7 +1522,7 @@ class TestClass : public TestFixture {
             "class A::szp\n"
             "{\n"
             "  szp &operator =(int *other) {}\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:6:8]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1533,7 +1533,7 @@ class TestClass : public TestFixture {
             "{\n"
             "  szp &operator =(int *other);\n"
             "};\n"
-            "A::szp &A::szp::operator =(int *other) {}");
+            "A::szp &A::szp::operator =(int *other) {}\n");
         ASSERT_EQUALS("[test.cpp:8:17]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1543,7 +1543,7 @@ class TestClass : public TestFixture {
             "class A::szp\n"
             "{\n"
             "  A::szp &operator =(int *other) {}\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:6:11]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1554,7 +1554,7 @@ class TestClass : public TestFixture {
             "{\n"
             "  A::szp &operator =(int *other);\n"
             "};\n"
-            "A::szp &A::szp::operator =(int *other) {}");
+            "A::szp &A::szp::operator =(int *other) {}\n");
         ASSERT_EQUALS("[test.cpp:8:17]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
     }
 
@@ -1565,7 +1565,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "  inline A &operator =(int *other) { return (*this); };\n"
             "  inline A &operator =(long *other) { return (*this = 0); };\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1575,7 +1575,7 @@ class TestClass : public TestFixture {
             "  A &operator =(long *other);\n"
             "};\n"
             "A &A::operator =(int *other) { return (*this); };\n"
-            "A &A::operator =(long *other) { return (*this = 0); };");
+            "A &A::operator =(long *other) { return (*this = 0); };\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1583,7 +1583,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "  inline A &operator =(int *other) { return (*this); };\n"
             "  inline A &operator =(long *other) { return operator = (*(int *)other); };\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1593,7 +1593,7 @@ class TestClass : public TestFixture {
             "  A &operator =(long *other);\n"
             "};\n"
             "A &A::operator =(int *other) { return (*this); };\n"
-            "A &A::operator =(long *other) { return operator = (*(int *)other); };");
+            "A &A::operator =(long *other) { return operator = (*(int *)other); };\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1603,7 +1603,7 @@ class TestClass : public TestFixture {
             "  A &operator =(long *other);\n"
             "};\n"
             "A &A::operator =(int *other) { return (*this); };\n"
-            "A &A::operator =(long *other) { return this->operator = (*(int *)other); };");
+            "A &A::operator =(long *other) { return this->operator = (*(int *)other); };\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis( // #9045
@@ -1615,7 +1615,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "        return *this;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1625,7 +1625,7 @@ class TestClass : public TestFixture {
             "P& P::operator = (const P& pc)\n"
             "{\n"
             "  return (P&)(*this += pc);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1635,21 +1635,21 @@ class TestClass : public TestFixture {
             "class A {\n"
             "public:\n"
             "    A & operator=(const A &a) { }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
             "protected:\n"
             "    A & operator=(const A &a) {}\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
             "private:\n"
             "    A & operator=(const A &a) {}\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1659,7 +1659,7 @@ class TestClass : public TestFixture {
             "        rand();\n"
             "        throw std::exception();\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) 'operator=' should either return reference to 'this' instance or be declared private and left unimplemented. [operatorEqShouldBeLeftUnimplemented]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1669,7 +1669,7 @@ class TestClass : public TestFixture {
             "        rand();\n"
             "        abort();\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) 'operator=' should either return reference to 'this' instance or be declared private and left unimplemented. [operatorEqShouldBeLeftUnimplemented]\n", errout_str());
 
         checkOpertorEqRetRefThis(
@@ -1677,7 +1677,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &a);\n"
             "};\n"
-            "A & A :: operator=(const A &a) { }");
+            "A & A :: operator=(const A &a) { }\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
     }
 
@@ -1694,7 +1694,7 @@ class TestClass : public TestFixture {
             "}\n"
             "UString& UString::operator=( const UString& s ) {\n"
             "    return assign( s );\n"
-            "}");
+            "}\n");
     }
 
     void operatorEqRetRefThis7() { // ticket #5782 Endless recursion in CheckClass::checkReturnPtrThis()
@@ -1712,7 +1712,7 @@ class TestClass : public TestFixture {
             "  basic_fbstring& replace() {\n"
             "    return replaceImplDiscr();\n"
             "  }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1736,7 +1736,7 @@ class TestClass : public TestFixture {
             "{\n"
             "public:\n"
             "    A & operator=(const A &a) { if (&a != this) { } return *this; }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test doesn't have an assignment test but it is not needed
@@ -1745,7 +1745,7 @@ class TestClass : public TestFixture {
             "{\n"
             "public:\n"
             "    A & operator=(const A &a) { return *this; }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test and has it
@@ -1763,7 +1763,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "        return *this;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // this class needs an assignment test but doesn't have it
@@ -1778,7 +1778,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "        return *this;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:5:9]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         // this test has an assignment test but doesn't need it
@@ -1788,7 +1788,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &);\n"
             "};\n"
-            "A & A::operator=(const A &a) { if (&a != this) { } return *this; }");
+            "A & A::operator=(const A &a) { if (&a != this) { } return *this; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test doesn't have an assignment test but doesn't need it
@@ -1798,7 +1798,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &);\n"
             "};\n"
-            "A & A::operator=(const A &a) { return *this; }");
+            "A & A::operator=(const A &a) { return *this; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test and has it
@@ -1817,7 +1817,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test and has the inverse test
@@ -1836,7 +1836,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         // this test needs an assignment test and has the inverse test
@@ -1855,7 +1855,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         // this test needs an assignment test and has the inverse test
@@ -1874,7 +1874,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         // this test needs an assignment test and has the inverse test
@@ -1893,7 +1893,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         // this test needs an assignment test and has the inverse test
@@ -1912,7 +1912,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         // this test needs an assignment test and has the inverse test
@@ -1934,7 +1934,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         // this test needs an assignment test and has the inverse test
@@ -1955,7 +1955,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
 
@@ -1972,7 +1972,7 @@ class TestClass : public TestFixture {
             "    free(s);\n"
             "    s = strdup(a.s);\n"
             "    return *this;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         // ticket #1224
@@ -1990,7 +1990,7 @@ class TestClass : public TestFixture {
             "    tree = new CodeTree(b);\n"
             "    delete oldtree;\n"
             "    return *this;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
     }
@@ -2006,7 +2006,7 @@ class TestClass : public TestFixture {
             "    public:\n"
             "        B & operator=(const B &b) { if (&b != this) { } return *this; }\n"
             "    };\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test doesn't have an assignment test but doesn't need it
@@ -2019,7 +2019,7 @@ class TestClass : public TestFixture {
             "    public:\n"
             "        B & operator=(const B &b) { return *this; }\n"
             "    };\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test but has it
@@ -2039,7 +2039,7 @@ class TestClass : public TestFixture {
             "            return *this;\n"
             "        }\n"
             "    };\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test but doesn't have it
@@ -2058,7 +2058,7 @@ class TestClass : public TestFixture {
             "            return *this;\n"
             "        }\n"
             "    };\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:8:13]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         // this test has an assignment test but doesn't need it
@@ -2072,7 +2072,7 @@ class TestClass : public TestFixture {
             "        B & operator=(const B &);\n"
             "    };\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B &b) { if (&b != this) { } return *this; }");
+            "A::B & A::B::operator=(const A::B &b) { if (&b != this) { } return *this; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test doesn't have an assignment test but doesn't need it
@@ -2086,7 +2086,7 @@ class TestClass : public TestFixture {
             "        B & operator=(const B &);\n"
             "    };\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B &b) { return *this; }");
+            "A::B & A::B::operator=(const A::B &b) { return *this; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test and has it
@@ -2109,7 +2109,7 @@ class TestClass : public TestFixture {
             "        s = strdup(b.s);\n"
             "    }\n"
             "    return *this;\n"
-            " }");
+            " }\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test but doesn't have it
@@ -2129,7 +2129,7 @@ class TestClass : public TestFixture {
             "    free(s);\n"
             "    s = strdup(b.s);\n"
             "    return *this;\n"
-            " }");
+            " }\n");
         ASSERT_EQUALS("[test.cpp:11:14]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
     }
 
@@ -2140,7 +2140,7 @@ class TestClass : public TestFixture {
             "{\n"
             "public:\n"
             "    A & operator=(const A &a) { return *this; }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test has multiple inheritance and needs an assignment test but there is no trivial way to test for it
@@ -2155,7 +2155,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "        return *this;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test has multiple inheritance so there is no trivial way to test for self assignment but doesn't need it
@@ -2165,7 +2165,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &);\n"
             "};\n"
-            "A & A::operator=(const A &a) { return *this; }");
+            "A & A::operator=(const A &a) { return *this; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test has multiple inheritance and needs an assignment test but there is no trivial way to test for it
@@ -2181,7 +2181,7 @@ class TestClass : public TestFixture {
             "    free(s);\n"
             "    s = strdup(a.s);\n"
             "    return *this;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2196,7 +2196,7 @@ class TestClass : public TestFixture {
             "    public:\n"
             "        B & operator=(const B &b) { return *this; }\n"
             "    };\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test has multiple inheritance and needs an assignment test but there is no trivial way to test for it
@@ -2215,7 +2215,7 @@ class TestClass : public TestFixture {
             "            return *this;\n"
             "        }\n"
             "    };\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test has multiple inheritance so there is no trivial way to test for self assignment but doesn't need it
@@ -2229,7 +2229,7 @@ class TestClass : public TestFixture {
             "        B & operator=(const B &);\n"
             "    };\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B &b) { return *this; }");
+            "A::B & A::B::operator=(const A::B &b) { return *this; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // this test has multiple inheritance and needs an assignment test but there is no trivial way to test for it
@@ -2249,7 +2249,7 @@ class TestClass : public TestFixture {
             "    free(s);\n"
             "    s = strdup(b.s);\n"
             "    return *this;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2269,7 +2269,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "        return *this;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2286,7 +2286,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "        return *this;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2303,7 +2303,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "        return *this;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2320,7 +2320,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "        return *this;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2337,7 +2337,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "        return *this;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2354,7 +2354,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "        return *this;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2371,7 +2371,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "        return *this;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2388,7 +2388,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "        return *this;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2406,7 +2406,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2424,7 +2424,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2442,7 +2442,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2460,7 +2460,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2478,7 +2478,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2496,7 +2496,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2514,7 +2514,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2532,7 +2532,7 @@ class TestClass : public TestFixture {
             "        s = strdup(a.s);\n"
             "    }\n"
             "    return *this;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
@@ -2544,7 +2544,7 @@ class TestClass : public TestFixture {
             "    free(s);\n"
             "    s = strdup(a.s);\n"
             "    return *this;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2563,7 +2563,7 @@ class TestClass : public TestFixture {
             "    }\n"
             "private:\n"
             "    char * data;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         checkOpertorEqToSelf(
@@ -2580,7 +2580,7 @@ class TestClass : public TestFixture {
             "    data = new char[strlen(a.data) + 1];\n"
             "    strcpy(data, a.data);\n"
             "    return *this;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:8:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         checkOpertorEqToSelf(
@@ -2596,7 +2596,7 @@ class TestClass : public TestFixture {
             "    }\n"
             "private:\n"
             "    char * data;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         checkOpertorEqToSelf(
@@ -2613,7 +2613,7 @@ class TestClass : public TestFixture {
             "    data = new char;\n"
             "    *data = *a.data;\n"
             "    return *this;\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("[test.cpp:8:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
     }
 
@@ -2630,7 +2630,7 @@ class TestClass : public TestFixture {
             "    {\n"
             "        return assign(a);\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2649,7 +2649,7 @@ class TestClass : public TestFixture {
             "FMat& FMat::operator=(const FMat& in)\n"
             "{\n"
             "    return copy(in);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2668,7 +2668,7 @@ class TestClass : public TestFixture {
             "Foo& Foo::operator=(Foo& other)\n"
             "{\n"
             "    return Foo::operator=(&other);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2697,12 +2697,12 @@ class TestClass : public TestFixture {
 
         checkVirtualDestructor("class Derived : public Base { };\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("", errout_str());
 
         checkVirtualDestructor("class Derived : Base { };\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2710,27 +2710,27 @@ class TestClass : public TestFixture {
         // Base class doesn't have a destructor
 
         checkVirtualDestructor("class Base { };\n"
-                               "class Derived : public Base { public: ~Derived() { (void)11; } };"
+                               "class Derived : public Base { public: ~Derived() { (void)11; } };\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("[test.cpp:1:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base { };\n"
-                               "class Derived : protected Base { public: ~Derived() { (void)11; } };"
+                               "class Derived : protected Base { public: ~Derived() { (void)11; } };\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("[test.cpp:1:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base { };\n"
-                               "class Derived : private Base { public: ~Derived() { (void)11; } };"
+                               "class Derived : private Base { public: ~Derived() { (void)11; } };\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("", errout_str());
 
         checkVirtualDestructor("class Base { };\n"
-                               "class Derived : Base { public: ~Derived() { (void)11; } };"
+                               "class Derived : Base { public: ~Derived() { (void)11; } };\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9104
@@ -2751,7 +2751,7 @@ class TestClass : public TestFixture {
                                "{\n"
                                "    Base* p = new Derived();\n"
                                "    delete p;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("[test.cpp:7:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("using namespace std;\n"
@@ -2772,7 +2772,7 @@ class TestClass : public TestFixture {
                                "{\n"
                                "    Base* p = new Derived();\n"
                                "    delete p;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("[test.cpp:8:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
     }
 
@@ -2780,21 +2780,21 @@ class TestClass : public TestFixture {
         // Base class has a destructor, but it's not virtual
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
-                               "class Derived : public Base { public: ~Derived() { (void)11; } };"
+                               "class Derived : public Base { public: ~Derived() { (void)11; } };\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
-                               "class Derived : protected Base { public: ~Derived() { (void)11; } };"
+                               "class Derived : protected Base { public: ~Derived() { (void)11; } };\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
-                               "class Derived : private Fred, public Base { public: ~Derived() { (void)11; } };"
+                               "class Derived : private Fred, public Base { public: ~Derived() { (void)11; } };\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
     }
 
@@ -2802,15 +2802,15 @@ class TestClass : public TestFixture {
         // Derived class doesn't have a destructor => undefined behaviour according to paragraph 3 in [expr.delete]
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
-                               "class Derived : public Base { };"
+                               "class Derived : public Base { };\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
-                               "class Derived : private Fred, public Base { };"
+                               "class Derived : private Fred, public Base { };\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
     }
 
@@ -2818,15 +2818,15 @@ class TestClass : public TestFixture {
         // Derived class has empty destructor => undefined behaviour according to paragraph 3 in [expr.delete]
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
-                               "class Derived : public Base { public: ~Derived() {} };"
+                               "class Derived : public Base { public: ~Derived() {} };\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
-                               "class Derived : public Base { public: ~Derived(); }; Derived::~Derived() {}"
+                               "class Derived : public Base { public: ~Derived(); }; Derived::~Derived() {}\n"
                                "Base *base = new Derived;\n"
-                               "delete base;");
+                               "delete base;\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
     }
 
@@ -2835,7 +2835,7 @@ class TestClass : public TestFixture {
         // points at derived class
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
-                               "class Derived : public Base { public: ~Derived() { (void)11; } };");
+                               "class Derived : public Base { public: ~Derived() { (void)11; } };\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2852,7 +2852,7 @@ class TestClass : public TestFixture {
                                "{\n"
                                "public:\n"
                                "    ~B() { int a; }\n"
-                               "};");
+                               "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2873,7 +2873,7 @@ class TestClass : public TestFixture {
                                "{\n"
                                "public:\n"
                                "    ~B() { int a; }\n"
-                               "};");
+                               "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // class A inherits virtual destructor from struct Base -> no error
@@ -2891,7 +2891,7 @@ class TestClass : public TestFixture {
                                "{\n"
                                "public:\n"
                                "    ~B() { int a; }\n"
-                               "};");
+                               "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // Unknown Base class -> it could have virtual destructor, so ignore
@@ -2905,7 +2905,7 @@ class TestClass : public TestFixture {
                                "{\n"
                                "public:\n"
                                "    ~B() { int a; }\n"
-                               "};");
+                               "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // Virtual destructor is inherited -> no error
@@ -2926,7 +2926,7 @@ class TestClass : public TestFixture {
                                "{\n"
                                "public:\n"
                                "    ~B() { int a; }\n"
-                               "};");
+                               "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // class A doesn't inherit virtual destructor from class Base -> error
@@ -2945,7 +2945,7 @@ class TestClass : public TestFixture {
                                "{\n"
                                "public:\n"
                                "    ~B() { int a; }\n"
-                               "};");
+                               "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:7]: (error) Class 'Base' which is inherited by class 'B' does not have a virtual destructor.\n",
                            "", errout_str());
     }
@@ -2967,7 +2967,7 @@ class TestClass : public TestFixture {
                                " ~B(){int a;}\n"
                                "};\n"
                                "\n"
-                               "AA<double> *p = new B; delete p;");
+                               "AA<double> *p = new B; delete p;\n");
         ASSERT_EQUALS("[test.cpp:9:3]: (error) Class 'AA < double >' which is inherited by class 'B' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
     }
 
@@ -3037,7 +3037,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(Fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class Fred\n"
@@ -3048,7 +3048,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(Fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class Fred\n"
@@ -3059,7 +3059,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(Fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class Fred\n"
@@ -3070,7 +3070,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(Fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:8:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred\n"
@@ -3081,7 +3081,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(Fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:8:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred {\n"
@@ -3090,7 +3090,7 @@ class TestClass : public TestFixture {
                       "};\n"
                       "void Fred::f() {\n"
                       "    memset(this, 0, sizeof(*this));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred\n"
@@ -3100,7 +3100,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class Fred\n"
@@ -3111,7 +3111,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:8:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred\n"
@@ -3123,7 +3123,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    Pebbles pebbles;\n"
                       "    memset(&pebbles, 0, sizeof(pebbles));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:9:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred\n"
@@ -3134,7 +3134,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:8:5]: (error) Using 'memset' on class that contains a virtual function. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred\n"
@@ -3145,7 +3145,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    static Fred fred;\n"
                       "    memset(&fred, 0, sizeof(fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:8:5]: (error) Using 'memset' on class that contains a virtual function. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred\n"
@@ -3160,7 +3160,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    Pebbles pebbles;\n"
                       "    memset(&pebbles, 0, sizeof(pebbles));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:12:5]: (error) Using 'memset' on class that contains a virtual function. [memsetClass]\n", errout_str());
 
         // Fred not defined in scope
@@ -3174,7 +3174,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(Fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Fred with namespace qualifier
@@ -3188,7 +3188,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    n1::Fred fred;\n"
                       "    memset(&fred, 0, sizeof(n1::Fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:10:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         // Fred with namespace qualifier
@@ -3202,7 +3202,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    n1::Fred fred;\n"
                       "    memset(&fred, 0, sizeof(fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:10:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class A {\n"
@@ -3213,7 +3213,7 @@ class TestClass : public TestFixture {
                       "  const int N = 10;\n"
                       "  A** arr = new A*[N];\n"
                       "  memset(arr, 0, N * sizeof(A*));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class A {\n" // #5116 - nested class data is mixed in the SymbolDatabase
@@ -3222,7 +3222,7 @@ class TestClass : public TestFixture {
                       "};\n"
                       "void f(A::B *b) {\n"
                       "  memset(b,0,4);\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4461 Warn about memset/memcpy on class with references as members
@@ -3232,7 +3232,7 @@ class TestClass : public TestFixture {
                       "void f() {\n"
                       "  A a;\n"
                       "  memset(&a, 0, sizeof(a));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:6:3]: (error) Using 'memset' on class that contains a reference. [memsetClassReference]\n", errout_str());
         checkNoMemset("class A {\n"
                       "  const B&b;\n"
@@ -3240,7 +3240,7 @@ class TestClass : public TestFixture {
                       "void f() {\n"
                       "  A a;\n"
                       "  memset(&a, 0, sizeof(a));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:6:3]: (error) Using 'memset' on class that contains a reference. [memsetClassReference]\n", errout_str());
 
         // #7456
@@ -3254,7 +3254,7 @@ class TestClass : public TestFixture {
                       "void func() {\n"
                       "  B b[4];\n"
                       "  memset(b, 0, sizeof(b));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8619
@@ -3309,11 +3309,11 @@ class TestClass : public TestFixture {
                       "      } vid;\n"
                       "    };\n"
                       "  } hdr;\n"
-                      "};"
+                      "};\n"
                       "void parseHeader() {\n"
                       "  ASFStreamHeader strhdr;\n"
                       "  memset(&strhdr, 0, sizeof(strhdr));\n"
-                      "}");
+                      "}\n");
     }
 
     void memsetOnStruct() {
@@ -3324,7 +3324,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("struct A\n"
@@ -3334,7 +3334,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    struct A a;\n"
                       "    memset(&a, 0, sizeof(struct A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("struct A\n"
@@ -3344,14 +3344,14 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    struct A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("void f()\n"
                       "{\n"
                       "    struct sockaddr_in6 fail;\n"
                       "    memset(&fail, 0, sizeof(struct sockaddr_in6));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("struct A\n"
@@ -3364,7 +3364,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       " struct A fail;\n"
                       " memset(&fail, 0, sizeof(struct A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:10:2]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct Fred\n"
@@ -3375,7 +3375,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(fred));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:8:5]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct Stringy {\n"
@@ -3387,7 +3387,7 @@ class TestClass : public TestFixture {
                       "int main() {\n"
                       "    Foo foo;\n"
                       "    memset(&foo, 0, sizeof(Foo));\n"
-                      "}");
+                      "}\n");
 
         ASSERT_EQUALS("[test.cpp:9:5]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n", errout_str());
     }
@@ -3400,7 +3400,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on class that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A\n"
@@ -3410,7 +3410,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A\n"
@@ -3420,7 +3420,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(struct A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A\n"
@@ -3430,7 +3430,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(a));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class A\n"
@@ -3440,7 +3440,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on class that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A\n"
@@ -3450,7 +3450,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A\n"
@@ -3460,7 +3460,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(a));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A\n"
@@ -3470,7 +3470,7 @@ class TestClass : public TestFixture {
                       "{\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A {\n"
@@ -3480,7 +3480,7 @@ class TestClass : public TestFixture {
                       "void f() {\n"
                       "    A a;\n"
                       "    memset(a, 0, 100);\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str()); // #4460
 
         checkNoMemset("struct C {\n"
@@ -3498,7 +3498,7 @@ class TestClass : public TestFixture {
                       "    memset(*c4, 0, 10);\n"
                       "    memset(c2, 0, 10);\n"
                       "    memset(c3, 0, 10);\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:9:5]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n"
                       "[test.cpp:11:5]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n"
                       "[test.cpp:12:5]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n"
@@ -3514,7 +3514,7 @@ class TestClass : public TestFixture {
                       "  multilevel_data *d = (multilevel_data *) malloc(sizeof(multilevel_data));\n"
                       "  memset(d, 0, sizeof(multilevel_data));\n"
                       "  return (void*) d;\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:8:3]: (portability) Using memset() on struct which contains a floating point number. [memsetClassFloat]\n", errout_str());
     }
 
@@ -3532,7 +3532,7 @@ class TestClass : public TestFixture {
                       "void f() {\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str()); // std::array is POD (#5481)
 
         checkNoMemset("struct st {\n"
@@ -3543,7 +3543,7 @@ class TestClass : public TestFixture {
                       "void f() {\n"
                       "  st s;\n"
                       "  std::memset(&s, 0, sizeof(st));\n"
-                      "}", settings);
+                      "}\n", settings);
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3554,7 +3554,7 @@ class TestClass : public TestFixture {
                       "void f() {\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (portability) Using memset() on struct which contains a floating point number. [memsetClassFloat]\n", errout_str());
 
         checkNoMemset("struct A {\n"
@@ -3563,7 +3563,7 @@ class TestClass : public TestFixture {
                       "void f() {\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (portability) Using memset() on struct which contains a floating point number. [memsetClassFloat]\n", errout_str());
 
         checkNoMemset("struct A {\n"
@@ -3572,7 +3572,7 @@ class TestClass : public TestFixture {
                       "void f(const A& b) {\n"
                       "    A a;\n"
                       "    memcpy(&a, &b, sizeof(A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("struct A {\n"
@@ -3581,7 +3581,7 @@ class TestClass : public TestFixture {
                       "void f() {\n"
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3589,7 +3589,7 @@ class TestClass : public TestFixture {
         checkNoMemset("void clang_tokenize(CXToken **Tokens) {\n"
                       "  *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size());\n"
                       "  memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size());\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3597,49 +3597,49 @@ class TestClass : public TestFixture {
         checkNoMemset("class C { C() {} };\n"
                       "void foo(C*& p) {\n"
                       "    p = malloc(sizeof(C));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:1:1]: (warning) Memory for class instance allocated with malloc(), but class provides constructors. [mallocOnClassWarning]\n", errout_str());
 
         checkNoMemset("class C { C(int z, Foo bar) { bar(); } };\n"
                       "void foo(C*& p) {\n"
                       "    p = malloc(sizeof(C));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:1:1]: (warning) Memory for class instance allocated with malloc(), but class provides constructors. [mallocOnClassWarning]\n", errout_str());
 
         checkNoMemset("struct C { C() {} };\n"
                       "void foo(C*& p) {\n"
                       "    p = realloc(p, sizeof(C));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:1:1]: (warning) Memory for class instance allocated with realloc(), but class provides constructors. [mallocOnClassWarning]\n", errout_str());
 
         checkNoMemset("struct C { virtual void bar(); };\n"
                       "void foo(C*& p) {\n"
                       "    p = malloc(sizeof(C));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:1:1]: (error) Memory for class instance allocated with malloc(), but class contains a virtual function. [mallocOnClassError]\n", errout_str());
 
         checkNoMemset("struct C { std::string s; };\n"
                       "void foo(C*& p) {\n"
                       "    p = malloc(sizeof(C));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:1:1]: (error) Memory for class instance allocated with malloc(), but class contains a 'std::string'. [mallocOnClassError]\n", errout_str());
 
         checkNoMemset("class C { };\n" // C-Style class/struct
                       "void foo(C*& p) {\n"
                       "    p = malloc(sizeof(C));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("struct C { C() {} };\n"
                       "void foo(C*& p) {\n"
                       "    p = new C();\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class C { C() {} };\n"
                       "void foo(D*& p) {\n" // Unknown type
                       "    p = malloc(sizeof(C));\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class AutoCloseFD {\n"
@@ -3650,7 +3650,7 @@ class TestClass : public TestFixture {
                       "};\n"
                       "void f() {\n"
                       "    AutoCloseFD fd = open(\"abc\", O_RDONLY | O_CLOEXEC);\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("struct C {\n" // #12313
@@ -3659,7 +3659,7 @@ class TestClass : public TestFixture {
                       "};\n"
                       "void f() {\n"
                       "    C c = strdup(\"abc\");\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3676,19 +3676,19 @@ class TestClass : public TestFixture {
     }
 
     void this_subtraction() {
-        checkThisSubtraction("; this-x ;");
+        checkThisSubtraction("; this-x ;\n");
         ASSERT_EQUALS("[test.cpp:1:3]: (warning) Suspicious pointer subtraction. Did you intend to write '->'? [thisSubtraction]\n", errout_str());
 
-        checkThisSubtraction("; *this = *this-x ;");
+        checkThisSubtraction("; *this = *this-x ;\n");
         ASSERT_EQUALS("", errout_str());
 
         checkThisSubtraction("; *this = *this-x ;\n"
-                             "this-x ;");
+                             "this-x ;\n");
         ASSERT_EQUALS("[test.cpp:2:1]: (warning) Suspicious pointer subtraction. Did you intend to write '->'? [thisSubtraction]\n", errout_str());
 
         checkThisSubtraction("; *this = *this-x ;\n"
                              "this-x ;\n"
-                             "this-x ;");
+                             "this-x ;\n");
         ASSERT_EQUALS("[test.cpp:2:1]: (warning) Suspicious pointer subtraction. Did you intend to write '->'? [thisSubtraction]\n"
                       "[test.cpp:3:1]: (warning) Suspicious pointer subtraction. Did you intend to write '->'? [thisSubtraction]\n", errout_str());
     }
@@ -3719,18 +3719,18 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    int getA() { return a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style, inconclusive) Technically the member function 'Fred::getA' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "    const std::string foo() { return \"\"; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:2:23]: (style) The member function 'Fred::foo' can be static. [functionStatic]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    const std::string & foo() { return \"\"; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:25]: (style) The member function 'Fred::foo' can be static. [functionStatic]\n", errout_str());
 
         // constructors can't be const..
@@ -3738,14 +3738,14 @@ class TestClass : public TestFixture {
                    "    int a;\n"
                    "public:\n"
                    "    Fred() { }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment through |=..
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    int setA() { a |= true; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // functions with a call to a member function can only be const, if that member function is const, too.. (#1305)
@@ -3754,7 +3754,7 @@ class TestClass : public TestFixture {
                    "    int x;\n"
                    "    void a() { x = 1; }\n"
                    "    void b() { a(); }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
@@ -3762,14 +3762,14 @@ class TestClass : public TestFixture {
                    "    int x;\n"
                    "    int a() const { return x; }\n"
                    "    void b() { a(); }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (style, inconclusive) Technically the member function 'Fred::b' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "public:\n"
                    "    int x;\n"
                    "    void b() { a(); }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (style) The member function 'Fred::b' can be static. [functionStatic]\n", errout_str());
 
         // static functions can't be const..
@@ -3778,12 +3778,12 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    static unsigned get()\n"
                    "    { return 0; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    const std::string foo() const throw() { return \"\"; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:2:23]: (style) The member function 'Fred::foo' can be static. [functionStatic]\n", errout_str());
     }
 
@@ -3793,49 +3793,49 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo() { s = \"\"; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument reference can be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string & a) { a = s; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string & a) { s = a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument references can be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string & a, std::string & b) { a = s; b = s; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string & a, std::string & b) { s = a; s = b; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string & a, std::string & b) { s = a; b = a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string & a, std::string & b) { a = s; s = b; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3844,42 +3844,42 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    int s;\n"
                    "    void foo(int * a) { *a = s; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    int s;\n"
                    "    void foo(int * a) { s = *a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument pointers can be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string * a, std::string * b) { *a = s; *b = s; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string * a, std::string * b) { s = *a; s = *b; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string * a, std::string * b) { s = *a; *b = s; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string * a, std::string * b) { *a = s; s = b; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3888,14 +3888,14 @@ class TestClass : public TestFixture {
                    "    int a;\n"
                    "    int getA();\n"
                    "};\n"
-                   "int Fred::getA() { return a; }");
+                   "int Fred::getA() { return a; }\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:5:11]: (style, inconclusive) Technically the member function 'Fred::getA' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    const std::string & foo();\n"
                    "};\n"
-                   "const std::string & Fred::foo() { return \"\"; }");
+                   "const std::string & Fred::foo() { return \"\"; }\n");
         ASSERT_EQUALS("[test.cpp:3:25] -> [test.cpp:5:27]: (style) The member function 'Fred::foo' can be static. [functionStatic]\n", errout_str());
 
         // functions with a function call to a non-const member can't be const.. (#1305)
@@ -3906,7 +3906,7 @@ class TestClass : public TestFixture {
                    "    void a() { x = 1; }\n"
                    "    void b();\n"
                    "};\n"
-                   "void Fred::b() { a(); }");
+                   "void Fred::b() { a(); }\n");
         ASSERT_EQUALS("", errout_str());
 
         // static functions can't be const..
@@ -3915,7 +3915,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    static unsigned get();\n"
                    "};\n"
-                   "static unsigned Fred::get() { return 0; }");
+                   "static unsigned Fred::get() { return 0; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to variable can't be const
@@ -3923,7 +3923,7 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "    void foo();\n"
                    "};\n"
-                   "void Fred::foo() { s = \"\"; }");
+                   "void Fred::foo() { s = \"\"; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument reference can be const
@@ -3931,7 +3931,7 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "    void foo(std::string & a);\n"
                    "};\n"
-                   "void Fred::foo(std::string & a) { a = s; }");
+                   "void Fred::foo(std::string & a) { a = s; }\n");
         ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:5:12]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable can't be const
@@ -3939,7 +3939,7 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "    void foo(std::string & a);\n"
                    "};\n"
-                   "void Fred::foo(std::string & a) { s = a; }");
+                   "void Fred::foo(std::string & a) { s = a; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument references can be const
@@ -3947,7 +3947,7 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "    void foo(std::string & a, std::string & b);\n"
                    "};\n"
-                   "void Fred::foo(std::string & a, std::string & b) { a = s; b = s; }");
+                   "void Fred::foo(std::string & a, std::string & b) { a = s; b = s; }\n");
         ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:5:12]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable, can't be const
@@ -3955,7 +3955,7 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "    void foo(std::string & a, std::string & b);\n"
                    "};\n"
-                   "void Fred::foo(std::string & a, std::string & b) { s = a; s = b; }");
+                   "void Fred::foo(std::string & a, std::string & b) { s = a; s = b; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
@@ -3963,7 +3963,7 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "    void foo(std::string & a, std::string & b);\n"
                    "};\n"
-                   "void Fred::foo(std::string & a, std::string & b) { s = a; b = a; }");
+                   "void Fred::foo(std::string & a, std::string & b) { s = a; b = a; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
@@ -3971,7 +3971,7 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "    void foo(std::string & a, std::string & b);\n"
                    "};\n"
-                   "void Fred::foo(std::string & a, std::string & b) { a = s; s = b; }");
+                   "void Fred::foo(std::string & a, std::string & b) { a = s; s = b; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument pointer can be const
@@ -3979,7 +3979,7 @@ class TestClass : public TestFixture {
                    "    int s;\n"
                    "    void foo(int * a);\n"
                    "};\n"
-                   "void Fred::foo(int * a) { *a = s; }");
+                   "void Fred::foo(int * a) { *a = s; }\n");
         ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:5:12]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable, can't be const
@@ -3987,7 +3987,7 @@ class TestClass : public TestFixture {
                    "    int s;\n"
                    "    void foo(int * a);\n"
                    "};\n"
-                   "void Fred::foo(int * a) { s = *a; }");
+                   "void Fred::foo(int * a) { s = *a; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument pointers can be const
@@ -3995,7 +3995,7 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "    void foo(std::string * a, std::string * b);\n"
                    "};\n"
-                   "void Fred::foo(std::string * a, std::string * b) { *a = s; *b = s; }");
+                   "void Fred::foo(std::string * a, std::string * b) { *a = s; *b = s; }\n");
         ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:5:12]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable, can't be const
@@ -4003,7 +4003,7 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "    void foo(std::string * a, std::string * b);\n"
                    "};\n"
-                   "void Fred::foo(std::string * a, std::string * b) { s = *a; s = *b; }");
+                   "void Fred::foo(std::string * a, std::string * b) { s = *a; s = *b; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
@@ -4011,7 +4011,7 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "    void foo(std::string * a, std::string * b);\n"
                    "};\n"
-                   "void Fred::foo(std::string * a, std::string * b) { s = *a; *b = s; }");
+                   "void Fred::foo(std::string * a, std::string * b) { s = *a; *b = s; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
@@ -4019,7 +4019,7 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "    void foo(std::string * a, std::string * b);\n"
                    "};\n"
-                   "void Fred::foo(std::string * a, std::string * b) { *a = s; s = b; }");
+                   "void Fred::foo(std::string * a, std::string * b) { *a = s; s = b; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // check functions with same name
@@ -4029,11 +4029,11 @@ class TestClass : public TestFixture {
                    "    void foo(std::string & a);\n"
                    "    void foo(const std::string & a);\n"
                    "};\n"
-                   "void Fred::foo() { }"
-                   "void Fred::foo(std::string & a) { a = s; }"
-                   "void Fred::foo(const std::string & a) { s = a; }");
+                   "void Fred::foo() { }\n"
+                   "void Fred::foo(std::string & a) { a = s; }\n"
+                   "void Fred::foo(const std::string & a) { s = a; }\n");
         ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:7:12]: (style) The member function 'Fred::foo' can be static. [functionStatic]\n"
-                      "[test.cpp:4:10] -> [test.cpp:7:32]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
+                      "[test.cpp:4:10] -> [test.cpp:8:12]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // check functions with different or missing parameter names
         checkConst("class Fred {\n"
@@ -4048,7 +4048,7 @@ class TestClass : public TestFixture {
                    "void Fred::foo2(int c, int d) { }\n"
                    "void Fred::foo3(int a, int b) { }\n"
                    "void Fred::foo4(int a, int b) { }\n"
-                   "void Fred::foo5(int, int) { }");
+                   "void Fred::foo5(int, int) { }\n");
         ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:9:12]: (style) The member function 'Fred::foo1' can be static. [functionStatic]\n"
                       "[test.cpp:4:10] -> [test.cpp:10:12]: (style) The member function 'Fred::foo2' can be static. [functionStatic]\n"
                       "[test.cpp:5:10] -> [test.cpp:11:12]: (style) The member function 'Fred::foo3' can be static. [functionStatic]\n"
@@ -4061,7 +4061,7 @@ class TestClass : public TestFixture {
                    "        int a;\n"
                    "        int getA() { return a; }\n"
                    "    };\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style, inconclusive) Technically the member function 'Fred::A::getA' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
@@ -4070,7 +4070,7 @@ class TestClass : public TestFixture {
                    "        int getA();\n"
                    "    };\n"
                    "    int A::getA() { return a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:6:12]: (style, inconclusive) Technically the member function 'Fred::A::getA' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
@@ -4079,7 +4079,7 @@ class TestClass : public TestFixture {
                    "        int getA();\n"
                    "    };\n"
                    "};\n"
-                   "int Fred::A::getA() { return a; }");
+                   "int Fred::A::getA() { return a; }\n");
         ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:7:14]: (style, inconclusive) Technically the member function 'Fred::A::getA' can be const. [functionConst]\n", errout_str());
 
         // check deeply nested classes
@@ -4092,7 +4092,7 @@ class TestClass : public TestFixture {
                    "            int getA() { return a; }\n"
                    "        };\n"
                    "    };\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style, inconclusive) Technically the member function 'Fred::B::getB' can be const. [functionConst]\n"
                       "[test.cpp:7:17]: (style, inconclusive) Technically the member function 'Fred::B::A::getA' can be const. [functionConst]\n"
                       , errout_str());
@@ -4108,7 +4108,7 @@ class TestClass : public TestFixture {
                    "        int A::getA() { return a; }\n"
                    "    };\n"
                    "    int B::getB() { return b; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:11:12]: (style, inconclusive) Technically the member function 'Fred::B::getB' can be const. [functionConst]\n"
                       "[test.cpp:7:17] -> [test.cpp:9:16]: (style, inconclusive) Technically the member function 'Fred::B::A::getA' can be const. [functionConst]\n", errout_str());
 
@@ -4123,7 +4123,7 @@ class TestClass : public TestFixture {
                    "    };\n"
                    "    int B::A::getA() { return a; }\n"
                    "    int B::getB() { return b; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:11:12]: (style, inconclusive) Technically the member function 'Fred::B::getB' can be const. [functionConst]\n"
                       "[test.cpp:7:17] -> [test.cpp:10:15]: (style, inconclusive) Technically the member function 'Fred::B::A::getA' can be const. [functionConst]\n", errout_str());
 
@@ -4138,7 +4138,7 @@ class TestClass : public TestFixture {
                    "    };\n"
                    "};\n"
                    "int Fred::B::A::getA() { return a; }\n"
-                   "int Fred::B::getB() { return b; }");
+                   "int Fred::B::getB() { return b; }\n");
         ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:12:14]: (style, inconclusive) Technically the member function 'Fred::B::getB' can be const. [functionConst]\n"
                       "[test.cpp:7:17] -> [test.cpp:11:17]: (style, inconclusive) Technically the member function 'Fred::B::A::getA' can be const. [functionConst]\n", errout_str());
     }
@@ -4148,7 +4148,7 @@ class TestClass : public TestFixture {
         checkConst("struct Fred {\n"
                    "    int a;\n"
                    "    bool operator<(const Fred &f) { return a < f.a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'Fred::operator<' can be const. [functionConst]\n", errout_str());
     }
 
@@ -4163,7 +4163,7 @@ class TestClass : public TestFixture {
                    "    {\n"
                    "        foo << 123;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct Foo {\n"
@@ -4175,7 +4175,7 @@ class TestClass : public TestFixture {
                    "    {\n"
                    "        std::cout << foo << 123;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:6:10]: (style, inconclusive) Technically the member function 'Fred::x' can be const. [functionConst]\n", errout_str());
     }
 
@@ -4184,13 +4184,13 @@ class TestClass : public TestFixture {
                    "    int array[10];\n"
                    "    int const & operator [] (unsigned int index) const { return array[index]; }\n"
                    "    int & operator [] (unsigned int index) { return array[index]; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct Fred {\n"
                    "    int array[10];\n"
                    "    int const & operator [] (unsigned int index) { return array[index]; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style, inconclusive) Technically the member function 'Fred::operator[]' can be const. [functionConst]\n", errout_str());
     }
 
@@ -4200,14 +4200,14 @@ class TestClass : public TestFixture {
                    "    int c;\n"
                    "public:\n"
                    "    operator int*() { return &c; };\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
                    "    int c;\n"
                    "public:\n"
                    "    operator const int*() { return &c; };\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (style, inconclusive) Technically the member function 'A::operatorconstint*' can be const. [functionConst]\n", errout_str());
 
         // #2375
@@ -4215,14 +4215,14 @@ class TestClass : public TestFixture {
                    "    int array[10];\n"
                    "    typedef int* (Fred::*UnspecifiedBoolType);\n"
                    "    operator UnspecifiedBoolType() { };\n"
-                   "};");
+                   "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::operatorint**' can be const.\n", "", errout_str());
 
         checkConst("struct Fred {\n"
                    "    int array[10];\n"
                    "    typedef int* (Fred::*UnspecifiedBoolType);\n"
                    "    operator UnspecifiedBoolType() { array[0] = 0; };\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4231,21 +4231,21 @@ class TestClass : public TestFixture {
                    "    int c;\n"
                    "public:\n"
                    "    operator int& () {return c}\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
                    "    int c;\n"
                    "public:\n"
                    "    operator const int& () {return c}\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (style, inconclusive) Technically the member function 'A::operatorconstint&' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "    int c;\n"
                    "public:\n"
                    "    operator int () {return c}\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (style, inconclusive) Technically the member function 'A::operatorint' can be const. [functionConst]\n", errout_str());
     }
 
@@ -4253,7 +4253,7 @@ class TestClass : public TestFixture {
         checkConst("class A {\n"
                    "    int c;\n"
                    "    void f() { os >> *this; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4267,7 +4267,7 @@ class TestClass : public TestFixture {
                    "        same = (i == a);\n"
                    "        return same;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'A::foo' can be const. [functionConst]\n", errout_str());
     }
 
@@ -4276,14 +4276,14 @@ class TestClass : public TestFixture {
         checkConst("class foo {\n"
                    "public:\n"
                    "};\n"
-                   "void bar() {}");
+                   "void bar() {}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred\n"
                    "{\n"
                    "public:\n"
                    "    void foo() { }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (style) The member function 'Fred::foo' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct fast_string\n"
@@ -4297,7 +4297,7 @@ class TestClass : public TestFixture {
                    "inline void fast_string::set_type(char t)\n"
                    "{\n"
                    "    buff[10] = t;\n"
-                   "}");
+                   "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4308,7 +4308,7 @@ class TestClass : public TestFixture {
                    "    void set(int i) { a = i; }\n"
                    "    void set(const foo & f) { *this = f; }\n"
                    "};\n"
-                   "void bar() {}");
+                   "void bar() {}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4320,7 +4320,7 @@ class TestClass : public TestFixture {
                    "    std::string strGetString() { return m_strValue; }\n"
                    "private:\n"
                    "    std::string m_strValue;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:17]: (style, inconclusive) Technically the member function 'A::strGetString' can be const. [functionConst]\n", errout_str());
     }
 
@@ -4331,7 +4331,7 @@ class TestClass : public TestFixture {
                    "    void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }\n"
                    "private:\n"
                    "    wxThread::ExitCode m_exitcode;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4342,7 +4342,7 @@ class TestClass : public TestFixture {
                    "    int foo() { return x = 0; }\n"
                    "private:\n"
                    "    int x;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
@@ -4350,7 +4350,7 @@ class TestClass : public TestFixture {
                    "    int foo() { return x ? x : x = 0; }\n"
                    "private:\n"
                    "    int x;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
@@ -4358,7 +4358,7 @@ class TestClass : public TestFixture {
                    "    int foo() { return x ? x = 0 : x; }\n"
                    "private:\n"
                    "    int x;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4369,7 +4369,7 @@ class TestClass : public TestFixture {
                    "    void set(struct tm time) { m_time = time; }\n"
                    "private:\n"
                    "    struct tm m_time;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4380,7 +4380,7 @@ class TestClass : public TestFixture {
                    "    int foo() { x = 0; }\n"
                    "private:\n"
                    "    mutable int x;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style, inconclusive) Technically the member function 'A::foo' can be const. [functionConst]\n", errout_str());
     }
 
@@ -4394,7 +4394,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::vector<int> m_vec;\n"
                    "    std::pair<int,double> m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:22]: (style, inconclusive) Technically the member function 'A::GetVec' can be const. [functionConst]\n"
                       "[test.cpp:5:27]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
@@ -4406,7 +4406,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::vector<int> m_vec;\n"
                    "    std::pair<int,double> m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:30]: (style, inconclusive) Technically the member function 'A::GetVec' can be const. [functionConst]\n"
                       "[test.cpp:5:35]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
     }
@@ -4419,7 +4419,7 @@ class TestClass : public TestFixture {
                    "    std::pair<std::vector<int>,double> GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair<std::vector<int>,double> m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:40]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
@@ -4428,7 +4428,7 @@ class TestClass : public TestFixture {
                    "    const std::pair<std::vector<int>,double>& GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair<std::vector<int>,double> m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:47]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
@@ -4437,7 +4437,7 @@ class TestClass : public TestFixture {
                    "    std::pair<std::vector<int>,double>& GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair<std::vector<int>,double> m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -4448,7 +4448,7 @@ class TestClass : public TestFixture {
                    "    pair<int ,double> GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    pair<int ,double> m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:23]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("using namespace std;"
@@ -4458,7 +4458,7 @@ class TestClass : public TestFixture {
                    "    const pair<int ,double> & GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    pair<int ,double> m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:31]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("using namespace std;"
@@ -4468,7 +4468,7 @@ class TestClass : public TestFixture {
                    "    pair<int ,double> & GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    pair<int ,double> m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -4478,7 +4478,7 @@ class TestClass : public TestFixture {
                    "    std::pair< int,std::vector<int> >  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair< int,std::vector<int> >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:40]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
@@ -4487,7 +4487,7 @@ class TestClass : public TestFixture {
                    "    const std::pair< int,std::vector<int> >&  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair< int,std::vector<int> >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:47]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
@@ -4496,7 +4496,7 @@ class TestClass : public TestFixture {
                    "    std::pair< int,std::vector<int> >&  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair< int,std::vector<int> >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -4507,7 +4507,7 @@ class TestClass : public TestFixture {
                    "    pair< vector<int>, int >  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    pair< vector<int>, int >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:31]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("using namespace std;"
@@ -4517,7 +4517,7 @@ class TestClass : public TestFixture {
                    "    const pair< vector<int>, int >&  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    pair< vector<int>, int >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:38]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("using namespace std;"
@@ -4527,7 +4527,7 @@ class TestClass : public TestFixture {
                    "    pair< vector<int>, int >&  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    pair< vector<int>, int >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
@@ -4536,7 +4536,7 @@ class TestClass : public TestFixture {
                    "    std::pair< std::vector<int>,std::vector<int> >  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair< std::vector<int>,std::vector<int> >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:53]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
@@ -4545,7 +4545,7 @@ class TestClass : public TestFixture {
                    "    const std::pair< std::vector<int>,std::vector<int> >&  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair< std::vector<int>,std::vector<int> >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:60]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
@@ -4554,7 +4554,7 @@ class TestClass : public TestFixture {
                    "    std::pair< std::vector<int>,std::vector<int> >&  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair< std::vector<int>,std::vector<int> >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -4565,7 +4565,7 @@ class TestClass : public TestFixture {
                    "    std::pair< std::pair < int, char > , int >  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair< std::pair < int, char > , int >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:49]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
@@ -4574,7 +4574,7 @@ class TestClass : public TestFixture {
                    "    const std::pair< std::pair < int, char > , int > & GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair< std::pair < int, char > , int >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:56]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
@@ -4583,7 +4583,7 @@ class TestClass : public TestFixture {
                    "    std::pair< std::pair < int, char > , int > & GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair< std::pair < int, char > , int >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -4593,7 +4593,7 @@ class TestClass : public TestFixture {
                    "    std::pair< int , std::pair < int, char > >  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair< int , std::pair < int, char > >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:49]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
@@ -4602,7 +4602,7 @@ class TestClass : public TestFixture {
                    "    const std::pair< int , std::pair < int, char > >&  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair< int , std::pair < int, char > >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:56]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
@@ -4611,7 +4611,7 @@ class TestClass : public TestFixture {
                    "    std::pair< int , std::pair < int, char > >&  GetPair() {return m_pair;}\n"
                    "private:\n"
                    "    std::pair< int , std::pair < int, char > >  m_pair;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -4622,7 +4622,7 @@ class TestClass : public TestFixture {
                    "    vector<int>  GetVec() {return m_Vec;}\n"
                    "private:\n"
                    "    vector<int>  m_Vec;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (style, inconclusive) Technically the member function 'A::GetVec' can be const. [functionConst]\n", errout_str());
 
         checkConst("using namespace std;"
@@ -4632,7 +4632,7 @@ class TestClass : public TestFixture {
                    "    const vector<int>&  GetVec() {return m_Vec;}\n"
                    "private:\n"
                    "    vector<int>  m_Vec;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:25]: (style, inconclusive) Technically the member function 'A::GetVec' can be const. [functionConst]\n", errout_str());
 
         checkConst("using namespace std;"
@@ -4642,7 +4642,7 @@ class TestClass : public TestFixture {
                    "    vector<int>&  GetVec() {return m_Vec;}\n"
                    "private:\n"
                    "    vector<int>  m_Vec;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -4651,7 +4651,7 @@ class TestClass : public TestFixture {
                    "    int * * foo() { return &x; }\n"
                    "private:\n"
                    "    const int * x;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
@@ -4659,7 +4659,7 @@ class TestClass : public TestFixture {
                    "    const int ** foo() { return &x; }\n"
                    "private:\n"
                    "    const int * x;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:18]: (style, inconclusive) Technically the member function 'A::foo' can be const. [functionConst]\n", errout_str());
     }
 
@@ -4667,7 +4667,7 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    unsigned long long int a;\n"
                    "    unsigned long long int getA() { return a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:28]: (style, inconclusive) Technically the member function 'Fred::getA' can be const. [functionConst]\n", errout_str());
 
         // constructors can't be const..
@@ -4675,14 +4675,14 @@ class TestClass : public TestFixture {
                    "    unsigned long long int a;\n"
                    "public:\n"
                    "    Fred() { }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment through |=..
         checkConst("class Fred {\n"
                    "    unsigned long long int a;\n"
                    "    unsigned long long int setA() { a |= true; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // static functions can't be const..
@@ -4691,7 +4691,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    static unsigned long long int get()\n"
                    "    { return 0; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4700,7 +4700,7 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    void set(int i) { Fred::a = i; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4711,7 +4711,7 @@ class TestClass : public TestFixture {
                    "    void set(int i, int j) { a[i].k = i; }\n"
                    "private:\n"
                    "    struct { int k; } a[4];\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4720,7 +4720,7 @@ class TestClass : public TestFixture {
                    "static int x;\n"
                    "public:\n"
                    "    void set(int i) { x = i; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (style) The member function 'Fred::set' can be static. [functionStatic]\n", errout_str());
     }
 
@@ -4732,7 +4732,7 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "public:\n"
                    "    void set(std::string ss) { s = ss; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4742,35 +4742,35 @@ class TestClass : public TestFixture {
                    "    int x : 3;\n"
                    "public:\n"
                    "    void set(int i) { x = i; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    list<int *> x;\n"
                    "public:\n"
                    "    list<int *> get() { return x; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    list<const int *> x;\n"
                    "public:\n"
                    "    list<const int *> get() { return x; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:23]: (style, inconclusive) Technically the member function 'Fred::get' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "    std::list<std::string &> x;\n"
                    "public:\n"
                    "    std::list<std::string &> get() { return x; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    std::list<const std::string &> x;\n"
                    "public:\n"
                    "    std::list<const std::string &> get() { return x; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:36]: (style, inconclusive) Technically the member function 'Fred::get' can be const. [functionConst]\n", errout_str());
     }
 
@@ -4786,7 +4786,7 @@ class TestClass : public TestFixture {
                    "        for (int i = 0 ; i < 10; l1[i] = NULL, i++);\n"
                    "    }\n"
                    "    void f1() { l1[0] = \"Hello\"; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4797,7 +4797,7 @@ class TestClass : public TestFixture {
                    "    B::C * v1;\n"
                    "public:\n"
                    "    void f1() { v1 = 0; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class A\n"
@@ -4806,7 +4806,7 @@ class TestClass : public TestFixture {
                    "    B::C * v1[0];\n"
                    "public:\n"
                    "    void f1() { v1[0] = 0; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4818,7 +4818,7 @@ class TestClass : public TestFixture {
                    "    void set_member(Type2 m) { _m = m; }\n"
                    "private:\n"
                    "    Type2 _m;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4831,7 +4831,7 @@ class TestClass : public TestFixture {
                    "}\n"
                    "private:\n"
                    "    std::map<QString, QString> *m_pSettings;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4846,7 +4846,7 @@ class TestClass : public TestFixture {
                    "{return m_strVal.c_str();}\n"
                    "private:\n"
                    "std::string m_strVal;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class A{\n"
@@ -4856,7 +4856,7 @@ class TestClass : public TestFixture {
                    "{return m_strVal.c_str();}\n"
                    "private:\n"
                    "std::string m_strVal;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style, inconclusive) Technically the member function 'A::strGetString' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A{\n"
@@ -4866,7 +4866,7 @@ class TestClass : public TestFixture {
                    "{return m_strVal.c_str();}\n"
                    "private:\n"
                    "std::string m_strVal;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:19]: (style, inconclusive) Technically the member function 'A::strGetString1' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A{\n"
@@ -4876,7 +4876,7 @@ class TestClass : public TestFixture {
                    "{return m_strVec.size();}\n"
                    "private:\n"
                    "std::vector<std::string> m_strVec;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:8]: (style, inconclusive) Technically the member function 'A::strGetSize' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A{\n"
@@ -4886,7 +4886,7 @@ class TestClass : public TestFixture {
                    "{return m_strVec.empty();}\n"
                    "private:\n"
                    "std::vector<std::string> m_strVec;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (style, inconclusive) Technically the member function 'A::strGetEmpty' can be const. [functionConst]\n", errout_str());
     }
 
@@ -4897,7 +4897,7 @@ class TestClass : public TestFixture {
                    "    std::swap<float>(delays_[index1], delays_[index2]);\n"
                    "}\n"
                    "float delays_[4];\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct DelayBase {\n"
@@ -4905,7 +4905,7 @@ class TestClass : public TestFixture {
                    "        return delays_[index1];\n"
                    "    }\n"
                    "    float delays_[4];\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style, inconclusive) Technically the member function 'DelayBase::swapSpecificDelays' can be const. [functionConst]\n", errout_str());
     }
 
@@ -4923,7 +4923,7 @@ class TestClass : public TestFixture {
                    "    if( m_d != 0 )\n"
                    "        return m_iRealVal / m_d;\n"
                    "    return dRet;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:12] -> [test.cpp:9:12]: (style, inconclusive) Technically the member function 'A::dGetValue' can be const. [functionConst]\n", errout_str());
     }
 
@@ -4940,7 +4940,7 @@ class TestClass : public TestFixture {
                    "        x=xPos;\n"
                    "        y=yPos;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class AA : public P {\n"
@@ -4950,7 +4950,7 @@ class TestClass : public TestFixture {
                    "    {\n"
                    "        UnknownScope::x = x_;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class AA {\n"
@@ -4960,7 +4960,7 @@ class TestClass : public TestFixture {
                    "    {\n"
                    "        UnknownScope::x = x_;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:4:17]: (style) The member function 'AA::vSetXPos' can be static. [functionStatic]\n", errout_str());
 
     }
@@ -4985,7 +4985,7 @@ class TestClass : public TestFixture {
                    "char* test::get()\n"
                    "{\n"
                    "  return value_;\n"
-                   "}");
+                   "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5000,7 +5000,7 @@ class TestClass : public TestFixture {
                    "    int get() {\n"
                    "        return a;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:7:9]: (style, inconclusive) Technically the member function 'Derived::get' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Base1 {\n"
@@ -5019,7 +5019,7 @@ class TestClass : public TestFixture {
                    "    int getB() {\n"
                    "        return b;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:11:9]: (style, inconclusive) Technically the member function 'Derived::getA' can be const. [functionConst]\n"
                       "[test.cpp:14:9]: (style, inconclusive) Technically the member function 'Derived::getB' can be const. [functionConst]\n", errout_str());
 
@@ -5033,7 +5033,7 @@ class TestClass : public TestFixture {
                    "    int get() {\n"
                    "        return a;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:8:9]: (style, inconclusive) Technically the member function 'Derived2::get' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Base {\n"
@@ -5048,7 +5048,7 @@ class TestClass : public TestFixture {
                    "    int get() {\n"
                    "        return a;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:10:9]: (style, inconclusive) Technically the member function 'Derived4::get' can be const. [functionConst]\n", errout_str());
 
         // check for false positives
@@ -5061,7 +5061,7 @@ class TestClass : public TestFixture {
                    "    int get() const {\n"
                    "        return a;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Base1 {\n"
@@ -5080,7 +5080,7 @@ class TestClass : public TestFixture {
                    "    int getB() const {\n"
                    "        return b;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Base {\n"
@@ -5093,7 +5093,7 @@ class TestClass : public TestFixture {
                    "    int get() const {\n"
                    "        return a;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Base {\n"
@@ -5108,7 +5108,7 @@ class TestClass : public TestFixture {
                    "    int get() const {\n"
                    "        return a;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5118,7 +5118,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    int a;\n"
                    "    int get() { return a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:5:9]: (style, inconclusive) Technically the member function 'Fred::get' can be const. [functionConst]\n", errout_str());
     }
 
@@ -5127,7 +5127,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    std::string a[10];\n"
                    "    void seta() { a[0] = \"\"; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5135,7 +5135,7 @@ class TestClass : public TestFixture {
         checkConst("class derived : public base {\n"
                    "public:\n"
                    "    void f(){}\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) Either there is a missing 'override', or the member function 'derived::f' can be static. [functionStatic]\n", errout_str());
     }
 
@@ -5144,7 +5144,7 @@ class TestClass : public TestFixture {
                    "    void init(Foo * foo) {\n"
                    "        foo.bar = this;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5163,7 +5163,7 @@ class TestClass : public TestFixture {
                    "                int getResourceName() { return var; }\n"
                    "                int var;\n"
                    "        };\n"
-                   "}");
+                   "}\n");
         ASSERT_EQUALS("[test.cpp:12:21]: (style, inconclusive) Technically the member function 'N::Derived::getResourceName' can be const. [functionConst]\n", errout_str());
 
         checkConst("namespace N\n"
@@ -5175,7 +5175,7 @@ class TestClass : public TestFixture {
                    "                int var;\n"
                    "        };\n"
                    "}\n"
-                   "int N::Base::getResourceName() { return var; }");
+                   "int N::Base::getResourceName() { return var; }\n");
         ASSERT_EQUALS("[test.cpp:6:21] -> [test.cpp:10:14]: (style, inconclusive) Technically the member function 'N::Base::getResourceName' can be const. [functionConst]\n", errout_str());
 
         checkConst("namespace N\n"
@@ -5190,7 +5190,7 @@ class TestClass : public TestFixture {
                    "namespace N\n"
                    "{\n"
                    "        int Base::getResourceName() { return var; }\n"
-                   "}");
+                   "}\n");
         ASSERT_EQUALS("[test.cpp:6:21] -> [test.cpp:12:19]: (style, inconclusive) Technically the member function 'N::Base::getResourceName' can be const. [functionConst]\n", errout_str());
 
         checkConst("namespace N\n"
@@ -5203,7 +5203,7 @@ class TestClass : public TestFixture {
                    "        };\n"
                    "}\n"
                    "using namespace N;\n"
-                   "int Base::getResourceName() { return var; }");
+                   "int Base::getResourceName() { return var; }\n");
         ASSERT_EQUALS("[test.cpp:6:21] -> [test.cpp:11:11]: (style, inconclusive) Technically the member function 'N::Base::getResourceName' can be const. [functionConst]\n", errout_str());
     }
 
@@ -5215,7 +5215,7 @@ class TestClass : public TestFixture {
                    "    {\n"
                    "        m_MaxQueueSize = a_MaxQueueSize;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5230,7 +5230,7 @@ class TestClass : public TestFixture {
                    "    }\n"
                    "private:\n"
                    "    std::string m_str;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:5:17]: (style, inconclusive) Technically the member function 'A::operator+' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred\n"
@@ -5244,7 +5244,7 @@ class TestClass : public TestFixture {
                    "    bool isValid() {\n"
                    "        return (x == 0x11224488);\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:9:10]: (style, inconclusive) Technically the member function 'Fred::isValid' can be const. [functionConst]\n", errout_str());
     }
 
@@ -5260,7 +5260,7 @@ class TestClass : public TestFixture {
                    "void Foo::MyMethod()\n"
                    "{\n"
                    "    (*oArq) << \"</table>\";\n"
-                   "}");
+                   "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5280,7 +5280,7 @@ class TestClass : public TestFixture {
                    "int * Foo::f()\n"
                    "{\n"
                    "    return p;\n"
-                   "}");
+                   "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -5297,7 +5297,7 @@ class TestClass : public TestFixture {
                    "   {\n"
                    "      pView = aView;\n"
                    "   }\n"
-                   "};");
+                   "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -5311,7 +5311,7 @@ class TestClass : public TestFixture {
                    "   {\n"
                    "      m_name = name;\n"
                    "   }\n"
-                   "};");
+                   "};\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -5323,7 +5323,7 @@ class TestClass : public TestFixture {
                    "   {\n"
                    "      pNum = apNum;\n"
                    "   }\n"
-                   "};");
+                   "};\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -5338,7 +5338,7 @@ class TestClass : public TestFixture {
                    "   {\n"
                    "      pNum = apNum;\n"
                    "   }\n"
-                   "};");
+                   "};\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -5355,7 +5355,7 @@ class TestClass : public TestFixture {
                    "   {\n"
                    "      pNum = apNum;\n"
                    "   }\n"
-                   "};");
+                   "};\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -5373,7 +5373,7 @@ class TestClass : public TestFixture {
                    "   {\n"
                    "      pNum = apNum;\n"
                    "   }\n"
-                   "};");
+                   "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -5387,7 +5387,7 @@ class TestClass : public TestFixture {
                    "};\n"
                    "bool Fred::f(Fred::AB * ab)\n"
                    "{\n"
-                   "}");
+                   "}\n");
 
         ASSERT_EQUALS("[test.cpp:5:10] -> [test.cpp:7:12]: (style) The member function 'Fred::f' can be static. [functionStatic]\n", errout_str());
 
@@ -5401,7 +5401,7 @@ class TestClass : public TestFixture {
                    "};\n"
                    "bool Fred::f(Fred::AB::CD * cd)\n"
                    "{\n"
-                   "}");
+                   "}\n");
 
         ASSERT_EQUALS("[test.cpp:7:10] -> [test.cpp:9:12]: (style) The member function 'Fred::f' can be static. [functionStatic]\n", errout_str());
 
@@ -5417,7 +5417,7 @@ class TestClass : public TestFixture {
                    "    bool Fred::f(Fred::AB::CD * cd)\n"
                    "    {\n"
                    "    }\n"
-                   "}");
+                   "}\n");
 
         ASSERT_EQUALS("[test.cpp:8:14] -> [test.cpp:10:16]: (style) The member function 'NS::Fred::f' can be static. [functionStatic]\n", errout_str());
 
@@ -5433,7 +5433,7 @@ class TestClass : public TestFixture {
                    "}\n"
                    "bool NS::Fred::f(NS::Fred::AB::CD * cd)\n"
                    "{\n"
-                   "}");
+                   "}\n");
 
         ASSERT_EQUALS("[test.cpp:8:14] -> [test.cpp:11:16]: (style) The member function 'NS::Fred::f' can be static. [functionStatic]\n", errout_str());
 
@@ -5449,7 +5449,7 @@ class TestClass : public TestFixture {
                    "};\n"
                    "bool Foo::Fred::f(Foo::Fred::AB::CD * cd)\n"
                    "{\n"
-                   "}");
+                   "}\n");
 
         ASSERT_EQUALS("[test.cpp:8:14] -> [test.cpp:11:17]: (style) The member function 'Foo::Fred::f' can be static. [functionStatic]\n", errout_str());
     }
@@ -5464,7 +5464,7 @@ class TestClass : public TestFixture {
                    "void A::foo( AA::BB::CC::DD b )\n"
                    "{\n"
                    "    a = b;\n"
-                   "}");
+                   "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -5488,7 +5488,7 @@ class TestClass : public TestFixture {
                    "    {\n"
                    "        a = b;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -5508,7 +5508,7 @@ class TestClass : public TestFixture {
                    "    {\n"
                    "        a = b;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5521,7 +5521,7 @@ class TestClass : public TestFixture {
                    "    {\n"
                    "        return 0 != (bOn = bOn);\n"
                    "    }\n"
-                   "};");
+                   "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -5538,7 +5538,7 @@ class TestClass : public TestFixture {
                    "        {\n"
                    "        }\n"
                    "    };\n"
-                   "}");
+                   "}\n");
 
         ASSERT_EQUALS("[test.cpp:8:13]: (style) The member function 'tools::WorkspaceControl::toGrid' can be static. [functionStatic]\n", errout_str());
     }
@@ -5553,7 +5553,7 @@ class TestClass : public TestFixture {
                    "    int fun2() {\n"
                    "        b++;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
 
         ASSERT_EQUALS("[test.cpp:3:9]: (style) The member function 'Altren::fun1' can be static. [functionStatic]\n"
                       "[test.cpp:7:9]: (style) The member function 'Altren::fun2' can be static. [functionStatic]\n", errout_str());
@@ -5565,7 +5565,7 @@ class TestClass : public TestFixture {
                    "  void foo() { delete this; }\n"
                    "  void foo(int i) const { }\n"
                    "  void bar() { foo(); }\n"
-                   "};");
+                   "};\n");
 
         ASSERT_EQUALS("[test.cpp:4:8]: (style) The member function 'Altren::foo' can be static. [functionStatic]\n", errout_str());
 
@@ -5574,7 +5574,7 @@ class TestClass : public TestFixture {
                    "  void foo() { delete this; }\n"
                    "  void foo(int i) const { }\n"
                    "  void bar() { foo(1); }\n"
-                   "};");
+                   "};\n");
 
         ASSERT_EQUALS("[test.cpp:4:8]: (style) The member function 'Altren::foo' can be static. [functionStatic]\n"
                       "[test.cpp:5:8]: (style, inconclusive) Technically the member function 'Altren::bar' can be const. [functionConst]\n", errout_str());
@@ -5597,7 +5597,7 @@ class TestClass : public TestFixture {
                    "};\n"
                    "bool TextIterator::setTagColour() {\n"
                    "    mSave = mCurrent;\n"
-                   "}");
+                   "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -5612,7 +5612,7 @@ class TestClass : public TestFixture {
                    "         {\n"
                    "             return _hash[key];\n"
                    "         }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5627,7 +5627,7 @@ class TestClass : public TestFixture {
                    "{\n"
                    "        if (mTileSize.height > 0) return;\n"
                    "        if (mEmptyView) return;\n"
-                   "}");
+                   "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -5641,7 +5641,7 @@ class TestClass : public TestFixture {
                    "    void SetSection(uint num) { pesdata()[6] = num; }\n"
                    "private:\n"
                    "    unsigned char *_pesdata;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class PESPacket {\n"
@@ -5656,7 +5656,7 @@ class TestClass : public TestFixture {
                    "{\n"
                    "public:\n"
                    "    void SetSection(uint num) { pesdata()[6] = num; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5666,7 +5666,7 @@ class TestClass : public TestFixture {
                    "    void DoSomethingElse() { DoSomething(bar); }\n"
                    "private:\n"
                    "    int bar;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) The member function 'foo::DoSomething' can be static. [functionStatic]\n", errout_str());
     }
 
@@ -5682,7 +5682,7 @@ class TestClass : public TestFixture {
                    "  public:\n"
                    "    B() {};\n"
                    "    bool One(bool b = false) { return false; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5690,7 +5690,7 @@ class TestClass : public TestFixture {
         checkConst("class Example {\n"
                    "  public:\n"
                    "    void Clear(void) { Example tmp; (*this) = tmp; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5700,7 +5700,7 @@ class TestClass : public TestFixture {
                    "    MyObject() : tmp(0) {}\n"
                    "public:\n"
                    "    void set(std::stringstream &in) { in >> tmp; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5710,7 +5710,7 @@ class TestClass : public TestFixture {
                    "    void foo(int x) {\n"
                    "    switch (x) { }\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'MyObject::foo' can be static. [functionStatic]\n", errout_str());
 
         checkConst("class A\n"
@@ -5750,7 +5750,7 @@ class TestClass : public TestFixture {
                    "    }\n"
                    "\n"
                    "    return RET_NOK;\n"
-                   "}");
+                   "}\n");
         ASSERT_EQUALS("[test.cpp:4:24] -> [test.cpp:9:19]: (style) The member function 'A::f' can be static. [functionStatic]\n", errout_str());
 
         checkConst("class MyObject {\n"
@@ -5758,7 +5758,7 @@ class TestClass : public TestFixture {
                    "    void foo(int x) {\n"
                    "    for (int i = 0; i < 5; i++) { }\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'MyObject::foo' can be static. [functionStatic]\n", errout_str());
     }
 
@@ -5783,7 +5783,7 @@ class TestClass : public TestFixture {
                    "  }\n"
                    "private:\n"
                    "  MyGUI::IntCoord mCoordValue;\n"
-                   "};");
+                   "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:7:13]: (style) The member function 'MyGUI::types::TCoord::size' can be static. [functionStatic]\n"
                            "[test.cpp:15]: (style, inconclusive) Technically the member function 'SelectorControl::getSize' can be const.\n",
                            "[test.cpp:7:13]: (style) The member function 'MyGUI::types::TCoord::size' can be static. [functionStatic]\n", errout_str());
@@ -5793,7 +5793,7 @@ class TestClass : public TestFixture {
                    "    void foo(Foo f) {\n"
                    "        b.run();\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct Bar {\n"
@@ -5805,7 +5805,7 @@ class TestClass : public TestFixture {
                    "    void foo(Foo f) {\n"
                    "        b.run();\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct Bar {\n"
@@ -5816,7 +5816,7 @@ class TestClass : public TestFixture {
                    "    void foo(Foo f) {\n"
                    "        b.run();\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) The member function 'Bar::run' can be static. [functionStatic]\n"
                       "[test.cpp:6:10]: (style, inconclusive) Technically the member function 'Foo::foo' can be const. [functionConst]\n", errout_str());
     }
@@ -5826,14 +5826,14 @@ class TestClass : public TestFixture {
                    "    void foo(Foo f) {\n"
                    "        f.clear();\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) The member function 'MyObject::foo' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct MyObject {\n"
                    "    int foo(Foo f) {\n"
                    "        return f.length();\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) The member function 'MyObject::foo' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct MyObject {\n"
@@ -5841,7 +5841,7 @@ class TestClass : public TestFixture {
                    "    int foo() {\n"
                    "        return f.length();\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct MyObject {\n"
@@ -5849,7 +5849,7 @@ class TestClass : public TestFixture {
                    "    int foo() {\n"
                    "        return f.length();\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style, inconclusive) Technically the member function 'MyObject::foo' can be const. [functionConst]\n", errout_str());
     }
 
@@ -5861,7 +5861,7 @@ class TestClass : public TestFixture {
                    "protected:\n"
                    "    int   re;\n"
                    "    int   im;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5876,7 +5876,7 @@ class TestClass : public TestFixture {
                    "    MyString append( const MyString& str )\n"
                    "    {       return operator+=( str ); }\n"
                    "    char *m_ptr;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
         checkConst("class MyString {\n"
                    "public:\n"
@@ -5885,7 +5885,7 @@ class TestClass : public TestFixture {
                    "    MyString append( const MyString& str )\n"
                    "    {       return operator+=( str ); }\n"
                    "    char *m_ptr;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5896,14 +5896,14 @@ class TestClass : public TestFixture {
                    "};\n"
                    "int MixerParticipant::GetAudioFrame() {\n"
                    "    return 0;\n"
-                   "}");
+                   "}\n");
 
         // this code is invalid so a false negative is OK
         checkConst("class MixerParticipant : public MixerParticipant {\n"
                    "    bool InitializeFileReader() {\n"
                    "       printf(\"music\");\n"
                    "    }\n"
-                   "};");
+                   "};\n");
 
         // Based on an example from SVN source code causing an endless recursion within CheckClass::isConstMemberFunc()
         // A more complete example including a template declaration like
@@ -5936,7 +5936,7 @@ class TestClass : public TestFixture {
                    "         {\n"
                    "             return _hash[key];\n"
                    "         }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5947,7 +5947,7 @@ class TestClass : public TestFixture {
                    "         std::string* p = &s;\n"
                    "         p->clear();\n"
                    "     }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A {\n"
@@ -5956,7 +5956,7 @@ class TestClass : public TestFixture {
                    "         std::string& r = s;\n"
                    "         r.clear();\n"
                    "     }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A {\n"
@@ -5965,7 +5965,7 @@ class TestClass : public TestFixture {
                    "         std::string& r = sth; r = s;\n"
                    "         r.clear();\n"
                    "     }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'A::clear' can be const. [functionConst]\n", errout_str());
 
         checkConst("struct A {\n"
@@ -5974,7 +5974,7 @@ class TestClass : public TestFixture {
                    "         const std::string* p = &s;\n"
                    "         p->somefunction();\n"
                    "     }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'A::clear' can be const. [functionConst]\n", errout_str());
 
         checkConst("struct A {\n"
@@ -5983,7 +5983,7 @@ class TestClass : public TestFixture {
                    "         const std::string& r = s;\n"
                    "         r.somefunction();\n"
                    "     }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'A::clear' can be const. [functionConst]\n", errout_str());
     }
 
@@ -5998,7 +5998,7 @@ class TestClass : public TestFixture {
                    "        }\n"
                    "        ::B::D::DKIPtr membervariable;\n"
                    "    };\n"
-                   "}");
+                   "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6017,7 +6017,7 @@ class TestClass : public TestFixture {
                    "    TemplateClass<int> a;\n"
                    "    TemplateClass<float> b;\n"
                    "    return 0;\n"
-                   "}");
+                   "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6027,7 +6027,7 @@ class TestClass : public TestFixture {
                    "    void f(int v) { g((char *) &v); }\n"
                    "    void g(char *) { n++; }\n"
                    "    int n;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6041,7 +6041,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    const std::list<std::shared_ptr<int>>& get() { return m_test.m_list; }\n"
                    "    TestList<std::shared_ptr<int>> m_test;\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:8:44]: (style, inconclusive) Technically the member function 'Test::get' can be const. [functionConst]\n", errout_str());
     }
 
@@ -6071,7 +6071,7 @@ class TestClass : public TestFixture {
                    "        call();\n"
                    "        call<int>(1, 2, 3);\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6084,7 +6084,7 @@ class TestClass : public TestFixture {
                    "    void test() {\n"
                    "        call(1, 2);\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6219,7 +6219,7 @@ class TestClass : public TestFixture {
                    "    void bar(void) {\n"
                    "        for(std::vector<std::string>::const_iterator it = m_str.begin(); it != m_str.end(); ++it) {;}\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (style, inconclusive) Technically the member function 'A::bar' can be const. [functionConst]\n", errout_str());
 
         // Don't crash
@@ -7074,7 +7074,7 @@ class TestClass : public TestFixture {
                    "    int bar6() {\n"
                    "        return foo3();\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:11:9]: (style) The member function 'Foo::bar3' can be static. [functionStatic]\n"
                       "[test.cpp:14:9]: (style) The member function 'Foo::bar4' can be static. [functionStatic]\n", errout_str());
     }
@@ -7085,7 +7085,7 @@ class TestClass : public TestFixture {
                    "        Bar b;\n"
                    "        b.takeFoo(this);\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct Foo {\n"
@@ -7093,7 +7093,7 @@ class TestClass : public TestFixture {
                    "        Foo f;\n"
                    "        f.foo();\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) The member function 'Foo::foo' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct A;\n" // #5839 - operator()
@@ -7104,7 +7104,7 @@ class TestClass : public TestFixture {
                    "    void dostuff() {\n"
                    "        B()(this);\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7116,7 +7116,7 @@ class TestClass : public TestFixture {
                    "    {\n"
                    "        v = 0;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7128,7 +7128,7 @@ class TestClass : public TestFixture {
                    "    {\n"
                    "        v[0] = \"Happy new year!\";\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7137,49 +7137,49 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    void nextA() { return ++a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    void nextA() { return --a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    void nextA() { return a++; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    void nextA() { return a--; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("int a;\n"
                    "class Fred {\n"
                    "    void nextA() { return ++a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a;\n"
                    "class Fred {\n"
                    "    void nextA() { return --a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a;\n"
                    "class Fred {\n"
                    "    void nextA() { return a++; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a;\n"
                    "class Fred {\n"
                    "    void nextA() { return a--; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct S {\n" // #10077
@@ -7195,61 +7195,61 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    void nextA() { return a=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    void nextA() { return a-=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    void nextA() { return a+=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    void nextA() { return a*=-1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    void nextA() { return a/=-2; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("int a;\n"
                    "class Fred {\n"
                    "    void nextA() { return a=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a;\n"
                    "class Fred {\n"
                    "    void nextA() { return a-=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a;\n"
                    "class Fred {\n"
                    "    void nextA() { return a+=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a;\n"
                    "class Fred {\n"
                    "    void nextA() { return a*=-1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a;\n"
                    "class Fred {\n"
                    "    void nextA() { return a/=-2; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
     }
 
@@ -7257,90 +7257,90 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    struct A { int a; } s;\n"
                    "    void nextA() { return s.a=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    struct A { int a; } s;\n"
                    "    void nextA() { return s.a-=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    struct A { int a; } s;\n"
                    "    void nextA() { return s.a+=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    struct A { int a; } s;\n"
                    "    void nextA() { return s.a*=-1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A { int a; } s;\n"
                    "class Fred {\n"
                    "    void nextA() { return s.a=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct A { int a; } s;\n"
                    "class Fred {\n"
                    "    void nextA() { return s.a-=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct A { int a; } s;\n"
                    "class Fred {\n"
                    "    void nextA() { return s.a+=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct A { int a; } s;\n"
                    "class Fred {\n"
                    "    void nextA() { return s.a*=-1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct A { int a; } s;\n"
                    "class Fred {\n"
                    "    void nextA() { return s.a/=-2; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct A { int a; };\n"
                    "class Fred {\n"
                    "    A s;\n"
                    "    void nextA() { return s.a=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A { int a; };\n"
                    "class Fred {\n"
                    "    A s;\n"
                    "    void nextA() { return s.a-=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A { int a; };\n"
                    "class Fred {\n"
                    "    A s;\n"
                    "    void nextA() { return s.a+=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A { int a; };\n"
                    "class Fred {\n"
                    "    A s;\n"
                    "    void nextA() { return s.a*=-1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A { int a; };\n"
                    "class Fred {\n"
                    "    A s;\n"
                    "    void nextA() { return s.a/=-2; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7349,49 +7349,49 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return ++a[0]; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return --a[0]; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]++; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]--; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return ++a[0]; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return --a[0]; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]++; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]--; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
     }
 
@@ -7399,61 +7399,61 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]-=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]+=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]*=-1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]/=-2; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]-=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]+=1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]*=-1; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]/=-2; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
     }
 
@@ -7462,8 +7462,8 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    int &getR() { return a; }\n"
-                   "    int *getP() { return &a; }"
-                   "};");
+                   "    int *getP() { return &a; }\n"
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7472,7 +7472,7 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    int *a;\n"
                    "    void clean() { delete a; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7480,14 +7480,14 @@ class TestClass : public TestFixture {
     void constLPVOID() {
         checkConst("class Fred {\n"
                    "    UNKNOWN a() { return 0; };\n"
-                   "};");
+                   "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:2]: (style) The member function 'Fred::a' can be static.\n", "", errout_str());
 
         // #1579 - HDC
         checkConst("class Fred {\n"
                    "    foo bar;\n"
                    "    UNKNOWN a() { return b; };\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7496,7 +7496,7 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    void f() const { };\n"
                    "    void a() { f(); };\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) The member function 'Fred::f' can be static. [functionStatic]\n"
                       "[test.cpp:3:10]: (style, inconclusive) Technically the member function 'Fred::a' can be const. [functionConst]\n", errout_str());
 
@@ -7507,7 +7507,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "   A(){}\n"
                    "   unsigned int GetVecSize()  {return m_v.size();}\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:6:17]: (style, inconclusive) Technically the member function 'A::GetVecSize' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A\n"
@@ -7516,7 +7516,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "   A(){}\n"
                    "   bool GetVecEmpty()  {return m_v.empty();}\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:6:9]: (style, inconclusive) Technically the member function 'A::GetVecEmpty' can be const. [functionConst]\n", errout_str());
     }
 
@@ -7528,7 +7528,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "   B() : b(0) { }\n"
                    "   int func() { return b; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:6:8]: (style, inconclusive) Technically the member function 'B::func' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A { };\n"
@@ -7538,7 +7538,7 @@ class TestClass : public TestFixture {
                    "   B() : b(0) { }\n"
                    "   int func();\n"
                    "};\n"
-                   "int B::func() { return b; }");
+                   "int B::func() { return b; }\n");
         ASSERT_EQUALS("[test.cpp:6:8] -> [test.cpp:8:8]: (style, inconclusive) Technically the member function 'B::func' can be const. [functionConst]\n", errout_str());
 
         // base class has no virtual function
@@ -7551,7 +7551,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    B() : b(0) { }\n"
                    "    int func() { return b; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:9:9]: (style, inconclusive) Technically the member function 'B::func' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
@@ -7564,7 +7564,7 @@ class TestClass : public TestFixture {
                    "    B() : b(0) { }\n"
                    "    int func();\n"
                    "};\n"
-                   "int B::func() { return b; }");
+                   "int B::func() { return b; }\n");
         ASSERT_EQUALS("[test.cpp:9:9] -> [test.cpp:11:8]: (style, inconclusive) Technically the member function 'B::func' can be const. [functionConst]\n", errout_str());
 
         // base class has virtual function
@@ -7577,7 +7577,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    B() : b(0) { }\n"
                    "    int func() { return b; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
@@ -7590,7 +7590,7 @@ class TestClass : public TestFixture {
                    "    B() : b(0) { }\n"
                    "    int func();\n"
                    "};\n"
-                   "int B::func() { return b; }");
+                   "int B::func() { return b; }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
@@ -7603,7 +7603,7 @@ class TestClass : public TestFixture {
                    "    B() : b(0) { }\n"
                    "    int func();\n"
                    "};\n"
-                   "int B::func() { return b; }");
+                   "int B::func() { return b; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // base class has no virtual function
@@ -7624,7 +7624,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    C() : c(0) { }\n"
                    "    int func() { return c; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:5:9]: (style, inconclusive) Technically the member function 'A::func' can be const. [functionConst]\n"
                       "[test.cpp:11:9]: (style, inconclusive) Technically the member function 'B::func' can be const. [functionConst]\n"
                       "[test.cpp:17:9]: (style, inconclusive) Technically the member function 'C::func' can be const. [functionConst]\n", errout_str());
@@ -7649,7 +7649,7 @@ class TestClass : public TestFixture {
                    "    C() : c(0) { }\n"
                    "    int func();\n"
                    "};\n"
-                   "int C::func() { return c; }");
+                   "int C::func() { return c; }\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:7:8]: (style, inconclusive) Technically the member function 'A::func' can be const. [functionConst]\n"
                       "[test.cpp:12:9] -> [test.cpp:14:8]: (style, inconclusive) Technically the member function 'B::func' can be const. [functionConst]\n"
                       "[test.cpp:19:9] -> [test.cpp:21:8]: (style, inconclusive) Technically the member function 'C::func' can be const. [functionConst]\n", errout_str());
@@ -7672,7 +7672,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    C() : c(0) { }\n"
                    "    int func() { return c; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
@@ -7695,7 +7695,7 @@ class TestClass : public TestFixture {
                    "    C() : c(0) { }\n"
                    "    int func();\n"
                    "};\n"
-                   "int C::func() { return c; }");
+                   "int C::func() { return c; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #1311
@@ -7716,7 +7716,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    Z(int x, int y, int z) : Y(x, y), z(z) { }\n"
                    "    int getZ() { return z; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:5:9]: (style, inconclusive) Technically the member function 'X::getX' can be const. [functionConst]\n"
                       "[test.cpp:11:9]: (style, inconclusive) Technically the member function 'Y::getY' can be const. [functionConst]\n"
                       "[test.cpp:17:9]: (style, inconclusive) Technically the member function 'Z::getZ' can be const. [functionConst]\n", errout_str());
@@ -7741,7 +7741,7 @@ class TestClass : public TestFixture {
                    "    Z(int x, int y, int z) : Y(x, y), z(z) { }\n"
                    "    int getZ();\n"
                    "};\n"
-                   "int Z::getZ() { return z; }");
+                   "int Z::getZ() { return z; }\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:7:8]: (style, inconclusive) Technically the member function 'X::getX' can be const. [functionConst]\n"
                       "[test.cpp:12:9] -> [test.cpp:14:8]: (style, inconclusive) Technically the member function 'Y::getY' can be const. [functionConst]\n"
                       "[test.cpp:19:9] -> [test.cpp:21:8]: (style, inconclusive) Technically the member function 'Z::getZ' can be const. [functionConst]\n", errout_str());
@@ -7755,7 +7755,7 @@ class TestClass : public TestFixture {
                             //"        i = 4;\n"
                             //"endif\n"
                             "    }\n"
-                            "};";
+                            "};\n";
 
         checkConst(code);
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'foo::f' can be static. [functionStatic]\n", errout_str());
@@ -7767,7 +7767,7 @@ class TestClass : public TestFixture {
     void constFriend() { // ticket #1921
         const char code[] = "class foo {\n"
                             "    friend void f() { }\n"
-                            "};";
+                            "};\n";
         checkConst(code);
         ASSERT_EQUALS("", errout_str());
     }
@@ -7782,7 +7782,7 @@ class TestClass : public TestFixture {
                    "    void setf(float x) {\n"
                    "        d.f = x;\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7799,7 +7799,7 @@ class TestClass : public TestFixture {
                    "    T c() {\n"
                    "        return y[1][6];\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:10:7]: (style, inconclusive) Technically the member function 'foo::c' can be const. [functionConst]\n", errout_str());
     }
 
@@ -7819,7 +7819,7 @@ class TestClass : public TestFixture {
                    "        for (decltype(auto) e : array)\n"
                    "            foo(e);\n"
                    "    }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("[test.cpp:8:10]: (style, inconclusive) Technically the member function 'Fred::f2' can be const. [functionConst]\n", errout_str());
 
         checkConst("struct T {\n" // #14390
@@ -7844,7 +7844,7 @@ class TestClass : public TestFixture {
                    "     std::shared_ptr<Data> data;\n"
                    "};\n"
                    "\n"
-                   "std::shared_ptr<Data> Fred::getData() { return data; }");
+                   "std::shared_ptr<Data> Fred::getData() { return data; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7852,7 +7852,7 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "public:\n"
                    "    const char *const *data;\n"
-                   "    const char *const *getData() { return data; }\n}");
+                   "    const char *const *getData() { return data; }\n}\n");
         ASSERT_EQUALS("[test.cpp:4:24]: (style, inconclusive) Technically the member function 'Fred::getData' can be const. [functionConst]\n", errout_str());
     }
 
@@ -7860,7 +7860,7 @@ class TestClass : public TestFixture {
         checkConst("struct A {\n"
                    "    int x = 1;\n"
                    "    auto get() -> int & { return x; }\n"
-                   "};");
+                   "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7919,7 +7919,7 @@ class TestClass : public TestFixture {
                                   "    int a, b, c;\n"
                                   "public:\n"
                                   "    Fred() : c(0), b(0), a(0) { }\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("[test.cpp:4:20] -> [test.cpp:2:12]: (style, inconclusive) Member variable 'Fred::b' is in the wrong place in the initializer list. [initializerList]\n"
                       "[test.cpp:4:26] -> [test.cpp:2:9]: (style, inconclusive) Member variable 'Fred::a' is in the wrong place in the initializer list. [initializerList]\n", errout_str());
 
@@ -7927,14 +7927,14 @@ class TestClass : public TestFixture {
                                   "    int a, b, c;\n"
                                   "public:\n"
                                   "    Fred() : c{0}, b{0}, a{0} { }\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("[test.cpp:4:20] -> [test.cpp:2:12]: (style, inconclusive) Member variable 'Fred::b' is in the wrong place in the initializer list. [initializerList]\n"
                       "[test.cpp:4:26] -> [test.cpp:2:9]: (style, inconclusive) Member variable 'Fred::a' is in the wrong place in the initializer list. [initializerList]\n", errout_str());
 
         checkInitializerListOrder("struct S {\n"
                                   "    S() : b(a = 1) {}\n"
                                   "    int a, b;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializerListOrder("struct S {\n"
@@ -7957,7 +7957,7 @@ class TestClass : public TestFixture {
                                   "        : B(\"abc\", s.nRows(), s.nCols())\n"
                                   "        , m_i(_i)\n"
                                   "    {}\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7968,41 +7968,41 @@ class TestClass : public TestFixture {
                                   "    C() : b(&a) {}\n"
                                   "    B b;\n"
                                   "    const A a;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("[test.cpp:4:11] -> [test.cpp:5:7]: (style, inconclusive) Member variable 'C::b' uses an uninitialized argument 'a' due to the order of declarations. [initializerList]\n",
                       errout_str());
 
         checkInitializerListOrder("struct S {\n"
                                   "    S(const std::string& f, std::string i, int b, int c) : a(0), b(b), c(c) {}\n"
                                   "    int a, b, c;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializerListOrder("struct S {\n"
                                   "    S() : p(a) {}\n"
                                   "    int* p;\n"
                                   "    int a[1];\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializerListOrder("struct S {\n"
                                   "    S() : p(&i) {}\n"
                                   "    int* p;\n"
                                   "    int i;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializerListOrder("struct S {\n"
                                   "    S() : a(b = 1) {}\n"
                                   "    int a, b;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializerListOrder("struct S {\n"
                                   "    S() : r(i) {}\n"
                                   "    int& r;\n"
                                   "    int i{};\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializerListOrder("struct B {\n"
@@ -8011,7 +8011,7 @@ class TestClass : public TestFixture {
                                   "struct D : B {\n"
                                   "    D() : B(), j(b) {}\n"
                                   "    int j;\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializerListOrder("struct S {\n"
@@ -8019,13 +8019,13 @@ class TestClass : public TestFixture {
                                   "    int a;\n"
                                   "    static int i;\n"
                                   "};\n"
-                                  "int S::i = 0;");
+                                  "int S::i = 0;\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializerListOrder("struct S {\n"
                                   "    S(int b) : a(b) {}\n"
                                   "    int a, b{};\n"
-                                  "};");
+                                  "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializerListOrder("class Foo {\n" // #3524
@@ -8075,113 +8075,113 @@ class TestClass : public TestFixture {
                                      "    int* b;\n" // No message for pointers: No performance gain
                                      "    Enum c;\n" // No message for enums: No performance gain
                                      "    Fred() { a = 0; b = 0; c = C; }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n"
                                      "    std::string s;\n"
                                      "    Fred() { a = 0; s = \"foo\"; }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("[test.cpp:3:21]: (performance) Variable 's' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class Fred {\n"
                                      "    std::string& s;\n" // Message is invalid for references, since their initialization in initializer list is required anyway and behaves different from assignment (#5004)
                                      "    Fred(const std::string& s_) : s(s_) { s = \"foo\"; }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n"
                                      "    std::vector<int> v;\n"
                                      "    Fred() { v = unknown; }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (performance) Variable 'v' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class C { std::string s; };\n"
                                      "class Fred {\n"
                                      "    C c;\n"
                                      "    Fred() { c = unknown; }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("[test.cpp:4:14]: (performance) Variable 'c' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C c;\n"
                                      "    Fred() { c = unknown; }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("[test.cpp:4:14]: (performance) Variable 'c' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C c;\n"
                                      "    Fred(Fred const & other) { c = other.c; }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("[test.cpp:4:32]: (performance) Variable 'c' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C c;\n"
                                      "    Fred(Fred && other) { c = other.c; }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("[test.cpp:4:27]: (performance) Variable 'c' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C a;\n"
                                      "    Fred() { initB(); a = b; }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C a;\n"
                                      "    Fred() : a(0) { if(b) a = 0; }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C a[5];\n"
                                      "    Fred() { for(int i = 0; i < 5; i++) a[i] = 0; }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C a; int b;\n"
                                      "    Fred() : b(5) { a = b; }\n" // Don't issue a message here: You actually could move it to the initialization list, but it would cause problems if you change the order of the variable declarations.
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C a;\n"
                                      "    Fred() { try { a = new int; } catch(...) {} }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n"
                                      "    std::string s;\n"
                                      "    Fred() { s = toString((size_t)this); }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n"
                                      "    std::string a;\n"
                                      "    std::string foo();\n"
                                      "    Fred() { a = foo(); }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n"
                                      "    std::string a;\n"
                                      "    Fred() { a = foo(); }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (performance) Variable 'a' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class Fred {\n" // #4332
                                      "    static std::string s;\n"
                                      "    Fred() { s = \"foo\"; }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n" // #5640
@@ -8192,7 +8192,7 @@ class TestClass : public TestFixture {
                                      "        str[1] = 0;\n"
                                      "        s = str;\n"
                                      "    }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class B {\n" // #5640
@@ -8200,7 +8200,7 @@ class TestClass : public TestFixture {
                                      "    B(const B& other) : _d(std::make_shared<A>()) {\n"
                                      "        *_d = *other._d;\n"
                                      "    }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Bar {\n" // #8466
@@ -8209,7 +8209,7 @@ class TestClass : public TestFixture {
                                      "    explicit Bar(const char s) : s{s} {}\n"
                                      "private:\n"
                                      "    char s;\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("unsigned bar(std::string);\n" // #8291
@@ -8218,7 +8218,7 @@ class TestClass : public TestFixture {
                                      "    int a_, b_;\n"
                                      "    Foo(int a, int b) : a_(a), b_(b) {}\n"
                                      "    Foo(int a, const std::string& b) : Foo(a, bar(b)) {}\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n" // #8111
@@ -8228,7 +8228,7 @@ class TestClass : public TestFixture {
                                      "        ostr << x;\n"
                                      "        a = ostr.str();\n"
                                      "    }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // bailout: multi line lambda in rhs => do not warn
@@ -8239,7 +8239,7 @@ class TestClass : public TestFixture {
                                      "            return 1;\n"
                                      "        };\n"
                                      "    }\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // don't warn if some other instance's members are assigned to
@@ -8248,7 +8248,7 @@ class TestClass : public TestFixture {
                                      "    C(C& c) : m_i(c.m_i) { c.m_i = (Foo)-1; }\n"
                                      "private:\n"
                                      "    Foo m_i;\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class A {\n" // #9821 - delegate constructor
@@ -8261,7 +8261,7 @@ class TestClass : public TestFixture {
                                      "\n"
                                      "private:\n"
                                      "    std::string st;\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("struct S {\n" // #14189
@@ -8276,7 +8276,7 @@ class TestClass : public TestFixture {
                                      "        p = std::make_unique<T>(s);\n"
                                      "    }\n"
                                      "    std::unique_ptr<T> p;\n"
-                                     "};");
+                                     "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -8297,14 +8297,14 @@ class TestClass : public TestFixture {
                                 "    int i;\n"
                                 "    Fred() : i(i) {\n"
                                 "    }\n"
-                                "};");
+                                "};\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Member variable 'i' is initialized by itself. [selfInitialization]\n", errout_str());
 
         checkSelfInitialization("class Fred {\n"
                                 "    int i;\n"
                                 "    Fred() : i{i} {\n"
                                 "    }\n"
-                                "};");
+                                "};\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Member variable 'i' is initialized by itself. [selfInitialization]\n", errout_str());
 
         checkSelfInitialization("class Fred {\n"
@@ -8312,7 +8312,7 @@ class TestClass : public TestFixture {
                                 "    Fred();\n"
                                 "};\n"
                                 "Fred::Fred() : i(i) {\n"
-                                "}");
+                                "}\n");
         ASSERT_EQUALS("[test.cpp:5:14]: (error) Member variable 'i' is initialized by itself. [selfInitialization]\n", errout_str());
 
         checkSelfInitialization("class A {\n" // #10427
@@ -8335,56 +8335,56 @@ class TestClass : public TestFixture {
                                 "    std::string s;\n"
                                 "    Fred() : s(s) {\n"
                                 "    }\n"
-                                "};");
+                                "};\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Member variable 's' is initialized by itself. [selfInitialization]\n", errout_str());
 
         checkSelfInitialization("class Fred {\n"
                                 "    int x;\n"
                                 "    Fred(int x);\n"
                                 "};\n"
-                                "Fred::Fred(int x) : x(x) { }");
+                                "Fred::Fred(int x) : x(x) { }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkSelfInitialization("class Fred {\n"
                                 "    int x;\n"
                                 "    Fred(int x);\n"
                                 "};\n"
-                                "Fred::Fred(int x) : x{x} { }");
+                                "Fred::Fred(int x) : x{x} { }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkSelfInitialization("class Fred {\n"
                                 "    std::string s;\n"
                                 "    Fred(const std::string& s) : s(s) {\n"
                                 "    }\n"
-                                "};");
+                                "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkSelfInitialization("class Fred {\n"
                                 "    std::string s;\n"
                                 "    Fred(const std::string& s) : s{s} {\n"
                                 "    }\n"
-                                "};");
+                                "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkSelfInitialization("struct Foo : Bar {\n"
                                 "    int i;\n"
                                 "    Foo(int i)\n"
                                 "        : Bar(\"\"), i(i) {}\n"
-                                "};");
+                                "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkSelfInitialization("struct Foo : std::Bar {\n" // #6073
                                 "    int i;\n"
                                 "    Foo(int i)\n"
                                 "        : std::Bar(\"\"), i(i) {}\n"
-                                "};");
+                                "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkSelfInitialization("struct Foo : std::Bar {\n" // #6073
                                 "    int i;\n"
                                 "    Foo(int i)\n"
                                 "        : std::Bar(\"\"), i{i} {}\n"
-                                "};");
+                                "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -8409,21 +8409,21 @@ class TestClass : public TestFixture {
                                  "    A();\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{f();}");
+                                 "{f();}\n");
         ASSERT_EQUALS("[test.cpp:7:2] -> [test.cpp:3:17]: (style) Virtual function 'f' is called from constructor 'A()' at line 7. Dynamic binding is not used. [virtualCallInConstructor]\n", errout_str());
 
         checkVirtualFunctionCall("class A {\n"
                                  "    virtual int f();\n"
                                  "    A() {f();}\n"
                                  "};\n"
-                                 "int A::f() { return 1; }");
+                                 "int A::f() { return 1; }\n");
         ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:2:17]: (style) Virtual function 'f' is called from constructor 'A()' at line 3. Dynamic binding is not used. [virtualCallInConstructor]\n", errout_str());
 
         checkVirtualFunctionCall("class A : B {\n"
                                  "    int f() override;\n"
                                  "    A() {f();}\n"
                                  "};\n"
-                                 "int A::f() { return 1; }");
+                                 "int A::f() { return 1; }\n");
         ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:2:9]: (style) Virtual function 'f' is called from constructor 'A()' at line 3. Dynamic binding is not used. [virtualCallInConstructor]\n", errout_str());
 
         checkVirtualFunctionCall("class B {\n"
@@ -8433,14 +8433,14 @@ class TestClass : public TestFixture {
                                  "    int f();\n" // <- not explicitly virtual
                                  "    A() {f();}\n"
                                  "};\n"
-                                 "int A::f() { return 1; }");
+                                 "int A::f() { return 1; }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  "{\n"
                                  "    A() { A::f(); }\n"
                                  "    virtual void f() {}\n"
-                                 "};");
+                                 "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkVirtualFunctionCall("class A : B {\n"
@@ -8526,7 +8526,7 @@ class TestClass : public TestFixture {
                                  "    A();\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{pure();}");
+                                 "{pure();}\n");
         ASSERT_EQUALS("[test.cpp:7:2] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in constructor. [pureVirtualCall]\n", errout_str());
 
         checkVirtualFunctionCall("class A\n"
@@ -8536,7 +8536,7 @@ class TestClass : public TestFixture {
                                  "    int m;\n"
                                  "};\n"
                                  "A::A():m(A::pure())\n"
-                                 "{}");
+                                 "{}\n");
         ASSERT_EQUALS("[test.cpp:7:13] -> [test.cpp:3:17]: (warning) Call of pure virtual function 'pure' in constructor. [pureVirtualCall]\n", errout_str());
 
         checkVirtualFunctionCall("namespace N {\n"
@@ -8557,7 +8557,7 @@ class TestClass : public TestFixture {
                                  "    int m;\n"
                                  "};\n"
                                  "A::~A()\n"
-                                 "{pure();}");
+                                 "{pure();}\n");
         ASSERT_EQUALS("[test.cpp:8:2] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in destructor. [pureVirtualCall]\n", errout_str());
 
         checkVirtualFunctionCall("class A\n"
@@ -8568,7 +8568,7 @@ class TestClass : public TestFixture {
                                  "    A();\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{nonpure();}");
+                                 "{nonpure();}\n");
         ASSERT_EQUALS("[test.cpp:9:2] -> [test.cpp:5:6] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in constructor. [pureVirtualCall]\n", errout_str());
 
         checkVirtualFunctionCall("class A\n"
@@ -8580,7 +8580,7 @@ class TestClass : public TestFixture {
                                  "    int m;\n"
                                  "};\n"
                                  "A::A():m(nonpure())\n"
-                                 "{}");
+                                 "{}\n");
         TODO_ASSERT_EQUALS("[test.cpp:9:2] -> [test.cpp:5:6] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in constructor. [pureVirtualCall]\n", "", errout_str());
 
         checkVirtualFunctionCall("class A\n"
@@ -8592,7 +8592,7 @@ class TestClass : public TestFixture {
                                  "    int m;\n"
                                  "};\n"
                                  "A::~A()\n"
-                                 "{nonpure();}");
+                                 "{nonpure();}\n");
         ASSERT_EQUALS("[test.cpp:10:2] -> [test.cpp:5:6] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in destructor. [pureVirtualCall]\n", errout_str());
 
         checkVirtualFunctionCall("class A\n"
@@ -8601,7 +8601,7 @@ class TestClass : public TestFixture {
                                  "    A(bool b);\n"
                                  "};\n"
                                  "A::A(bool b)\n"
-                                 "{if (b) pure();}");
+                                 "{if (b) pure();}\n");
         ASSERT_EQUALS("[test.cpp:7:9] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in constructor. [pureVirtualCall]\n", errout_str());
 
         checkVirtualFunctionCall("class A\n"
@@ -8611,7 +8611,7 @@ class TestClass : public TestFixture {
                                  "    int m;\n"
                                  "};\n"
                                  "A::~A()\n"
-                                 "{if (b) pure();}");
+                                 "{if (b) pure();}\n");
         ASSERT_EQUALS("[test.cpp:8:9] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in destructor. [pureVirtualCall]\n", errout_str());
 
         // #5831
@@ -8619,7 +8619,7 @@ class TestClass : public TestFixture {
                                  "public:\n"
                                  "  virtual ~abc() throw() {}\n"
                                  "  virtual void def(void* g) throw () = 0;\n"
-                                 "};");
+                                 "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4992
@@ -8630,7 +8630,7 @@ class TestClass : public TestFixture {
                                  "        m_callback = [this]() { return VirtualMethod(); };\n"
                                  "    }\n"
                                  "    virtual void VirtualMethod() = 0;\n"
-                                 "};");
+                                 "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #10559
@@ -8649,7 +8649,7 @@ class TestClass : public TestFixture {
                                  "    A(const A & a);\n"
                                  "};\n"
                                  "A::A(const A & a)\n"
-                                 "{a.pure();}");
+                                 "{a.pure();}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkVirtualFunctionCall("class A\n"
@@ -8662,7 +8662,7 @@ class TestClass : public TestFixture {
                                  "    virtual void pure()=0;\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{B b; b.pure();}");
+                                 "{B b; b.pure();}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -8675,7 +8675,7 @@ class TestClass : public TestFixture {
                                  "A::A()\n"
                                  "{pureWithBody();}\n"
                                  "void A::pureWithBody()\n"
-                                 "{}");
+                                 "{}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkVirtualFunctionCall("class A\n"
@@ -8688,7 +8688,7 @@ class TestClass : public TestFixture {
                                  "A::A()\n"
                                  "{nonpure();}\n"
                                  "void A::pureWithBody()\n"
-                                 "{}");
+                                 "{}\n");
         ASSERT_EQUALS("", errout_str());
 
     }
@@ -8702,7 +8702,7 @@ class TestClass : public TestFixture {
                                  "    A();\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{nonpure(false);}");
+                                 "{nonpure(false);}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkVirtualFunctionCall("class A\n"
@@ -8713,7 +8713,7 @@ class TestClass : public TestFixture {
                                  "    A();\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{nonpure(false);}");
+                                 "{nonpure(false);}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkVirtualFunctionCall("class A\n"
@@ -8728,7 +8728,7 @@ class TestClass : public TestFixture {
                                  "    A();\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{nonpure(false);}");
+                                 "{nonpure(false);}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -8749,15 +8749,15 @@ class TestClass : public TestFixture {
 
     void override1() {
         checkOverride("class Base { virtual void f(); };\n"
-                      "class Derived : Base { virtual void f(); };");
+                      "class Derived : Base { virtual void f(); };\n");
         ASSERT_EQUALS("[test.cpp:1:27] -> [test.cpp:2:37]: (style) The function 'f' overrides a function in a base class but is not marked with a 'override' specifier. [missingOverride]\n", errout_str());
 
         checkOverride("class Base { virtual void f(); };\n"
-                      "class Derived : Base { virtual void f() override; };");
+                      "class Derived : Base { virtual void f() override; };\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOverride("class Base { virtual void f(); };\n"
-                      "class Derived : Base { virtual void f() final; };");
+                      "class Derived : Base { virtual void f() final; };\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOverride("class Base {\n"
@@ -8769,7 +8769,7 @@ class TestClass : public TestFixture {
                       "public :\n"
                       "    auto foo( ) const -> size_t { return 0; }\n"
                       "    auto bar( ) const -> size_t override { return 0; }\n"
-                      "};");
+                      "};\n");
         ASSERT_EQUALS("[test.cpp:3:18] -> [test.cpp:8:10]: (style) The function 'foo' overrides a function in a base class but is not marked with a 'override' specifier. [missingOverride]\n", errout_str());
 
         checkOverride("namespace Test {\n"
@@ -8781,7 +8781,7 @@ class TestClass : public TestFixture {
                       "class C : Test::C {\n"
                       "public:\n"
                       "    ~C();\n"
-                      "};");
+                      "};\n");
         ASSERT_EQUALS("[test.cpp:4:18] -> [test.cpp:9:6]: (style) The destructor '~C' overrides a destructor in a base class but is not marked with a 'override' specifier. [missingOverride]\n", errout_str());
 
         checkOverride("struct Base {\n"
@@ -8791,7 +8791,7 @@ class TestClass : public TestFixture {
                       "struct Derived: public Base {\n"
                       "   void foo() override;\n"
                       "   void foo(int);\n"
-                      "};");
+                      "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOverride("struct B {\n" // #9092
@@ -8929,19 +8929,19 @@ class TestClass : public TestFixture {
 
     void overrideCVRefQualifiers() {
         checkOverride("class Base { virtual void f(); };\n"
-                      "class Derived : Base { void f() const; }");
+                      "class Derived : Base { void f() const; }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOverride("class Base { virtual void f(); };\n"
-                      "class Derived : Base { void f() volatile; }");
+                      "class Derived : Base { void f() volatile; }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOverride("class Base { virtual void f(); };\n"
-                      "class Derived : Base { void f() &; }");
+                      "class Derived : Base { void f() &; }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOverride("class Base { virtual void f(); };\n"
-                      "class Derived : Base { void f() &&; }");
+                      "class Derived : Base { void f() &&; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -8963,51 +8963,51 @@ class TestClass : public TestFixture {
         checkUselessOverride("struct B { virtual int f() { return 5; } };\n" // #11757
                              "struct D : B {\n"
                              "    int f() override { return B::f(); }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:1:24] -> [test.cpp:3:9]: (style) The function 'f' overrides a function in a base class but just delegates back to the base class. [uselessOverride]\n", errout_str());
 
         checkUselessOverride("struct B { virtual void f(); };\n"
                              "struct D : B {\n"
                              "    void f() override { B::f(); }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:1:25] -> [test.cpp:3:10]: (style) The function 'f' overrides a function in a base class but just delegates back to the base class. [uselessOverride]\n", errout_str());
 
         checkUselessOverride("struct B { virtual int f() = 0; };\n"
                              "int B::f() { return 5; }\n"
                              "struct D : B {\n"
                              "    int f() override { return B::f(); }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUselessOverride("struct B { virtual int f(int i); };\n"
                              "struct D : B {\n"
                              "    int f(int i) override { return B::f(i); }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:1:24] -> [test.cpp:3:9]: (style) The function 'f' overrides a function in a base class but just delegates back to the base class. [uselessOverride]\n", errout_str());
 
         checkUselessOverride("struct B { virtual int f(int i); };\n"
                              "struct D : B {\n"
                              "    int f(int i) override { return B::f(i + 1); }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUselessOverride("struct B { virtual int f(int i, int j); };\n"
                              "struct D : B {\n"
                              "    int f(int i, int j) override { return B::f(j, i); }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUselessOverride("struct B { virtual int f(); };\n"
                              "struct I { virtual int f() = 0; };\n"
                              "struct D : B, I {\n"
                              "    int f() override { return B::f(); }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUselessOverride("struct S { virtual void f(); };\n"
                              "struct D : S {\n"
                              "    void f() final { S::f(); }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUselessOverride("struct S {\n"
@@ -9017,7 +9017,7 @@ class TestClass : public TestFixture {
                              "struct D : S {\n"
                              "public:\n"
                              "    void f() override { S::f(); }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUselessOverride("struct B { virtual void f(int, int, int) const; };\n" // #11799
@@ -9027,7 +9027,7 @@ class TestClass : public TestFixture {
                              "};\n"
                              "void D::f(int a, int b, int c) const {\n"
                              "    B::f(a, b, m);\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUselessOverride("struct B {\n" // #11803
@@ -9038,7 +9038,7 @@ class TestClass : public TestFixture {
                              "    void f() override { B::f(); }\n"
                              "    void f(int i) override;\n"
                              "    void g() { f(); }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUselessOverride("struct B { virtual void f(); };\n" // #11808
@@ -9047,7 +9047,7 @@ class TestClass : public TestFixture {
                              "    void f() override {\n"
                              "        B::f();\n"
                              "    }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUselessOverride("struct B {\n"
@@ -9061,7 +9061,7 @@ class TestClass : public TestFixture {
                              "    int g() override { return 7; }\n"
                              "    int h(int j, int i) override { return i + j; }\n"
                              "    int j(int i, int j) override { return i + j; }\n"
-                             "};");
+                             "};\n");
         ASSERT_EQUALS("[test.cpp:3:17] -> [test.cpp:9:9]: (style) The function 'g' overrides a function in a base class but is identical to the overridden function [uselessOverride]\n"
                       "[test.cpp:5:17] -> [test.cpp:11:9]: (style) The function 'j' overrides a function in a base class but is identical to the overridden function [uselessOverride]\n",
                       errout_str());
@@ -9150,7 +9150,7 @@ class TestClass : public TestFixture {
     }
 
     void unsafeClassRefMember() {
-        checkUnsafeClassRefMember("class C { C(const std::string &s) : s(s) {} const std::string &s; };");
+        checkUnsafeClassRefMember("class C { C(const std::string &s) : s(s) {} const std::string &s; };\n");
         ASSERT_EQUALS("[test.cpp:1:37]: (warning) Unsafe class: The const reference member 'C::s' is initialized by a const reference constructor argument. You need to be careful about lifetime issues. [unsafeClassRefMember]\n", errout_str());
     }
 
@@ -9177,7 +9177,7 @@ class TestClass : public TestFixture {
                               "private:\n"
                               "  static C *mInstance;\n"
                               "  void hello() {}\n"
-                              "};");
+                              "};\n");
         ASSERT_EQUALS("[test.cpp:3:38]: warning: Calling method 'hello()' when 'this' might be invalid [thisUseAfterFree]\n"
                       "[test.cpp:5:13]: note: Assuming 'mInstance' is used as 'this'\n"
                       "[test.cpp:3:20]: note: Delete 'mInstance', invalidating 'this'\n"
@@ -9190,7 +9190,7 @@ class TestClass : public TestFixture {
                               "private:\n"
                               "  static std::shared_ptr<C> mInstance;\n"
                               "  void hello() {}\n"
-                              "};");
+                              "};\n");
         ASSERT_EQUALS("[test.cpp:3:39]: warning: Calling method 'hello()' when 'this' might be invalid [thisUseAfterFree]\n"
                       "[test.cpp:5:29]: note: Assuming 'mInstance' is used as 'this'\n"
                       "[test.cpp:3:20]: note: Delete 'mInstance', invalidating 'this'\n"
@@ -9204,7 +9204,7 @@ class TestClass : public TestFixture {
                               "  static std::shared_ptr<C> mInstance;\n"
                               "  void hello();\n"
                               "  void reset() { mInstance.reset(); }\n"
-                              "};");
+                              "};\n");
         ASSERT_EQUALS("[test.cpp:3:29]: warning: Calling method 'hello()' when 'this' might be invalid [thisUseAfterFree]\n"
                       "[test.cpp:5:29]: note: Assuming 'mInstance' is used as 'this'\n"
                       "[test.cpp:7:18]: note: Delete 'mInstance', invalidating 'this'\n"
@@ -9218,7 +9218,7 @@ class TestClass : public TestFixture {
                               "private:\n"
                               "  static C *self;\n"
                               "  int x;\n"
-                              "};");
+                              "};\n");
         ASSERT_EQUALS("[test.cpp:3:33]: warning: Using member 'x' when 'this' might be invalid [thisUseAfterFree]\n"
                       "[test.cpp:5:13]: note: Assuming 'self' is used as 'this'\n"
                       "[test.cpp:3:20]: note: Delete 'self', invalidating 'this'\n"
@@ -9231,7 +9231,7 @@ class TestClass : public TestFixture {
                               "private:\n"
                               "  static C *self;\n"
                               "  std::map<int,int> x;\n"
-                              "};");
+                              "};\n");
         ASSERT_EQUALS("[test.cpp:3:33]: warning: Using member 'x' when 'this' might be invalid [thisUseAfterFree]\n"
                       "[test.cpp:5:13]: note: Assuming 'self' is used as 'this'\n"
                       "[test.cpp:3:20]: note: Delete 'self', invalidating 'this'\n"
@@ -9246,7 +9246,7 @@ class TestClass : public TestFixture {
                               "private:\n"
                               "  std::shared_ptr<C> mInstance;\n"
                               "  void hello() {}\n"
-                              "};");
+                              "};\n");
         ASSERT_EQUALS("[test.cpp:4:39]: warning: Calling method 'hello()' when 'this' might be invalid [thisUseAfterFree]\n"
                       "[test.cpp:6:22]: note: Assuming 'mInstance' is used as 'this'\n"
                       "[test.cpp:4:20]: note: Delete 'mInstance', invalidating 'this'\n"
@@ -9260,7 +9260,7 @@ class TestClass : public TestFixture {
                               "private:\n"
                               "  C *self;\n"
                               "  int x;\n"
-                              "};");
+                              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkThisUseAfterFree("class C {\n"
@@ -9270,7 +9270,7 @@ class TestClass : public TestFixture {
                               "private:\n"
                               "  std::shared_ptr<C> mInstance;\n"
                               "  void hello() {}\n"
-                              "};");
+                              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkThisUseAfterFree("class C\n"
@@ -9287,7 +9287,7 @@ class TestClass : public TestFixture {
                               "    static C* instanceSingleton;\n"
                               "};\n"
                               "\n"
-                              "C* C::instanceSingleton;");
+                              "C* C::instanceSingleton;\n");
         ASSERT_EQUALS("", errout_str());
 
         // Avoid false positive when pointer is deleted in lambda
@@ -9303,7 +9303,7 @@ class TestClass : public TestFixture {
                               "    auto done = [this] () { delete p; };\n"
                               "    dostuff();\n"
                               "    done();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkThisUseAfterFree("class C {\n" // #13311
@@ -9319,7 +9319,7 @@ class TestClass : public TestFixture {
                               "    if (self)\n"
                               "        delete self;\n"
                               "    self = new C();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -9348,19 +9348,19 @@ class TestClass : public TestFixture {
     }
 
     void ctuOneDefinitionRule() {
-        ctu({"class C { C() { std::cout << 0; } };", "class C { C() { std::cout << 1; } };"});
+        ctu({"class C { C() { std::cout << 0; } };\n", "class C { C() { std::cout << 1; } };\n"});
         ASSERT_EQUALS("[1.cpp:1:1] -> [0.cpp:1:1]: (error) The one definition rule is violated, different classes/structs have the same name 'C' [ctuOneDefinitionRuleViolation]\n", errout_str());
 
-        ctu({"class C { C(); }; C::C() { std::cout << 0; }", "class C { C(); }; C::C() { std::cout << 1; }"});
+        ctu({"class C { C(); }; C::C() { std::cout << 0; }\n", "class C { C(); }; C::C() { std::cout << 1; }\n"});
         ASSERT_EQUALS("[1.cpp:1:1] -> [0.cpp:1:1]: (error) The one definition rule is violated, different classes/structs have the same name 'C' [ctuOneDefinitionRuleViolation]\n", errout_str());
 
         ctu({"class C { C() {} };\n", "class C { C() {} };\n"});
         ASSERT_EQUALS("", errout_str());
 
-        ctu({"class C { C(); }; C::C(){}", "class C { C(); }; C::C(){}"});
+        ctu({"class C { C(); }; C::C(){}\n", "class C { C(); }; C::C(){}\n"});
         ASSERT_EQUALS("", errout_str());
 
-        ctu({"class A::C { C() { std::cout << 0; } };", "class B::C { C() { std::cout << 1; } };"});
+        ctu({"class A::C { C() { std::cout << 0; } };\n", "class B::C { C() { std::cout << 1; } };\n"});
         ASSERT_EQUALS("", errout_str());
 
         // 11435 - template specialisations
@@ -9386,8 +9386,8 @@ class TestClass : public TestFixture {
     }
 
     void testGetFileInfo() {
-        getFileInfo("void foo() { union { struct { }; }; }"); // don't crash
-        getFileInfo("struct sometype { sometype(); }; sometype::sometype() = delete;"); // don't crash
+        getFileInfo("void foo() { union { struct { }; }; }\n"); // don't crash
+        getFileInfo("struct sometype { sometype(); }; sometype::sometype() = delete;\n"); // don't crash
     }
 
 #define checkReturnByReference(...) checkReturnByReference_(__FILE__, __LINE__, __VA_ARGS__)
diff --git a/test/testcondition.cpp b/test/testcondition.cpp
index 8567d9b11a7..6d62b644043 100644
--- a/test/testcondition.cpp
+++ b/test/testcondition.cpp
@@ -172,59 +172,59 @@ class TestCondition : public TestFixture {
               "{\n"
               "    int y = x & 4;\n"
               "    if (y == 3);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:4:8]: (style) Mismatching assignment and comparison, comparison 'y==3' is always false. [assignIfError]\n", errout_str());
 
         check("void foo(int x)\n"
               "{\n"
               "    int y = x & 4;\n"
               "    if (y != 3);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:4:8]: (style) Mismatching assignment and comparison, comparison 'y!=3' is always true. [assignIfError]\n", errout_str());
 
         // |
         check("void foo(int x) {\n"
               "    int y = x | 0x14;\n"
               "    if (y == 0x710);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:8]: (style) Mismatching assignment and comparison, comparison 'y==0x710' is always false. [assignIfError]\n", errout_str());
 
         check("void foo(int x) {\n"
               "    int y = x | 0x14;\n"
               "    if (y == 0x71f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // various simple assignments
         check("void foo(int x) {\n"
               "    int y = (x+1) | 1;\n"
               "    if (y == 2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:8]: (style) Mismatching assignment and comparison, comparison 'y==2' is always false. [assignIfError]\n", errout_str());
 
         check("void foo() {\n"
               "    int y = 1 | x();\n"
               "    if (y == 2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:8]: (style) Mismatching assignment and comparison, comparison 'y==2' is always false. [assignIfError]\n", errout_str());
 
         // multiple conditions
         check("void foo(int x) {\n"
               "    int y = x & 4;\n"
               "    if ((y == 3) && (z == 1));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:9]: (style) Mismatching assignment and comparison, comparison 'y==3' is always false. [assignIfError]\n", errout_str());
 
         check("void foo(int x) {\n"
               "    int y = x & 4;\n"
               "    if ((x==123) || ((y == 3) && (z == 1)));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:22]: (style) Mismatching assignment and comparison, comparison 'y==3' is always false. [assignIfError]\n", errout_str());
 
         check("void f(int x) {\n"
               "    int y = x & 7;\n"
               "    if (setvalue(&y) && y != 8);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // recursive checking into scopes
@@ -232,20 +232,20 @@ class TestCondition : public TestFixture {
               "    int y = x & 7;\n"
               "    if (z) y=0;\n"
               "    else { if (y==8); }\n" // always false
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:4:15]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false. [assignIfError]\n", errout_str());
 
         // while
         check("void f(int x) {\n"
               "    int y = x & 7;\n"
               "    while (y==8);\n" // local variable => always false
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:11]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false. [assignIfError]\n", errout_str());
 
         check("void f(int x) {\n"
               "    extern int y; y = x & 7;\n"
               "    while (y==8);\n" // non-local variable => no error
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
@@ -254,7 +254,7 @@ class TestCondition : public TestFixture {
               "        int y = 16 | a;\n"
               "        while (y != 0) y--;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g(int x);\n"
@@ -264,7 +264,7 @@ class TestCondition : public TestFixture {
               "        int y = 16 | a;\n"
               "        while (y != 0) g(y);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:5:15] -> [test.cpp:6:15]: (style) Mismatching assignment and comparison, comparison 'y!=0' is always true. [assignIfError]\n",
             errout_str());
@@ -276,7 +276,7 @@ class TestCondition : public TestFixture {
               "        int y = 16 | a;\n"
               "        while (y != 0) g(y);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // calling function
@@ -284,14 +284,14 @@ class TestCondition : public TestFixture {
               "    int y = x & 7;\n"
               "    do_something();\n"
               "    if (y==8);\n" // local variable => always false
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:4:8]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false. [assignIfError]\n", errout_str());
 
         check("void f(int x) {\n"
               "    int y = x & 7;\n"
               "    do_something(&y);\n" // passing variable => no error
               "    if (y==8);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void do_something(int);\n"
@@ -299,14 +299,14 @@ class TestCondition : public TestFixture {
               "    int y = x & 7;\n"
               "    do_something(y);\n"
               "    if (y==8);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:5:8]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false. [assignIfError]\n", errout_str());
 
         check("void f(int x) {\n"
               "    extern int y; y = x & 7;\n"
               "    do_something();\n"
               "    if (y==8);\n" // non-local variable => no error
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4434 : false positive: ?:
@@ -314,28 +314,28 @@ class TestCondition : public TestFixture {
               "    x = x & 1;\n"
               "    x = x & 1 ? 1 : -1;\n"
               "    if(x != -1) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4735
         check("void f() {\n"
               "    int x = *(char*)&0x12345678;\n"
               "    if (x==18) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // bailout: no variable info
         check("void foo(int x) {\n"
               "    y = 2 | x;\n"  // y not declared => no error
               "    if(y == 1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // bailout: negative number
         check("void foo(int x) {\n"
               "    int y = -2 | x;\n" // negative number => no error
               "    if (y==1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // bailout: pass variable to function
@@ -343,7 +343,7 @@ class TestCondition : public TestFixture {
               "    int y = 2 | x;\n"
               "    bar(&y);\n"  // pass variable to function => no error
               "    if (y==1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // no crash on unary operator& (#5643)
@@ -351,7 +351,7 @@ class TestCondition : public TestFixture {
         check("SdrObject* ApplyGraphicToObject() {\n"
               "    if (&rHitObject) {}\n"
               "    else if (rHitObject.IsClosedObj() && !&rHitObject) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Condition '&rHitObject' is always true [knownConditionTrueFalse]\n"
                       "[test.cpp:3:42]: (style) Condition '!&rHitObject' is always false [knownConditionTrueFalse]\n",
                       errout_str());
@@ -364,7 +364,7 @@ class TestCondition : public TestFixture {
               "    if (c == 4)\n"
               "      c  = 0;\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int a) {\n" // #6662
@@ -372,7 +372,7 @@ class TestCondition : public TestFixture {
               "  while (x <= 4) {\n"
               "    if (x != 5) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:8]: (style) Mismatching assignment and comparison, comparison 'x!=5' is always true. [assignIfError]\n", errout_str());
 
         check("void f(int a) {\n" // #6662
@@ -380,7 +380,7 @@ class TestCondition : public TestFixture {
               "  while ((x += 4) < 10) {\n"
               "    if (x != 5) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -388,7 +388,7 @@ class TestCondition : public TestFixture {
               "    while (x) {\n"
               "        g(x);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g(int x);\n"
@@ -397,7 +397,7 @@ class TestCondition : public TestFixture {
               "    while (x) {\n"
               "        g(x);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (style) Condition 'x' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void g(int & x);\n"
@@ -406,7 +406,7 @@ class TestCondition : public TestFixture {
               "    while (x) {\n"
               "        g(x);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
     }
@@ -415,13 +415,13 @@ class TestCondition : public TestFixture {
         check("void f(int a) {\n"
               "    int b = a & 0xf0;\n"
               "    b &= 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:5]: (style) Mismatching bitmasks. Result is always 0 (X = Y & 0xf0; Z = X & 0x1; => Z=0). [mismatchingBitAnd]\n", errout_str());
 
         check("void f(int a) {\n"
               "    int b = a & 0xf0;\n"
               "    int c = b & 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:9]: (style) Mismatching bitmasks. Result is always 0 (X = Y & 0xf0; Z = X & 0x1; => Z=0). [mismatchingBitAnd]\n", errout_str());
 
         check("void f(int a) {\n"
@@ -430,67 +430,67 @@ class TestCondition : public TestFixture {
               "    case 1: b &= 1; break;\n"
               "    case 2: b &= 2; break;\n"
               "    };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void comparison() {
         // CheckCondition::comparison test cases
         // '=='
-        check("void f(int a) {\n assert( (a & 0x07) == 8U );\n}");
+        check("void f(int a) {\n assert( (a & 0x07) == 8U );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X & 0x7) == 0x8' is always false. [comparisonError]\n",errout_str());
-        check("void f(int a) {\n assert( (a & b & 4 & c ) == 3 );\n}");
+        check("void f(int a) {\n assert( (a & b & 4 & c ) == 3 );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:21]: (style) Expression '(X & 0x4) == 0x3' is always false. [comparisonError]\n", errout_str());
-        check("void f(int a) {\n assert( (a | 0x07) == 8U );\n}");
+        check("void f(int a) {\n assert( (a | 0x07) == 8U );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X | 0x7) == 0x8' is always false. [comparisonError]\n",errout_str());
-        check("void f(int a) {\n assert( (a & 0x07) == 7U );\n}");
+        check("void f(int a) {\n assert( (a & 0x07) == 7U );\n}\n");
         ASSERT_EQUALS("", errout_str());
-        check("void f(int a) {\n assert( (a | 0x01) == -15 );\n}");
+        check("void f(int a) {\n assert( (a | 0x01) == -15 );\n}\n");
         ASSERT_EQUALS("", errout_str());
         // '!='
-        check("void f(int a) {\n assert( (a & 0x07) != 8U );\n}");
+        check("void f(int a) {\n assert( (a & 0x07) != 8U );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X & 0x7) != 0x8' is always true. [comparisonError]\n",errout_str());
-        check("void f(int a) {\n assert( (a | 0x07) != 8U );\n}");
+        check("void f(int a) {\n assert( (a | 0x07) != 8U );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X | 0x7) != 0x8' is always true. [comparisonError]\n",errout_str());
-        check("void f(int a) {\n assert( (a & 0x07) != 7U );\n}");
+        check("void f(int a) {\n assert( (a & 0x07) != 7U );\n}\n");
         ASSERT_EQUALS("", errout_str());
-        check("void f(int a) {\n assert( (a | 0x07) != 7U );\n}");
+        check("void f(int a) {\n assert( (a | 0x07) != 7U );\n}\n");
         ASSERT_EQUALS("", errout_str());
         // '>='
-        check("void f(int a) {\n assert( (a & 0x07) >= 8U );\n}");
+        check("void f(int a) {\n assert( (a & 0x07) >= 8U );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X & 0x7) >= 0x8' is always false. [comparisonError]\n",errout_str());
-        check("void f(unsigned int a) {\n assert( (a | 0x7) >= 7U );\n}");
+        check("void f(unsigned int a) {\n assert( (a | 0x7) >= 7U );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X | 0x7) >= 0x7' is always true. [comparisonError]\n",errout_str());
-        check("void f(int a) {\n assert( (a & 0x07) >= 7U );\n}");
+        check("void f(int a) {\n assert( (a & 0x07) >= 7U );\n}\n");
         ASSERT_EQUALS("",errout_str());
-        check("void f(int a) {\n assert( (a | 0x07) >= 8U );\n}");
+        check("void f(int a) {\n assert( (a | 0x07) >= 8U );\n}\n");
         ASSERT_EQUALS("",errout_str()); //correct for negative 'a'
         // '>'
-        check("void f(int a) {\n assert( (a & 0x07) > 7U );\n}");
+        check("void f(int a) {\n assert( (a & 0x07) > 7U );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X & 0x7) > 0x7' is always false. [comparisonError]\n",errout_str());
-        check("void f(unsigned int a) {\n assert( (a | 0x7) > 6U );\n}");
+        check("void f(unsigned int a) {\n assert( (a | 0x7) > 6U );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X | 0x7) > 0x6' is always true. [comparisonError]\n",errout_str());
-        check("void f(int a) {\n assert( (a & 0x07) > 6U );\n}");
+        check("void f(int a) {\n assert( (a & 0x07) > 6U );\n}\n");
         ASSERT_EQUALS("",errout_str());
-        check("void f(int a) {\n assert( (a | 0x07) > 7U );\n}");
+        check("void f(int a) {\n assert( (a | 0x07) > 7U );\n}\n");
         ASSERT_EQUALS("",errout_str()); //correct for negative 'a'
         // '<='
-        check("void f(int a) {\n assert( (a & 0x07) <= 7U );\n}");
+        check("void f(int a) {\n assert( (a & 0x07) <= 7U );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X & 0x7) <= 0x7' is always true. [comparisonError]\n",errout_str());
-        check("void f(unsigned int a) {\n assert( (a | 0x08) <= 7U );\n}");
+        check("void f(unsigned int a) {\n assert( (a | 0x08) <= 7U );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X | 0x8) <= 0x7' is always false. [comparisonError]\n",errout_str());
-        check("void f(int a) {\n assert( (a & 0x07) <= 6U );\n}");
+        check("void f(int a) {\n assert( (a & 0x07) <= 6U );\n}\n");
         ASSERT_EQUALS("",errout_str());
-        check("void f(int a) {\n assert( (a | 0x08) <= 7U );\n}");
+        check("void f(int a) {\n assert( (a | 0x08) <= 7U );\n}\n");
         ASSERT_EQUALS("",errout_str()); //correct for negative 'a'
         // '<'
-        check("void f(int a) {\n assert( (a & 0x07) < 8U );\n}");
+        check("void f(int a) {\n assert( (a & 0x07) < 8U );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X & 0x7) < 0x8' is always true. [comparisonError]\n",errout_str());
-        check("void f(unsigned int a) {\n assert( (a | 0x07) < 7U );\n}");
+        check("void f(unsigned int a) {\n assert( (a | 0x07) < 7U );\n}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X | 0x7) < 0x7' is always false. [comparisonError]\n",errout_str());
-        check("void f(int a) {\n assert( (a & 0x07) < 3U );\n}");
+        check("void f(int a) {\n assert( (a & 0x07) < 3U );\n}\n");
         ASSERT_EQUALS("",errout_str());
-        check("void f(int a) {\n assert( (a | 0x07) < 7U );\n}");
+        check("void f(int a) {\n assert( (a | 0x07) < 7U );\n}\n");
         ASSERT_EQUALS("",errout_str()); //correct for negative 'a'
 
         check("void f(int i) {\n" // #11998
@@ -536,14 +536,14 @@ class TestCondition : public TestFixture {
               "{\n"
               "    if (x & 7);\n"
               "    else { if (x == 1); }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (style) Expression is always false because 'else if' condition matches previous condition at line 3. [multiCondition]\n", errout_str());
 
         check("void foo(int x)\n"
               "{\n"
               "    if (x & 7);\n"
               "    else { if (x & 1); }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (style) Expression is always false because 'else if' condition matches previous condition at line 3. [multiCondition]\n", errout_str());
 
         check("extern int bar() __attribute__((pure));\n"
@@ -551,7 +551,7 @@ class TestCondition : public TestFixture {
               "{\n"
               "    if ( bar() >1 && b) {}\n"
               "    else if (bar() >1 && b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:23]: (style) Expression is always false because 'else if' condition matches previous condition at line 4. [multiCondition]\n", errout_str());
 
         checkPureFunction("extern int bar();\n"
@@ -559,14 +559,14 @@ class TestCondition : public TestFixture {
                           "{\n"
                           "    if ( bar() >1 && b) {}\n"
                           "    else if (bar() >1 && b) {}\n"
-                          "}");
+                          "}\n");
         ASSERT_EQUALS("[test.cpp:5:23]: (style) Expression is always false because 'else if' condition matches previous condition at line 4. [multiCondition]\n", errout_str());
 
         // 7284
         check("void foo() {\n"
               "    if (a) {}\n"
               "    else if (!!a) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         // #11059
@@ -593,53 +593,53 @@ class TestCondition : public TestFixture {
         check("void f(int a, int &b) {\n"
               "    if (a) { b = 1; }\n"
               "    else { if (a) { b = 2; } }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(int a, int &b) {\n"
               "    if (a) { b = 1; }\n"
               "    else { if (a) { b = 2; } }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(int a, int &b) {\n"
               "    if (a == 1) { b = 1; }\n"
               "    else { if (a == 2) { b = 2; }\n"
               "    else { if (a == 1) { b = 3; } } }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(int a, int &b) {\n"
               "    if (a == 1) { b = 1; }\n"
               "    else { if (a == 2) { b = 2; }\n"
               "    else { if (a == 2) { b = 3; } } }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (style) Expression is always false because 'else if' condition matches previous condition at line 3. [multiCondition]\n", errout_str());
 
         check("void f(int a, int &b) {\n"
               "    if (a++) { b = 1; }\n"
               "    else { if (a++) { b = 2; }\n"
               "    else { if (a++) { b = 3; } } }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int a, int &b) {\n"
               "    if (!strtok(NULL, \" \")) { b = 1; }\n"
               "    else { if (!strtok(NULL, \" \")) { b = 2; } }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         {
             check("void f(Class &c) {\n"
                   "    if (c.dostuff() == 3) {}\n"
                   "    else { if (c.dostuff() == 3) {} }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("", errout_str());
 
             check("void f(const Class &c) {\n"
                   "    if (c.dostuff() == 3) {}\n"
                   "    else { if (c.dostuff() == 3) {} }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("[test.cpp:3:28]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
         }
 
@@ -647,13 +647,13 @@ class TestCondition : public TestFixture {
               "   x = x / 2;\n"
               "   if (x < 100) { b = 1; }\n"
               "   else { x = x / 2; if (x < 100) { b = 2; } }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int64_t i) {\n"
               "   if(i == 0x02e2000000 || i == 0xa0c6000000)\n"
               "       foo(i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket 3689 ( avoid false positive )
@@ -675,13 +675,13 @@ class TestCondition : public TestFixture {
               "            return -1;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(WIDGET *widget) {\n"
               "  if (dynamic_cast<BUTTON*>(widget)){}\n"
               "  else if (dynamic_cast<LABEL*>(widget)){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class B { virtual void v() {} };\n" // #11037
@@ -698,67 +698,67 @@ class TestCondition : public TestFixture {
         check("void f(int x) {\n" // #6482
               "  if (x & 1) {}\n"
               "  else if (x == 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "  if (x & 15) {}\n"
               "  else if (x == 40) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x == sizeof(double)) {}\n"
-              "  else { if (x == sizeof(long double)) {} }"
-              "}");
+              "  else { if (x == sizeof(long double)) {} }\n"
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "  if (x & 0x08) {}\n"
               "  else if (x & 0xF8) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "  if (x & 0xF8) {}\n"
               "  else if (x & 0x08) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "   if(a && b){}\n"
               "   else if( !!b && !!a){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "   if(a && b){}\n"
               "   else if( !!b && a){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "   if(a && b){}\n"
               "   else if( b && !!a){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "   if(a && b){}\n"
               "   else if( b && !(!a)){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "   if(a && b){}\n"
               "   else if( !!b && !(!a)){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "   if(a && b){}\n"
               "   else if( !!(b) && !!(a+b)){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8168
@@ -770,7 +770,7 @@ class TestCondition : public TestFixture {
               "void TestFunction(int value) {\n"
               "    if ( value & (int)Value1 ) {}\n"
               "    else if ( value & (int)Value2 ) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(size_t x) {\n"
@@ -792,7 +792,7 @@ class TestCondition : public TestFixture {
         check("void f(int x) {\n"
               "    if (x) {}\n"
               "    else if (!x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: style: Expression is always true because 'else if' condition is opposite to previous condition at line 2. [multiCondition]\n"
                       "[test.cpp:2:9]: note: first condition\n"
                       "[test.cpp:3:14]: note: else if condition is opposite to first condition\n", errout_str());
@@ -801,7 +801,7 @@ class TestCondition : public TestFixture {
               "    int y = x;\n"
               "    if (x) {}\n"
               "    else if (!y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:14]: style: Expression is always true because 'else if' condition is opposite to previous condition at line 3. [multiCondition]\n"
                       "[test.cpp:2:13]: note: 'y' is assigned value 'x' here.\n"
                       "[test.cpp:3:9]: note: first condition\n"
@@ -812,31 +812,31 @@ class TestCondition : public TestFixture {
         check("bool f(int x) {\n"
               "    bool b = x | 0x02;\n"
               "    return b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("bool f(int x) {\n"
               "    bool b = 0x02 | x;\n"
               "    return b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:19]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("int f(int x) {\n"
               "    int b = x | 0x02;\n"
               "    return b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(int x) {\n"
               "    bool b = x & 0x02;\n"
               "    return b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(int x) {\n"
               "    if(x | 0x02)\n"
               "        return b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("bool f(int x) {\n"
@@ -844,27 +844,27 @@ class TestCondition : public TestFixture {
               "    if(b) y = 0;\n"
               "    if(x | y)\n"
               "        return b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(int x) {\n"
               "    foo(a && (x | 0x02));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("int f(int x) {\n"
               "    return (x | 0x02) ? 0 : 5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("int f(int x) {\n"
               "    return x ? (x | 0x02) : 5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(int x) {\n"
               "    return x | 0x02;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("bool f(int x) {\n"
@@ -872,19 +872,19 @@ class TestCondition : public TestFixture {
               "    return x | 0x02;\n"
               "  }\n"
               "  return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("const bool f(int x) {\n"
               "    return x | 0x02;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("struct F {\n"
               "  static const bool f(int x) {\n"
               "      return x | 0x02;\n"
               "  }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("struct F {\n"
@@ -892,12 +892,12 @@ class TestCondition : public TestFixture {
               "};\n"
               "F::b_t f(int x) {\n"
               "  return x | 0x02;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("int f(int x) {\n"
               "    return x | 0x02;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void create_rop_masks_4( rop_mask_bits *bits) {\n"
@@ -905,7 +905,7 @@ class TestCondition : public TestFixture {
               "BYTE *and_bits = bits->and;\n"
               "rop_mask *rop_mask;\n"
               "and_bits[mask_offset] |= (rop_mask->and & 0x0f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(unsigned a, unsigned b) {\n"
@@ -913,7 +913,7 @@ class TestCondition : public TestFixture {
               "  if (cmd1 | a) {\n"
               "    if (b == 0x0C) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int i) {\n" // #11082
@@ -941,7 +941,7 @@ class TestCondition : public TestFixture {
               "#if BAR_ENABLED\n"
               "    FEATURE_BAR |\n"
               "#endif\n"
-              "    0;");
+              "    0;\n");
         ASSERT_EQUALS("", errout_str());
 
         check("enum precedence { PC0, UNARY };\n"
@@ -960,84 +960,84 @@ class TestCondition : public TestFixture {
         check("void f(int x) {\n"
               "    if ((x != 1) || (x != 3))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Logical disjunction always evaluates to true: x != 1 || x != 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (1 != x || 3 != x)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical disjunction always evaluates to true: x != 1 || x != 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x<0 && !x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (warning) Logical conjunction always evaluates to false: x < 0 && !x. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x==0 && x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning) Logical conjunction always evaluates to false: x == 0 && x. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n" // ast..
               "    if (y == 1 && x == 1 && x == 7) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:26]: (warning) Logical conjunction always evaluates to false: x == 1 && x == 7. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if (x != 1 || y != 1)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if ((y == 1) && (x != 1) || (x != 3))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if ((x != 1) || (x != 3) && (y == 1))\n"
               "        a++;\n"
-              "}"
+              "}\n"
               );
         ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:2:24]: (style) Condition 'x!=3' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x != 1) && (x != 3))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x == 1) || (x == 3))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if ((x != 1) || (y != 3))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if ((x != hotdog) || (y != hotdog))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if ((x != 5) || (y != 5))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
         check("void f(int x) {\n"
               "    if ((x != 5) || (x != 6))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Logical disjunction always evaluates to true: x != 5 || x != 6. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(unsigned int a, unsigned int b, unsigned int c) {\n"
@@ -1046,7 +1046,7 @@ class TestCondition : public TestFixture {
               "        return true;\n"
               "    }\n"
               "    return false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:23] -> [test.cpp:2:35]: (style) Condition 'c!=a' is always false [knownConditionTrueFalse]\n", errout_str());
     }
 
@@ -1054,224 +1054,224 @@ class TestCondition : public TestFixture {
         check("void f(float x) {\n"
               "    if ((x == 1) && (x == 1.0))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x == 1) && (x == 0x00000001))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:2:24]: (style) Condition 'x==0x00000001' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x == 1 && x == 3)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical conjunction always evaluates to false: x == 1 && x == 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x == 1.0 && x == 3.0)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // float comparisons with == and != are not checked right now - such comparison is a bad idea
 
         check("void f(float x) {\n"
               "    if (x == 1 && x == 1.0)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void bar(float f) {\n" // #5246
               "    if ((f > 0) && (f < 1)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (x < 1 && x > 1)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 1. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x < 1.0 && x > 1.0)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) Logical conjunction always evaluates to false: x < 1.0 && x > 1.0. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x < 1 && x > 1.0)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 1.0. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x >= 1.0 && x <= 1.001)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (x < 1 && x > 3)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(float x) {\n"
               "    if (x < 1.0 && x > 3.0)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) Logical conjunction always evaluates to false: x < 1.0 && x > 3.0. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (1 > x && 3 < x)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x < 3 && x > 1)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 3 || x < 10)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical disjunction always evaluates to true: x > 3 || x < 10. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x >= 3 || x <= 10)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical disjunction always evaluates to true: x >= 3 || x <= 10. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x >= 3 || x < 10)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical disjunction always evaluates to true: x >= 3 || x < 10. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 3 || x <= 10)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical disjunction always evaluates to true: x > 3 || x <= 10. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 3 || x < 3)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (x >= 3 || x <= 3)\n"
               "        a++;\n"
-              "}"
+              "}\n"
               );
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical disjunction always evaluates to true: x >= 3 || x <= 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x >= 3 || x < 3)\n"
               "        a++;\n"
-              "}"
+              "}\n"
               );
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical disjunction always evaluates to true: x >= 3 || x < 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 3 || x <= 3)\n"
               "        a++;\n"
-              "}"
+              "}\n"
               );
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical disjunction always evaluates to true: x > 3 || x <= 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "   if((x==3) && (x!=4))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (style) Redundant condition: The condition 'x != 4' is redundant since 'x == 3' is sufficient. [redundantCondition]\n", errout_str());
 
         check("void f(const std::string &s) {\n" // #8860
               "    const std::size_t p = s.find(\"42\");\n"
               "    const std::size_t * const ptr = &p;\n"
               "    if(p != std::string::npos && p == 0 && *ptr != 1){;}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:36] -> [test.cpp:4:49]: (style) Condition '*ptr!=1' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x!=4) && (x==3))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (style) Redundant condition: The condition 'x != 4' is redundant since 'x == 3' is sufficient. [redundantCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x==3) || (x!=4))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (style) Redundant condition: The condition 'x == 3' is redundant since 'x != 4' is sufficient. [redundantCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x!=4) || (x==3))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (style) Redundant condition: The condition 'x == 3' is redundant since 'x != 4' is sufficient. [redundantCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x==3) && (x!=3))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical conjunction always evaluates to false: x == 3 && x != 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x==6) || (x!=6))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical disjunction always evaluates to true: x == 6 || x != 6. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 10 || x < 3)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 5 && x == 1)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x > 5 && x == 1. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 5 && x == 6)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (style) Redundant condition: The condition 'x > 5' is redundant since 'x == 6' is sufficient. [redundantCondition]\n", errout_str());
 
         // #3419
         check("void f() {\n"
               "    if ( &q != &a && &q != &b ) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3676
         check("void f(int m_x2, int w, int x) {\n"
               "    if (x + w - 1 > m_x2 || m_x2 < 0 )\n"
               "        m_x2 = x + w - 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(float x) {\n" // x+1 => x
               "  if (x <= 1.0e20 && x >= -1.0e20) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(float x) {\n" // x+1 => x
               "  if (x >= 1.0e20 && x <= 1.0e21) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(float x) {\n" // x+1 => x
               "  if (x <= -1.0e20 && x >= -1.0e21) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1281,7 +1281,7 @@ class TestCondition : public TestFixture {
               "    c = x < 1 && x == 3;\n"
               "    d = x >= 5 && x == 1;\n"
               "    e = x <= 1 && x == 3;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x > 5 && x == 1. [incorrectLogicOperator]\n"
                       "[test.cpp:3:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x == 3. [incorrectLogicOperator]\n"
                       "[test.cpp:4:16]: (warning) Logical conjunction always evaluates to false: x >= 5 && x == 1. [incorrectLogicOperator]\n"
@@ -1292,7 +1292,7 @@ class TestCondition : public TestFixture {
         check("#define ZERO 0\n"
               "void f(int x) {\n"
               "  if (x && x != ZERO) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int N) {\n" // #9789
@@ -1307,7 +1307,7 @@ class TestCondition : public TestFixture {
     void incorrectLogicOperator5() { // complex expressions
         check("void f(int x) {\n"
               "  if (x+3 > 2 || x+3 < 10) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical disjunction always evaluates to true: x+3 > 2 || x+3 < 10. [incorrectLogicOperator]\n", errout_str());
     }
 
@@ -1315,51 +1315,51 @@ class TestCondition : public TestFixture {
         const Settings s = settingsBuilder(settings0).certainty(Certainty::inconclusive).build();
         check("void f(char x) {\n"
               "  if (x == '1' || x == '2') {}\n"
-              "}", s);
+              "}\n", s);
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char x) {\n"
               "  if (x == '1' && x == '2') {}\n"
-              "}", s);
+              "}\n", s);
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical conjunction always evaluates to false: x == '1' && x == '2'. [incorrectLogicOperator]\n", errout_str());
 
         check("int f(char c) {\n"
               "  return (c >= 'a' && c <= 'z');\n"
-              "}", s);
+              "}\n", s);
         ASSERT_EQUALS("", errout_str());
 
         check("int f(char c) {\n"
               "  return (c <= 'a' && c >= 'z');\n"
-              "}", s);
+              "}\n", s);
         ASSERT_EQUALS("[test.cpp:2:20]: (warning, inconclusive) Logical conjunction always evaluates to false: c <= 'a' && c >= 'z'. [incorrectLogicOperator]\n", errout_str());
 
         check("int f(char c) {\n"
               "  return (c <= 'a' && c >= 'z');\n"
-              "}"); // TODO: use s?
+              "}\n"); // TODO: use s?
         ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:2:25]: (style) Return value 'c>='z'' is always false [knownConditionTrueFalse]\n", errout_str());
     }
 
     void incorrectLogicOperator7() { // opposite expressions
         check("void f(int i) {\n"
               "  if (i || !i) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (warning) Logical disjunction always evaluates to true: i || !(i). [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int a, int b) {\n"
               "  if (a>b || a<=b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (warning) Logical disjunction always evaluates to true: a > b || a <= b. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int a, int b) {\n"
               "  if (a>b || a<b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6064 False positive incorrectLogicOperator - invalid assumption about template type?
         check("template<typename T> T icdf( const T uniform ) {\n"
               "   if ((0<uniform) && (uniform<1))\n"
               "     {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6081 False positive: incorrectLogicOperator, with close negative comparisons
@@ -1369,14 +1369,14 @@ class TestCondition : public TestFixture {
               "        return;\n"
               "    else\n"
               "        return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void incorrectLogicOperator8() { // opposite expressions
         check("void f(int i) {\n"
               "  if (!(i!=10) && !(i!=20)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical conjunction always evaluates to false: !(i != 10) && !(i != 20). [incorrectLogicOperator]\n", errout_str());
     }
 
@@ -1385,7 +1385,7 @@ class TestCondition : public TestFixture {
               "class OtherType;\n"
               "void foo (OtherType* obj) {\n"
               "    assert((!obj) || dynamic_cast<MyType*>(obj));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1394,21 +1394,21 @@ class TestCondition : public TestFixture {
               "void f(Type_t t) {\n"
               "    if ((t == A) && (t == B))\n"
               "    {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:18]: (warning) Logical conjunction always evaluates to false: t == 0 && t == 1. [incorrectLogicOperator]\n", errout_str());
     }
 
     void incorrectLogicOperator11() {
-        check("void foo(int i, const int n) { if ( i < n && i == n ) {} }");
+        check("void foo(int i, const int n) { if ( i < n && i == n ) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:43]: (warning) Logical conjunction always evaluates to false: i < n && i == n. [incorrectLogicOperator]\n", errout_str());
 
-        check("void foo(int i, const int n) { if ( i > n && i == n ) {} }");
+        check("void foo(int i, const int n) { if ( i > n && i == n ) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:43]: (warning) Logical conjunction always evaluates to false: i > n && i == n. [incorrectLogicOperator]\n", errout_str());
 
-        check("void foo(int i, const int n) { if ( i == n && i > n ) {} }");
+        check("void foo(int i, const int n) { if ( i == n && i > n ) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:44]: (warning) Logical conjunction always evaluates to false: i == n && i > n. [incorrectLogicOperator]\n", errout_str());
 
-        check("void foo(int i, const int n) { if ( i == n && i < n ) {} }");
+        check("void foo(int i, const int n) { if ( i == n && i < n ) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:44]: (warning) Logical conjunction always evaluates to false: i == n && i < n. [incorrectLogicOperator]\n", errout_str());
     }
 
@@ -1422,7 +1422,7 @@ class TestCondition : public TestFixture {
               "  y.f();\n"
               "  if (a > x && a < y)\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:5:9] -> [test.cpp:6:9] -> [test.cpp:8:13]: (warning) Logical conjunction always evaluates to false: a > x && a < y. [incorrectLogicOperator]\n",
             errout_str());
@@ -1436,7 +1436,7 @@ class TestCondition : public TestFixture {
               "  y.f();\n"
               "  if (a > x && a < y)\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(A a, A b) {\n"
@@ -1445,7 +1445,7 @@ class TestCondition : public TestFixture {
               "  y.f();\n"
               "  if (a > x && a < y)\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(A a, A b) {\n"
@@ -1454,7 +1454,7 @@ class TestCondition : public TestFixture {
               "  y.f();\n"
               "  if (a > x && a < y)\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:15] -> [test.cpp:3:15] -> [test.cpp:5:13]: (warning) Logical conjunction always evaluates to false: a > x && a < y. [incorrectLogicOperator]\n",
             errout_str());
@@ -1468,7 +1468,7 @@ class TestCondition : public TestFixture {
               "  y.f();\n"
               "  if (a > x && a < y)\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:9]: (style) Condition 'a>x' is always false [knownConditionTrueFalse]\n"
                       "[test.cpp:8:18]: (style) Condition 'a<y' is always false [knownConditionTrueFalse]\n",
                       errout_str());
@@ -1482,7 +1482,7 @@ class TestCondition : public TestFixture {
               "  y.f();\n"
               "  if (a > x && a < y)\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:9]: (style) Condition 'a>x' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void foo(A a) {\n"
@@ -1491,7 +1491,7 @@ class TestCondition : public TestFixture {
               "  y.f();\n"
               "  if (a > x && a < y)\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9]: (style) Condition 'a>x' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void foo(A a) {\n"
@@ -1500,7 +1500,7 @@ class TestCondition : public TestFixture {
               "  y.f();\n"
               "  if (a > x && a < y)\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9]: (style) Condition 'a>x' is always false [knownConditionTrueFalse]\n"
                       "[test.cpp:5:18]: (style) Condition 'a<y' is always false [knownConditionTrueFalse]\n",
                       errout_str());
@@ -1511,13 +1511,13 @@ class TestCondition : public TestFixture {
         check("void f(const int &v) {\n"
               "    const int x=v;\n"
               "    if ((v == 1) && (x == 2)) {;}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17] -> [test.cpp:3:18]: (warning) Logical conjunction always evaluates to false: v == 1 && x == 2. [incorrectLogicOperator]\n", errout_str());
 
         check("void f2(const int *v) {\n"
               "    const int *x=v;\n"
               "    if ((*v == 1) && (*x == 2)) {;}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18] -> [test.cpp:3:19]: (warning) Logical conjunction always evaluates to false: *(v) == 1 && *(x) == 2. [incorrectLogicOperator]\n", errout_str());
     }
 
@@ -1724,7 +1724,7 @@ class TestCondition : public TestFixture {
               "      if (f && g)\n"
               "        ;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:200:11] -> [test.cpp:200:16]: (style) Condition 'g' is always true [knownConditionTrueFalse]\n", errout_str());
     }
 
@@ -1780,31 +1780,31 @@ class TestCondition : public TestFixture {
         check("void f(void) {\n" // #8892
               "    const char c[1] = { \'x\' }; \n"
               "    if(c[0] == \'x\'){;}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (style) Condition 'c[0]=='x'' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 5 && x != 1)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (style) Redundant condition: The condition 'x != 1' is redundant since 'x > 5' is sufficient. [redundantCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 5 && x != 6)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x > 5) && (x != 1))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (style) Redundant condition: The condition 'x != 1' is redundant since 'x > 5' is sufficient. [redundantCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x > 5) && (x != 6))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, bool& b) {\n"
@@ -1812,7 +1812,7 @@ class TestCondition : public TestFixture {
               "    c = x < 5 || x == 4;\n"
               "    d = x >= 3 || x == 4;\n"
               "    e = x <= 5 || x == 4;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (style) Redundant condition: The condition 'x == 4' is redundant since 'x > 3' is sufficient. [redundantCondition]\n"
                       "[test.cpp:3:15]: (style) Redundant condition: The condition 'x == 4' is redundant since 'x < 5' is sufficient. [redundantCondition]\n"
                       "[test.cpp:4:16]: (style) Redundant condition: The condition 'x == 4' is redundant since 'x >= 3' is sufficient. [redundantCondition]\n"
@@ -1824,7 +1824,7 @@ class TestCondition : public TestFixture {
               "    c = x < 1 || x != 3;\n"
               "    d = x >= 5 || x != 1;\n"
               "    e = x <= 1 || x != 3;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (style) Redundant condition: The condition 'x > 5' is redundant since 'x != 1' is sufficient. [redundantCondition]\n"
                       "[test.cpp:3:15]: (style) Redundant condition: The condition 'x < 1' is redundant since 'x != 3' is sufficient. [redundantCondition]\n"
                       "[test.cpp:4:16]: (style) Redundant condition: The condition 'x >= 5' is redundant since 'x != 1' is sufficient. [redundantCondition]\n"
@@ -1836,7 +1836,7 @@ class TestCondition : public TestFixture {
               "    c = x > 5 || x > 6;\n"
               "    d = x < 6 && x < 5;\n"
               "    e = x < 5 || x < 6;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (style) Redundant condition: The condition 'x > 5' is redundant since 'x > 6' is sufficient. [redundantCondition]\n"
                       "[test.cpp:3:15]: (style) Redundant condition: The condition 'x > 6' is redundant since 'x > 5' is sufficient. [redundantCondition]\n"
                       "[test.cpp:4:15]: (style) Redundant condition: The condition 'x < 6' is redundant since 'x < 5' is sufficient. [redundantCondition]\n"
@@ -1848,7 +1848,7 @@ class TestCondition : public TestFixture {
               "    c = x > 5.5 || x > 6.5;\n"
               "    d = x < 6.5 && x < 5.5;\n"
               "    e = x < 5.5 || x < 6.5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (style) Redundant condition: The condition 'x > 5.5' is redundant since 'x > 6.5' is sufficient. [redundantCondition]\n"
                       "[test.cpp:3:17]: (style) Redundant condition: The condition 'x > 6.5' is redundant since 'x > 5.5' is sufficient. [redundantCondition]\n"
                       "[test.cpp:4:17]: (style) Redundant condition: The condition 'x < 6.5' is redundant since 'x < 5.5' is sufficient. [redundantCondition]\n"
@@ -1866,49 +1866,49 @@ class TestCondition : public TestFixture {
         check("void f(int x) {\n"
               "    if (x < 1 && x > 3)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (1 > x && x > 3)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x < 1 && 3 < x)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (1 > x && 3 < x)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 3 && x < 1)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x > 3 && x < 1. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (3 < x && x < 1)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x > 3 && x < 1. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 3 && 1 > x)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x > 3 && x < 1. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (3 < x && 1 > x)\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x > 3 && x < 1. [incorrectLogicOperator]\n", errout_str());
     }
 
@@ -1918,7 +1918,7 @@ class TestCondition : public TestFixture {
               "    b2 = a % c == 100000;\n"
               "    b3 = a % 5 == c;\n"
               "    return a % 5 == 5-p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(bool& b1, bool& b2, bool& b3, bool& b4, bool& b5) {\n"
@@ -1928,7 +1928,7 @@ class TestCondition : public TestFixture {
               "    b4 = a % 5 != 5;\n"
               "    b5 = a % 5 >= 5;\n"
               "    return a % 5 > 5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:16]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n"
             "[test.cpp:3:16]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n"
@@ -1942,7 +1942,7 @@ class TestCondition : public TestFixture {
               "    b1 = bar() % 5 < 889;\n"
               "    if(x[593] % 5 <= 5)\n"
               "        b2 = x.a % 5 == 5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:20]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n"
             "[test.cpp:3:19]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n"
@@ -1952,7 +1952,7 @@ class TestCondition : public TestFixture {
         check("void f() {\n"
               "    if (a % 2 + b % 2 == 2)\n"
               "        foo();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1961,21 +1961,21 @@ class TestCondition : public TestFixture {
               "    if(a==b)\n"
               "        if(a!=b)\n"
               "            cout << a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:13]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("bool foo(int a, int b) {\n"
               "    if(a==b)\n"
               "        return a!=b;\n"
               "    return false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:17]: (warning) Opposite inner 'return' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void foo(int a, int b) {\n"
               "    if(a==b)\n"
               "        if(b!=a)\n"
               "            cout << a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:13]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void foo(int a) {\n"
@@ -1985,7 +1985,7 @@ class TestCondition : public TestFixture {
               "        else\n"
               "            cout << 100;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:3:14]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         // #4186
@@ -1996,7 +1996,7 @@ class TestCondition : public TestFixture {
               "        else\n"
               "            cout << 100;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // 4170
@@ -2015,7 +2015,7 @@ class TestCondition : public TestFixture {
               "    }\n"
               "    void next();\n"
               "    const char *tok;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int i)\n"
@@ -2026,7 +2026,7 @@ class TestCondition : public TestFixture {
               "           cout << a;\n"
               "       }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int& i) {\n"
@@ -2038,7 +2038,7 @@ class TestCondition : public TestFixture {
               "        if(i<5) {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int& i);\n"
@@ -2049,7 +2049,7 @@ class TestCondition : public TestFixture {
               "        if(i<5) {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int i);\n"
@@ -2059,7 +2059,7 @@ class TestCondition : public TestFixture {
               "        if(i<5) {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:5:13]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void foo(const int &i);\n"
@@ -2069,7 +2069,7 @@ class TestCondition : public TestFixture {
               "        if(i<5) {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:5:13]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void foo(int i);\n"
@@ -2080,7 +2080,7 @@ class TestCondition : public TestFixture {
               "        if(i<5) {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:6:13]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("class C { void f(int &i) const; };\n" // #7028 - variable is changed by const method
@@ -2089,7 +2089,7 @@ class TestCondition : public TestFixture {
               "    c.f(i);\n"
               "    if (i != 5) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // see linux revision 1f80c0cc
@@ -2103,7 +2103,7 @@ class TestCondition : public TestFixture {
               "           err = rc;\n"
               "       }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:11] -> [test.cpp:7:14]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
 
@@ -2114,7 +2114,7 @@ class TestCondition : public TestFixture {
               "    array[0] += 5;\n"
               "    if (array[0] > 2) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6227 - FP caused by simplifications of casts and known variables
@@ -2123,7 +2123,7 @@ class TestCondition : public TestFixture {
               "       B *b = dynamic_cast<B*>(a);\n"
               "       if(!b) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a) {\n"
@@ -2131,7 +2131,7 @@ class TestCondition : public TestFixture {
               "       int b = a;\n"
               "       if(!b) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:2:7] -> [test.cpp:4:11]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void foo(unsigned u) {\n"
@@ -2141,7 +2141,7 @@ class TestCondition : public TestFixture {
               "      u = x;\n"
               "    }\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8186
@@ -2149,7 +2149,7 @@ class TestCondition : public TestFixture {
               "  for (int i=0;i<4;i++) {\n"
               "    if (i==5) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17] -> [test.cpp:3:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         // #8938
@@ -2158,7 +2158,7 @@ class TestCondition : public TestFixture {
               "        GetActiveCell(&(upperleft.Col), &(upperleft.Row));\n"
               "        if (upperleft.Row == -1) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9702
@@ -2171,7 +2171,7 @@ class TestCondition : public TestFixture {
               "    }\n"
               "    bool IsSet() const { return m_value; }\n"
               "    bool m_value = false;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #12725
@@ -2193,7 +2193,7 @@ class TestCondition : public TestFixture {
               "           err = rc;\n"
               "       }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void Fred::f() {\n" // daca: ace
@@ -2201,7 +2201,7 @@ class TestCondition : public TestFixture {
               "    this->next_ = n;\n"
               "    if (this->next_ != map_man_->table_) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void test(float *f) {\n" // #7405
@@ -2209,13 +2209,13 @@ class TestCondition : public TestFixture {
               "    (*f) += 0.1f;\n"
               "    if(*f<10) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int * f(int * x, int * y) {\n"
               "    if(!x) return x;\n"
               "    return y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2227,7 +2227,7 @@ class TestCondition : public TestFixture {
               "    fred.dostuff();\n"
               "    if (!fred.isValid()) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:19] -> [test.cpp:5:9]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("class Fred { public: bool isValid() const; void dostuff() const; };\n"
@@ -2237,7 +2237,7 @@ class TestCondition : public TestFixture {
               "    fred.dostuff();\n" // <- dostuff() is const, warn
               "    if (!fred.isValid()) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:19] -> [test.cpp:6:9]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void f() {\n"
@@ -2246,7 +2246,7 @@ class TestCondition : public TestFixture {
               "    fred.dostuff();\n"
               "    if (!fred.isValid()) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6385 "crash in Variable::getFlag()"
@@ -2257,14 +2257,14 @@ class TestCondition : public TestFixture {
               "             qApp->removeTranslator(mTranslator);\n"
               "        }\n"
               "   }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str()); // just don't crash...
 
         check("bool f(std::ofstream &CFileStream) {\n" // #8198
               "  if(!CFileStream.good()) { return; }\n"
               "  CFileStream << \"abc\";\n"
               "  if (!CFileStream.good()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2275,7 +2275,7 @@ class TestCondition : public TestFixture {
               "       x = do_something();\n"
               "       if (x != -1) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5750 - another fp when undeclared variable is used
@@ -2284,7 +2284,7 @@ class TestCondition : public TestFixture {
               "       r += 3;\n"
               "       if (r > w) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6574 - another fp when undeclared variable is used
@@ -2293,7 +2293,7 @@ class TestCondition : public TestFixture {
               "       i++;\n"
               "       if(!i) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // undeclared array
@@ -2302,7 +2302,7 @@ class TestCondition : public TestFixture {
               "    a[x] -= dt;\n"
               "    if (a[x] < 0) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6313 - false positive: opposite conditions in nested if blocks when condition changed
@@ -2312,7 +2312,7 @@ class TestCondition : public TestFixture {
               "      if(!var){}\n"
               "      else {}\n"
               "   }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // daca hyphy
@@ -2321,7 +2321,7 @@ class TestCondition : public TestFixture {
               "    rec.Delete(i);\n"
               "    if (rec.lLength!=0) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2335,7 +2335,7 @@ class TestCondition : public TestFixture {
               "    doStuff(&s);\n"
               "    if (hasFailed) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:7]: (style) Condition '!hasFailed' is always true [knownConditionTrueFalse]\n", errout_str());
     }
 
@@ -2346,7 +2346,7 @@ class TestCondition : public TestFixture {
               "  if (x<4) {\n"
               "    if (x==5) {}\n" // <- Warning
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
                       errout_str());
         check("void f(int x) {\n"
@@ -2354,14 +2354,14 @@ class TestCondition : public TestFixture {
               "  if (x<4) {\n"
               "    if (x!=5) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x!=5' is always true [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<4) {\n"
               "    if (x>5) {}\n" // <- Warning
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
                       errout_str());
         check("void f(int x) {\n"
@@ -2369,7 +2369,7 @@ class TestCondition : public TestFixture {
               "  if (x<4) {\n"
               "    if (x>=5) {}\n" // <- Warning
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
                       errout_str());
         check("void f(int x) {\n"
@@ -2377,14 +2377,14 @@ class TestCondition : public TestFixture {
               "  if (x<4) {\n"
               "    if (x<5) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x<5' is always true [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<4) {\n"
               "    if (x<=5) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x<=5' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x) {\n"
@@ -2392,49 +2392,49 @@ class TestCondition : public TestFixture {
               "  if (x<5) {\n"
               "    if (x==4) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<5) {\n"
               "    if (x!=4) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<5) {\n"
               "    if (x!=6) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x!=6' is always true [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<5) {\n"
               "    if (x>4) {}\n" // <- Warning
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x>4' is always false [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<5) {\n"
               "    if (x>=4) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<5) {\n"
               "    if (x<4) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<5) {\n"
               "    if (x<=4) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x<=4' is always true [knownConditionTrueFalse]\n", errout_str());
 
         // first comparison: >
@@ -2443,35 +2443,35 @@ class TestCondition : public TestFixture {
               "  if (x>4) {\n"
               "    if (x==5) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>4) {\n"
               "    if (x>5) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>4) {\n"
               "    if (x>=5) {}\n" // <- Warning
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x>=5' is always true [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>4) {\n"
               "    if (x<5) {}\n" // <- Warning
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x<5' is always false [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>4) {\n"
               "    if (x<=5) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
@@ -2479,7 +2479,7 @@ class TestCondition : public TestFixture {
               "  if (x>5) {\n"
               "    if (x==4) {}\n" // <- Warning
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
                       errout_str());
         check("void f(int x) {\n"
@@ -2487,21 +2487,21 @@ class TestCondition : public TestFixture {
               "  if (x>5) {\n"
               "    if (x>4) {}\n" // <- Warning
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x>4' is always true [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>5) {\n"
               "    if (x>=4) {}\n" // <- Warning
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x>=4' is always true [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>5) {\n"
               "    if (x<4) {}\n" // <- Warning
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
                       errout_str());
         check("void f(int x) {\n"
@@ -2509,7 +2509,7 @@ class TestCondition : public TestFixture {
               "  if (x>5) {\n"
               "    if (x<=4) {}\n" // <- Warning
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
                       errout_str());
 
@@ -2517,62 +2517,62 @@ class TestCondition : public TestFixture {
               "  if (x < 4) {\n"
               "    if (10 < x) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:12]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
     }
 
     void oppositeInnerCondition3() {
-        check("void f3(char c) { if(c=='x') if(c=='y') {}}");
+        check("void f3(char c) { if(c=='x') if(c=='y') {}}\n");
         ASSERT_EQUALS("[test.cpp:1:23] -> [test.cpp:1:34]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f4(char *p) { if(*p=='x') if(*p=='y') {}}");
+        check("void f4(char *p) { if(*p=='x') if(*p=='y') {}}\n");
         ASSERT_EQUALS("[test.cpp:1:25] -> [test.cpp:1:37]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f5(const char * const p) { if(*p=='x') if(*p=='y') {}}");
+        check("void f5(const char * const p) { if(*p=='x') if(*p=='y') {}}\n");
         ASSERT_EQUALS("[test.cpp:1:38] -> [test.cpp:1:50]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f5(const char * const p) { if('x'==*p) if('y'==*p) {}}");
+        check("void f5(const char * const p) { if('x'==*p) if('y'==*p) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:39] -> [test.cpp:1:51]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f6(char * const p) { if(*p=='x') if(*p=='y') {}}");
+        check("void f6(char * const p) { if(*p=='x') if(*p=='y') {}}\n");
         ASSERT_EQUALS("[test.cpp:1:32] -> [test.cpp:1:44]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f7(const char * p) { if(*p=='x') if(*p=='y') {}}");
+        check("void f7(const char * p) { if(*p=='x') if(*p=='y') {}}\n");
         ASSERT_EQUALS("[test.cpp:1:32] -> [test.cpp:1:44]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f8(int i) { if(i==4) if(i==2) {}}");
+        check("void f8(int i) { if(i==4) if(i==2) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:22] -> [test.cpp:1:31]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f9(int *p) { if (*p==4) if(*p==2) {}}");
+        check("void f9(int *p) { if (*p==4) if(*p==2) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:25] -> [test.cpp:1:35]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f10(int * const p) { if (*p==4) if(*p==2) {}}");
+        check("void f10(int * const p) { if (*p==4) if(*p==2) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:33] -> [test.cpp:1:43]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f11(const int *p) { if (*p==4) if(*p==2) {}}");
+        check("void f11(const int *p) { if (*p==4) if(*p==2) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:32] -> [test.cpp:1:42]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f12(const int * const p) { if (*p==4) if(*p==2) {}}");
+        check("void f12(const int * const p) { if (*p==4) if(*p==2) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:39] -> [test.cpp:1:49]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("struct foo {\n"
               "    int a;\n"
               "    int b;\n"
               "};\n"
-              "void f(foo x) { if(x.a==4) if(x.b==2) {}}");
+              "void f(foo x) { if(x.a==4) if(x.b==2) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct foo {\n"
               "    int a;\n"
               "    int b;\n"
               "};\n"
-              "void f(foo x) { if(x.a==4) if(x.b==4) {}}");
+              "void f(foo x) { if(x.a==4) if(x.b==4) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f3(char a, char b) { if(a==b) if(a==0) {}}");
+        check("void f3(char a, char b) { if(a==b) if(a==0) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int x) { if (x == 1) if (x != 1) {} }");
+        check("void f(int x) { if (x == 1) if (x != 1) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:23] -> [test.cpp:1:35]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
     }
 
@@ -2580,8 +2580,8 @@ class TestCondition : public TestFixture {
         check("void f(int x) {\n"
               "  if (a>3 && x > 100) {\n"
               "    if (x < 10) {}\n"
-              "  }"
-              "}");
+              "  }\n"
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16] -> [test.cpp:3:11]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void f(bool x, const int a, const int b) {\n"
@@ -2632,69 +2632,69 @@ class TestCondition : public TestFixture {
     }
 
     void oppositeInnerConditionEmpty() {
-        check("void f1(const std::string &s) { if(s.size() > 42) if(s.empty()) {}}");
+        check("void f1(const std::string &s) { if(s.size() > 42) if(s.empty()) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:45] -> [test.cpp:1:61]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f1(const std::string &s) { if(s.size() > 0) if(s.empty()) {}}");
+        check("void f1(const std::string &s) { if(s.size() > 0) if(s.empty()) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:45] -> [test.cpp:1:60]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f1(const std::string &s) { if(s.size() < 0) if(s.empty()) {}} "); // <- CheckOther reports: checking if unsigned expression is less than zero
+        check("void f1(const std::string &s) { if(s.size() < 0) if(s.empty()) {}} \n"); // <- CheckOther reports: checking if unsigned expression is less than zero
         ASSERT_EQUALS("[test.cpp:1:45] -> [test.cpp:1:60]: (style) Condition 's.empty()' is always false [knownConditionTrueFalse]\n", errout_str());
 
-        check("void f1(const std::string &s) { if(s.empty()) if(s.size() > 42) {}}");
+        check("void f1(const std::string &s) { if(s.empty()) if(s.size() > 42) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:43] -> [test.cpp:1:59]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("template<class T> void f1(const T &s) { if(s.size() > 42) if(s.empty()) {}}");
+        check("template<class T> void f1(const T &s) { if(s.size() > 42) if(s.empty()) {}}\n");
         ASSERT_EQUALS("", errout_str()); //We don't know the type of T so we don't know the relationship between size() and empty(). e.g. s might be a 50 tonne truck with nothing in it.
 
-        check("void f2(const std::wstring &s) { if(s.empty()) if(s.size() > 42) {}}");
+        check("void f2(const std::wstring &s) { if(s.empty()) if(s.size() > 42) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:44] -> [test.cpp:1:60]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f1(QString s) { if(s.isEmpty()) if(s.length() > 42) {}}");
+        check("void f1(QString s) { if(s.isEmpty()) if(s.length() > 42) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:34] -> [test.cpp:1:52]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f1(const std::string &s, bool b) { if(s.empty() || ((s.size() == 1) && b)) {}}");
+        check("void f1(const std::string &s, bool b) { if(s.empty() || ((s.size() == 1) && b)) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &x, const std::string &y) { if(x.size() > 42) if(y.empty()) {}}");
+        check("void f1(const std::string &x, const std::string &y) { if(x.size() > 42) if(y.empty()) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &x, const std::string &y) { if(y.empty()) if(x.size() > 42) {}}");
+        check("void f1(const std::string &x, const std::string &y) { if(y.empty()) if(x.size() > 42) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string v[10]) { if(v[0].size() > 42) if(v[1].empty()) {}}");
+        check("void f1(const std::string v[10]) { if(v[0].size() > 42) if(v[1].empty()) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &s) { if(s.size() <= 1) if(s.empty()) {}}");
+        check("void f1(const std::string &s) { if(s.size() <= 1) if(s.empty()) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &s) { if(s.size() <= 2) if(s.empty()) {}}");
+        check("void f1(const std::string &s) { if(s.size() <= 2) if(s.empty()) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &s) { if(s.size() < 2) if(s.empty()) {}}");
+        check("void f1(const std::string &s) { if(s.size() < 2) if(s.empty()) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &s) { if(s.size() >= 0) if(s.empty()) {}} "); // CheckOther says: Unsigned expression 's.size()' can't be negative so it is unnecessary to test it. [unsignedPositive]
+        check("void f1(const std::string &s) { if(s.size() >= 0) if(s.empty()) {}} \n"); // CheckOther says: Unsigned expression 's.size()' can't be negative so it is unnecessary to test it. [unsignedPositive]
         ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &s) { if(42 < s.size()) if(s.empty()) {}}");
+        check("void f1(const std::string &s) { if(42 < s.size()) if(s.empty()) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:39] -> [test.cpp:1:61]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f1(const std::string &s) { if(s.empty()) if(42 < s.size()) {}}");
+        check("void f1(const std::string &s) { if(s.empty()) if(42 < s.size()) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:43] -> [test.cpp:1:53]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void f(const std::string& s, int n) {\n" // #14716
               "    if (s.size() < n)\n"
               "        if (s.empty()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // TODO: These are identical condition since size cannot be negative
-        check("void f1(const std::string &s) { if(s.size() <= 0) if(s.empty()) {}}");
+        check("void f1(const std::string &s) { if(s.size() <= 0) if(s.empty()) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
         // TODO: These are identical condition since size cannot be negative
-        check("void f1(const std::string &s) { if(s.size() < 1) if(s.empty()) {}}");
+        check("void f1(const std::string &s) { if(s.size() < 1) if(s.empty()) {}}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2709,7 +2709,7 @@ class TestCondition : public TestFixture {
               "    }\n"
               "    void bar();\n"
               "    int get() const;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct CD {\n"
@@ -2737,7 +2737,7 @@ class TestCondition : public TestFixture {
               "  bool b = f();\n"
               "  x += 1;\n"
               "  if (!b && f()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(double d) {\n"
@@ -2766,10 +2766,10 @@ class TestCondition : public TestFixture {
     }
 
     void identicalInnerCondition() {
-        check("void f1(int a, int b) { if(a==b) if(a==b) {}}");
+        check("void f1(int a, int b) { if(a==b) if(a==b) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:29] -> [test.cpp:1:38]: (warning) Identical inner 'if' condition is always true. [identicalInnerCondition]\n", errout_str());
 
-        check("void f2(int a, int b) { if(a!=b) if(a!=b) {}}");
+        check("void f2(int a, int b) { if(a!=b) if(a!=b) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:29] -> [test.cpp:1:38]: (warning) Identical inner 'if' condition is always true. [identicalInnerCondition]\n", errout_str());
 
         // #6645 false negative: condition is always false
@@ -2778,38 +2778,38 @@ class TestCondition : public TestFixture {
               "     if(a) {}\n"
               "     else  {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:6] -> [test.cpp:3:9]: (warning) Identical inner 'if' condition is always true. [identicalInnerCondition]\n", errout_str());
 
         check("bool f(int a, int b) {\n"
               "    if(a == b) { return a == b; }\n"
               "    return false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:2:27]: (warning) Identical inner 'return' condition is always true. [identicalInnerCondition]\n", errout_str());
 
         check("bool f(bool a) {\n"
               "    if(a) { return a; }\n"
               "    return false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int* f(int* a, int * b) {\n"
               "    if(a) { return a; }\n"
               "    return b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int* f(std::shared_ptr<int> a, std::shared_ptr<int> b) {\n"
               "    if(a.get()) { return a.get(); }\n"
               "    return b.get();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { int * x; };\n"
               "int* f(A a, int * b) {\n"
               "    if(a.x) { return a.x; }\n"
               "    return b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -2821,7 +2821,7 @@ class TestCondition : public TestFixture {
               "        get_value (&value);\n"
               "        if ((value >> 28) & 1) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkP("#define TYPE_1 \"a\"\n" // #13202
@@ -2833,7 +2833,7 @@ class TestCondition : public TestFixture {
                "        if (s == TYPE_2) {}\n"
                "        else if (s == TYPE_3) {}\n"
                "    }\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const int* p, const int* e) {\n" // #14595
@@ -2856,7 +2856,7 @@ class TestCondition : public TestFixture {
               "    if (a[0] == 1) {\n"
               "        if (a[0] == 1) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14] -> [test.cpp:4:18]: (warning) Identical inner 'if' condition is always true. [identicalInnerCondition]\n",
                       errout_str());
     }
@@ -2865,53 +2865,53 @@ class TestCondition : public TestFixture {
         check("void f(int x) {\n" // #8137
               "  if (x > 100) { return; }\n"
               "  if (x > 100) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:9]: (warning) Identical condition 'x>100', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("bool f(int x) {\n"
               "  if (x > 100) { return false; }\n"
               "  return x > 100;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:12]: (warning) Identical condition and return expression 'x>100', return value is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x > 100) { return; }\n"
               "  if (x > 100 || y > 100) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:9]: (warning) Identical condition 'x>100', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x > 100) { return; }\n"
               "  if (x > 100 && y > 100) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:9]: (warning) Identical condition 'x>100', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x > 100) { return; }\n"
               "  if (abc) {}\n"
               "  if (x > 100) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:9]: (warning) Identical condition 'x>100', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x > 100) { return; }\n"
               "  while (abc) { y = x; }\n"
               "  if (x > 100) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:9]: (warning) Identical condition 'x>100', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         ASSERT_THROW_INTERNAL(check("void f(int x) {\n"  // #8217 - crash for incomplete code
                                     "  if (x > 100) { return; }\n"
                                     "  X(do);\n"
                                     "  if (x > 100) {}\n"
-                                    "}"),
+                                    "}\n"),
                               SYNTAX);
 
         check("void f(const int *i) {\n"
               "  if (!i) return;\n"
               "  if (!num1tok) { *num1 = *num2; }\n"
               "  if (!i) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7] -> [test.cpp:4:7]: (warning) Identical condition '!i', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void C::f(Tree &coreTree) {\n" // daca
@@ -2919,7 +2919,7 @@ class TestCondition : public TestFixture {
               "    return;\n"
               "  coreTree.dostuff();\n"
               "  if(!coreTree.build()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C { void f(const Tree &coreTree); };\n"
@@ -2928,7 +2928,7 @@ class TestCondition : public TestFixture {
               "    return;\n"
               "  coreTree.dostuff();\n"
               "  if(!coreTree.build()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6] -> [test.cpp:6:6]: (warning) Identical condition '!coreTree.build()', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void f(int x) {\n" // daca: labplot
@@ -2941,7 +2941,7 @@ class TestCondition : public TestFixture {
               "    else return 4;\n"
               "  }\n"
               "  return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("static int failed = 0;\n"
@@ -2949,14 +2949,14 @@ class TestCondition : public TestFixture {
               "  if (failed) return;\n"
               "  checkBuffer();\n"
               "  if (failed) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // daca icu
         check("void f(const uint32_t *section, int32_t  start) {\n"
               "  if(10<=section[start]) { return; }\n"
               "  if(++start<100 && 10<=section[start]) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // daca iqtree
@@ -2966,7 +2966,7 @@ class TestCondition : public TestFixture {
               "  if (ch != '|') return;\n"
               "  in >> ch;\n"
               "  if (ch != '|') {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8924
@@ -2977,7 +2977,7 @@ class TestCondition : public TestFixture {
               "        if (this->FileIndex < 0) return;\n"
               "    }\n"
               "    int FileIndex;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:29]: (style) Condition 'this->FileIndex<0' is always false [knownConditionTrueFalse]\n", errout_str());
 
         // #8858 - #if
@@ -2989,7 +2989,7 @@ class TestCondition : public TestFixture {
               "    ret = bar2();\n"
               "#endif\n"
               "    return ret;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #10456
@@ -3027,7 +3027,7 @@ class TestCondition : public TestFixture {
               "    x += y;\n"
               "    if (x == 0) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
@@ -3035,7 +3035,7 @@ class TestCondition : public TestFixture {
               "    x += y;\n"
               "    if (x == 1) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int * x, int * y) {\n"
@@ -3043,7 +3043,7 @@ class TestCondition : public TestFixture {
               "    (*y)++;\n"
               "    if (x[*y] == 0) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g(int[]);\n" // #14724
@@ -3052,7 +3052,7 @@ class TestCondition : public TestFixture {
               "        g(a);\n"
               "        if (a[0] == 1) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3061,14 +3061,14 @@ class TestCondition : public TestFixture {
               "    if (x == 1) {\n"
               "        if (x & 7) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:15]: (warning) Overlapping inner 'if' condition is always true. [overlappingInnerCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x & 7) {\n"
               "        if (x == 1) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3076,102 +3076,102 @@ class TestCondition : public TestFixture {
     void clarifyCondition1() {
         check("void f() {\n"
               "    if (x = b() < 0) {}\n" // don't simplify and verify this code
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:8]: (style) Suspicious condition (assignment + comparison); Clarify expression with parentheses. [clarifyCondition]\n", errout_str());
 
         check("void f(int i) {\n"
               "    for (i = 0; i < 10; i++) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    x = a<int>(); if (x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    if (x = b < 0 ? 1 : 2) {}\n" // don't simplify and verify this code
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int y = rand(), z = rand();\n"
               "    if (y || (!y && z));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Redundant condition: !y. 'y || (!y && z)' is equivalent to 'y || z' [redundantCondition]\n", errout_str());
 
         check("void f() {\n"
               "    int y = rand(), z = rand();\n"
               "    if (y || !y && z);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Redundant condition: !y. 'y || (!y && z)' is equivalent to 'y || z' [redundantCondition]\n", errout_str());
 
         check("void f() {\n"
               "    if (!a || a && b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (style) Redundant condition: a. '!a || (a && b)' is equivalent to '!a || b' [redundantCondition]\n", errout_str());
 
 
         check("void f(const Token *tok) {\n"
               "    if (!tok->next()->function() ||\n"
               "        (tok->next()->function() && tok->next()->function()->isConstructor()));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:34]: (style) Redundant condition: tok->next()->function(). '!A || (A && B)' is equivalent to '!A || B' [redundantCondition]\n", errout_str());
 
         check("void f() {\n"
               "    if (!tok->next()->function() ||\n"
               "        (!tok->next()->function() && tok->next()->function()->isConstructor()));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    if (!tok->next()->function() ||\n"
               "        (!tok2->next()->function() && tok->next()->function()->isConstructor()));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const Token *tok) {\n"
               "    if (!tok->next(1)->function(1) ||\n"
               "        (tok->next(1)->function(1) && tok->next(1)->function(1)->isConstructor()));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:36]: (style) Redundant condition: tok->next(1)->function(1). '!A || (A && B)' is equivalent to '!A || B' [redundantCondition]\n", errout_str());
 
         check("void f() {\n"
               "    if (!tok->next()->function(1) ||\n"
               "        (tok->next()->function(2) && tok->next()->function()->isConstructor()));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "   int y = rand(), z = rand();\n"
               "   if (y==0 || y!=0 && z);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (style) Redundant condition: y!=0. 'y==0 || (y!=0 && z)' is equivalent to 'y==0 || z' [redundantCondition]\n", errout_str());
 
         check("void f() {\n"
               "  if (x>0 || (x<0 && y)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Test Token::expressionString, TODO move this test
         check("void f() {\n"
               "  if (!dead || (dead && (*it).ticks > 0)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Redundant condition: dead. '!dead || (dead && (*it).ticks>0)' is equivalent to '!dead || (*it).ticks>0' [redundantCondition]\n", errout_str());
 
         check("void f() {\n"
               "  if (!x || (x && (2>(y-1)))) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) Redundant condition: x. '!x || (x && 2>(y-1))' is equivalent to '!x || 2>(y-1)' [redundantCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "    if (a || (a && b)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Redundant condition: a. 'a || (a && b)' is equivalent to 'a' [redundantCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "    if (a && (a || b)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Redundant condition: a. 'a && (a || b)' is equivalent to 'a' [redundantCondition]\n", errout_str());
     }
 
@@ -3179,14 +3179,14 @@ class TestCondition : public TestFixture {
     void clarifyCondition2() {
         check("void f() {\n"
               "    if (x & 3 == 2) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:8]: (style) Suspicious condition (bitwise operator + comparison); Clarify expression with parentheses. [clarifyCondition]\n"
                       "[test.cpp:2:11]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses. [clarifyCondition]\n"
                       "[test.cpp:2:11]: (style) Condition 'x&3==2' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    if (a & fred1.x == fred2.y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:8]: (style) Suspicious condition (bitwise operator + comparison); Clarify expression with parentheses. [clarifyCondition]\n"
                       "[test.cpp:2:11]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses. [clarifyCondition]\n"
                       , errout_str());
@@ -3196,50 +3196,50 @@ class TestCondition : public TestFixture {
     void clarifyCondition3() {
         check("void f(int w) {\n"
               "    if(!w & 0x8000) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses. [clarifyCondition]\n", errout_str());
 
         check("void f(int w) {\n"
               "    if((!w) & 0x8000) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    if (x == foo() & 2) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses. [clarifyCondition]\n", errout_str());
 
         check("void f() {\n"
               "    if (2 & x == foo()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses. [clarifyCondition]\n", errout_str());
 
         check("void f() {\n"
               "    if (2 & (x == foo())) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(std::list<int> &ints) { }");
+        check("void f(std::list<int> &ints) { }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { A<x &> a; }");
+        check("void f() { A<x &> a; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { a(x<y|z,0); }", dinit(CheckOptions, $.cpp = false));  // language is c => there are never templates
+        check("void f() { a(x<y|z,0); }\n", dinit(CheckOptions, $.cpp = false));  // language is c => there are never templates
         ASSERT_EQUALS("[test.c:1:17]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses. [clarifyCondition]\n", errout_str());
 
-        check("class A<B&,C>;");
+        check("class A<B&,C>;\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    if (result != (char *)&inline_result) { }\n" // don't simplify and verify cast
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8495
         check("void f(bool a, bool b) {\n"
               "    C & a & b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3254,13 +3254,13 @@ class TestCondition : public TestFixture {
               "     {\n"
               "         return left.first < right.first;\n"
               "     }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void clarifyCondition5() { // ticket #3609 (using | in template instantiation)
         check("template<bool B> struct CWinTraits;\n"
-              "CWinTraits<WS_CHILD|WS_VISIBLE>::GetWndStyle(0);");
+              "CWinTraits<WS_CHILD|WS_VISIBLE>::GetWndStyle(0);\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3269,7 +3269,7 @@ class TestCondition : public TestFixture {
               "SharedPtr& operator=( SharedPtr<Y> const & r ) {\n"
               "    px = r.px;\n"
               "    return *this;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3278,7 +3278,7 @@ class TestCondition : public TestFixture {
         check("void f(bool error) {\n"
               "    bool & withoutSideEffects=found.first->second;\n" // Declaring a reference to a boolean; & is no operator at all
               "    execute(secondExpression, &programMemory, &result, &error);\n" // Unary &
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3288,24 +3288,24 @@ class TestCondition : public TestFixture {
         check("bool a();\n"
               "bool f(bool b) {\n"
               "    return (a() & b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(bool *a, bool b) {\n"
               "    return (a[10] & b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { bool a; };\n"
               "bool f(struct A a, bool b) {\n"
               "    return (a.a & b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { bool a; };\n"
               "bool f(struct A a, bool b) {\n"
               "    return (A::a & b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3313,7 +3313,7 @@ class TestCondition : public TestFixture {
         check("void png_parse(uint64_t init, int buf_size) {\n"
               "    if (init == 0x89504e470d0a1a0a || init == 0x8a4d4e470d0a1a0a)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3322,7 +3322,7 @@ class TestCondition : public TestFixture {
               "void foo() {\n"
               "    if( ( value >= 0x7ff0000000000001ULL )\n"
               "            && ( value <= 0x7fffffffffffffffULL ) );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3332,7 +3332,7 @@ class TestCondition : public TestFixture {
               "  int x1 = s->x;\n"
               "  int x2 = s->x;\n"
               "  if (x1 == 10 && x2 == 10) {}\n" // <<
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10] -> [test.cpp:4:22]: (style) Condition 'x2==10' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f ()\n"// #8220
@@ -3348,27 +3348,27 @@ class TestCondition : public TestFixture {
               "        a ++;\n"
               "    }\n"
               "    ret = b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:27] -> [test.cpp:8:40]: (style) Condition '8<a' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n" // #4842
               "  int x = 0;\n"
               "  if (a) { return; }\n" // <- this is just here to fool simplifyKnownVariabels
               "  if (!x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (style) Condition '!x' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("bool f(int x) {\n"
               "  if(x == 0) { x++; return x == 0; }\n"
               "  return false;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:8] -> [test.cpp:2:30]: (style) Return value 'x==0' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n" // #6898 (Token::expressionString)
               "  int x = 0;\n"
               "  A(x++ == 1);\n"
               "  A(x++ == 2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Condition 'x++==1' is always false [knownConditionTrueFalse]\n"
                       "[test.cpp:4:9]: (style) Condition 'x++==2' is always false [knownConditionTrueFalse]\n",
                       errout_str());
@@ -3380,68 +3380,68 @@ class TestCondition : public TestFixture {
               "  if (bar == 2)\n"
               "    ret = true;\n"
               "  return ret;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &s) { if(s.empty()) if(s.size() == 0) {}}");
+        check("void f1(const std::string &s) { if(s.empty()) if(s.size() == 0) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:43] -> [test.cpp:1:59]: (style) Condition 's.size()==0' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   if( buf != 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (style) Condition 'buf!=0' is always true [knownConditionTrueFalse]\n", errout_str()); // #8924
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   if( !buf ) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8]: (style) Condition '!buf' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   bool b = buf;\n"
               "   if( b ) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:8]: (style) Condition 'b' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   bool b = buf;\n"
               "   if( !b ) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:8]: (style) Condition '!b' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   int * p = nullptr;\n"
               "   if( buf == p ) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (style) Condition 'buf==p' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(bool x) {\n"
               "   int buf[42];\n"
               "   if( buf || x ) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8]: (style) Condition 'buf' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int * p) {\n"
               "   int buf[42];\n"
               "   if( buf == p ) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   int p[42];\n"
               "   if( buf == p ) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   if( buf == 1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Avoid FP when condition comes from macro
@@ -3450,7 +3450,7 @@ class TestCondition : public TestFixture {
               "  int x = 0;\n"
               "  if (a) { return; }\n" // <- this is just here to fool simplifyKnownVariabels
               "  if (NOT x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("#define M  x != 0\n"
@@ -3458,27 +3458,27 @@ class TestCondition : public TestFixture {
               "  int x = 0;\n"
               "  if (a) { return; }\n" // <- this is just here to fool simplifyKnownVariabels
               "  if (M) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("#define IF(X)  if (X && x())\n"
               "void f() {\n"
               "  IF(1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Avoid FP for sizeof condition
         check("void f() {\n"
               "  if (sizeof(char) != 123) {}\n"
               "  if (123 != sizeof(char)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int x = 123;\n"
               "  if (sizeof(char) != x) {}\n"
               "  if (x != sizeof(char)) {}\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Condition 'sizeof(char)!=x' is always true\n"
                            "[test.cpp:4]: (style) Condition 'x!=sizeof(char)' is always true\n", "", errout_str());
 
@@ -3487,7 +3487,7 @@ class TestCondition : public TestFixture {
         check("void f() {\n"
               "  int x = 0;\n"
               "  assert(x == 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9363 - do not warn about value passed to function
@@ -3495,7 +3495,7 @@ class TestCondition : public TestFixture {
               "    if (b) {\n"
               "        if (bar(!b)) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -3510,7 +3510,7 @@ class TestCondition : public TestFixture {
               "        assert((int)(0==0));\n"
               "        assert((int)(0==0) && \"bla\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7750 char literals in boolean expressions
@@ -3519,7 +3519,7 @@ class TestCondition : public TestFixture {
               "  if(L'b'){}\n"
               "  if(1 && 'c'){}\n"
               "  int x = 'd' ? 1 : 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8206 - knownCondition always false
@@ -3527,26 +3527,26 @@ class TestCondition : public TestFixture {
               "{\n"
               "        if(i > 4)\n"
               "          for( int x = 0; i < 3; ++x){}\n" // <<
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14] -> [test.cpp:4:29]: (style) Condition 'i<3' is always false [knownConditionTrueFalse]\n", errout_str());
 
         // Skip literals
-        check("void f() { if(true) {} }");
+        check("void f() { if(true) {} }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { if(false) {} }");
+        check("void f() { if(false) {} }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { if(!true) {} }");
+        check("void f() { if(!true) {} }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { if(!false) {} }");
+        check("void f() { if(!false) {} }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { if(0) {} }");
+        check("void f() { if(0) {} }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { if(1) {} }");
+        check("void f() { if(1) {} }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int i) {\n"
@@ -3555,36 +3555,36 @@ class TestCondition : public TestFixture {
               "    else if (!b && i == 1) {}\n"
               "    if (b)\n"
               "    {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:14]: (style) Condition '!b' is always true [knownConditionTrueFalse]\n", errout_str());
 
-        check("bool f() { return nullptr; }");
+        check("bool f() { return nullptr; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("enum E { A };\n"
-              "bool f() { return A; }");
+              "bool f() { return A; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f() {\n"
               "    const int x = 0;\n"
               "    return x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int f(void){return 1/abs(10);}");
+        check("int f(void){return 1/abs(10);}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f() {\n"
               "    int x = 0;\n"
               "    return x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f() {\n"
               "    const int a = 50;\n"
               "    const int b = 52;\n"
               "    return a+b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style) Return value 'a+b' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("int f() {\n"
@@ -3593,7 +3593,7 @@ class TestCondition : public TestFixture {
               "    a++;\n"
               "    b++;\n"
               "    return a+b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool& g();\n"
@@ -3601,7 +3601,7 @@ class TestCondition : public TestFixture {
               "    bool & b = g();\n"
               "    b = false;\n"
               "    return b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -3610,13 +3610,13 @@ class TestCondition : public TestFixture {
               "        b = false;\n"
               "        return b;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(long maxtime) {\n"
               "  if (std::time(0) > maxtime)\n"
               "    return std::time(0) > maxtime;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(double param) {\n"
@@ -3626,7 +3626,7 @@ class TestCondition : public TestFixture {
               "  }\n"
               "  if (param<0.)\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int i) {\n"
@@ -3636,7 +3636,7 @@ class TestCondition : public TestFixture {
               "  }\n"
               "  if (cond && (42==i))\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // 8842 crash
@@ -3646,15 +3646,15 @@ class TestCondition : public TestFixture {
               "  void f() {\n"
               "    if (b) return;\n"
               "  }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const char* x, const char* t) {\n"
               "    if (!(strcmp(x, y) == 0)) { return; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(const int a[]){ if (a == 0){} }");
+        check("void f(const int a[]){ if (a == 0){} }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -3665,7 +3665,7 @@ class TestCondition : public TestFixture {
               "  bool c = s<s;\n"
               "  if (c) return 0;\n"
               "  else return 42;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("long X::g(bool unknown, int& result) {\n"
@@ -3674,35 +3674,35 @@ class TestCondition : public TestFixture {
               "    f = f || unknown;\n"
               "    f ? result = 42 : ret = -1;\n"
               "    return ret;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (style) Condition 'f' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("int f(void *handle) {\n"
               "    if (!handle) return 0;\n"
               "    if (handle) return 1;\n"
               "    else return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:9]: (style) Condition 'handle' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("int f(void *handle) {\n"
               "    if (handle == 0) return 0;\n"
               "    if (handle) return 1;\n"
               "    else return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Condition 'handle' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("int f(void *handle) {\n"
               "    if (handle != 0) return 0;\n"
               "    if (handle) return 1;\n"
               "    else return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16] -> [test.cpp:3:9]: (warning) Identical condition 'handle!=0', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("int f(void *handle) {\n"
               "    if (handle != nullptr) return 0;\n"
               "    if (handle) return 1;\n"
               "    else return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16] -> [test.cpp:3:9]: (warning) Identical condition 'handle!=nullptr', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void f(const char* p) {\n" // #13716
@@ -3710,7 +3710,7 @@ class TestCondition : public TestFixture {
               "    if (p == NULL) {}\n"
               "    if (p == nullptr) {}\n"
               "    if (p == 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:11]: (style) The if condition is the same as the previous if condition [duplicateCondition]\n",
                       errout_str());
 
@@ -3718,7 +3718,7 @@ class TestCondition : public TestFixture {
               "    if (p) {}\n"
               "    else if (!p) {}\n"
               "    else if (p == NULL) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:14]: (style) Expression is always true because 'else if' condition is opposite to previous condition at line 2. [multiCondition]\n"
                       "[test.cpp:4:16]: (style) Expression is always false because 'else if' condition matches previous condition at line 3. [multiCondition]\n",
                       errout_str());
@@ -3728,7 +3728,7 @@ class TestCondition : public TestFixture {
               "        return;\n"
               "    if (x == nullptr || y == nullptr)\n"
               "        return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void* g();\n"
@@ -3739,7 +3739,7 @@ class TestCondition : public TestFixture {
               "            break;\n"
               "    }\n"
               "    if (a) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void* g();\n"
@@ -3748,26 +3748,26 @@ class TestCondition : public TestFixture {
               "        a = g();\n"
               "    }\n"
               "    if (a) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12] -> [test.cpp:6:9]: (style) Condition 'a' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int * x, bool b) {\n"
               "    if (!x && b) {}\n"
               "    else if (x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const std::string x=\"xyz\";\n"
               "    if(!x.empty()){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8]: (style) Condition '!x.empty()' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("std::string g();\n"
               "void f() {\n"
               "    const std::string msg = g();\n"
               "    if(!msg.empty()){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *array, int size ) {\n"
@@ -3776,7 +3776,7 @@ class TestCondition : public TestFixture {
               "            continue;\n"
               "        if(array){}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (style) Condition 'array' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int *array, int size ) {\n"
@@ -3785,7 +3785,7 @@ class TestCondition : public TestFixture {
               "            continue;\n"
               "        else if(array){}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:17]: (style) Condition 'array' is always true [knownConditionTrueFalse]\n", errout_str());
 
         // #9277
@@ -3795,7 +3795,7 @@ class TestCondition : public TestFixture {
               "        return 0;\n"
               "    else\n"
               "        return 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9954
@@ -3817,7 +3817,7 @@ class TestCondition : public TestFixture {
               "  bool x = false;\n"
               "  g({0, 1}, x);\n"
               "  if (x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9318
@@ -3828,7 +3828,7 @@ class TestCondition : public TestFixture {
               "    return;\n"
               "  auto b = dynamic_cast<B*>(x);\n"
               "  if (b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int foo() {\n"
@@ -3846,7 +3846,7 @@ class TestCondition : public TestFixture {
         check("bool g();\n"
               "void f(bool x) {\n"
               "    if (x) while(x) x = g();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // isLikelyStream
@@ -3856,7 +3856,7 @@ class TestCondition : public TestFixture {
               "       iss >> x;\n"
               "       if (!iss) break;\n"
               "   }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9332
@@ -3868,14 +3868,14 @@ class TestCondition : public TestFixture {
               "    void* c = a.g();\n"
               "    if (!c) return;\n"
               "    bool compare = c == b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9361
         check("void f(char c) {\n"
               "    if (c == '.') {}\n"
               "    else if (isdigit(c) != 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9351
@@ -3883,7 +3883,7 @@ class TestCondition : public TestFixture {
               "    const bool b = x < 42;\n"
               "    if(b) return b?0:-1;\n"
               "    return 42;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:3:18]: (style) Condition 'b' is always true [knownConditionTrueFalse]\n", errout_str());
 
         // #9362
@@ -3893,7 +3893,7 @@ class TestCondition : public TestFixture {
               "    if((v != 0x00)) {\n"
               "        if( (v & 0x01) == 0x00) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9367
@@ -3902,25 +3902,25 @@ class TestCondition : public TestFixture {
               "        return;\n"
               "    if (x % 360L == 0)\n"
               "        return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int a, int b) {\n"
               "    static const int x = 10;\n"
               "    return x == 1 ? a : b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("const bool x = false;\n"
               "void f() {\n"
               "    if (x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("const bool x = false;\n"
               "void f() {\n"
               "    if (!x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9709
@@ -3931,7 +3931,7 @@ class TestCondition : public TestFixture {
               "    if (r != nullptr)\n"
               "        ok = a != 0;\n"
               "    if (ok) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9816
@@ -4120,7 +4120,7 @@ class TestCondition : public TestFixture {
         check("void foo(unsigned int max) {\n"
               "    unsigned int num = max - 1;\n"
               "    if (num < 0) {}\n" // <- do not report knownConditionTrueFalse
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #10297
@@ -4459,7 +4459,7 @@ class TestCondition : public TestFixture {
         ASSERT_EQUALS("", errout_str());
 
         // #8358
-        check("void f(double d) { if ((d * 0) != 0) {} }");
+        check("void f(double d) { if ((d * 0) != 0) {} }\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6870
@@ -4819,7 +4819,7 @@ class TestCondition : public TestFixture {
               "        return 9;\n"
               " \n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int g();\n" // #10561
@@ -4834,7 +4834,7 @@ class TestCondition : public TestFixture {
               "    }\n"
               "    catch (...) {}\n"
               "    return b ? 1 : 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -4990,10 +4990,10 @@ class TestCondition : public TestFixture {
               "}\n");
         ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:4:14]: (style) Condition 'x==y' is always false [knownConditionTrueFalse]\n", errout_str());
 
-        check("void f(bool a, bool b) {  if (a == b && a && !b){} }");
+        check("void f(bool a, bool b) {  if (a == b && a && !b){} }\n");
         ASSERT_EQUALS("[test.cpp:1:41] -> [test.cpp:1:46]: (style) Condition '!b' is always false [knownConditionTrueFalse]\n", errout_str());
 
-        check("bool f(bool a, bool b) { if(a && b && (!a)){} }");
+        check("bool f(bool a, bool b) { if(a && b && (!a)){} }\n");
         ASSERT_EQUALS("[test.cpp:1:29] -> [test.cpp:1:40]: (style) Condition '!a' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x, int y) {\n"
@@ -5205,7 +5205,7 @@ class TestCondition : public TestFixture {
               "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("struct A { int x; int y; };"
+        check("struct A { int x; int y; };\n"
               "void use(int);\n"
               "void test(A a) {\n"
               "    int i = a.x;\n"
@@ -5214,10 +5214,10 @@ class TestCondition : public TestFixture {
               "    if (i == j) {}\n"
               "    if (i == a.x) {}\n"
               "    if (j == a.x) {}\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:6:11]: (style) Condition 'i==j' is always true [knownConditionTrueFalse]\n"
-                      "[test.cpp:7:11]: (style) Condition 'i==a.x' is always true [knownConditionTrueFalse]\n"
-                      "[test.cpp:8:11]: (style) Condition 'j==a.x' is always true [knownConditionTrueFalse]\n",
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:11]: (style) Condition 'i==j' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:8:11]: (style) Condition 'i==a.x' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:9:11]: (style) Condition 'j==a.x' is always true [knownConditionTrueFalse]\n",
                       errout_str());
 
         check("struct S { int i; };\n" // #12795
@@ -5258,7 +5258,7 @@ class TestCondition : public TestFixture {
               "        x++;\n"
               "        if (x == 1) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:4:15]: (style) Condition 'x==1' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x) {\n"
@@ -5266,7 +5266,7 @@ class TestCondition : public TestFixture {
               "        x++;\n"
               "        if (x != 1) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:4:15]: (style) Condition 'x!=1' is always true [knownConditionTrueFalse]\n", errout_str());
 
         // #6890
@@ -5278,7 +5278,7 @@ class TestCondition : public TestFixture {
               "        if (x == -1) {}\n"
               "        else {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x==-1' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int i) {\n"
@@ -5289,7 +5289,7 @@ class TestCondition : public TestFixture {
               "        if (x != -1) {}\n"
               "        else {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x!=-1' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int i) {\n"
@@ -5300,7 +5300,7 @@ class TestCondition : public TestFixture {
               "        if (x >= -1) {}\n"
               "        else {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x>=-1' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int i) {\n"
@@ -5311,7 +5311,7 @@ class TestCondition : public TestFixture {
               "        if (x > -1) {}\n"
               "        else {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x>-1' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int i) {\n"
@@ -5322,7 +5322,7 @@ class TestCondition : public TestFixture {
               "        if (x < -1) {}\n"
               "        else {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x<-1' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int i) {\n"
@@ -5333,7 +5333,7 @@ class TestCondition : public TestFixture {
               "        if (x <= -1) {}\n"
               "        else {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x<=-1' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int i) {\n"
@@ -5344,7 +5344,7 @@ class TestCondition : public TestFixture {
               "        if (x > 7) {}\n"
               "        else {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x>7' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int i) {\n"
@@ -5355,7 +5355,7 @@ class TestCondition : public TestFixture {
               "        if (x > 9) {}\n"
               "        else {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int i) {\n"
@@ -5366,7 +5366,7 @@ class TestCondition : public TestFixture {
               "        if (x > 10) {}\n"
               "        else {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #11100
@@ -5391,7 +5391,7 @@ class TestCondition : public TestFixture {
               "        if(pos > 0)\n"
               "            --pos;\n"
               "    return pos;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:5:16]: (style) Condition 'pos>0' is always true [knownConditionTrueFalse]\n", errout_str());
 
         // #9721
@@ -5400,7 +5400,7 @@ class TestCondition : public TestFixture {
               "        if ( (x>255) || (-128>x) )\n"
               "            return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:30]: (style) Condition '-128>x' is always false [knownConditionTrueFalse]\n", errout_str());
 
         // #8778
@@ -5414,7 +5414,7 @@ class TestCondition : public TestFixture {
         check("void f() {\n"
               "    for(int x = 0; x < 3; ++x)\n"
               "        if(x == -5) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (style) Condition 'x==-5' is always false [knownConditionTrueFalse]\n", errout_str());
 
         // #8407
@@ -5423,7 +5423,7 @@ class TestCondition : public TestFixture {
               "        if(i == 0) return 1; \n" // <<
               "        else return 0;\n"
               "    return -1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (style) Condition 'i==0' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(unsigned int u1, unsigned int u2) {\n"
@@ -5495,7 +5495,7 @@ class TestCondition : public TestFixture {
               "        c2(g );\n"
               "    if ( !g.empty() )\n"
               "        return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int flag) {\n"
@@ -5506,7 +5506,7 @@ class TestCondition : public TestFixture {
               "        c2(g );\n"
               "    if ( !g.empty() )\n"
               "        return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -5717,7 +5717,7 @@ class TestCondition : public TestFixture {
               "            {;}\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:20] -> [test.cpp:7:27]: (style) Condition 'i==1' is always true [knownConditionTrueFalse]\n", errout_str());
 
         // #10863
@@ -5831,7 +5831,7 @@ class TestCondition : public TestFixture {
     void alwaysTruePremiumMisra() {
         const char code[] = "void f() {\n"
                             "  if (3 > 2) {}\n"
-                            "}";
+                            "}\n";
 
         check(code);
         ASSERT_EQUALS("", errout_str());
@@ -5847,7 +5847,7 @@ class TestCondition : public TestFixture {
               "  int val = 0;\n"
               "  if (val < 0) continue;\n"
               "  if (val > 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -5855,7 +5855,7 @@ class TestCondition : public TestFixture {
               "  if (val < 0) {\n"
               "    if (val > 0) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -5863,7 +5863,7 @@ class TestCondition : public TestFixture {
               "  if (val < 0) {\n"
               "    if (val < 0) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -5871,7 +5871,7 @@ class TestCondition : public TestFixture {
               "  int foo = 0;\n"
               "  if (activate) {}\n"
               "  else if (foo) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (style) Condition 'activate' is always false [knownConditionTrueFalse]\n"
                       "[test.cpp:5:12]: (style) Condition 'foo' is always false [knownConditionTrueFalse]\n", errout_str());
 
@@ -5879,7 +5879,7 @@ class TestCondition : public TestFixture {
         check("void f() {\n"
               "  const int b[2] = { 1,0 };\n"
               "  if(b[1] == 2) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Condition 'b[1]==2' is always false [knownConditionTrueFalse]\n", errout_str());
 
         // #9878
@@ -5896,40 +5896,40 @@ class TestCondition : public TestFixture {
         check("void f(bool x) {\n"
               "    if(x) {}\n"
               "    if(x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:8] -> [test.cpp:3:8]: (style) The if condition is the same as the previous if condition [duplicateCondition]\n",
                       errout_str());
 
         check("void f(int x) {\n"
               "    if(x == 1) {}\n"
               "    if(x == 1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:3:10]: (style) The if condition is the same as the previous if condition [duplicateCondition]\n",
                       errout_str());
 
         check("void f(int x) {\n"
               "    if(x == 1) {}\n"
               "    if(x == 2) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if(x == 1) {}\n"
               "    if(x != 1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool x) {\n"
               "    if(x) {}\n"
               "    g();\n"
               "    if(x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if(x == 1) { x++; }\n"
               "    if(x == 1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8996
@@ -5941,7 +5941,7 @@ class TestCondition : public TestFixture {
               "  g(d);\n"
               "  if (a) {}\n"
               "  if (b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9311
@@ -5956,7 +5956,7 @@ class TestCondition : public TestFixture {
               "  g(d);\n"
               "  if (a) {}\n"
               "  if (b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8993
@@ -5964,7 +5964,7 @@ class TestCondition : public TestFixture {
               "  auto y = x;\n"
               "  if (x.empty()) y = \"1\";\n"
               "  if (y.empty()) return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9106
@@ -5972,7 +5972,7 @@ class TestCondition : public TestFixture {
               "void f(A a, int c) {\n"
               "    if (a.b) a.b = c;\n"
               "    if (a.b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -6094,7 +6094,7 @@ class TestCondition : public TestFixture {
               "        ;\n"
               "    if (other.mPA.cols > 0 && other.mPA.rows > 0)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n" // #11202
@@ -6143,27 +6143,27 @@ class TestCondition : public TestFixture {
     void checkInvalidTestForOverflow() {
         check("void f(char *p, unsigned int x) {\n"
               "    assert((p + x) < p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20]: (warning) Invalid test for overflow '(p+x)<p'; pointer overflow is undefined behavior. Some mainstream compilers remove such overflow tests when optimising the code and assume it's always false. [invalidTestForOverflow]\n", errout_str());
 
         check("void f(char *p, unsigned int x) {\n"
               "    assert((p + x) >= p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20]: (warning) Invalid test for overflow '(p+x)>=p'; pointer overflow is undefined behavior. Some mainstream compilers remove such overflow tests when optimising the code and assume it's always true. [invalidTestForOverflow]\n", errout_str());
 
         check("void f(char *p, unsigned int x) {\n"
               "    assert(p > (p + x));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (warning) Invalid test for overflow 'p>(p+x)'; pointer overflow is undefined behavior. Some mainstream compilers remove such overflow tests when optimising the code and assume it's always false. [invalidTestForOverflow]\n", errout_str());
 
         check("void f(char *p, unsigned int x) {\n"
               "    assert(p <= (p + x));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (warning) Invalid test for overflow 'p<=(p+x)'; pointer overflow is undefined behavior. Some mainstream compilers remove such overflow tests when optimising the code and assume it's always true. [invalidTestForOverflow]\n", errout_str());
 
         check("void f(signed int x) {\n" // unsigned overflow => don't warn
               "    assert(x + 100U < x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -6171,57 +6171,57 @@ class TestCondition : public TestFixture {
 
 #define MSG(EXPR, RESULT)   "[test.cpp:1:30]: (warning) Invalid test for overflow '" EXPR "'; signed integer overflow is undefined behavior. Some mainstream compilers remove such overflow tests when optimising the code and assume it's always " RESULT ". [invalidTestForOverflow]\n"
 
-        check("int f(int x) { return x + 10 > x; }");
+        check("int f(int x) { return x + 10 > x; }\n");
         ASSERT_EQUALS(MSG("x+10>x", "true"), errout_str());
 
-        check("int f(int x) { return x + 10 >= x; }");
+        check("int f(int x) { return x + 10 >= x; }\n");
         ASSERT_EQUALS(MSG("x+10>=x", "true"), errout_str());
 
-        check("int f(int x) { return x + 10 < x; }");
+        check("int f(int x) { return x + 10 < x; }\n");
         ASSERT_EQUALS(MSG("x+10<x", "false"), errout_str());
 
-        check("int f(int x) { return x + 10 <= x; }");
+        check("int f(int x) { return x + 10 <= x; }\n");
         ASSERT_EQUALS(MSG("x+10<=x", "false"), errout_str());
 
-        check("int f(int x) { return x - 10 > x; }");
+        check("int f(int x) { return x - 10 > x; }\n");
         ASSERT_EQUALS(MSG("x-10>x", "false"), errout_str());
 
-        check("int f(int x) { return x - 10 >= x; }");
+        check("int f(int x) { return x - 10 >= x; }\n");
         ASSERT_EQUALS(MSG("x-10>=x", "false"), errout_str());
 
-        check("int f(int x) { return x - 10 < x; }");
+        check("int f(int x) { return x - 10 < x; }\n");
         ASSERT_EQUALS(MSG("x-10<x", "true"), errout_str());
 
-        check("int f(int x) { return x - 10 <= x; }");
+        check("int f(int x) { return x - 10 <= x; }\n");
         ASSERT_EQUALS(MSG("x-10<=x", "true"), errout_str());
 
         // x + y < x
 #undef MSG
 #define MSG(EXPR, RESULT)   "[test.cpp:1:36]: (warning) Invalid test for overflow '" EXPR "'; signed integer overflow is undefined behavior. Some mainstream compilers removes handling of overflows when optimising the code and change the code to '" RESULT "'. [invalidTestForOverflow]\n"
 
-        check("int f(int x, int y) { return x + y < x; }");
+        check("int f(int x, int y) { return x + y < x; }\n");
         ASSERT_EQUALS(MSG("x+y<x", "y<0"), errout_str());
 
-        check("int f(int x, int y) { return x + y <= x; }");
+        check("int f(int x, int y) { return x + y <= x; }\n");
         ASSERT_EQUALS(MSG("x+y<=x", "y<=0"), errout_str());
 
-        check("int f(int x, int y) { return x + y > x; }");
+        check("int f(int x, int y) { return x + y > x; }\n");
         ASSERT_EQUALS(MSG("x+y>x", "y>0"), errout_str());
 
-        check("int f(int x, int y) { return x + y >= x; }");
+        check("int f(int x, int y) { return x + y >= x; }\n");
         ASSERT_EQUALS(MSG("x+y>=x", "y>=0"), errout_str());
 
         // x - y < x
-        check("int f(int x, int y) { return x - y < x; }");
+        check("int f(int x, int y) { return x - y < x; }\n");
         ASSERT_EQUALS(MSG("x-y<x", "y>0"), errout_str());
 
-        check("int f(int x, int y) { return x - y <= x; }");
+        check("int f(int x, int y) { return x - y <= x; }\n");
         ASSERT_EQUALS(MSG("x-y<=x", "y>=0"), errout_str());
 
-        check("int f(int x, int y) { return x - y > x; }");
+        check("int f(int x, int y) { return x - y > x; }\n");
         ASSERT_EQUALS(MSG("x-y>x", "y<0"), errout_str());
 
-        check("int f(int x, int y) { return x - y >= x; }");
+        check("int f(int x, int y) { return x - y >= x; }\n");
         ASSERT_EQUALS(MSG("x-y>=x", "y<=0"), errout_str());
     }
 
@@ -6230,55 +6230,55 @@ class TestCondition : public TestFixture {
               "    enum states {A,B,C};\n"
               "    const unsigned g_flags = B|C;\n"
               "    if(g_flags & A) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (style) Condition 'g_flags&A' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    int a = 5;"
               "    if(a) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (style) Condition 'a' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    int a = 5;"
               "    while(a + 1) { a--; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a = 5;"
               "    while(a + 1) { return; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:27]: (style) Condition 'a+1' is always true [knownConditionTrueFalse]\n", errout_str());
     }
 
     void alwaysTrueFalseInLogicalOperators() {
         check("bool f();\n"
-              "void foo() { bool x = true; if(x||f()) {}}");
+              "void foo() { bool x = true; if(x||f()) {}}\n");
         ASSERT_EQUALS("[test.cpp:2:32]: (style) Condition 'x' is always true [knownConditionTrueFalse]\n", errout_str());
 
-        check("void foo(bool b) { bool x = true; if(x||b) {}}");
+        check("void foo(bool b) { bool x = true; if(x||b) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:38]: (style) Condition 'x' is always true [knownConditionTrueFalse]\n", errout_str());
 
-        check("void foo(bool b) { if(true||b) {}}");
+        check("void foo(bool b) { if(true||b) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f();\n"
-              "void foo() { bool x = false; if(x||f()) {}}");
+              "void foo() { bool x = false; if(x||f()) {}}\n");
         ASSERT_EQUALS("[test.cpp:2:33]: (style) Condition 'x' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("bool f();\n"
-              "void foo() { bool x = false; if(x&&f()) {}}");
+              "void foo() { bool x = false; if(x&&f()) {}}\n");
         ASSERT_EQUALS("[test.cpp:2:33]: (style) Condition 'x' is always false [knownConditionTrueFalse]\n", errout_str());
 
-        check("void foo(bool b) { bool x = false; if(x&&b) {}}");
+        check("void foo(bool b) { bool x = false; if(x&&b) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:39]: (style) Condition 'x' is always false [knownConditionTrueFalse]\n", errout_str());
 
-        check("void foo(bool b) { if(false&&b) {}}");
+        check("void foo(bool b) { if(false&&b) {}}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f();\n"
-              "void foo() { bool x = true; if(x&&f()) {}}");
+              "void foo() { bool x = true; if(x&&f()) {}}\n");
         ASSERT_EQUALS("[test.cpp:2:32]: (style) Condition 'x' is always true [knownConditionTrueFalse]\n", errout_str());
 
         // #9578
@@ -6303,7 +6303,7 @@ class TestCondition : public TestFixture {
               "    if (!b) {\n"
               "        bool x = a || b;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:18]: (style) Condition '!b' is always false [knownConditionTrueFalse]\n"
                       "[test.cpp:7:9] -> [test.cpp:8:23]: (style) Condition 'b' is always false [knownConditionTrueFalse]\n",
                       errout_str());
@@ -6312,7 +6312,7 @@ class TestCondition : public TestFixture {
     void pointerAdditionResultNotNull() {
         check("void f(char *ptr) {\n"
               "  if (ptr + 1 != 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Comparison is wrong. Result of 'ptr+1' can't be 0 unless there is pointer overflow, and pointer overflow is undefined behaviour. [pointerAdditionResultNotNull]\n", errout_str());
     }
 
@@ -6322,7 +6322,7 @@ class TestCondition : public TestFixture {
         check("void f(int& x, int y) {\n"
               "    if (x == y)\n"
               "        x = y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: style: Assignment 'x=y' is redundant with condition 'x==y'. [duplicateConditionalAssign]\n"
                       "[test.cpp:2:11]: note: Condition 'x==y'\n"
                       "[test.cpp:3:11]: note: Assignment 'x=y' is redundant\n", errout_str());
@@ -6330,7 +6330,7 @@ class TestCondition : public TestFixture {
         check("void f(int& x, int y) {\n"
               "    if (x != y)\n"
               "        x = y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: style: The statement 'if (x!=y) x=y' is logically equivalent to 'x=y'. [duplicateConditionalAssign]\n"
                       "[test.cpp:3:11]: note: Assignment 'x=y'\n"
                       "[test.cpp:2:11]: note: Condition 'x!=y' is redundant\n", errout_str());
@@ -6340,7 +6340,7 @@ class TestCondition : public TestFixture {
               "        x = y;\n"
               "    else\n"
               "        x = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: style: Assignment 'x=y' is redundant with condition 'x==y'. [duplicateConditionalAssign]\n"
                       "[test.cpp:2:11]: note: Condition 'x==y'\n"
                       "[test.cpp:3:11]: note: Assignment 'x=y' is redundant\n", errout_str());
@@ -6350,13 +6350,13 @@ class TestCondition : public TestFixture {
               "        x = y;\n"
               "    else\n"
               "        x = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int& x, int y) {\n"
               "    if (x == y)\n"
               "        x = y + 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g();\n"
@@ -6365,7 +6365,7 @@ class TestCondition : public TestFixture {
               "        x = y;\n"
               "        g();\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(bool b) {\n"
@@ -6411,12 +6411,12 @@ class TestCondition : public TestFixture {
     void checkAssignmentInCondition() {
         check("void f(std::string s) {\n"
               "    if (s=\"123\"){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) Suspicious assignment in condition. Condition 's=\"123\"' is always true. [assignmentInCondition]\n", errout_str());
 
         check("void f(std::string *p) {\n"
               "    if (p=foo()){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(uint32_t u) {\n" // #2490
@@ -6432,65 +6432,65 @@ class TestCondition : public TestFixture {
 
         check("void f(unsigned char c) {\n"
               "  if (c == 256) {}\n"
-              "}", settingsUnix64);
+              "}\n", settingsUnix64);
         ASSERT_EQUALS("[test.cpp:2:12]: (style) Comparing expression of type 'unsigned char' against value 256. Condition is always false. [compareValueOutOfTypeRangeError]\n", errout_str());
 
         check("void f(unsigned char* b, int i) {\n" // #6372
               "  if (b[i] == 256) {}\n"
-              "}", settingsUnix64);
+              "}\n", settingsUnix64);
         ASSERT_EQUALS("[test.cpp:2:15]: (style) Comparing expression of type 'unsigned char' against value 256. Condition is always false. [compareValueOutOfTypeRangeError]\n", errout_str());
 
         check("void f(unsigned char c) {\n"
               "  if (c == 255) {}\n"
-              "}", settingsUnix64);
+              "}\n", settingsUnix64);
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b) {\n"
               "  if (b == true) {}\n"
-              "}", settingsUnix64);
+              "}\n", settingsUnix64);
         ASSERT_EQUALS("", errout_str());
 
         // #10372
         check("void f(signed char x) {\n"
               "  if (x == 0xff) {}\n"
-              "}", settingsUnix64);
+              "}\n", settingsUnix64);
         ASSERT_EQUALS("[test.cpp:2:12]: (style) Comparing expression of type 'signed char' against value 255. Condition is always false. [compareValueOutOfTypeRangeError]\n", errout_str());
 
         check("void f(short x) {\n"
               "  if (x == 0xffff) {}\n"
-              "}", settingsUnix64);
+              "}\n", settingsUnix64);
         ASSERT_EQUALS("[test.cpp:2:12]: (style) Comparing expression of type 'signed short' against value 65535. Condition is always false. [compareValueOutOfTypeRangeError]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x == 0xffffffff) {}\n"
-              "}", settingsUnix64);
+              "}\n", settingsUnix64);
         ASSERT_EQUALS("", errout_str());
 
         check("void f(long x) {\n"
               "  if (x == ~0L) {}\n"
-              "}", settingsUnix64);
+              "}\n", settingsUnix64);
         ASSERT_EQUALS("", errout_str());
 
         check("void f(long long x) {\n"
               "  if (x == ~0LL) {}\n"
-              "}", settingsUnix64);
+              "}\n", settingsUnix64);
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int x) {\n"
               "    const int i = 0xFFFFFFFF;\n"
               "    if (x == i) {}\n"
-              "}", settingsUnix64);
+              "}\n", settingsUnix64);
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  char c;\n"
               "  if ((c = foo()) != -1) {}\n"
-              "}", settingsUnix64);
+              "}\n", settingsUnix64);
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "  if (x < 3000000000) {}\n"
-              "}", settingsUnix64);
+              "}\n", settingsUnix64);
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Comparing expression of type 'signed int' against value 3000000000. Condition is always true. [compareValueOutOfTypeRangeError]\n", errout_str());
 
         check("void f(const signed char i) {\n" // #8545
@@ -6624,7 +6624,7 @@ class TestCondition : public TestFixture {
             "  }\n"
             "\n"
             "  S1 mS;\n"
-            "};"
+            "};\n"
             );
         ASSERT_EQUALS("[test.cpp:13:11] -> [test.cpp:18:13]: (style) Condition 'mS.b' is always false [knownConditionTrueFalse]\n", errout_str());
     }
diff --git a/test/testconstructors.cpp b/test/testconstructors.cpp
index 5f2fd228dc4..4de49f54311 100644
--- a/test/testconstructors.cpp
+++ b/test/testconstructors.cpp
@@ -240,21 +240,21 @@ class TestConstructors : public TestFixture {
               "{\n"
               "public:\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
               "private:\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:1:1]: (style) The class 'Fred' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n", errout_str());
 
         check("struct Fred\n"
               "{\n"
               "private:\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:1:1]: (style) The struct 'Fred' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n", errout_str());
     }
 
@@ -267,7 +267,7 @@ class TestConstructors : public TestFixture {
               "    Fred(Fred const & other) : i(other.i) {}\n"
               "    Fred(Fred && other) : i(other.i) {}\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
@@ -277,7 +277,7 @@ class TestConstructors : public TestFixture {
               "    Fred(Fred const & other) {i=other.i}\n"
               "    Fred(Fred && other) {i=other.i}\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
@@ -287,7 +287,7 @@ class TestConstructors : public TestFixture {
               "    Fred(Fred const & other) {}\n"
               "    Fred(Fred && other) {}\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:5:5]: (warning) Member variable 'Fred::i' is not initialized in the copy constructor. [uninitMemberVar]\n"
                       "[test.cpp:6:5]: (warning) Member variable 'Fred::i' is not initialized in the move constructor. [uninitMemberVar]\n", errout_str());
@@ -298,7 +298,7 @@ class TestConstructors : public TestFixture {
               "    Fred(Fred const & other) {}\n"
               "    Fred(Fred && other) {}\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:4:5]: (warning) Member variable 'Fred::i' is not initialized in the copy constructor. [uninitMemberVar]\n"
                       "[test.cpp:5:5]: (warning) Member variable 'Fred::i' is not initialized in the move constructor. [uninitMemberVar]\n", errout_str());
@@ -312,7 +312,7 @@ class TestConstructors : public TestFixture {
               "    int i;\n"
               "};\n"
               "Fred::Fred() :i(0)\n"
-              "{ }");
+              "{ }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Fred\n"
@@ -321,7 +321,7 @@ class TestConstructors : public TestFixture {
               "    int i;\n"
               "};\n"
               "Fred::Fred()\n"
-              "{ i = 0; }");
+              "{ i = 0; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Fred\n"
@@ -330,7 +330,7 @@ class TestConstructors : public TestFixture {
               "    int i;\n"
               "};\n"
               "Fred::Fred()\n"
-              "{ }");
+              "{ }\n");
         ASSERT_EQUALS("[test.cpp:6:7]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -365,7 +365,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "private:\n"
               "    int mValue;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -375,7 +375,7 @@ class TestConstructors : public TestFixture {
               "    A<T>(const T & t) { x = t.x; }\n"
               "private:\n"
               "    int x;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template <class T> struct A {\n"
@@ -383,7 +383,7 @@ class TestConstructors : public TestFixture {
               "    A<T>(const T & t) : x(t.x) { }\n"
               "private:\n"
               "    int x;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template <class T> struct A {\n"
@@ -392,7 +392,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    int x;\n"
               "    int y;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) Member variable 'A::y' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:3:5]: (warning) Member variable 'A::y' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
@@ -401,14 +401,14 @@ class TestConstructors : public TestFixture {
         check("class Fred;\n"
               "struct Fred {\n"
               "    int x;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void simple8() {
         check("struct Fred { int x; };\n"
               "class Barney { Fred fred; };\n"
-              "class Wilma { struct Betty { int x; } betty; };");
+              "class Wilma { struct Betty { int x; } betty; };\n");
         ASSERT_EQUALS("[test.cpp:2:1]: (style) The class 'Barney' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n"
                       "[test.cpp:3:1]: (style) The class 'Wilma' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n", errout_str());
     }
@@ -419,7 +419,7 @@ class TestConstructors : public TestFixture {
               "    Fred() : x(0) { }\n"
               "private:\n"
               "    int x;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -429,7 +429,7 @@ class TestConstructors : public TestFixture {
               "    Fred() = default;\n"
               "private:\n"
               "    int x;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'Fred::x' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct S {\n" // #9391
@@ -457,7 +457,7 @@ class TestConstructors : public TestFixture {
               "    int b{1}, c{2};\n"
               "    int d, e{3};\n"
               "    int f{4}, g;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'Fred::d' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:3:5]: (warning) Member variable 'Fred::g' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
@@ -469,7 +469,7 @@ class TestConstructors : public TestFixture {
               "    Fred() { Init(); }\n"
               "    void Init(int i = 0);\n"
               "};\n"
-              "void Fred::Init(int i) { x = i; }");
+              "void Fred::Init(int i) { x = i; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred {\n"
@@ -479,7 +479,7 @@ class TestConstructors : public TestFixture {
               "    Fred() { Init(0); }\n"
               "    void Init(int i, int j = 0);\n"
               "};\n"
-              "void Fred::Init(int i, int j) { x = i; y = j; }");
+              "void Fred::Init(int i, int j) { x = i; y = j; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -487,7 +487,7 @@ class TestConstructors : public TestFixture {
         check("class Fred {\n"
               "    int x=1;\n"
               "    int *y=0;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -500,7 +500,7 @@ class TestConstructors : public TestFixture {
               "    {}\n"
               "private:\n"
               "    int x;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred : public Base<A, B> {"
@@ -511,7 +511,7 @@ class TestConstructors : public TestFixture {
               "    {}\n"
               "private:\n"
               "    int x;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -590,7 +590,7 @@ class TestConstructors : public TestFixture {
         check("class Fred\n"
               "{\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:1:1]: (style) The class 'Fred' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n", errout_str());
     }
 
@@ -602,7 +602,7 @@ class TestConstructors : public TestFixture {
               "};\n"
               "\n"
               "void Fred::foobar()\n"
-              "{ }");
+              "{ }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -611,7 +611,7 @@ class TestConstructors : public TestFixture {
               "{\n"
               "private:\n"
               "    static int foobar;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -620,7 +620,7 @@ class TestConstructors : public TestFixture {
               "{\n"
               "public:\n"
               "    int foobar;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -628,7 +628,7 @@ class TestConstructors : public TestFixture {
         check("namespace Foo\n"
               "{\n"
               "    int i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -642,14 +642,14 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    cpucyclesT m_v;\n"
               "    bool m_b;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void noConstructor7() {
         // ticket #4391
         check("short bar;\n"
-              "class foo;");
+              "class foo;\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -657,7 +657,7 @@ class TestConstructors : public TestFixture {
         // ticket #4404
         check("class LineSegment;\n"
               "class PointArray  { };\n"
-              "void* tech_ = NULL;");
+              "void* tech_ = NULL;\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -668,7 +668,7 @@ class TestConstructors : public TestFixture {
               " CGreeting() : CGreetingBase<char>(), MessageSet(false) {}\n"
               "private:\n"
               " bool MessageSet;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -688,28 +688,28 @@ class TestConstructors : public TestFixture {
               "    virtual ~A();\n"
               "private:\n"
               "    wxTimer *WxTimer1;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
 
     void noConstructor11() { // #3552
         check("class Fred { int x; };\n"
-              "union U { int y; Fred fred; };");
+              "union U { int y; Fred fred; };\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void noConstructor12() { // #8951
-        check("class Fred { int x{0}; };");
+        check("class Fred { int x{0}; };\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("class Fred { int x=0; };");
+        check("class Fred { int x=0; };\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("class Fred { int x[1]={0}; };"); // #8850
+        check("class Fred { int x[1]={0}; };\n"); // #8850
         ASSERT_EQUALS("", errout_str());
 
-        check("class Fred { int x[1]{0}; };");
+        check("class Fred { int x[1]{0}; };\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -803,15 +803,15 @@ class TestConstructors : public TestFixture {
     // ticket #3190 "SymbolDatabase: Parse of sub class constructor fails"
     void forwardDeclaration() {
         check("class foo;\n"
-              "int bar;");
+              "int bar;\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class foo;\n"
-              "class foo;");
+              "class foo;\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class foo{};\n"
-              "class foo;");
+              "class foo;\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -821,7 +821,7 @@ class TestConstructors : public TestFixture {
               "    Fred()\n"
               "    { this->i = 0; }\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -836,7 +836,7 @@ class TestConstructors : public TestFixture {
               "            i = 1;\n"
               "    }\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -855,7 +855,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    const Fred & operator=(const Fred &fred)\n"
               "    { i = fred.i; return *this; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Fred {\n"
@@ -866,7 +866,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    const Fred & operator=(const Fred &fred)\n"
               "    { i = fred.i; return *this; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A\n"
@@ -881,7 +881,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "  int i;\n"
               "  int j;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -892,7 +892,7 @@ class TestConstructors : public TestFixture {
               "    Fred() { i = 0; }\n"
               "    void operator=(const Fred &fred) { }\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
     }
 
@@ -904,7 +904,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    void Init() { i = 0; }\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -921,7 +921,7 @@ class TestConstructors : public TestFixture {
               "        }\n"
               "        return *this\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:6:12]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
 
         check("class Fred\n"
@@ -936,7 +936,7 @@ class TestConstructors : public TestFixture {
               "        }\n"
               "        return *this\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:6:12]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
 
         check("class Fred\n"
@@ -951,7 +951,7 @@ class TestConstructors : public TestFixture {
               "        }\n"
               "        return *this\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:6:12]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
 
         check("class Fred\n"
@@ -966,7 +966,7 @@ class TestConstructors : public TestFixture {
               "        }\n"
               "        return *this\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -981,7 +981,7 @@ class TestConstructors : public TestFixture {
               "        Fred(rhs).swap(*this);\n"
               "        return *this;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -991,7 +991,7 @@ class TestConstructors : public TestFixture {
               "    Fred & operator=(const Fred &rhs) {\n"
               "        return *this;\n"
               "    }\n"
-              "};",dinit(CheckOptions, $.inconclusive = true));
+              "};\n",dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:3:12]: (warning, inconclusive) Member variable 'Fred::data' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
 
         check("struct Fred {\n"
@@ -999,7 +999,7 @@ class TestConstructors : public TestFixture {
               "    Fred & operator=(const Fred &rhs) {\n"
               "        return *this;\n"
               "    }\n"
-              "};",dinit(CheckOptions, $.inconclusive = true));
+              "};\n",dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:3:12]: (warning, inconclusive) Member variable 'Fred::ints' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
 
         check("struct Fred {\n"
@@ -1007,7 +1007,7 @@ class TestConstructors : public TestFixture {
               "    Fred & operator=(const Fred &rhs) {\n"
               "        return *this;\n"
               "    }\n"
-              "};",dinit(CheckOptions, $.inconclusive = true));
+              "};\n",dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:3:12]: (warning, inconclusive) Member variable 'Fred::data' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
     }
 
@@ -1113,7 +1113,7 @@ class TestConstructors : public TestFixture {
               "        int b;\n"
               "        Fred() { b = 0; }\n"
               "    };\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -1133,7 +1133,7 @@ class TestConstructors : public TestFixture {
               "        int b;\n"
               "        Fred() { b = 0; }\n"
               "    };\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -1153,7 +1153,7 @@ class TestConstructors : public TestFixture {
               "        int b;\n"
               "        Fred() { b = 0; }\n"
               "    };\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -1175,7 +1175,7 @@ class TestConstructors : public TestFixture {
               "            Fred() { b = 0; }\n"
               "        };\n"
               "    }\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -1197,7 +1197,7 @@ class TestConstructors : public TestFixture {
               "            Fred() { }\n"
               "        };\n"
               "    }\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("[test.cpp:7:13]: (warning) Member variable 'Fred::a' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:16:13]: (warning) Member variable 'Fred::b' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
@@ -1217,7 +1217,7 @@ class TestConstructors : public TestFixture {
               "c::c()\n"
               "{\n"
               "    m_iMyInt1 = m_iMyInt2 = 0;\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -1250,7 +1250,7 @@ class TestConstructors : public TestFixture {
               "void c::InitInt()\n"
               "{\n"
               "    m_iMyInt = 0;\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -1263,7 +1263,7 @@ class TestConstructors : public TestFixture {
               "    Fred();\n"
               "};\n"
               "Fred::Fred() : s(NULL)\n"
-              "{ }");
+              "{ }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Fred\n"
@@ -1272,7 +1272,7 @@ class TestConstructors : public TestFixture {
               "    Fred();\n"
               "};\n"
               "Fred::Fred()\n"
-              "{ s = NULL; }");
+              "{ s = NULL; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Fred\n"
@@ -1281,7 +1281,7 @@ class TestConstructors : public TestFixture {
               "    Fred();\n"
               "};\n"
               "Fred::Fred()\n"
-              "{ }");
+              "{ }\n");
         ASSERT_EQUALS("[test.cpp:6:7]: (warning) Member variable 'Fred::s' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -1293,7 +1293,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    void update() const;\n"
               "    mutable int x;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1304,7 +1304,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred() { }\n"
               "    static void *p;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1317,7 +1317,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "private:\n"
               "  std::map<int, double> * values_{};\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1335,7 +1335,7 @@ class TestConstructors : public TestFixture {
               "    {\n"
               "        U.a = 0;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
@@ -1349,7 +1349,7 @@ class TestConstructors : public TestFixture {
               "    Fred()\n"
               "    {\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:9:5]: (warning) Member variable 'Fred::U' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -1360,7 +1360,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A(int n) { }\n"
               "    A() : A(42) {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:5:5]: (warning) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
@@ -1369,7 +1369,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A(int n) { number = n; }\n"
               "    A() : A(42) {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"
@@ -1377,7 +1377,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A(int n) : A() { }\n"
               "    A() {}\n"
-              "};", dinit(CheckOptions, $.inconclusive = true));
+              "};\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:5:5]: (warning, inconclusive) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
@@ -1386,7 +1386,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A(int n) : A() { }\n"
               "    A() { number = 42; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"
@@ -1394,7 +1394,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A(int n) { }\n"
               "    A() : A{42} {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:5:5]: (warning) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
@@ -1403,7 +1403,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A(int n) { number = n; }\n"
               "    A() : A{42} {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"
@@ -1411,7 +1411,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A(int n) : A{} { }\n"
               "    A() {}\n"
-              "};", dinit(CheckOptions, $.inconclusive = true));
+              "};\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:5:5]: (warning, inconclusive) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
@@ -1420,7 +1420,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A(int n) : A{} { }\n"
               "    A() { number = 42; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #6675
@@ -1430,7 +1430,7 @@ class TestConstructors : public TestFixture {
               "  int foo_;\n"
               "};\n"
               "Foo::Foo() : Foo(0) {}\n"
-              "Foo::Foo(int foo) : foo_(foo) {}");
+              "Foo::Foo(int foo) : foo_(foo) {}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Noexcept ctors
@@ -1442,7 +1442,7 @@ class TestConstructors : public TestFixture {
               "    A() noexcept;\n"
               "};\n"
               "\n"
-              "A::A() noexcept: A(0) {}");
+              "A::A() noexcept: A(0) {}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #8581
@@ -1452,7 +1452,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A(int a) : _a(a) {}\n"
               "    A(float a) : A(int(a)) {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #8258
@@ -1464,7 +1464,7 @@ class TestConstructors : public TestFixture {
               "    int _a;\n"
               "    int _b;\n"
               "    F _f;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1488,7 +1488,7 @@ class TestConstructors : public TestFixture {
               "    : a(true)\n"
               "    , b(0)\n"
               "{\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1503,7 +1503,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "  Derived() {}\n"
               "  void foo() override;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:9:3]: (warning) Member variable 'Base::x' is not initialized in the constructor. Maybe it should be initialized directly in the class Base? [uninitDerivedMemberVar]\n", errout_str());
 
         check("struct A {\n" // #3462
@@ -1590,7 +1590,7 @@ class TestConstructors : public TestFixture {
               "class C : public S {\n"
               "public:\n"
               "    C() { all = 0; tick = 0; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -1606,7 +1606,7 @@ class TestConstructors : public TestFixture {
               "class C : public S {\n"
               "public:\n"
               "    C() { flag1 = flag2 = 0; tick = 0; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -1622,7 +1622,7 @@ class TestConstructors : public TestFixture {
               "class C : public S {\n"
               "public:\n"
               "    C() {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:13:5]: (warning) Member variable 'S::all' is not initialized in the constructor. Maybe it should be initialized directly in the class S? [uninitDerivedMemberVar]\n"
                       "[test.cpp:13:5]: (warning) Member variable 'S::flag1' is not initialized in the constructor. Maybe it should be initialized directly in the class S? [uninitDerivedMemberVar]\n"
                       "[test.cpp:13:5]: (warning) Member variable 'S::flag2' is not initialized in the constructor. Maybe it should be initialized directly in the class S? [uninitDerivedMemberVar]\n", errout_str());
@@ -1638,7 +1638,7 @@ class TestConstructors : public TestFixture {
                   "    Fred();\n"
                   "};\n"
                   "Fred::Fred()\n"
-                  "{ }", s);
+                  "{ }\n", s);
             ASSERT_EQUALS("[test.cpp:7:7]: (warning) Member variable 'Fred::var' is not initialized in the constructor. [uninitMemberVarPrivate]\n", errout_str());
         }
 
@@ -1651,7 +1651,7 @@ class TestConstructors : public TestFixture {
                   "    Fred();\n"
                   "};\n"
                   "Fred::Fred()\n"
-                  "{ }", s);
+                  "{ }\n", s);
             ASSERT_EQUALS("", errout_str());
         }
     }
@@ -1673,7 +1673,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred() { };\n"
               "    Fred(const Fred &) { };\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
@@ -1683,7 +1683,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred() { };\n"
               "    Fred(const Fred &) { };\n"
-              "};", dinit(CheckOptions, $.inconclusive = true));
+              "};\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:7:5]: (warning, inconclusive) Member variable 'Fred::var' is not assigned in the copy constructor. Should it be copied? [missingMemberCopy]\n", errout_str());
 
         check("class Fred\n"
@@ -1731,7 +1731,7 @@ class TestConstructors : public TestFixture {
               "A::A(){}\n"
               "A::B::B(int x){}\n"
               "A::B::C::C(int y){}\n"
-              "A::B::C::D::D(int z){}");
+              "A::B::C::D::D(int z){}\n");
         // Note that the example code is not compilable. The A constructor must
         // explicitly initialize A::b. A warning for A::b is not necessary.
         ASSERT_EQUALS("[test.cpp:20:4]: (warning) Member variable 'A::a' is not initialized in the constructor. [uninitMemberVar]\n"
@@ -1761,7 +1761,7 @@ class TestConstructors : public TestFixture {
               "A::A(){}\n"
               "A::B::B(int x){}\n"
               "A::B::C::C(int y){}\n"
-              "A::B::C::D::D(const A::B::C::D & d){}");
+              "A::B::C::D::D(const A::B::C::D & d){}\n");
         // Note that the example code is not compilable. The A constructor must
         // explicitly initialize A::b. A warning for A::b is not necessary.
         ASSERT_EQUALS("[test.cpp:20:4]: (warning) Member variable 'A::a' is not initialized in the constructor. [uninitMemberVar]\n"
@@ -1792,7 +1792,7 @@ class TestConstructors : public TestFixture {
               "A::A(){}\n"
               "A::B::B(int x){}\n"
               "A::B::C::C(int y){}\n"
-              "A::B::C::D::D(const A::B::C::D::E & e){}");
+              "A::B::C::D::D(const A::B::C::D::E & e){}\n");
         // Note that the example code is not compilable. The A constructor must
         // explicitly initialize A::b. A warning for A::b is not necessary.
         ASSERT_EQUALS("[test.cpp:21:4]: (warning) Member variable 'A::a' is not initialized in the constructor. [uninitMemberVar]\n"
@@ -1814,7 +1814,7 @@ class TestConstructors : public TestFixture {
               "    A(const A&){}\n"
               "    A(A &&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class B\n"
@@ -1829,7 +1829,7 @@ class TestConstructors : public TestFixture {
               "    A(const A&){}\n"
               "    A(A &&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class B\n"
@@ -1846,7 +1846,7 @@ class TestConstructors : public TestFixture {
               "    A(const A&){}\n"
               "    A(A &&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class B\n"
@@ -1862,7 +1862,7 @@ class TestConstructors : public TestFixture {
               "    A(const A&){}\n"
               "    A(A &&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A : public std::vector<int>\n"
@@ -1878,7 +1878,7 @@ class TestConstructors : public TestFixture {
               "    B(const B&){}\n"
               "    B(B &&){}\n"
               "    const B& operator=(const B&){return *this;}\n"
-              "};", dinit(CheckOptions, $.inconclusive = true));
+              "};\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:11:5]: (warning, inconclusive) Member variable 'B::a' is not assigned in the copy constructor. Should it be copied? [missingMemberCopy]\n"
                       "[test.cpp:12:5]: (warning, inconclusive) Member variable 'B::a' is not assigned in the move constructor. Should it be moved? [missingMemberCopy]\n"
                       "[test.cpp:13:14]: (warning, inconclusive) Member variable 'B::a' is not assigned a value in 'B::operator='. [operatorEqVarError]\n",
@@ -1898,7 +1898,7 @@ class TestConstructors : public TestFixture {
               "    A(const A&){}\n"
               "    A(A &&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:13:5]: (warning) Member variable 'A::m_SemVar' is not initialized in the move constructor. [uninitMemberVar]\n", errout_str());
 
         check("class B\n"
@@ -1916,7 +1916,7 @@ class TestConstructors : public TestFixture {
               "    A(const A&){}\n"
               "    A(A &&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
@@ -1926,7 +1926,7 @@ class TestConstructors : public TestFixture {
               "    A(){}\n"
               "    A(const A&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1944,7 +1944,7 @@ class TestConstructors : public TestFixture {
               "    A(){}\n"
               "    A(const A&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
-              "};", dinit(CheckOptions, $.inconclusive = true));
+              "};\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("class B\n"
@@ -1961,7 +1961,7 @@ class TestConstructors : public TestFixture {
               "    A(){}\n"
               "    A(const A&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
-              "};", dinit(CheckOptions, $.inconclusive = true));
+              "};\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:12:5]: (warning) Member variable 'A::m_SemVar' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:13:5]: (warning) Member variable 'A::m_SemVar' is not initialized in the copy constructor. [uninitMemberVar]\n"
                       "[test.cpp:14:14]: (warning) Member variable 'A::m_SemVar' is not assigned a value in 'A::operator='. [operatorEqVarError]\n", errout_str());
@@ -1972,14 +1972,14 @@ class TestConstructors : public TestFixture {
               "    B b;\n"
               "    A() {}\n"
               "    A(const A& rhs) {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    B b;\n"
               "    A() {}\n"
               "    A(const A& rhs) {}\n"
-              "};", dinit(CheckOptions, $.inconclusive = true));
+              "};\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:4:5]: (warning, inconclusive) Member variable 'A::b' is not assigned in the copy constructor. Should it be copied? [missingMemberCopy]\n", errout_str());
     }
 
@@ -1995,7 +1995,7 @@ class TestConstructors : public TestFixture {
               "}\n"
               "void S::Set(const T& val) {\n"
               "    t = val;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2004,7 +2004,7 @@ class TestConstructors : public TestFixture {
               "  Foo(int m) { this->setMember(m); }\n"
               "  void setMember(int m) { member = m; }\n"
               "  int member;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2016,7 +2016,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred() : var(0) {}\n"
               "    ~Fred() {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2024,7 +2024,7 @@ class TestConstructors : public TestFixture {
         check("class something {\n"
               "    int * ( something :: * process()) () { return 0; }\n"
               "    something() { process(); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2035,7 +2035,7 @@ class TestConstructors : public TestFixture {
               "        int& pa = a;\n"
               "        pa = 4;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -2044,7 +2044,7 @@ class TestConstructors : public TestFixture {
               "        int* pa = &a;\n"
               "        *pa = 4;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -2054,7 +2054,7 @@ class TestConstructors : public TestFixture {
               "        for (int i = 0; i < 2; i++)\n"
               "            *pa++ = i;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -2063,7 +2063,7 @@ class TestConstructors : public TestFixture {
               "        int* pa = a[1];\n"
               "        *pa = 0;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'S::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct S {\n"
@@ -2072,7 +2072,7 @@ class TestConstructors : public TestFixture {
               "        int pa = a;\n"
               "        pa = 4;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'S::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -2091,7 +2091,7 @@ class TestConstructors : public TestFixture {
               "    A() {\n"
               "        Wrapper<dim>::foo(x);\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2109,7 +2109,7 @@ class TestConstructors : public TestFixture {
               "        d = rhs.get();\n"
               "    }\n"
               "    double d;\n"
-              "};", s);
+              "};\n", s);
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n" // #8485
@@ -2136,7 +2136,7 @@ class TestConstructors : public TestFixture {
               "{ }\n"
               "\n"
               "void Fred::operator=(const Fred &f)\n"
-              "{ }", dinit(CheckOptions, $.inconclusive = true));
+              "{ }\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:13:12]: (warning, inconclusive) Member variable 'Fred::ints' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
 
         const Settings s = settingsBuilder().certainty(Certainty::inconclusive).severity(Severity::style).severity(Severity::warning).library("std.cfg").build();
@@ -2161,7 +2161,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "private:\n"
               "    ECODES _code;\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("[test.cpp:10:5]: (warning) Member variable 'Fred::_code' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
@@ -2174,7 +2174,7 @@ class TestConstructors : public TestFixture {
               "  B() {}\n"
               "private:\n"
               "  float f;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:6:3]: (warning) Member variable 'B::f' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class C\n"
@@ -2187,7 +2187,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "C::C(FILE *fp) {\n"
               "    C::fp = fp;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2198,7 +2198,7 @@ class TestConstructors : public TestFixture {
               "    John() { (*this).i = 0; }\n"
               "private:\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2213,7 +2213,7 @@ class TestConstructors : public TestFixture {
               "        Bar();\n"
               "    };\n"
               "    Bar bars[2];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // Using struct that doesn't have constructor
@@ -2226,7 +2226,7 @@ class TestConstructors : public TestFixture {
               "        int x;\n"
               "    };\n"
               "    Bar bars[2];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Foo::bars' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -2240,7 +2240,7 @@ class TestConstructors : public TestFixture {
               "        int x;\n"
               "    };\n"
               "    struct Bar bar;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2252,7 +2252,7 @@ class TestConstructors : public TestFixture {
               "    Foo &operator=(const Foo &)\n"
               "    { return *this; }\n"
               "    static int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2263,7 +2263,7 @@ class TestConstructors : public TestFixture {
               "    explicit Foo(int i) : Bar(mi=i) { }\n"
               "private:\n"
               "    int mi;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Foo : public Bar\n"
@@ -2272,7 +2272,7 @@ class TestConstructors : public TestFixture {
               "    explicit Foo(int i) : Bar{mi=i} { }\n"
               "private:\n"
               "    int mi;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2293,7 +2293,7 @@ class TestConstructors : public TestFixture {
               "    Foo copy(rhs);\n"
               "    copy.Swap(*this);\n"
               "    return *this;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2310,7 +2310,7 @@ class TestConstructors : public TestFixture {
               "    {\n"
               "    }\n"
               "    return *this;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:11]: (warning) Member variable 'Foo::a' is not assigned a value in 'Foo::operator='. [operatorEqVarError]\n", errout_str());
     }
 
@@ -2324,7 +2324,7 @@ class TestConstructors : public TestFixture {
               "Prefs::Prefs(wxSize size)\n"
               "{\n"
               "    SetMinSize( wxSize( 48,48 ) );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:8]: (warning) Member variable 'Prefs::xasd' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -2336,7 +2336,7 @@ class TestConstructors : public TestFixture {
               "        int var1;\n"
               "        int var2;\n"
               "};\n"
-              "A::A() : var1(0) { }");
+              "A::A() : var1(0) { }\n");
         ASSERT_EQUALS("[test.cpp:8:4]: (warning) Member variable 'A::var2' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -2347,7 +2347,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "        int var;\n"
               "};\n"
-              "A::A(int a) { }");
+              "A::A(int a) { }\n");
         ASSERT_EQUALS("[test.cpp:7:4]: (warning) Member variable 'A::var' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -2363,7 +2363,7 @@ class TestConstructors : public TestFixture {
               "        : x(x), y(y)\n"
               "    {}\n"
               "    int x, y;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Point::x' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:4:5]: (warning) Member variable 'Point::y' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
@@ -2375,7 +2375,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A()\n"
               "    {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (warning) Member variable 'A::ints' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -2390,7 +2390,7 @@ class TestConstructors : public TestFixture {
               "};\n"
               "Foo::Foo()\n"
               "{\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:6]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // single namespace
@@ -2406,7 +2406,7 @@ class TestConstructors : public TestFixture {
               "    Foo::Foo()\n"
               "    {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:10]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // constructor outside namespace
@@ -2422,7 +2422,7 @@ class TestConstructors : public TestFixture {
               "}\n"
               "Foo::Foo()\n"
               "{\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // constructor outside namespace
@@ -2438,7 +2438,7 @@ class TestConstructors : public TestFixture {
               "}\n"
               "Output::Foo::Foo()\n"
               "{\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:11:14]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // constructor outside namespace with using, #4792
@@ -2455,7 +2455,7 @@ class TestConstructors : public TestFixture {
               "using namespace Output;"
               "Foo::Foo()\n"
               "{\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:11:29]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // constructor in separate namespace
@@ -2474,7 +2474,7 @@ class TestConstructors : public TestFixture {
               "    Foo::Foo()\n"
               "    {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:13:10]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // constructor in different separate namespace
@@ -2493,7 +2493,7 @@ class TestConstructors : public TestFixture {
               "    Foo::Foo()\n"
               "    {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // constructor in different separate namespace (won't compile)
@@ -2512,7 +2512,7 @@ class TestConstructors : public TestFixture {
               "    Output::Foo::Foo()\n"
               "    {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // constructor in nested separate namespace
@@ -2534,7 +2534,7 @@ class TestConstructors : public TestFixture {
               "        {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:15:14]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // constructor in nested different separate namespace
@@ -2556,7 +2556,7 @@ class TestConstructors : public TestFixture {
               "        {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // constructor in nested different separate namespace
@@ -2578,7 +2578,7 @@ class TestConstructors : public TestFixture {
               "        {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2592,7 +2592,7 @@ class TestConstructors : public TestFixture {
               "};\n"
               "Fred::~Fred()\n"
               "{\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2610,7 +2610,7 @@ class TestConstructors : public TestFixture {
               "    {\n"
               "        foo.set(0);\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Foo\n"
@@ -2625,7 +2625,7 @@ class TestConstructors : public TestFixture {
               "    Bar()\n"
               "    {\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:10:5]: (warning) Member variable 'Bar::foo' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -2642,7 +2642,7 @@ class TestConstructors : public TestFixture {
               "    {\n"
               "        foo[0].a = 0;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Foo\n"
@@ -2656,7 +2656,7 @@ class TestConstructors : public TestFixture {
               "    Bar()\n"
               "    {\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:9:5]: (warning) Member variable 'Bar::foo' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -2672,7 +2672,7 @@ class TestConstructors : public TestFixture {
               "    A() { }\n"
               "private:\n"
               "    Altren value;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2696,7 +2696,7 @@ class TestConstructors : public TestFixture {
               "    {\n"
               "        free(m_str);\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2708,7 +2708,7 @@ class TestConstructors : public TestFixture {
               "        std::streamsize dataLength_;\n"
               "        double bitsInData_;\n"
               "    } obj;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (warning) Member variable 'LocalClass::bitsInData_' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct copy_protected;\n"
@@ -2719,7 +2719,7 @@ class TestConstructors : public TestFixture {
               "        std::streamsize dataLength_;\n"
               "        double bitsInData_;\n"
               "    } obj;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS(
             "[test.cpp:5:9]: (warning) Member variable 'LocalClass::bitsInData_' is not initialized in the constructor. [uninitMemberVar]\n",
             errout_str());
@@ -2732,7 +2732,7 @@ class TestConstructors : public TestFixture {
               "        std::streamsize dataLength_;\n"
               "        double bitsInData_;\n"
               "    } obj;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS(
             "[test.cpp:5:9]: (warning) Member variable 'LocalClass::bitsInData_' is not initialized in the constructor. [uninitMemberVar]\n",
             errout_str());
@@ -2747,7 +2747,7 @@ class TestConstructors : public TestFixture {
               "};\n"
               "Fred::Fred() {\n"
               "    a[x::y] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2764,7 +2764,7 @@ class TestConstructors : public TestFixture {
               "Fred & Fred::clone(const Fred & other) {\n"
               "    x = 0;\n"
               "    return *this;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred {\n"
@@ -2778,7 +2778,7 @@ class TestConstructors : public TestFixture {
               "}\n"
               "Fred & Fred::clone(const Fred & other) {\n"
               "    return *this;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:14]: (warning) Member variable 'Fred::x' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
     }
 
@@ -2796,7 +2796,7 @@ class TestConstructors : public TestFixture {
               "Fred::Fred(struct C c, D d) { }\n"
               "Fred::Fred(E e, struct F f) { }\n"
               "Fred::Fred(G g, H h) { }\n"
-              "Fred::Fred(struct I i, struct J j) { }");
+              "Fred::Fred(struct I i, struct J j) { }\n");
         ASSERT_EQUALS("[test.cpp:10:7]: (warning) Member variable 'Fred::x' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:11:7]: (warning) Member variable 'Fred::x' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:12:7]: (warning) Member variable 'Fred::x' is not initialized in the constructor. [uninitMemberVar]\n"
@@ -2905,7 +2905,7 @@ class TestConstructors : public TestFixture {
               "    A(int s) {\n"
               "        v = new int [sz = s];\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2916,7 +2916,7 @@ class TestConstructors : public TestFixture {
               "    A() {\n"
               "        rtl::math::setNan(&d);\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
         check("class A {\n"
               "    double d;\n"
@@ -2924,7 +2924,7 @@ class TestConstructors : public TestFixture {
               "    A() {\n"
               "        ::rtl::math::setNan(&d);\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2939,7 +2939,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    void foo(int a) { i = a; }\n"
               "    void foo(float a) { f = a; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2971,7 +2971,7 @@ class TestConstructors : public TestFixture {
               "    D() { foo(); }\n"
               "	void foo() { }\n"
               "	void foo() const { i = 0; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:18:5]: (warning) Member variable 'C::i' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:25:5]: (warning) Member variable 'D::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
@@ -2988,7 +2988,7 @@ class TestConstructors : public TestFixture {
               "}\n"
               "using namespace NS;\n"
               "MyClass::~MyClass() { }\n"
-              "MyClass::MyClass() : SomeVar(false) { }");
+              "MyClass::MyClass() : SomeVar(false) { }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3006,7 +3006,7 @@ class TestConstructors : public TestFixture {
               "}\n"
               "void MyClass::Restart() {\n"
               "    m_retCode = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3019,7 +3019,7 @@ class TestConstructors : public TestFixture {
               "   {\n"
               "      if (1) {}\n"
               "   }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:4]: (warning) Member variable 'Foo::member' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
         check("class Foo {\n"
               "   friend class Bar;\n"
@@ -3029,7 +3029,7 @@ class TestConstructors : public TestFixture {
               "   {\n"
               "      while (1) {}\n"
               "   }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:4]: (warning) Member variable 'Foo::member' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
         check("class Foo {\n"
               "   friend class Bar;\n"
@@ -3039,7 +3039,7 @@ class TestConstructors : public TestFixture {
               "   {\n"
               "      for (;;) {}\n"
               "   }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:4]: (warning) Member variable 'Foo::member' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -3051,7 +3051,7 @@ class TestConstructors : public TestFixture {
               "        int x;\n"
               "    };\n"
               "};\n"
-              "app::B::B(void){}");
+              "app::B::B(void){}\n");
         ASSERT_EQUALS("[test.cpp:8:9]: (warning) Member variable 'B::x' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -3103,7 +3103,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "private:\n"
               "    char name[255];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'John::name' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class John\n"
@@ -3113,7 +3113,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "private:\n"
               "    char name[255];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class John\n"
@@ -3123,7 +3123,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "private:\n"
               "    char name[255];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class John\n"
@@ -3132,7 +3132,7 @@ class TestConstructors : public TestFixture {
               "    John() { }\n"
               "\n"
               "    double  operator[](const unsigned long i);\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A;\n"
@@ -3141,7 +3141,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    John() { }\n"
               "    A a[5];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A;\n"
@@ -3150,7 +3150,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    John() { }\n"
               "    A (*a)[5];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (warning) Member variable 'John::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -3162,7 +3162,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "private:\n"
               "    char name[255];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5754
@@ -3173,7 +3173,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "private:\n"
               "    char name[255];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3190,7 +3190,7 @@ class TestConstructors : public TestFixture {
               "        memset(a,0,sizeof(a));\n"
               "        memset(b,0,sizeof(b));\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3207,7 +3207,7 @@ class TestConstructors : public TestFixture {
               "        if (snprintf(a,10,\"a\")) { }\n"
               "        if (snprintf(b,10,\"b\")) { }\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3219,7 +3219,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Foo()\n"
               "    { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3231,7 +3231,7 @@ class TestConstructors : public TestFixture {
               "    static const char STR[];\n"
               "};\n"
               "const char Foo::STR[] = \"abc\";\n"
-              "Foo::Foo() { }");
+              "Foo::Foo() { }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3241,7 +3241,7 @@ class TestConstructors : public TestFixture {
               "    int array[10];\n"
               "public:\n"
               "    Foo() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (warning) Member variable 'Foo::array' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class Foo\n"
@@ -3249,7 +3249,7 @@ class TestConstructors : public TestFixture {
               "    int array[10];\n"
               "public:\n"
               "    Foo() { memset(array, 0, sizeof(array)); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Foo\n"
@@ -3257,7 +3257,7 @@ class TestConstructors : public TestFixture {
               "    int array[10];\n"
               "public:\n"
               "    Foo() { ::memset(array, 0, sizeof(array)); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3266,7 +3266,7 @@ class TestConstructors : public TestFixture {
               "    char a[10];\n"
               "public:\n"
               "    Foo() { ::ZeroMemory(a); }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3277,7 +3277,7 @@ class TestConstructors : public TestFixture {
               "    BaseGDL* eArr[3];\n"
               "public:\n"
               "    IxExprListT() {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (warning) Member variable 'IxExprListT::eArr' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
         check("struct sRAIUnitDefBL {\n"
               "  sRAIUnitDefBL();\n"
@@ -3286,7 +3286,7 @@ class TestConstructors : public TestFixture {
               "struct sRAIUnitDef {\n"
               "  sRAIUnitDef() {}\n"
               "  sRAIUnitDefBL *List[35];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:6:3]: (warning) Member variable 'sRAIUnitDef::List' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -3333,7 +3333,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "private:\n"
               "    char a[2][2];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3344,7 +3344,7 @@ class TestConstructors : public TestFixture {
               "    char a[2][2][2];\n"
               "public:\n"
               "    John() { a[0][0][0] = 0; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3355,7 +3355,7 @@ class TestConstructors : public TestFixture {
               "    Foo()\n"
               "        : bar({\"a\", \"b\"})\n"
               "    {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3371,7 +3371,7 @@ class TestConstructors : public TestFixture {
               "    Fred() : f{0, true} { }\n"
               "    float get() const;\n"
               "};\n"
-              "float Fred::get() const { return g; }");
+              "float Fred::get() const { return g; }\n");
         ASSERT_EQUALS("[test.cpp:9:5]: (warning) Member variable 'Fred::g' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -3387,7 +3387,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A() {\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
@@ -3401,7 +3401,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A() {\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:10:5]: (warning) Member variable 'A::b' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class A\n"
@@ -3416,7 +3416,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A() {\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3433,7 +3433,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred()\n"
               "    { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:11:5]: (warning) Member variable 'Fred::p' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct POINT\n"
@@ -3449,7 +3449,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred()\n"
               "    { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct POINT\n"
@@ -3465,7 +3465,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred()\n"
               "    { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // non static data-member initialization
@@ -3481,7 +3481,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred()\n"
               "    { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3493,13 +3493,13 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred()\n"
               "    { a = 0; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred {\n"
               "private:\n"
               "    union { int a{}; int b; };\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3513,7 +3513,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred() : data_type(0)\n"
               "    { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:8:5]: (warning) Member variable 'Fred::data' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -3526,7 +3526,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    void Init();"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // Unknown non-member function (friend class)
@@ -3537,7 +3537,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    friend ABC;\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // Unknown non-member function (is Init a virtual function?)
@@ -3547,7 +3547,7 @@ class TestConstructors : public TestFixture {
               "    Fred() { Init(); }\n"
               "private:\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // Unknown non-member function
@@ -3557,7 +3557,7 @@ class TestConstructors : public TestFixture {
               "    Fred() { Init(); }\n"
               "private:\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // Unknown non-member function
@@ -3568,7 +3568,7 @@ class TestConstructors : public TestFixture {
               "    Fred() { Init(); }\n"
               "private:\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // Unknown member functions and unknown static functions
@@ -3588,7 +3588,7 @@ class TestConstructors : public TestFixture {
               "    static void static_f();\n"
               "private:\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // Unknown overloaded member functions
@@ -3601,7 +3601,7 @@ class TestConstructors : public TestFixture {
               "    void func();\n"
               "private:\n"
               "    int i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3613,7 +3613,7 @@ class TestConstructors : public TestFixture {
               "    Fred() {}\n"
               "private:\n"
               "    unsigned int i;\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("[test.cpp:5:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
@@ -3624,7 +3624,7 @@ class TestConstructors : public TestFixture {
               "struct Y {\n"
               "    Y() {}\n"
               "    X x;\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3640,7 +3640,7 @@ class TestConstructors : public TestFixture {
               "        if(!(in >> foo))\n"
               "            throw 0;\n"
               "    }\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3652,7 +3652,7 @@ class TestConstructors : public TestFixture {
               "    typedef int * pointer;\n"
               "    Foo() : a(0) {}\n"
               "    pointer a;\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3663,7 +3663,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    int * pointer;\n"
               "    Foo() { memset(this, 0, sizeof(*this)); }\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -3672,7 +3672,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    int * pointer;\n"
               "    Foo() { ::memset(this, 0, sizeof(*this)); }\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -3681,13 +3681,13 @@ class TestConstructors : public TestFixture {
               "    int * p;\n"
               "    char c;\n"
               "    Foo() { memset(p, 0, sizeof(int)); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Foo::c' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
         check("struct Foo {\n"
               "    int i;\n"
               "    char c;\n"
               "    Foo() { memset(&i, 0, sizeof(int)); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Foo::c' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
         check("struct Foo { int f; };\n"
               "struct Bar { int b; };\n"
@@ -3701,7 +3701,7 @@ class TestConstructors : public TestFixture {
               "int main() {\n"
               "  FooBar foobar;\n"
               "  return foobar.foo.f + foobar.bar.b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:3]: (warning) Member variable 'FooBar::bar' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
         check("struct Foo { int f; };\n"
               "struct Bar { int b; };\n"
@@ -3715,7 +3715,7 @@ class TestConstructors : public TestFixture {
               "int main() {\n"
               "  FooBar foobar;\n"
               "  return foobar.foo.f + foobar.bar.b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:3]: (warning) Member variable 'FooBar::bar' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // #7755
@@ -3724,7 +3724,7 @@ class TestConstructors : public TestFixture {
               "    memset(this->data, 0, 42);\n"
               "  }\n"
               "  char data[42];\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3734,7 +3734,7 @@ class TestConstructors : public TestFixture {
             check("class Foo {\n"
                   "    int foo;\n"
                   "    Foo() { }\n"
-                  "};", s);
+                  "};\n", s);
             ASSERT_EQUALS("", errout_str());
         }
 
@@ -3743,7 +3743,7 @@ class TestConstructors : public TestFixture {
             check("class Foo {\n"
                   "    int foo;\n"
                   "    Foo() { }\n"
-                  "};", s);
+                  "};\n", s);
             ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'Foo::foo' is not initialized in the constructor. [uninitMemberVarPrivate]\n", errout_str());
         }
     }
@@ -3756,7 +3756,7 @@ class TestConstructors : public TestFixture {
               "    Foo() { }\n"
               "public:\n"
               "    explicit Foo(int _i) { }\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("[test.cpp:7:14]: (warning) Member variable 'Foo::foo' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
@@ -3777,7 +3777,7 @@ class TestConstructors : public TestFixture {
               "int* A::f(int* p)\n"
               "{\n"
               "    return p;\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3791,7 +3791,7 @@ class TestConstructors : public TestFixture {
               "    int *i;\n"
               "public:\n"
               "    Fred() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3805,7 +3805,7 @@ class TestConstructors : public TestFixture {
               "    Fred() { }\n"
               "private:\n"
               "    int x;\n"
-              "};", s);
+              "};\n", s);
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3815,7 +3815,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred() { }\n"
               "    int *operator [] (int index) { return 0; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3829,7 +3829,7 @@ class TestConstructors : public TestFixture {
               "    { f.d = 0; }\n"
               "\n"
               "    double d;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
@@ -3841,7 +3841,7 @@ class TestConstructors : public TestFixture {
               "    { }\n"
               "\n"
               "    double d;\n"
-              "};");
+              "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::d' is not initialized in the constructor. [uninitMemberVar]\n", "", errout_str());
     }
 
@@ -3855,7 +3855,7 @@ class TestConstructors : public TestFixture {
               "    { f.d = 0; return true; }\n"
               "\n"
               "    double d;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
@@ -3867,7 +3867,7 @@ class TestConstructors : public TestFixture {
               "    { return true; }\n"
               "\n"
               "    double d;\n"
-              "};");
+              "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::d' is not initialized in the constructor. [uninitMemberVar]\n", "",  errout_str());
     }
 
@@ -3881,7 +3881,7 @@ class TestConstructors : public TestFixture {
               "    { d = 0; return true; }\n"
               "\n"
               "    double d;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
@@ -3893,7 +3893,7 @@ class TestConstructors : public TestFixture {
               "    { return true; }\n"
               "\n"
               "    double d;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::d' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -3907,7 +3907,7 @@ class TestConstructors : public TestFixture {
               "    { f.d = 0; }\n"
               "\n"
               "    double d;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
@@ -3919,7 +3919,7 @@ class TestConstructors : public TestFixture {
               "    { }\n"
               "\n"
               "    double d;\n"
-              "};");
+              "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::d' is not initialized in the constructor. [uninitMemberVar]\n", "", errout_str());
     }
 
@@ -3933,7 +3933,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A() { Init( B ); };\n"
               "    void Init( Structure& S ) { S.C = 0; };\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Structure {\n"
@@ -3945,7 +3945,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A() { Init( B ); };\n"
               "    void Init(const Structure& S) { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:8:5]: (warning) Member variable 'A::B' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
@@ -3970,7 +3970,7 @@ class TestConstructors : public TestFixture {
               "A::B::B()\n"
               "{\n"
               "    i = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class B\n"
@@ -3996,7 +3996,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "A::B::B()\n"
               "{\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:18:4]: (warning) Member variable 'B::j' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:22:7]: (warning) Member variable 'B::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
@@ -4017,7 +4017,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Foo() { }\n"
               "};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("namespace n1\n"
@@ -4039,7 +4039,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Foo() { }\n"
               "};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:11:10]: (warning) Member variable 'Foo::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("namespace n1\n"
@@ -4061,7 +4061,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Foo() { }\n"
               "};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4082,7 +4082,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    void init(int value)\n"
               "    { i = value; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
@@ -4100,7 +4100,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    void init(int value)\n"
               "    { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (warning) Member variable 'A::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class bar {\n" // #9887
@@ -4121,7 +4121,7 @@ class TestConstructors : public TestFixture {
               "    int a;\n"
               "    A() { a=0; }\n"
               "    A(A const &a) { operator=(a); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -4132,7 +4132,7 @@ class TestConstructors : public TestFixture {
               "        a = rhs.a;\n"
               "        return *this;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -4142,7 +4142,7 @@ class TestConstructors : public TestFixture {
               "    A & operator = (const A & rhs) {\n"
               "        return *this;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'A::a' is not initialized in the copy constructor. [uninitMemberVar]\n"
                       "[test.cpp:5:9]: (warning) Member variable 'A::a' is not assigned a value in 'A::operator='. [operatorEqVarError]\n", errout_str());
     }
@@ -4154,28 +4154,28 @@ class TestConstructors : public TestFixture {
               "struct B {\n"
               "    A* a;\n"
               "    B() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct A;\n"
               "struct B {\n"
               "    A* a;\n"
               "    B() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct A;\n"
               "struct B {\n"
               "    const A* a;\n"
               "    B() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct A;\n"
               "struct B {\n"
               "    A* const a;\n"
               "    B() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class Test {\n" // #8498
@@ -4226,7 +4226,7 @@ class TestConstructors : public TestFixture {
               "    A* const a;\n"
               "    B() { }\n"
               "    B(B& b) { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:5:5]: (warning) Member variable 'B::a' is not initialized in the copy constructor. [uninitMemberVar]\n", errout_str());
 
@@ -4234,21 +4234,21 @@ class TestConstructors : public TestFixture {
               "struct B {\n"
               "    A* const a;\n"
               "    B& operator=(const B& r) { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str()); // #3804
 
         check("struct B {\n"
               "    const int a;\n"
               "    B() { }\n"
               "    B(B& b) { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n"
                       "[test.cpp:4:5]: (warning) Member variable 'B::a' is not initialized in the copy constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct B {\n"
               "    const int a;\n"
               "    B& operator=(const B& r) { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4258,7 +4258,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "  C() _STLP_NOTHROW {}\n"
               "  C(const C&) _STLP_NOTHROW {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4267,7 +4267,7 @@ class TestConstructors : public TestFixture {
               "  int mValue;\n"
               "public:\n"
               "  operatorX() : mValue(0) {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4277,7 +4277,7 @@ class TestConstructors : public TestFixture {
               "  T* mElements;\n"
               "};\n"
               "template <class T> Container<T>::Container() : mElements(nullptr) {}\n"
-              "Container<int> intContainer;");
+              "Container<int> intContainer;\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4287,7 +4287,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    SelectionPosition() {}\n"
               "    const rvec &x() const;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4302,7 +4302,7 @@ class TestConstructors : public TestFixture {
               "        x = 1;\n"
               "        return true;\n"
               "    }\n"
-              "};", dinit(CheckOptions, $.inconclusive = true));
+              "};\n", dinit(CheckOptions, $.inconclusive = true));
         TODO_ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Member variable 'C::x' is not initialized in the constructor.\n",
                            "[test.cpp:3:5]: (warning) Member variable 'C::x' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
@@ -4316,7 +4316,7 @@ class TestConstructors : public TestFixture {
               "        x = 1;\n"
               "        return true;\n"
               "    }\n"
-              "};", dinit(CheckOptions, $.inconclusive = true));
+              "};\n", dinit(CheckOptions, $.inconclusive = true));
         TODO_ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Member variable 'C::x' is not initialized in the constructor.\n",
                            "[test.cpp:3:5]: (warning) Member variable 'C::x' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
@@ -4330,7 +4330,7 @@ class TestConstructors : public TestFixture {
               "        x = 1;\n"
               "        return true;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4343,7 +4343,7 @@ class TestConstructors : public TestFixture {
               "        x = 1;\n"
               "        return true;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4353,7 +4353,7 @@ class TestConstructors : public TestFixture {
               "        i = i * SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4363,7 +4363,7 @@ class TestConstructors : public TestFixture {
               "        i = i / SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4373,7 +4373,7 @@ class TestConstructors : public TestFixture {
               "        i = i % SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4383,7 +4383,7 @@ class TestConstructors : public TestFixture {
               "        i = i + SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4393,7 +4393,7 @@ class TestConstructors : public TestFixture {
               "        i = i - SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4403,7 +4403,7 @@ class TestConstructors : public TestFixture {
               "        i = i << SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4413,7 +4413,7 @@ class TestConstructors : public TestFixture {
               "        i = i >> SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4423,7 +4423,7 @@ class TestConstructors : public TestFixture {
               "        i = i ^ SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4438,7 +4438,7 @@ class TestConstructors : public TestFixture {
               "        x = 1;\n"
               "        return true;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4451,7 +4451,7 @@ class TestConstructors : public TestFixture {
               "        x = 1;\n"
               "        return true;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4461,7 +4461,7 @@ class TestConstructors : public TestFixture {
               "        i *= SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4471,7 +4471,7 @@ class TestConstructors : public TestFixture {
               "        i /= SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4481,7 +4481,7 @@ class TestConstructors : public TestFixture {
               "        i %= SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4491,7 +4491,7 @@ class TestConstructors : public TestFixture {
               "        i += SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4501,7 +4501,7 @@ class TestConstructors : public TestFixture {
               "        i -= SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4511,7 +4511,7 @@ class TestConstructors : public TestFixture {
               "        i <<= SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4521,7 +4521,7 @@ class TestConstructors : public TestFixture {
               "        i >>= SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4531,7 +4531,7 @@ class TestConstructors : public TestFixture {
               "        i ^= SetValue();\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4546,7 +4546,7 @@ class TestConstructors : public TestFixture {
               "        x = 1;\n"
               "        return true;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4559,7 +4559,7 @@ class TestConstructors : public TestFixture {
               "        x = 1;\n"
               "        return true;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4568,7 +4568,7 @@ class TestConstructors : public TestFixture {
               "        bool b = (0 < SetValue());\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4577,7 +4577,7 @@ class TestConstructors : public TestFixture {
               "        bool b = (0 <= SetValue());\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4586,7 +4586,7 @@ class TestConstructors : public TestFixture {
               "        bool b = (0 > SetValue());\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
@@ -4595,7 +4595,7 @@ class TestConstructors : public TestFixture {
               "        bool b = (0 >= SetValue());\n"
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4613,7 +4613,7 @@ class TestConstructors : public TestFixture {
               "class C {\n"
               "  private:\n"
               "    A* b;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template<class T> class A{};\n"
@@ -4625,7 +4625,7 @@ class TestConstructors : public TestFixture {
               "    bool m_value;\n"
               "};\n"
               "template<class T1, class T2>\n"
-              "A<B<T1, T2>>::A() : m_value(false) {}");
+              "A<B<T1, T2>>::A() : m_value(false) {}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template <typename T> struct S;\n" // #11177
@@ -4644,7 +4644,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    A& operator=() { return *this; }\n"
               "};\n"
-              "A<decltype(SOMETHING)> a;");
+              "A<decltype(SOMETHING)> a;\n");
         ASSERT_EQUALS("", errout_str());
     }
 
diff --git a/test/testcppcheck.cpp b/test/testcppcheck.cpp
index 17c5b8eff3c..ffd4d387cfc 100644
--- a/test/testcppcheck.cpp
+++ b/test/testcppcheck.cpp
@@ -175,7 +175,7 @@ class TestCppcheck : public TestFixture {
                         "void f()\n"
                         "{\n"
                         "  (void)(*((int*)0));\n"
-                        "}");
+                        "}\n");
 
         int called = 0;
         std::unordered_set<std::string> addons;
@@ -259,7 +259,7 @@ class TestCppcheck : public TestFixture {
                         "void f()\n"
                         "{\n"
                         "  (void)(*((int*)0));\n"
-                        "}");
+                        "}\n");
 
         int called = 0;
         std::unordered_set<std::string> addons;
@@ -342,7 +342,7 @@ class TestCppcheck : public TestFixture {
                         "void f()\n"
                         "{\n"
                         "  (void)(*((int*)0));\n"
-                        "}");
+                        "}\n");
 
         const char xmldata[] = R"(<def format="2"><markup ext=".c" reporterrors="false"/></def>)";
         const Settings s = settingsBuilder().libraryxml(xmldata).build();
@@ -364,11 +364,11 @@ class TestCppcheck : public TestFixture {
                         "inline void f()\n"
                         "{\n"
                         "  (void)(*((int*)0));\n"
-                        "}");
+                        "}\n");
         ScopedFile test_file_a("a.c",
-                               "#include \"inc.h\"");
+                               "#include \"inc.h\"\n");
         ScopedFile test_file_b("b.c",
-                               "#include \"inc.h\"");
+                               "#include \"inc.h\"\n");
 
         // this is the "simple" format
         const auto s = dinit(Settings, $.templateFormat = templateFormat); // TODO: remove when we only longer rely on toString() in unique message handling
@@ -400,7 +400,7 @@ class TestCppcheck : public TestFixture {
                              "long a=m[9], b=m[9];\n"
                              "(void)a;\n"
                              "(void)b;\n"
-                             "}");
+                             "}\n");
 
         // this is the "simple" format
         const auto s = dinit(Settings, $.templateFormat = templateFormat); // TODO: remove when we only longer rely on toString() in unique message handling?
@@ -490,7 +490,7 @@ class TestCppcheck : public TestFixture {
                             ";\n";
 
         simplecpp::OutputList outputList;
-        const simplecpp::TokenList tokens2(code, files, "", &outputList);
+        const simplecpp::TokenList tokens2(code, files, "", {}, &outputList);
         const std::string expected2 = "  <rawtokens>\n"
                                       "    <file index=\"0\" name=\"test.c\"/>\n"
                                       "    <file index=\"1\" name=\"\"/>\n"
diff --git a/test/testerrorlogger.cpp b/test/testerrorlogger.cpp
index 014ac3a0a8f..c849d3a0c61 100644
--- a/test/testerrorlogger.cpp
+++ b/test/testerrorlogger.cpp
@@ -140,7 +140,7 @@ class TestErrorLogger : public TestFixture {
             ASSERT_EQUALS("info", loc.getinfo());
         }
         {
-            const SimpleTokenList tokenlist("a", "dir/a.cpp");
+            const SimpleTokenList tokenlist("a\n", "dir/a.cpp");
             {
                 const ErrorMessage::FileLocation loc(tokenlist.front(), &tokenlist.get());
                 ASSERT_EQUALS("dir/a.cpp", loc.getOrigFile(false));
@@ -173,7 +173,7 @@ class TestErrorLogger : public TestFixture {
             }
         }
         {
-            const SimpleTokenList tokenlist("a", "dir\\a.cpp");
+            const SimpleTokenList tokenlist("a\n", "dir\\a.cpp");
             {
                 const ErrorMessage::FileLocation loc(tokenlist.front(), &tokenlist.get());
                 ASSERT_EQUALS("dir\\a.cpp", loc.getOrigFile(false));
@@ -213,12 +213,12 @@ class TestErrorLogger : public TestFixture {
         ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation("dir/a.cpp", "info", 1, 1).getfile(false));
         ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation("dir\\a.cpp", "info", 1, 1).getfile(false));
         {
-            const SimpleTokenList tokenlist("a", "dir/a.cpp");
+            const SimpleTokenList tokenlist("a\n", "dir/a.cpp");
             ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation(tokenlist.front(), &tokenlist.get()).getfile(false));
             ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation(tokenlist.front(), "info", &tokenlist.get()).getfile(false));
         }
         {
-            const SimpleTokenList tokenlist("a", "dir\\a.cpp");
+            const SimpleTokenList tokenlist("a\n", "dir\\a.cpp");
             ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation(tokenlist.front(), &tokenlist.get()).getfile(false));
             ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation(tokenlist.front(), "info", &tokenlist.get()).getfile(false));
         }
diff --git a/test/testexceptionsafety.cpp b/test/testexceptionsafety.cpp
index 1be46fbf282..7e3de4405b0 100644
--- a/test/testexceptionsafety.cpp
+++ b/test/testexceptionsafety.cpp
@@ -84,7 +84,7 @@ class TestExceptionSafety : public TestFixture {
               "    ~x() {\n"
               "        throw e;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (warning) Class x is not safe, destructor throws exception [exceptThrowInDestructor]\n"
                       "[test.cpp:3:9]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
@@ -93,7 +93,7 @@ class TestExceptionSafety : public TestFixture {
               "};\n"
               "x::~x() {\n"
               "    throw e;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (warning) Class x is not safe, destructor throws exception [exceptThrowInDestructor]\n"
                       "[test.cpp:5:5]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
@@ -105,7 +105,7 @@ class TestExceptionSafety : public TestFixture {
               "        } catch (...) {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class x {\n"
@@ -114,7 +114,7 @@ class TestExceptionSafety : public TestFixture {
               "            throw e;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
         // #11031 should not warn when noexcept false
@@ -123,7 +123,7 @@ class TestExceptionSafety : public TestFixture {
               "    ~A() noexcept(false) {\n"
               "        throw 30;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -134,7 +134,7 @@ class TestExceptionSafety : public TestFixture {
               "    if (x)\n"
               "        throw 123;\n"
               "    p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9]: (warning) Exception thrown in invalid state, 'p' points at deallocated memory. [exceptDeallocThrow]\n", errout_str());
 
         check("void f() {\n"
@@ -143,7 +143,7 @@ class TestExceptionSafety : public TestFixture {
               "    if (foo)\n"
               "        throw 1;\n"
               "    p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9]: (warning) Exception thrown in invalid state, 'p' points at deallocated memory. [exceptDeallocThrow]\n", errout_str());
     }
 
@@ -154,7 +154,7 @@ class TestExceptionSafety : public TestFixture {
               "    if (foo)\n"
               "        throw 1;\n"
               "    p = new int;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -162,7 +162,7 @@ class TestExceptionSafety : public TestFixture {
               "    delete p;\n"
               "    reset(p);\n"
               "    throw 1;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -171,14 +171,14 @@ class TestExceptionSafety : public TestFixture {
               "    static int* p = 0;\n"
               "    delete p;\n"
               "    throw 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    static int* p = 0;\n"
               "    delete p;\n"
               "    throw 1;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Exception thrown in invalid state, 'p' points at deallocated memory. [exceptDeallocThrow]\n", errout_str());
     }
 
@@ -192,7 +192,7 @@ class TestExceptionSafety : public TestFixture {
               "    {\n"
               "        throw err;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:9]: (style) Throwing a copy of the caught exception instead of rethrowing the original exception. [exceptRethrowCopy]\n", errout_str());
     }
 
@@ -206,7 +206,7 @@ class TestExceptionSafety : public TestFixture {
               "    {\n"
               "        throw err;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:9]: (style) Throwing a copy of the caught exception instead of rethrowing the original exception. [exceptRethrowCopy]\n", errout_str());
     }
 
@@ -218,7 +218,7 @@ class TestExceptionSafety : public TestFixture {
               "    catch(std::runtime_error& err) {\n"
               "        throw err;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:9]: (style) Throwing a copy of the caught exception instead of rethrowing the original exception. [exceptRethrowCopy]\n", errout_str());
     }
 
@@ -233,7 +233,7 @@ class TestExceptionSafety : public TestFixture {
               "        exception err2;\n"
               "        throw err2;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -250,7 +250,7 @@ class TestExceptionSafety : public TestFixture {
               "            throw inner;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:13]: (style) Throwing a copy of the caught exception instead of rethrowing the original exception. [exceptRethrowCopy]\n", errout_str());
 
         check("void f() {\n"
@@ -265,7 +265,7 @@ class TestExceptionSafety : public TestFixture {
               "            throw outer;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -277,7 +277,7 @@ class TestExceptionSafety : public TestFixture {
               "    catch( ::std::exception err) {\n"
               "        foo(err);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (style) Exception should be caught by reference. [catchExceptionByValue]\n", errout_str());
 
         check("void f() {\n"
@@ -287,7 +287,7 @@ class TestExceptionSafety : public TestFixture {
               "    catch(const exception err) {\n"
               "        foo(err);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (style) Exception should be caught by reference. [catchExceptionByValue]\n", errout_str());
 
         check("void f() {\n"
@@ -297,7 +297,7 @@ class TestExceptionSafety : public TestFixture {
               "    catch( ::std::exception& err) {\n"
               "        foo(err);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -307,7 +307,7 @@ class TestExceptionSafety : public TestFixture {
               "    catch(exception* err) {\n"
               "        foo(err);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -317,7 +317,7 @@ class TestExceptionSafety : public TestFixture {
               "    catch(const exception& err) {\n"
               "        foo(err);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -327,7 +327,7 @@ class TestExceptionSafety : public TestFixture {
               "    catch(int err) {\n"
               "        foo(err);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -337,7 +337,7 @@ class TestExceptionSafety : public TestFixture {
               "    catch(exception* const err) {\n"
               "        foo(err);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -347,14 +347,14 @@ class TestExceptionSafety : public TestFixture {
               "void func3() noexcept(true) { throw 1; }\n"
               "void func4() noexcept(false) { throw 1; }\n"
               "void func5() noexcept(true) { func1(); }\n"
-              "void func6() noexcept(false) { func1(); }");
+              "void func6() noexcept(false) { func1(); }\n");
         ASSERT_EQUALS("[test.cpp:2:25]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n"
                       "[test.cpp:3:31]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n"
                       "[test.cpp:5:31]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
         // avoid false positives
         check("const char *func() noexcept { return 0; }\n"
-              "const char *func1() noexcept { try { throw 1; } catch(...) {} return 0; }");
+              "const char *func1() noexcept { try { throw 1; } catch(...) {} return 0; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n" // #14526
@@ -378,12 +378,12 @@ class TestExceptionSafety : public TestFixture {
               "void func2() throw() { throw 1; }\n"
               "void func3() throw(int) { throw 1; }\n"
               "void func4() throw() { func1(); }\n"
-              "void func5() throw(int) { func1(); }");
+              "void func5() throw(int) { func1(); }\n");
         ASSERT_EQUALS("[test.cpp:2:24]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n"
                       "[test.cpp:4:24]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
         // avoid false positives
-        check("const char *func() throw() { return 0; }");
+        check("const char *func() throw() { return 0; }\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -451,12 +451,12 @@ class TestExceptionSafety : public TestFixture {
     void nothrowAttributeThrow() {
         check("void func1() throw(int) { throw 1; }\n"
               "void func2() __attribute((nothrow)); void func2() { throw 1; }\n"
-              "void func3() __attribute((nothrow)); void func3() { func1(); }");
+              "void func3() __attribute((nothrow)); void func3() { func1(); }\n");
         ASSERT_EQUALS("[test.cpp:2:53]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n"
                       "[test.cpp:3:53]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
         // avoid false positives
-        check("const char *func() __attribute((nothrow)); void func1() { return 0; }");
+        check("const char *func() __attribute((nothrow)); void func1() { return 0; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -465,30 +465,30 @@ class TestExceptionSafety : public TestFixture {
               "  void copyMemberValues() throw () {\n"
               "      copyMemberValues();\n"
               "   }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void nothrowDeclspecThrow() {
         check("void func1() throw(int) { throw 1; }\n"
               "void __declspec(nothrow) func2() { throw 1; }\n"
-              "void __declspec(nothrow) func3() { func1(); }");
+              "void __declspec(nothrow) func3() { func1(); }\n");
         ASSERT_EQUALS("[test.cpp:2:36]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n"
                       "[test.cpp:3:36]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
         // avoid false positives
-        check("const char *func() __attribute((nothrow)); void func1() { return 0; }");
+        check("const char *func() __attribute((nothrow)); void func1() { return 0; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void rethrowNoCurrentException1() {
-        check("void func1(const bool flag) { try{ if(!flag) throw; } catch (int&) { ; } }");
+        check("void func1(const bool flag) { try{ if(!flag) throw; } catch (int&) { ; } }\n");
         ASSERT_EQUALS("[test.cpp:1:46]: (error) Rethrowing current exception with 'throw;', it seems there is no current exception to rethrow."
                       " If there is no current exception this calls std::terminate(). More: https://isocpp.org/wiki/faq/exceptions#throw-without-an-object [rethrowNoCurrentException]\n", errout_str());
     }
 
     void rethrowNoCurrentException2() {
-        check("void func1() { try{ ; } catch (...) { ; } throw; }");
+        check("void func1() { try{ ; } catch (...) { ; } throw; }\n");
         ASSERT_EQUALS("[test.cpp:1:43]: (error) Rethrowing current exception with 'throw;', it seems there is no current exception to rethrow."
                       " If there is no current exception this calls std::terminate(). More: https://isocpp.org/wiki/faq/exceptions#throw-without-an-object [rethrowNoCurrentException]\n", errout_str());
     }
@@ -496,7 +496,7 @@ class TestExceptionSafety : public TestFixture {
     void rethrowNoCurrentException3() {
         check("void on_error() { try { throw; } catch (const int &) { ; } catch (...) { ; } }\n"      // exception dispatcher idiom
               "void func2() { try{ ; } catch (const int&) { throw; } ; }\n"
-              "void func3() { throw 0; }");
+              "void func3() { throw 0; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
diff --git a/test/testfunctions.cpp b/test/testfunctions.cpp
index d5a18f7d916..4ebe3360aba 100644
--- a/test/testfunctions.cpp
+++ b/test/testfunctions.cpp
@@ -142,14 +142,14 @@ class TestFunctions : public TestFixture {
         check("void f()\n"
               "{\n"
               "    bsd_signal(SIGABRT, SIG_IGN);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Obsolescent function 'bsd_signal' called. It is recommended to use 'sigaction' instead. [bsd_signalCalled]\n", errout_str());
 
         check("int f()\n"
               "{\n"
               "    int bsd_signal(0);\n"
               "    return bsd_signal;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -158,7 +158,7 @@ class TestFunctions : public TestFixture {
               "    if(!hp = gethostbyname(\"127.0.0.1\")) {\n"
               "        exit(1);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:14]: (style) Obsolescent function 'gethostbyname' called. It is recommended to use 'getaddrinfo' instead. [gethostbynameCalled]\n", errout_str());
 
         check("void f()\n"
@@ -168,13 +168,13 @@ class TestFunctions : public TestFixture {
               "    if(!hp = gethostbyaddr((char *) &addr, sizeof(addr), AF_INET)) {\n"
               "        exit(1);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:14]: (style) Obsolescent function 'gethostbyaddr' called. It is recommended to use 'getnameinfo' instead. [gethostbyaddrCalled]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    usleep( 1000 );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Obsolescent function 'usleep' called. It is recommended to use 'nanosleep' or 'setitimer' instead. [usleepCalled]\n", errout_str());
     }
 
@@ -186,7 +186,7 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    n1::index();\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::size_t f()\n"
@@ -194,19 +194,19 @@ class TestFunctions : public TestFixture {
               "    std::size_t index(0);\n"
               "    index++;\n"
               "    return index;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f()\n"
               "{\n"
               "    return this->index();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "    int index( 0 );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("const char f()\n"
@@ -214,7 +214,7 @@ class TestFunctions : public TestFixture {
               "    const char var[6] = \"index\";\n"
               "    const char i = index(var, 0);\n"
               "    return i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:20]: (style) Obsolescent function 'index' called. It is recommended to use 'strchr' instead. [indexCalled]\n",
                       errout_str());
     }
@@ -222,7 +222,7 @@ class TestFunctions : public TestFixture {
     void prohibitedFunctions_qt_index() {
         check("void TDataModel::forceRowRefresh(int row) {\n"
               "    emit dataChanged(index(row, 0), index(row, columnCount() - 1));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:22]: (style) Obsolescent function 'index' called. It is recommended to use 'strchr' instead. [indexCalled]\n"
             "[test.cpp:2:37]: (style) Obsolescent function 'index' called. It is recommended to use 'strchr' instead. [indexCalled]\n",
@@ -233,14 +233,14 @@ class TestFunctions : public TestFixture {
         check("void f()\n"
               "{\n"
               "    int rindex( 0 );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "    const char var[7] = \"rindex\";\n"
               "    print(rindex(var, 0));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Obsolescent function 'rindex' called. It is recommended to use 'strrchr' instead. [rindexCalled]\n", errout_str());
     }
 
@@ -250,7 +250,7 @@ class TestFunctions : public TestFixture {
               "public:\n"
               "    Fred() : index(0) { }\n"
               "    int index;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -258,13 +258,13 @@ class TestFunctions : public TestFixture {
         check("void f()\n"
               "{\n"
               "    char *x = gets(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead. [getsCalled]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    foo(x, gets(a));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead. [getsCalled]\n", errout_str());
     }
 
@@ -272,32 +272,32 @@ class TestFunctions : public TestFixture {
         check("void f()\n"
               "{\n"
               "    char *x = alloca(10);\n"
-              "}");  // #4382 - there are no VLAs in C++
+              "}\n");  // #4382 - there are no VLAs in C++
         ASSERT_EQUALS("[test.cpp:3:15]: (warning) Obsolete function 'alloca' called. [allocaCalled]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    char *x = alloca(10);\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:3:15]: (warning) Obsolete function 'alloca' called. In C99 and later it is recommended to use a variable length array instead. [allocaCalled]\n", errout_str());
 
         const Settings s = settingsBuilder(settings).c(Standards::C89).cpp(Standards::CPP03).build();
         check("void f()\n"
               "{\n"
               "    char *x = alloca(10);\n"
-              "}", s);  // #4382 - there are no VLAs in C++
+              "}\n", s);  // #4382 - there are no VLAs in C++
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "    char *x = alloca(10);\n"
-              "}", s, false); // #7558 - no alternative to alloca in C89
+              "}\n", s, false); // #7558 - no alternative to alloca in C89
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "    char *x = alloca(10);\n"
-              "}", s, false);
+              "}\n", s, false);
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -311,7 +311,7 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    int b ; b = ftime ( 1 ) ;\n"
               "    return 0 ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -321,7 +321,7 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    char *x = std::gets(str);\n"
               "    char *y = gets(str);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:20]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead. [getsCalled]\n"
                       "[test.cpp:4:15]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead. [getsCalled]\n", errout_str());
     }
@@ -332,7 +332,7 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    char *x = std::gets(str);\n"
               "    usleep( 1000 );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:20]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead. [getsCalled]\n"
                       "[test.cpp:4:5]: (style) Obsolescent function 'usleep' called. It is recommended to use 'nanosleep' or 'setitimer' instead. [usleepCalled]\n", errout_str());
     }
@@ -344,14 +344,14 @@ class TestFunctions : public TestFixture {
               "    char s [ 10 ] ;\n"
               "    gets ( s ) ;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead. [getsCalled]\n", errout_str());
 
         check("int getcontext(ucontext_t *ucp);\n"
               "void f (ucontext_t *ucp)\n"
               "{\n"
               "    getcontext ( ucp ) ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (portability) Obsolescent function 'getcontext' called. Applications are recommended to be rewritten to use POSIX threads. [getcontextCalled]\n", errout_str());
     }
 
@@ -362,7 +362,7 @@ class TestFunctions : public TestFixture {
               "    char s [ 10 ] ;\n"
               "    gets ( s ) ;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -371,7 +371,7 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    char *cpwd;"
               "    crypt(pwd, cpwd);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:20]: (warning) Return value of function crypt() is not used. [ignoredReturnValue]\n"
                       "[test.cpp:3:20]: (portability) Non reentrant function 'crypt' called. For threadsafe applications it is recommended to use the reentrant replacement function 'crypt_r'. [cryptCalled]\n", errout_str());
 
@@ -380,7 +380,7 @@ class TestFunctions : public TestFixture {
               "    char *pwd = getpass(\"Password:\");"
               "    char *cpwd;"
               "    crypt(pwd, cpwd);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:57]: (warning) Return value of function crypt() is not used. [ignoredReturnValue]\n"
                       "[test.cpp:3:57]: (portability) Non reentrant function 'crypt' called. For threadsafe applications it is recommended to use the reentrant replacement function 'crypt_r'. [cryptCalled]\n", errout_str());
 
@@ -388,7 +388,7 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    int crypt = 0;"
               "    return crypt;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -397,14 +397,14 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    time_t t = 0;"
               "    auto lt = std::localtime(&t);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:37]: (portability) Non reentrant function 'localtime' called. For threadsafe applications it is recommended to use the reentrant replacement function 'localtime_r'. [localtimeCalled]\n", errout_str());
 
         // Passed as function argument
         check("void f()\n"
               "{\n"
               "    printf(\"Magic guess: %d\", getpwent());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:31]: (portability) Non reentrant function 'getpwent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwent_r'. [getpwentCalled]\n", errout_str());
 
         // Pass return value
@@ -412,14 +412,14 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    time_t t = 0;"
               "    struct tm *foo = localtime(&t);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:39]: (portability) Non reentrant function 'localtime' called. For threadsafe applications it is recommended to use the reentrant replacement function 'localtime_r'. [localtimeCalled]\n", errout_str());
 
         // Access via global namespace
         check("void f()\n"
               "{\n"
               "    ::getpwent();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (warning) Return value of function ::getpwent() is not used. [ignoredReturnValue]\n"
                       "[test.cpp:3:7]: (portability) Non reentrant function 'getpwent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwent_r'. [getpwentCalled]\n", errout_str());
 
@@ -427,68 +427,68 @@ class TestFunctions : public TestFixture {
         check("int getpwent()\n"
               "{\n"
               "    return 123;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Be quiet on other namespaces
         check("void f()\n"
               "{\n"
               "    foobar::getpwent();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Be quiet on class member functions
         check("void f()\n"
               "{\n"
               "    foobar.getpwent();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void invalidFunctionUsage1() {
-        check("void f() { memset(a,b,sizeof(a)!=12); }");
+        check("void f() { memset(a,b,sizeof(a)!=12); }\n");
         ASSERT_EQUALS("[test.cpp:1:32]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
 
-        check("void f() { memset(a,b,sizeof(a)!=0); }");
+        check("void f() { memset(a,b,sizeof(a)!=0); }\n");
         ASSERT_EQUALS("[test.cpp:1:32]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
 
-        check("void f() { memset(a,b,!c); }");
+        check("void f() { memset(a,b,!c); }\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
 
         // Ticket #6990
-        check("void f(bool c) { memset(a,b,c); }");
+        check("void f(bool c) { memset(a,b,c); }\n");
         ASSERT_EQUALS("[test.cpp:1:29]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
-        check("void f() { memset(a,b,true); }");
+        check("void f() { memset(a,b,true); }\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
 
         // Ticket #6588 (c mode)
         check("void record(char* buf, int n) {\n"
               "  memset(buf, 0, n < 255);\n"           /* KO */
               "  memset(buf, 0, n < 255 ? n : 255);\n" /* OK */
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:2:20]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
 
         // Ticket #6588 (c++ mode)
         check("void record(char* buf, int n) {\n"
               "  memset(buf, 0, n < 255);\n"           /* KO */
               "  memset(buf, 0, n < 255 ? n : 255);\n" /* OK */
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
 
         check("int boolArgZeroIsInvalidButOneIsValid(int a, int param) {\n"
               "  return div(a, param > 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:23]: (error) Invalid div() argument nr 2. The value is 0 or 1 (boolean) but the valid values are ':-1,1:'. [invalidFunctionArg]\n", errout_str());
 
         check("void boolArgZeroIsValidButOneIsInvalid(int param) {\n"
               "  strtol(a, b, param > 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (error) Invalid strtol() argument nr 3. The value is 0 or 1 (boolean) but the valid values are '0,2:36'. [invalidFunctionArg]\n", errout_str());
 
-        check("void f() { strtol(a,b,1); }");
+        check("void f() { strtol(a,b,1); }\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (error) Invalid strtol() argument nr 3. The value is 1 but the valid values are '0,2:36'. [invalidFunctionArg]\n", errout_str());
 
-        check("void f() { strtol(a,b,10); }");
+        check("void f() { strtol(a,b,10); }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::vector<int>& v) {\n" //  #10754
@@ -531,16 +531,16 @@ class TestFunctions : public TestFixture {
     }
 
     void invalidFunctionUsageStrings() {
-        check("size_t f() { char x = 'x'; return strlen(&x); }");
+        check("size_t f() { char x = 'x'; return strlen(&x); }\n");
         ASSERT_EQUALS("[test.cpp:1:42]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
-        check("size_t f() { return strlen(&x); }");
+        check("size_t f() { return strlen(&x); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("size_t f(char x) { return strlen(&x); }");
+        check("size_t f(char x) { return strlen(&x); }\n");
         ASSERT_EQUALS("[test.cpp:1:34]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
-        check("size_t f() { char x = '\\0'; return strlen(&x); }");
+        check("size_t f() { char x = '\\0'; return strlen(&x); }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("size_t f() {\n"
@@ -550,41 +550,41 @@ class TestFunctions : public TestFixture {
               "  else\n"
               "    x = 'a';\n"
               "  return strlen(&x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:17]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
-        check("int f() { char x = '\\0'; return strcmp(\"Hello world\", &x); }");
+        check("int f() { char x = '\\0'; return strcmp(\"Hello world\", &x); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int f() { char x = 'x'; return strcmp(\"Hello world\", &x); }");
+        check("int f() { char x = 'x'; return strcmp(\"Hello world\", &x); }\n");
         ASSERT_EQUALS("[test.cpp:1:54]: (error) Invalid strcmp() argument nr 2. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
-        check("size_t f(char x) { char * y = &x; return strlen(y); }");
+        check("size_t f(char x) { char * y = &x; return strlen(y); }\n");
         TODO_ASSERT_EQUALS("[test.cpp:1:42]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", "", errout_str());
 
-        check("size_t f(char x) { char * y = &x; char *z = y; return strlen(z); }");
+        check("size_t f(char x) { char * y = &x; char *z = y; return strlen(z); }\n");
         TODO_ASSERT_EQUALS("[test.cpp:1:42]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", "", errout_str());
 
-        check("size_t f() { char x = 'x'; char * y = &x; char *z = y; return strlen(z); }");
+        check("size_t f() { char x = 'x'; char * y = &x; char *z = y; return strlen(z); }\n");
         TODO_ASSERT_EQUALS("[test.cpp:1:42]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", "", errout_str());
 
-        check("size_t f() { char x = '\\0'; char * y = &x; char *z = y; return strlen(z); }");
+        check("size_t f() { char x = '\\0'; char * y = &x; char *z = y; return strlen(z); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("size_t f() { char x[] = \"Hello world\"; return strlen(x); }");
+        check("size_t f() { char x[] = \"Hello world\"; return strlen(x); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("size_t f(char x[]) { return strlen(x); }");
+        check("size_t f(char x[]) { return strlen(x); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int f(char x, char y) { return strcmp(&x, &y); }");
+        check("int f(char x, char y) { return strcmp(&x, &y); }\n");
         ASSERT_EQUALS("[test.cpp:1:39]: (error) Invalid strcmp() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n"
                       "[test.cpp:1:43]: (error) Invalid strcmp() argument nr 2. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
-        check("size_t f() { char x[] = \"Hello world\"; return strlen(&x[0]); }");
+        check("size_t f() { char x[] = \"Hello world\"; return strlen(&x[0]); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("size_t f() { char* x = \"Hello world\"; return strlen(&x[0]); }");
+        check("size_t f() { char* x = \"Hello world\"; return strlen(&x[0]); }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -597,11 +597,11 @@ class TestFunctions : public TestFixture {
               "  size_t l1 = strlen(&s1.x);\n"
               "  size_t l2 = strlen(&s2.x);\n"
               "  return l1 + l2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:22]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n"
                       "[test.cpp:9:22]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
-        check("const char x = 'x'; size_t f() { return strlen(&x); }");
+        check("const char x = 'x'; size_t f() { return strlen(&x); }\n");
         ASSERT_EQUALS("[test.cpp:1:48]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
         check("struct someStruct {\n"
@@ -616,7 +616,7 @@ class TestFunctions : public TestFixture {
               "int f(struct someStruct * const tp, const int k)\n"
               "{\n"
               "    return strcmp(&tp->x.buf[k], \"needle\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct someStruct {\n"
@@ -625,29 +625,29 @@ class TestFunctions : public TestFixture {
               "int f(struct someStruct * const tp, const int k)\n"
               "{\n"
               "    return strcmp(&tp->buf[k], \"needle\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("const char x = 'x'; size_t f() { char y = x; return strlen(&y); }");
+        check("const char x = 'x'; size_t f() { char y = x; return strlen(&y); }\n");
         ASSERT_EQUALS("[test.cpp:1:60]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
-        check("const char x = '\\0'; size_t f() { return strlen(&x); }");
+        check("const char x = '\\0'; size_t f() { return strlen(&x); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("const char x = '\\0'; size_t f() { char y = x; return strlen(&y); }");
+        check("const char x = '\\0'; size_t f() { char y = x; return strlen(&y); }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("size_t f() {\n"
               "  char * a = \"Hello world\";\n"
               "  char ** b = &a;\n"
               "  return strlen(&b[0][0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("size_t f() {\n"
               "  char ca[] = \"asdf\";\n"
               "  return strlen((char*) &ca);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5225
@@ -658,67 +658,67 @@ class TestFunctions : public TestFixture {
               "  strcat(str, &d);\n"
               "  puts(str);\n"
               "  return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:15]: (error) Invalid strcat() argument nr 2. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
         check("FILE* f(void) {\n"
               "  const char fileName[1] = { \'x\' };\n"
               "  return fopen(fileName, \"r\"); \n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Invalid fopen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
         check("FILE* f(void) {\n"
               "  const char fileName[2] = { \'x\', \'y\' };\n"
               "  return fopen(fileName, \"r\"); \n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Invalid fopen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
         check("FILE* f(void) {\n"
               "  const char fileName[3] = { \'x\', \'y\' ,\'\\0\' };\n"
               "  return fopen(fileName, \"r\"); \n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("FILE* f(void) {\n"
               "  const char fileName[3] = { \'x\', \'\\0\' ,\'y\' };\n"
               "  return fopen(fileName, \"r\"); \n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("FILE* f(void) {\n"
               "  const char fileName[3] = { \'x\', \'y\' };\n" // implicit '\0' added at the end
               "  return fopen(fileName, \"r\"); \n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("FILE* f(void) {\n"
               "  const char fileName[] = { \'\\0\' };\n"
               "  return fopen(fileName, \"r\"); \n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("FILE* f(void) {\n"
               "  const char fileName[] = { \'0\' + 42 };\n" // no size is explicitly defined, no implicit '\0' is added
               "  return fopen(fileName, \"r\"); \n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Invalid fopen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
         check("FILE* f(void) {\n"
               "  const char fileName[] = { \'0\' + 42, \'x\' };\n" // no size is explicitly defined, no implicit '\0' is added
               "  return fopen(fileName, \"r\"); \n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Invalid fopen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
         check("FILE* f(void) {\n"
               "  const char fileName[2] = { \'0\' + 42 };\n" // implicitly '\0' added at the end because size is set to 2
               "  return fopen(fileName, \"r\"); \n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("FILE* f(void) {\n"
               "  const char fileName[] = { };\n"
               "  return fopen(fileName, \"r\"); \n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void scanMetaTypes()\n" // don't crash
@@ -729,7 +729,7 @@ class TestFunctions : public TestFixture {
               "        if (strstr(name, \"GammaRay::\") != name)\n"
               "            metaTypes.push_back(mtId);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
@@ -771,10 +771,10 @@ class TestFunctions : public TestFixture {
               "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("size_t f() { wchar_t x = L'x'; return wcslen(&x); }");
+        check("size_t f() { wchar_t x = L'x'; return wcslen(&x); }\n");
         ASSERT_EQUALS("[test.cpp:1:46]: (error) Invalid wcslen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
-        check("void f() { char a[10] = \"1234567890\"; puts(a); }", dinit(CheckOptions, $.cpp = false)); // #1770
+        check("void f() { char a[10] = \"1234567890\"; puts(a); }\n", dinit(CheckOptions, $.cpp = false)); // #1770
         ASSERT_EQUALS("[test.c:1:44]: (error) Invalid puts() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
     }
 
@@ -800,7 +800,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  sqrt(-1) << std::endl;\n"
               "    std::cout <<  sqrtf(-1) << std::endl;\n"
               "    std::cout <<  sqrtl(-1) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:25]: (error) Invalid sqrt() argument nr 1. The value is -1 but the valid values are '0.0:'. [invalidFunctionArg]\n"
                       "[test.cpp:4:26]: (error) Invalid sqrtf() argument nr 1. The value is -1 but the valid values are '0.0:'. [invalidFunctionArg]\n"
                       "[test.cpp:5:26]: (error) Invalid sqrtl() argument nr 1. The value is -1 but the valid values are '0.0:'. [invalidFunctionArg]\n", errout_str());
@@ -811,7 +811,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  sqrt(-0.) << std::endl;\n"
               "    std::cout <<  sqrtf(-0.) << std::endl;\n"
               "    std::cout <<  sqrtl(-0.) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -819,7 +819,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  sqrt(1) << std::endl;\n"
               "    std::cout <<  sqrtf(1) << std::endl;\n"
               "    std::cout <<  sqrtl(1) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -839,7 +839,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  log1p(-3) << std::endl;\n"
               "    std::cout <<  log1pf(-3) << std::endl;\n"
               "    std::cout <<  log1pl(-3) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:24]: (error) Invalid log() argument nr 1. The value is -2 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
                       "[test.cpp:4:25]: (error) Invalid logf() argument nr 1. The value is -2 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
                       "[test.cpp:5:25]: (error) Invalid logl() argument nr 1. The value is -2 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
@@ -876,7 +876,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  log1p(-2) << std::endl;\n"
               "    std::cout <<  log1pf(-2) << std::endl;\n"
               "    std::cout <<  log1pl(-2) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:24]: (error) Invalid log() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
                       "[test.cpp:4:25]: (error) Invalid logf() argument nr 1. The value is -1 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
                       "[test.cpp:5:25]: (error) Invalid logl() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
@@ -913,7 +913,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  log1p(-2.0) << std::endl;\n"
               "    std::cout <<  log1pf(-2.0) << std::endl;\n"
               "    std::cout <<  log1pl(-2.0) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:25]: (error) Invalid log() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
                       "[test.cpp:4:26]: (error) Invalid logf() argument nr 1. The value is -1 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
                       "[test.cpp:5:26]: (error) Invalid logl() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
@@ -950,7 +950,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  log1p(-1.1) << std::endl;\n"
               "    std::cout <<  log1pf(-1.1) << std::endl;\n"
               "    std::cout <<  log1pl(-1.1) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:25]: (error) Invalid log() argument nr 1. The value is -0.1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
                       "[test.cpp:4:26]: (error) Invalid logf() argument nr 1. The value is -0.1 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
                       "[test.cpp:5:26]: (error) Invalid logl() argument nr 1. The value is -0.1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
@@ -987,7 +987,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  log1p(-1.) << std::endl;\n"
               "    std::cout <<  log1pf(-1.0) << std::endl;\n"
               "    std::cout <<  log1pl(-1) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:23]: (error) Invalid log() argument nr 1. The value is 0 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
                       "[test.cpp:4:25]: (error) Invalid logf() argument nr 1. The value is 0 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
                       "[test.cpp:5:25]: (error) Invalid logl() argument nr 1. The value is 0 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
@@ -1060,21 +1060,21 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  log1p(2.0)        << std::endl;\n"
               "    std::cout <<  log1pf(2.0)       << std::endl;\n"
               "    std::cout <<  log1pf(2.0f)      << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    std::string *log(0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3473 - no warning if "log" is a variable
-        check("Fred::Fred() : log(0) { }");
+        check("Fred::Fred() : log(0) { }\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5748
-        check("void f() { foo.log(0); }");
+        check("void f() { foo.log(0); }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1112,7 +1112,7 @@ class TestFunctions : public TestFixture {
               "    + acosl(0.1E-1)  \n"
               "    + acosl(+0.1E-1) \n"
               "    + acosl(-0.1E-1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -1120,7 +1120,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  acos(1.1) << std::endl;\n"
               "    std::cout <<  acosf(1.1) << std::endl;\n"
               "    std::cout <<  acosl(1.1) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:25]: (error) Invalid acos() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
                       "[test.cpp:4:26]: (error) Invalid acosf() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
                       "[test.cpp:5:26]: (error) Invalid acosl() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n", errout_str());
@@ -1130,7 +1130,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  acos(-1.1) << std::endl;\n"
               "    std::cout <<  acosf(-1.1) << std::endl;\n"
               "    std::cout <<  acosl(-1.1) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:26]: (error) Invalid acos() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
                       "[test.cpp:4:27]: (error) Invalid acosf() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
                       "[test.cpp:5:27]: (error) Invalid acosl() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n", errout_str());
@@ -1173,7 +1173,7 @@ class TestFunctions : public TestFixture {
               "    + asinl(0.1E-1)  \n"
               "    + asinl(+0.1E-1) \n"
               "    + asinl(-0.1E-1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -1181,7 +1181,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  asin(1.1) << std::endl;\n"
               "    std::cout <<  asinf(1.1) << std::endl;\n"
               "    std::cout <<  asinl(1.1) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:25]: (error) Invalid asin() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
                       "[test.cpp:4:26]: (error) Invalid asinf() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
                       "[test.cpp:5:26]: (error) Invalid asinl() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n", errout_str());
@@ -1191,7 +1191,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  asin(-1.1) << std::endl;\n"
               "    std::cout <<  asinf(-1.1) << std::endl;\n"
               "    std::cout <<  asinl(-1.1) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:26]: (error) Invalid asin() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
                       "[test.cpp:4:27]: (error) Invalid asinf() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
                       "[test.cpp:5:27]: (error) Invalid asinl() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n", errout_str());
@@ -1204,7 +1204,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  pow(0,-10) << std::endl;\n"
               "    std::cout <<  powf(0,-10) << std::endl;\n"
               "    std::cout <<  powl(0,-10) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (warning) Passing values 0 and -10 to pow() leads to implementation-defined result. [wrongmathcall]\n"
                       "[test.cpp:4:19]: (warning) Passing values 0 and -10 to powf() leads to implementation-defined result. [wrongmathcall]\n"
                       "[test.cpp:5:19]: (warning) Passing values 0 and -10 to powl() leads to implementation-defined result. [wrongmathcall]\n", errout_str());
@@ -1214,7 +1214,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  pow(0,10) << std::endl;\n"
               "    std::cout <<  powf(0,10) << std::endl;\n"
               "    std::cout <<  powl(0,10) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1255,7 +1255,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  atan2l(0.1E-1,3)   ;\n"
               "    std::cout <<  atan2l(+0.1E-1,1)  ;\n"
               "    std::cout <<  atan2l(-0.1E-1,8)  ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -1263,7 +1263,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  atan2(0,0) << std::endl;\n"
               "    std::cout <<  atan2f(0,0) << std::endl;\n"
               "    std::cout <<  atan2l(0,0) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (warning) Passing values 0 and 0 to atan2() leads to implementation-defined result. [wrongmathcall]\n"
                       "[test.cpp:4:19]: (warning) Passing values 0 and 0 to atan2f() leads to implementation-defined result. [wrongmathcall]\n"
                       "[test.cpp:5:19]: (warning) Passing values 0 and 0 to atan2l() leads to implementation-defined result. [wrongmathcall]\n", errout_str());
@@ -1276,7 +1276,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  fmod(1.0,0) << std::endl;\n"
               "    std::cout <<  fmodf(1.0,0) << std::endl;\n"
               "    std::cout <<  fmodl(1.0,0) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:28]: (error) Invalid fmod() argument nr 2. The value is 0 but the valid values are '!0.0'. [invalidFunctionArg]\n"
                       "[test.cpp:4:29]: (error) Invalid fmodf() argument nr 2. The value is 0 but the valid values are '!0.0'. [invalidFunctionArg]\n"
                       "[test.cpp:5:29]: (error) Invalid fmodl() argument nr 2. The value is 0 but the valid values are '!0.0'. [invalidFunctionArg]\n"
@@ -1289,7 +1289,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  fmod(1.0,1) << std::endl;\n"
               "    std::cout <<  fmodf(1.0,1) << std::endl;\n"
               "    std::cout <<  fmodl(1.0,1) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1298,7 +1298,7 @@ class TestFunctions : public TestFixture {
               "    print(exp(x) - 1);\n"
               "    print(log(1 + x));\n"
               "    print(1 - erf(x));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Expression 'exp(x) - 1' can be replaced by 'expm1(x)' to avoid loss of precision. [unpreciseMathCall]\n"
                       "[test.cpp:3:11]: (style) Expression 'log(1 + x)' can be replaced by 'log1p(x)' to avoid loss of precision. [unpreciseMathCall]\n"
                       "[test.cpp:4:11]: (style) Expression '1 - erf(x)' can be replaced by 'erfc(x)' to avoid loss of precision. [unpreciseMathCall]\n", errout_str());
@@ -1307,7 +1307,7 @@ class TestFunctions : public TestFixture {
               "    print(exp(x) - 1.0);\n"
               "    print(log(1.0 + x));\n"
               "    print(1.0 - erf(x));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Expression 'exp(x) - 1' can be replaced by 'expm1(x)' to avoid loss of precision. [unpreciseMathCall]\n"
                       "[test.cpp:3:11]: (style) Expression 'log(1 + x)' can be replaced by 'log1p(x)' to avoid loss of precision. [unpreciseMathCall]\n"
                       "[test.cpp:4:12]: (style) Expression '1 - erf(x)' can be replaced by 'erfc(x)' to avoid loss of precision. [unpreciseMathCall]\n", errout_str());
@@ -1316,7 +1316,7 @@ class TestFunctions : public TestFixture {
               "    print(exp(3 + x*f(a)) - 1);\n"
               "    print(log(x*4 + 1));\n"
               "    print(1 - erf(34*x + f(x) - c));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Expression 'exp(x) - 1' can be replaced by 'expm1(x)' to avoid loss of precision. [unpreciseMathCall]\n"
                       "[test.cpp:3:11]: (style) Expression 'log(1 + x)' can be replaced by 'log1p(x)' to avoid loss of precision. [unpreciseMathCall]\n"
                       "[test.cpp:4:11]: (style) Expression '1 - erf(x)' can be replaced by 'erfc(x)' to avoid loss of precision. [unpreciseMathCall]\n", errout_str());
@@ -1324,7 +1324,7 @@ class TestFunctions : public TestFixture {
         check("void foo() {\n"
               "    print(2*exp(x) - 1);\n"
               "    print(1 - erf(x)/2.0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1341,67 +1341,67 @@ class TestFunctions : public TestFixture {
 
         check("void foo() {\n"
               "  mystrcmp(a, b);\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("[test.cpp:2:3]: (warning) Return value of function mystrcmp() is not used. [ignoredReturnValue]\n", errout_str());
 
         check("void foo() {\n"
               "  foo::mystrcmp(a, b);\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("[test.cpp:2:8]: (warning) Return value of function foo::mystrcmp() is not used. [ignoredReturnValue]\n", errout_str());
 
         check("void f() {\n"
               "  foo x;\n"
               "  x.mystrcmp(a, b);\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Return value of function x.mystrcmp() is not used. [ignoredReturnValue]\n", errout_str());
 
         check("bool mystrcmp(char* a, char* b);\n" // cppcheck sees a custom strcmp definition, but it returns a value. Assume it is the one specified in the library.
               "void foo() {\n"
               "    mystrcmp(a, b);\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Return value of function mystrcmp() is not used. [ignoredReturnValue]\n", errout_str());
 
         check("void mystrcmp(char* a, char* b);\n" // cppcheck sees a custom strcmp definition which returns void!
               "void foo() {\n"
               "    mystrcmp(a, b);\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    class mystrcmp { mystrcmp() {} };\n" // strcmp is a constructor definition here
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    return mystrcmp(a, b);\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    return foo::mystrcmp(a, b);\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if(mystrcmp(a, b));\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    bool b = mystrcmp(a, b);\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("", errout_str());
 
         // #6194
         check("void foo() {\n"
               "    MyStrCmp mystrcmp(x, y);\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("", errout_str());
 
         // #6197
         check("void foo() {\n"
               "    abc::def.mystrcmp(a,b);\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("", errout_str());
 
         // #6233
@@ -1412,30 +1412,30 @@ class TestFunctions : public TestFixture {
               "    };\n"
               "    lambda(13.3);\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // TODO: use settings2?
 
         // #6669
         check("void foo(size_t size) {\n"
               "   void * res{malloc(size)};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // TODO: use settings2?
 
         // #7447
         check("void foo() {\n"
               "   int x{mystrcmp(a,b)};\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("", errout_str());
 
         // #7905
         check("void foo() {\n"
               "   int x({mystrcmp(a,b)});\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n" // don't crash
               "  DEBUG(123)(mystrcmp(a,b))(fd);\n"
-              "}", settings2);
+              "}\n", settings2);
         check("struct teststruct {\n"
               "    int testfunc1() __attribute__ ((warn_unused_result)) { return 1; }\n"
               "    [[nodiscard]] int testfunc2() { return 1; }\n"
@@ -1446,7 +1446,7 @@ class TestFunctions : public TestFixture {
               "    TestStruct1.testfunc1();\n"
               "    TestStruct1.testfunc2();\n"
               "    return 0;\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("[test.cpp:4:18]: (warning) Return value of function testfunc1() is not used. [ignoredReturnValue]\n"
                       "[test.cpp:4:31]: (warning) Return value of function testfunc2() is not used. [ignoredReturnValue]\n"
                       "[test.cpp:8:17]: (warning) Return value of function TestStruct1.testfunc1() is not used. [ignoredReturnValue]\n"
@@ -1456,7 +1456,7 @@ class TestFunctions : public TestFixture {
         check("template <typename... a> uint8_t b(std::tuple<uint8_t> d) {\n"
               "  std::tuple<a...> c{std::move(d)};\n"
               "  return std::get<0>(c);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // TODO: use settings2?
 
         check("struct A { int x; };\n"
@@ -1464,13 +1464,13 @@ class TestFunctions : public TestFixture {
               "A f(int x, Ts... xs) {\n"
               "    return {std::move(x), static_cast<int>(xs)...};\n"
               "}\n"
-              "A g() { return f(1); }");
+              "A g() { return f(1); }\n");
         ASSERT_EQUALS("", errout_str()); // TODO: use settings2?
 
         // #8412 - unused operator result
         check("void foo() {\n"
               "  !mystrcmp(a, b);\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("[test.cpp:2:4]: (warning) Return value of function mystrcmp() is not used. [ignoredReturnValue]\n", errout_str());
 
         check("void f(std::vector<int*> v) {\n"
@@ -1502,24 +1502,24 @@ class TestFunctions : public TestFixture {
 
         check("void foo() {\n"
               "  mystrcmp(a, b);\n"
-              "}", settings2);
+              "}\n", settings2);
         ASSERT_EQUALS("[test.cpp:2:3]: (style) Error code from the return value of function mystrcmp() is not used. [ignoredReturnErrorCode]\n", errout_str());
     }
 
     void memsetZeroBytes() {
         check("void f() {\n"
               "    memset(p, 10, 0x0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) memset() called to fill 0 bytes. [memsetZeroBytes]\n", errout_str());
 
         check("void f() {\n"
               "    memset(p, sizeof(p), 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) memset() called to fill 0 bytes. [memsetZeroBytes]\n", errout_str());
 
         check("void f() {\n"
               "    memset(p, sizeof(p), i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6269 false positives in case of overloaded standard library functions
@@ -1528,13 +1528,13 @@ class TestFunctions : public TestFixture {
               "  void f( void )   {\n"
               "     memset( 0 );\n"
               "  }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7285
         check("void f() {\n"
               "    memset(&tm, sizeof(tm), 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) memset() called to fill 0 bytes. [memsetZeroBytes]\n", errout_str());
 
     }
@@ -1545,7 +1545,7 @@ class TestFunctions : public TestFixture {
               "    memset(is, 1.0f, 40);\n"
               "    int* is2 = new int[10];\n"
               "    memset(is2, 0.1f, 40);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (portability) The 2nd memset() argument '1.0f' is a float, its representation is implementation defined. [memsetFloat]\n"
                       "[test.cpp:5:18]: (portability) The 2nd memset() argument '0.1f' is a float, its representation is implementation defined. [memsetFloat]\n", errout_str());
 
@@ -1553,19 +1553,19 @@ class TestFunctions : public TestFixture {
               "    int* is = new int[10];\n"
               "    float g = computeG();\n"
               "    memset(is, g, 40);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (portability) The 2nd memset() argument 'g' is a float, its representation is implementation defined. [memsetFloat]\n", errout_str());
 
         check("void f() {\n"
               "    int* is = new int[10];\n"
               "    memset(is, 0.0f, 40);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // FP
               "    float x = 2.3f;\n"
               "    memset(a, (x?64:0), 40);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -1573,7 +1573,7 @@ class TestFunctions : public TestFixture {
               "    memset(ss, 256, 4);\n"
               "    short ss2[2];\n"
               "    memset(ss2, -129, 4);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (warning) The 2nd memset() argument '256' doesn't fit into an 'unsigned char'. [memsetValueOutOfRange]\n"
                       "[test.cpp:5:18]: (warning) The 2nd memset() argument '-129' doesn't fit into an 'unsigned char'. [memsetValueOutOfRange]\n", errout_str());
 
@@ -1588,23 +1588,23 @@ class TestFunctions : public TestFixture {
               "    memset(cs2, 255, 30);\n"
               "    char cs3[30];\n"
               "    memset(cs3, 0, 30);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int is[10];\n"
               "    const int i = g();\n"
               "    memset(is, 1.0f + i, 40);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:21]: (portability) The 2nd memset() argument '1.0f+i' is a float, its representation is implementation defined. [memsetFloat]\n", errout_str());
     }
 
     void checkMissingReturn1() {
-        check("int f() {}");
+        check("int f() {}\n");
         ASSERT_EQUALS("[test.cpp:1:10]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
 
         {
-            const char code[] = "int main(void) {}";
+            const char code[] = "int main(void) {}\n";
             {
                 const Settings s = settingsBuilder().c(Standards::C89).build();
 
@@ -1622,16 +1622,16 @@ class TestFunctions : public TestFixture {
             }
         }
 
-        check("F(A,B) { x=1; }");
+        check("F(A,B) { x=1; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("auto foo4() -> void {}");
+        check("auto foo4() -> void {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void STDCALL foo() {}");
+        check("void STDCALL foo() {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void operator=(int y) { x=y; }");
+        check("void operator=(int y) { x=y; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
@@ -1647,14 +1647,14 @@ class TestFunctions : public TestFixture {
         check("int foo(int x) {\n"
               "  return 1;\n"
               "  (void)x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int foo(int x) {\n"
               "  if (x) goto out;\n"
               "  return 1;\n"
               "out:\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
 
         // switch
@@ -1663,7 +1663,7 @@ class TestFunctions : public TestFixture {
               "        case 1: break;\n" // <- error
               "        case 2: return 1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
 
         check("int f() {\n"
@@ -1671,7 +1671,7 @@ class TestFunctions : public TestFixture {
               "        case 1: return 2; break;\n"
               "        default: return 1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool test(unsigned char v1, int v2) {\n"
@@ -1685,7 +1685,7 @@ class TestFunctions : public TestFixture {
               "        default:\n"
               "            return true;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // if/else
@@ -1693,7 +1693,7 @@ class TestFunctions : public TestFixture {
               "    if (x) {\n"
               "        return 1;\n"
               "    }\n" // <- error (missing else)
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
 
         check("int f(int x) {\n"
@@ -1702,19 +1702,19 @@ class TestFunctions : public TestFixture {
               "    } else {\n"
               "        return 1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
 
         check("int f() {\n"
               "    if (!0) {\n"
               "        return 1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    if (!0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
 
         // loop
@@ -1722,7 +1722,7 @@ class TestFunctions : public TestFixture {
               "    while (1) {\n"
               "        dostuff();\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // return {..}
@@ -1731,20 +1731,20 @@ class TestFunctions : public TestFixture {
               "        return {};\n"
               "    else\n"
               "        return {1, 2};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // noreturn function
-        check("int f(int x) { exit(0); }");
+        check("int f(int x) { exit(0); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int f(int x) { assert(0); }");
+        check("int f(int x) { assert(0); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int f(int x) { if (x) return 1; else return bar({1}, {}); }");
+        check("int f(int x) { if (x) return 1; else return bar({1}, {}); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("auto f() -> void {}"); // #10342
+        check("auto f() -> void {}\n"); // #10342
         ASSERT_EQUALS("", errout_str());
 
         check("struct S1 {\n" // #7433
@@ -1764,36 +1764,36 @@ class TestFunctions : public TestFixture {
                       errout_str());
 
         // #11171
-        check("std::enable_if_t<sizeof(uint64_t) == 8> f() {}");
+        check("std::enable_if_t<sizeof(uint64_t) == 8> f() {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("std::enable_if_t<sizeof(uint64_t) == 8, int> f() {}");
+        check("std::enable_if_t<sizeof(uint64_t) == 8, int> f() {}\n");
         ASSERT_EQUALS(
             "[test.cpp:1:51]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n",
             errout_str());
 
-        check("template<class T> std::enable_if_t<std::is_same<T, int>{}, int> f(T) {}");
+        check("template<class T> std::enable_if_t<std::is_same<T, int>{}, int> f(T) {}\n");
         ASSERT_EQUALS(
             "[test.cpp:1:71]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n",
             errout_str());
 
-        check("template<class T> std::enable_if_t<std::is_same<T, int>{}> f(T) {}");
+        check("template<class T> std::enable_if_t<std::is_same<T, int>{}> f(T) {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("typename std::enable_if<sizeof(uint64_t) == 8>::type f() {}");
+        check("typename std::enable_if<sizeof(uint64_t) == 8>::type f() {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("typename std::enable_if<sizeof(uint64_t) == 8, int>::type f() {}");
+        check("typename std::enable_if<sizeof(uint64_t) == 8, int>::type f() {}\n");
         ASSERT_EQUALS(
             "[test.cpp:1:64]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n",
             errout_str());
 
-        check("template<class T> typename std::enable_if<std::is_same<T, int>{}, int>::type f(T) {}");
+        check("template<class T> typename std::enable_if<std::is_same<T, int>{}, int>::type f(T) {}\n");
         ASSERT_EQUALS(
             "[test.cpp:1:84]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n",
             errout_str());
 
-        check("template<class T> typename std::enable_if<std::is_same<T, int>{}>::type f(T) {}");
+        check("template<class T> typename std::enable_if<std::is_same<T, int>{}>::type f(T) {}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -1954,35 +1954,35 @@ class TestFunctions : public TestFixture {
 
     // NRVO check
     void returnLocalStdMove1() {
-        check("struct A{}; A f() { A var; return std::move(var); }");
+        check("struct A{}; A f() { A var; return std::move(var); }\n");
         ASSERT_EQUALS("[test.cpp:1:45]: (performance) Using std::move for returning object by-value from function will affect copy elision optimization."
                       " More: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-return-move-local [returnStdMoveLocal]\n", errout_str());
     }
 
     // RVO, C++03 ctor style
     void returnLocalStdMove2() {
-        check("struct A{}; A f() { return std::move( A() ); }");
+        check("struct A{}; A f() { return std::move( A() ); }\n");
         ASSERT_EQUALS("[test.cpp:1:40]: (performance) Using std::move for returning object by-value from function will affect copy elision optimization."
                       " More: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-return-move-local [returnStdMoveLocal]\n", errout_str());
     }
 
     // RVO, new ctor style
     void returnLocalStdMove3() {
-        check("struct A{}; A f() { return std::move(A{}); }");
+        check("struct A{}; A f() { return std::move(A{}); }\n");
         ASSERT_EQUALS("[test.cpp:1:39]: (performance) Using std::move for returning object by-value from function will affect copy elision optimization."
                       " More: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-return-move-local [returnStdMoveLocal]\n", errout_str());
     }
 
     // Function argument
     void returnLocalStdMove4() {
-        check("struct A{}; A f(A a) { return std::move(A{}); }");
+        check("struct A{}; A f(A a) { return std::move(A{}); }\n");
         ASSERT_EQUALS("[test.cpp:1:42]: (performance) Using std::move for returning object by-value from function will affect copy elision optimization."
                       " More: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-return-move-local [returnStdMoveLocal]\n", errout_str());
     }
 
     void returnLocalStdMove5() {
         check("struct A{} a; A f1() { return std::move(a); }\n"
-              "A f2() { volatile A var; return std::move(var); }");
+              "A f2() { volatile A var; return std::move(var); }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S { std::string msg{ \"abc\" }; };\n"
@@ -2009,14 +2009,14 @@ class TestFunctions : public TestFixture {
               "   int *a;\n"
               "   a = malloc( -10 );\n"
               "   free(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (error) Invalid malloc() argument nr 1. The value is -10 but the valid values are '0:'. [invalidFunctionArg]\n", errout_str());
 
         check("void f() {\n"
               "   int *a;\n"
               "   a = alloca( -10 );\n"
               "   free(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8]: (warning) Obsolete function 'alloca' called. [allocaCalled]\n"
                       "[test.cpp:3:17]: (error) Invalid alloca() argument nr 1. The value is -10 but the valid values are '0:'. [invalidFunctionArg]\n", errout_str());
     }
@@ -2027,12 +2027,12 @@ class TestFunctions : public TestFixture {
 
         check("void f() {\n"
               "    lib_func();"
-              "}", s);
+              "}\n", s);
         ASSERT_EQUALS("[test.cpp:2:5]: (information) --check-library: There is no matching configuration for function lib_func() [checkLibraryFunction]\n", errout_str());
 
         check("void f(void* v) {\n"
               "    lib_func(v);"
-              "}", s);
+              "}\n", s);
         ASSERT_EQUALS("[test.cpp:2:5]: (information) --check-library: There is no matching configuration for function lib_func() [checkLibraryFunction]\n", errout_str());
 
         // #10105
@@ -2048,7 +2048,7 @@ class TestFunctions : public TestFixture {
               "\n"
               "        void testFunctionReturnType() {\n"
               "        }\n"
-              "};", s);
+              "};\n", s);
         ASSERT_EQUALS("", errout_str());
 
         // #11183
@@ -2058,7 +2058,7 @@ class TestFunctions : public TestFixture {
               "\n"
               "void f() {\n"
               "    cb(std::string(\"\"));\n"
-              "}", s);
+              "}\n", s);
         TODO_ASSERT_EQUALS("", "[test.cpp:6:5]: (information) --check-library: There is no matching configuration for function cb() [checkLibraryFunction]\n", errout_str());
 
         // #7375
diff --git a/test/testgarbage.cpp b/test/testgarbage.cpp
index 7d91a013940..c798950b8e3 100644
--- a/test/testgarbage.cpp
+++ b/test/testgarbage.cpp
@@ -321,7 +321,7 @@ class TestGarbage : public TestFixture {
 
 
     void final_class_x() {
-        const char code[] = "class __declspec(dllexport) x final { };";
+        const char code[] = "class __declspec(dllexport) x final { };\n";
         SimpleTokenizer tokenizer(settings, *this);
         ASSERT(tokenizer.tokenize(code));
         ASSERT_EQUALS("", errout_str());
@@ -329,18 +329,18 @@ class TestGarbage : public TestFixture {
 
     void wrong_syntax1() {
         {
-            const char code[] ="TR(kvmpio, PROTO(int rw), ARGS(rw), TP_(aa->rw;))";
+            const char code[] ="TR(kvmpio, PROTO(int rw), ARGS(rw), TP_(aa->rw;))\n";
             ASSERT_THROW_INTERNAL(checkCode(code), UNKNOWN_MACRO);
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] ="struct A { template<int> struct { }; };";
+            const char code[] ="struct A { template<int> struct { }; };\n";
             ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
         }
 
         {
-            const char code[] ="enum ABC { A,B, typedef enum { C } };";
+            const char code[] ="enum ABC { A,B, typedef enum { C } };\n";
             ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
         }
     }
@@ -351,7 +351,7 @@ class TestGarbage : public TestFixture {
                             "    Y<int, int, int, int, int, char> y;\n"
                             "}\n"
                             "\n"
-                            "void G( template <typename T> class (j) ) {}";
+                            "void G( template <typename T> class (j) ) {}\n";
 
         // don't segfault..
         ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
@@ -366,7 +366,7 @@ class TestGarbage : public TestFixture {
                             "  for(  #endif typedef typedef cb[N] )\n"
                             "        ca[N]; =  cb[i]\n"
                             " )\n"
-                            "}";
+                            "}\n";
 
         SimpleTokenizer tokenizer(settings, *this);
         try {
@@ -380,25 +380,25 @@ class TestGarbage : public TestFixture {
     }
 
     void wrong_syntax4() {   // #3618
-        const char code[] = "typedef void (x) (int);    return x&";
+        const char code[] = "typedef void (x) (int);    return x&\n";
 
         ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
     }
 
     void wrong_syntax_if_macro() {
         // #2518 #4171
-        ASSERT_THROW_INTERNAL(checkCode("void f() { if MACRO(); }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { if MACRO(); }\n"), SYNTAX);
 
         // #4668 - note there is no semicolon after MACRO()
-        ASSERT_THROW_INTERNAL(checkCode("void f() { if (x) MACRO() {} }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { if (x) MACRO() {} }\n"), SYNTAX);
 
         // #4810 - note there is no semicolon after MACRO()
-        ASSERT_THROW_INTERNAL(checkCode("void f() { if (x) MACRO() else ; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { if (x) MACRO() else ; }\n"), SYNTAX);
     }
 
     void wrong_syntax_class_x_y() {
         // #3585
-        const char code[] = "class x y { };";
+        const char code[] = "class x y { };\n";
 
         {
             SimpleTokenizer tokenizer(settings, *this, false);
@@ -413,65 +413,65 @@ class TestGarbage : public TestFixture {
     }
 
     void wrong_syntax_anonymous_struct() {
-        ASSERT_THROW_INTERNAL(checkCode("struct { int x; } = {0};"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("struct { int x; } * = {0};"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("struct { int x; } = {0};\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("struct { int x; } * = {0};\n"), SYNTAX);
     }
 
     void syntax_case_default() {
-        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case: z(); break;}}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case: z(); break;}}\n"), SYNTAX);
 
-        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case;: z(); break;}}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case;: z(); break;}}\n"), SYNTAX);
 
-        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case {}: z(); break;}}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case {}: z(); break;}}\n"), SYNTAX);
 
-        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case 0?{1}:{2} : z(); break;}}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case 0?{1}:{2} : z(); break;}}\n"), SYNTAX);
 
-        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case 0?1;:{2} : z(); break;}}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case 0?1;:{2} : z(); break;}}\n"), SYNTAX);
 
-        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case 0?(1?{3:4}):2 : z(); break;}}"), AST);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case 0?(1?{3:4}):2 : z(); break;}}\n"), AST);
 
         //ticket #4234
-        ASSERT_THROW_INTERNAL(checkCode("( ) { switch break ; { switch ( x ) { case } y break ; : } }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("( ) { switch break ; { switch ( x ) { case } y break ; : } }\n"), SYNTAX);
 
         //ticket #4267
-        ASSERT_THROW_INTERNAL(checkCode("f ( ) { switch break; { switch ( x ) { case } case break; -6: ( ) ; } }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("f ( ) { switch break; { switch ( x ) { case } case break; -6: ( ) ; } }\n"), SYNTAX);
 
         // Missing semicolon
-        ASSERT_THROW_INTERNAL(checkCode("void foo () { switch(0) case 0 : default : }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void foo () { switch(0) case 0 : default : }\n"), SYNTAX);
     }
 
     void garbageCode1() {
-        (void)checkCode("struct x foo_t; foo_t typedef y;");
+        (void)checkCode("struct x foo_t; foo_t typedef y;\n");
     }
 
     void garbageCode2() { //#4300 (segmentation fault)
-        TODO_ASSERT_THROW(checkCode("enum { D = 1  struct  { } ; }  s.b = D;"), InternalError);
+        TODO_ASSERT_THROW(checkCode("enum { D = 1  struct  { } ; }  s.b = D;\n"), InternalError);
     }
 
     void garbageCode3() { //#4849 (segmentation fault in Tokenizer::simplifyStructDecl (invalid code))
-        TODO_ASSERT_THROW(checkCode("enum {  D = 2 s ; struct y  { x } ; } { s.a = C ; s.b = D ; }"), InternalError);
+        TODO_ASSERT_THROW(checkCode("enum {  D = 2 s ; struct y  { x } ; } { s.a = C ; s.b = D ; }\n"), InternalError);
     }
 
     void garbageCode4() { // #4887
-        ASSERT_THROW_INTERNAL(checkCode("void f ( ) { = a ; if ( 1 ) if = ( 0 ) ; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f ( ) { = a ; if ( 1 ) if = ( 0 ) ; }\n"), SYNTAX);
     }
 
     void garbageCode5() { // #5168 (segmentation fault)
-        ASSERT_THROW_INTERNAL(checkCode("( asm : ; void : );"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("( asm : ; void : );\n"), SYNTAX);
     }
 
     void garbageCode6() { // #5214
-        ASSERT_THROW_INTERNAL(checkCode("int b = ( 0 ? ? ) 1 : 0 ;"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("int a = int b = ( 0 ? ? ) 1 : 0 ;"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("int b = ( 0 ? ? ) 1 : 0 ;\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("int a = int b = ( 0 ? ? ) 1 : 0 ;\n"), SYNTAX);
     }
 
     void garbageCode7() {
-        ASSERT_THROW_INTERNAL(checkCode("1 (int j) { return return (c) * sizeof } y[1];"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("foo(Args&&...) fn void = { } auto template<typename... bar(Args&&...)"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("1 (int j) { return return (c) * sizeof } y[1];\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("foo(Args&&...) fn void = { } auto template<typename... bar(Args&&...)\n"), SYNTAX);
     }
 
     void garbageCode8() { // #5604
-        TODO_ASSERT_THROW(checkCode("{ enum struct : };"), InternalError);
+        TODO_ASSERT_THROW(checkCode("{ enum struct : };\n"), InternalError);
         TODO_ASSERT_THROW(checkCode("int ScopedEnum{ template<typename T> { { e = T::error }; };\n"
                                     "ScopedEnum1<int> se1; { enum class E : T { e = 0 = e ScopedEnum2<void*> struct UnscopedEnum3 { T{ e = 4 }; };\n"
                                     "arr[(int) E::e]; }; UnscopedEnum3<int> e2 = f()\n"
@@ -479,48 +479,48 @@ class TestGarbage : public TestFixture {
                                     "namespace UnscopedEnum { template<typename T> struct UnscopedEnum1 { E{ e = T::error }; }; UnscopedEnum1<int> { enum E : { e = 0 }; };\n"
                                     "UnscopedEnum2<void*> ue3; template<typename T> struct UnscopedEnum3 { enum { }; }; int arr[E::e]; };\n"
                                     "UnscopedEnum3<int> namespace template<typename T> int f() { enum E { e }; T::error }; return (int) E(); } int test1 int g() { enum E { e = E };\n"
-                                    "E::e; } int test2 = g<int>(); }"), InternalError);
+                                    "E::e; } int test2 = g<int>(); }\n"), InternalError);
     }
 
     void garbageCode9() {
-        TODO_ASSERT_THROW(checkCode("enum { e = { } } ( ) { { enum { } } } { e } "), InternalError);
+        TODO_ASSERT_THROW(checkCode("enum { e = { } } ( ) { { enum { } } } { e } \n"), InternalError);
     }
 
     void garbageCode10() { // #6127
-        ASSERT_THROW_INTERNAL(checkCode("for( rl=reslist; rl!=NULL; rl=rl->next )"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("for( rl=reslist; rl!=NULL; rl=rl->next )\n"), SYNTAX);
     }
 
     void garbageCode12() { // do not crash
-        (void)checkCode("{ g; S (void) { struct } { } int &g; }");
+        (void)checkCode("{ g; S (void) { struct } { } int &g; }\n");
         ignore_errout(); // we do not care about the output
     }
 
     void garbageCode13() { // Ticket #2607 - crash
-        (void)checkCode("struct C {} {} x");
+        (void)checkCode("struct C {} {} x\n");
     }
 
     void garbageCode15() { // Ticket #5203
-        ASSERT_THROW_INTERNAL(checkCode("int f ( int* r ) { {  int s[2] ; f ( s ) ; if ( ) } }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("int f ( int* r ) { {  int s[2] ; f ( s ) ; if ( ) } }\n"), SYNTAX);
     }
 
     void garbageCode16() { // #6080 (segmentation fault)
-        (void)checkCode("{ } A() { delete }"); // #6080
+        (void)checkCode("{ } A() { delete }\n"); // #6080
         ignore_errout(); // we do not care about the output
     }
 
     void garbageCode17() {
         ASSERT_THROW_INTERNAL(checkCode("void h(int l) {\n"
                                         "    while\n" // Don't crash (#3870)
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
     }
 
     void garbageCode18() {
-        ASSERT_THROW_INTERNAL(checkCode("switch(){case}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("switch(){case}\n"), SYNTAX);
     }
 
     void garbageCode20() {
         // #3953 (valgrind errors on garbage code)
-        ASSERT_EQUALS("void f ( 0 * ) ;", checkCode("void f ( 0 * ) ;"));
+        ASSERT_EQUALS("void f ( 0 * ) ;", checkCode("void f ( 0 * ) ;\n"));
     }
 
     void garbageCode21() {
@@ -531,7 +531,7 @@ class TestGarbage : public TestFixture {
                                         "    x;\n"
                                         "    int a, a2, a2*x; if () ;\n"
                                         "  )\n"
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
     }
 
     void garbageCode22() {
@@ -539,7 +539,7 @@ class TestGarbage : public TestFixture {
         ASSERT_THROW_INTERNAL(checkCode("int f()\n"
                                         "{\n"
                                         "    return if\n"
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
     }
 
     void garbageCode23() {
@@ -547,7 +547,7 @@ class TestGarbage : public TestFixture {
         ASSERT_THROW_INTERNAL_EQUALS(checkCode("{\n"
                                                "    if (1) = x\n"
                                                "    else abort s[2]\n"
-                                               "}"),
+                                               "}\n"),
                                      SYNTAX,
                                      "syntax error");
     }
@@ -570,7 +570,7 @@ class TestGarbage : public TestFixture {
                                         "    switch ( x ) {\n"
                                         "        case struct Tree : break;\n"
                                         "    }\n"
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
         ignore_errout(); // we do not care about the output
     }
 
@@ -582,13 +582,13 @@ class TestGarbage : public TestFixture {
                                         "    case 0:\n"
                                         "        return;\n"
                                         "    }\n"
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
     }
 
     void garbageCode27() {
         ASSERT_THROW_INTERNAL(checkCode("int f() {\n"
                                         "    return if\n"
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
     }
 
     void garbageCode28() { // #5702 (segmentation fault)
@@ -596,7 +596,7 @@ class TestGarbage : public TestFixture {
         (void)checkCode("struct R1 {\n"
                         "  int a;\n"
                         "  R1 () : a { }\n"
-                        "};");
+                        "};\n");
         ignore_errout(); // we do not care about the output
     }
 
@@ -604,16 +604,16 @@ class TestGarbage : public TestFixture {
         // simply survive - a syntax error would be even better (#5867)
         (void)checkCode("void f(int x) {\n"
                         " x = 42\n"
-                        "}");
+                        "}\n");
         ignore_errout(); // we do not care about the output
     }
 
     void garbageCode31() {
-        ASSERT_THROW_INTERNAL(checkCode("typedef struct{}x[([],)]typedef e y;(y,x 0){}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("typedef struct{}x[([],)]typedef e y;(y,x 0){}\n"), SYNTAX);
     }
 
     void garbageCode33() { // #6613 (segmentation fault)
-        (void)checkCode("main(()B{});");
+        (void)checkCode("main(()B{});\n");
     }
 
     // Bug #6626 crash: Token::astOperand2() const ( do while )
@@ -621,13 +621,13 @@ class TestGarbage : public TestFixture {
         const char code[] = "void foo(void) {\n"
                             " do\n"
                             " while (0);\n"
-                            "}";
+                            "}\n";
         ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
     }
 
     void garbageCode35() {
         // ticket #2604 segmentation fault
-        ASSERT_THROW_INTERNAL(checkCode("sizeof <= A"), AST);
+        ASSERT_THROW_INTERNAL(checkCode("sizeof <= A\n"), AST);
     }
 
     void garbageCode36() { // #6334
@@ -641,311 +641,311 @@ class TestGarbage : public TestFixture {
 
     void garbageCode37() {
         // #5166 segmentation fault (invalid code) in lib/checkother.cpp:329 ( void * f { } void b ( ) { * f } )
-        (void)checkCode("void * f { } void b ( ) { * f }");
+        (void)checkCode("void * f { } void b ( ) { * f }\n");
         ignore_errout(); // we do not care about the output
     }
 
     void garbageCode38() { // Ticket #6666 (segmentation fault)
-        (void)checkCode("{ f2 { } } void f3 () { delete[] } { }");
+        (void)checkCode("{ f2 { } } void f3 () { delete[] } { }\n");
         ignore_errout(); // we do not care about the output
     }
 
     void garbageCode40() { // #6620 (segmentation fault)
-        (void)checkCode("{ ( ) () { virtual } ; { } E } A { : { } ( ) } * const ( ) const { }");
+        (void)checkCode("{ ( ) () { virtual } ; { } E } A { : { } ( ) } * const ( ) const { }\n");
         // test doesn't seem to work on any platform: ASSERT_THROW(checkCode("{ ( ) () { virtual } ; { } E } A { : { } ( ) } * const ( ) const { }", "test.c"), InternalError);
     }
 
     void garbageCode41() { // #6685 (segmentation fault)
-        (void)checkCode(" { } { return } *malloc(__SIZE_TYPE__ size); *memcpy(void n); static * const () { memcpy (*slot, 3); } { (); } { }");
+        (void)checkCode(" { } { return } *malloc(__SIZE_TYPE__ size); *memcpy(void n); static * const () { memcpy (*slot, 3); } { (); } { }\n");
     }
 
     void garbageCode42() { // #5760 (segmentation fault)
-        (void)checkCode("{  } * const ( ) { }");
+        (void)checkCode("{  } * const ( ) { }\n");
     }
 
     void garbageCode43() { // #6703 (segmentation fault)
-        (void)checkCode("int { }; struct A<void> a = { }");
+        (void)checkCode("int { }; struct A<void> a = { }\n");
     }
 
     void garbageCode44() { // #6704
-        ASSERT_THROW_INTERNAL(checkCode("{ { }; }; { class A : }; public typedef b;"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ { }; }; { class A : }; public typedef b;\n"), SYNTAX);
     }
 
     void garbageCode45() { // #6608
-        ASSERT_THROW_INTERNAL(checkCode("struct true template < > { = } > struct Types \"s\" ; static_assert < int > ;"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("struct true template < > { = } > struct Types \"s\" ; static_assert < int > ;\n"), SYNTAX);
     }
 
     void garbageCode46() { // #6705 (segmentation fault)
-        (void)checkCode(" { bar(char *x); void foo (int ...) { struct } va_list ap; va_start(ap, size); va_arg(ap, (d)); }");
+        (void)checkCode(" { bar(char *x); void foo (int ...) { struct } va_list ap; va_start(ap, size); va_arg(ap, (d)); }\n");
         ignore_errout(); // we do not care about the output
     }
 
     void garbageCode47() { // #6706 (segmentation fault)
-        (void)checkCode(" { { }; }; * new private: B: B;");
+        (void)checkCode(" { { }; }; * new private: B: B;\n");
     }
 
     void garbageCode48() { // #6712 (segmentation fault)
-        ASSERT_THROW_INTERNAL(checkCode(" { d\" ) d ...\" } int main ( ) { ( ) catch ( A a ) { { } catch ( ) \"\" } }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode(" { d\" ) d ...\" } int main ( ) { ( ) catch ( A a ) { { } catch ( ) \"\" } }\n"), SYNTAX);
     }
 
     void garbageCode49() { // #6715
-        ASSERT_THROW_INTERNAL(checkCode(" ( ( ) ) { } ( { ( __builtin_va_arg_pack ( ) ) ; } ) { ( int { ( ) ( ( ) ) } ( ) { } ( ) ) += ( ) }"), AST);
+        ASSERT_THROW_INTERNAL(checkCode(" ( ( ) ) { } ( { ( __builtin_va_arg_pack ( ) ) ; } ) { ( int { ( ) ( ( ) ) } ( ) { } ( ) ) += ( ) }\n"), AST);
     }
 
     void garbageCode51() { // #6719
-        ASSERT_THROW_INTERNAL(checkCode(" (const \"C\" ...); struct base { int f2; base (int arg1, int arg2); }; global_base(0x55, 0xff); { ((global_base.f1 0x55) (global_base.f2 0xff)) { } } base::base(int arg1, int arg2) { f2 = }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode(" (const \"C\" ...); struct base { int f2; base (int arg1, int arg2); }; global_base(0x55, 0xff); { ((global_base.f1 0x55) (global_base.f2 0xff)) { } } base::base(int arg1, int arg2) { f2 = }\n"), SYNTAX);
     }
 
     void garbageCode53() { // #6721
-        ASSERT_THROW_INTERNAL(checkCode("{ { } }; void foo (struct int i) { x->b[i] = = }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ { } }; void foo (struct int i) { x->b[i] = = }\n"), SYNTAX);
     }
 
     void garbageCode54() { // #6722
-        ASSERT_THROW_INTERNAL(checkCode("{ typedef long ((pf) p) (); }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ typedef long ((pf) p) (); }\n"), SYNTAX);
     }
 
     void garbageCode55() { // #6724
-        ASSERT_THROW_INTERNAL(checkCode("() __attribute__((constructor)); { } { }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("() __attribute__((constructor)); { } { }\n"), SYNTAX);
     }
 
     void garbageCode56() { // #6713
-        ASSERT_THROW_INTERNAL(checkCode("void foo() { int a = 0; int b = ???; }"), AST);
+        ASSERT_THROW_INTERNAL(checkCode("void foo() { int a = 0; int b = ???; }\n"), AST);
     }
 
     void garbageCode57() { // #6731
-        ASSERT_THROW_INTERNAL(checkCode("{ } if () try { } catch (...) B::~B { }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ } if () try { } catch (...) B::~B { }\n"), SYNTAX);
     }
 
     void garbageCode58() { // #6732, #6762
-        ASSERT_THROW_INTERNAL(checkCode("{ }> {= ~A()^{} }P { }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("{= ~A()^{} }P { } { }> is"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ }> {= ~A()^{} }P { }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{= ~A()^{} }P { } { }> is\n"), SYNTAX);
     }
 
     void garbageCode59() { // #6735
-        ASSERT_THROW_INTERNAL(checkCode("{ { } }; char font8x8[256][8]"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ { } }; char font8x8[256][8]\n"), SYNTAX);
     }
 
     void garbageCode60() { // #6736
-        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef int int_array[]; int_array &right ="), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef int int_array[]; int_array &right =\n"), SYNTAX);
     }
 
     void garbageCode61() { // #6737
-        ASSERT_THROW_INTERNAL(checkCode("{ (const U&) }; { }; { }; struct U : virtual public"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ (const U&) }; { }; { }; struct U : virtual public\n"), SYNTAX);
     }
 
     void garbageCode63() { // #6739
-        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef int u_array[]; typedef u_array &u_array_ref; (u_array_ref arg) { } u_array_ref u_array_ref_gbl_obj0"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef int u_array[]; typedef u_array &u_array_ref; (u_array_ref arg) { } u_array_ref u_array_ref_gbl_obj0\n"), SYNTAX);
     }
 
     void garbageCode64() { // #6740
-        ASSERT_THROW_INTERNAL(checkCode("{ } foo(void (*bar)(void))"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ } foo(void (*bar)(void))\n"), SYNTAX);
     }
 
     void garbageCode65() { // #6741 (segmentation fault)
         // TODO write some syntax error
-        (void)checkCode("{ } { } typedef int u_array[]; typedef u_array &u_array_ref; (u_array_ref arg) { } u_array_ref");
+        (void)checkCode("{ } { } typedef int u_array[]; typedef u_array &u_array_ref; (u_array_ref arg) { } u_array_ref\n");
     }
 
     void garbageCode66() { // #6742
-        ASSERT_THROW_INTERNAL(checkCode("{ { } }; { { } }; { }; class bar : public virtual"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ { } }; { { } }; { }; class bar : public virtual\n"), SYNTAX);
     }
 
     void garbageCode68() { // #6745 (segmentation fault)
-        (void)checkCode("(int a[3]); typedef void (*fp) (void); fp");
+        (void)checkCode("(int a[3]); typedef void (*fp) (void); fp\n");
     }
 
     void garbageCode69() { // #6746
-        ASSERT_THROW_INTERNAL(checkCode("{ (make_mess, aux); } typedef void F(void); aux(void (*x)()) { } (void (*y)()) { } F*"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ (make_mess, aux); } typedef void F(void); aux(void (*x)()) { } (void (*y)()) { } F*\n"), SYNTAX);
     }
 
     void garbageCode70() { // #6747
-        ASSERT_THROW_INTERNAL(checkCode("{ } __attribute__((constructor)) void"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ } __attribute__((constructor)) void\n"), SYNTAX);
     }
 
     void garbageCode71() { // #6748
-        ASSERT_THROW_INTERNAL(checkCode("( ) { } typedef void noattr_t ( ) ; noattr_t __attribute__ ( )"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("( ) { } typedef void noattr_t ( ) ; noattr_t __attribute__ ( )\n"), SYNTAX);
     }
 
     void garbageCode72() { // #6749
-        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef void voidfn(void); <voidfn&"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef void voidfn(void); <voidfn&\n"), SYNTAX);
     }
 
     void garbageCode73() { // #6750
-        ASSERT_THROW_INTERNAL(checkCode("typedef int IRT[2]; IRT&"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("typedef int IRT[2]; IRT&\n"), SYNTAX);
     }
 
     void garbageCode74() { // #6751
-        ASSERT_THROW_INTERNAL(checkCode("_lenraw(const char* digits) { } typedef decltype(sizeof(0)) { } operator"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("_lenraw(const char* digits) { } typedef decltype(sizeof(0)) { } operator\n"), SYNTAX);
     }
 
     void garbageCode76() { // #6754
-        ASSERT_THROW_INTERNAL(checkCode(" ( ) ( ) { ( ) [ ] } TEST ( ) { ( _broadcast_f32x4 ) ( ) ( ) ( ) ( ) if ( ) ( ) ; } E mask = ( ) [ ] ( ) res1.x ="), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode(" ( ) ( ) { ( ) [ ] } TEST ( ) { ( _broadcast_f32x4 ) ( ) ( ) ( ) ( ) if ( ) ( ) ; } E mask = ( ) [ ] ( ) res1.x =\n"), SYNTAX);
     }
 
     void garbageCode77() { // #6755
-        ASSERT_THROW_INTERNAL(checkCode("void foo (int **p) { { { };>= } } unsigned *d = (b b--) --*d"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void foo (int **p) { { { };>= } } unsigned *d = (b b--) --*d\n"), SYNTAX);
     }
 
     void garbageCode78() { // #6756
-        ASSERT_THROW_INTERNAL(checkCode("( ) { [ ] } ( ) { } const_array_of_int ( ) { } typedef int A [ ] [ ] ; A a = { { } { } }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("( ) { [ ] } ( ) { } const_array_of_int ( ) { } typedef int A [ ] [ ] ; A a = { { } { } }\n"), SYNTAX);
         ignore_errout(); // we do not care about the output
     }
 
     void garbageCode79() { // #6757
-        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef void ( func_type ) ( ) ; func_type & ( )"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef void ( func_type ) ( ) ; func_type & ( )\n"), SYNTAX);
     }
 
     void garbageCode80() { // #6759
-        ASSERT_THROW_INTERNAL(checkCode("( ) { ; ( ) ; ( * ) [ ] ; [ ] = ( ( ) ( ) h ) ! ( ( ) ) } { ; } { } head heads [ ] = ; = & heads [ 2 ]"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("( ) { ; ( ) ; ( * ) [ ] ; [ ] = ( ( ) ( ) h ) ! ( ( ) ) } { ; } { } head heads [ ] = ; = & heads [ 2 ]\n"), SYNTAX);
     }
 
     void garbageCode81() { // #6760
-        ASSERT_THROW_INTERNAL(checkCode("{ } [ ] { ( ) } { } typedef void ( *fptr1 ) ( ) const"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ } [ ] { ( ) } { } typedef void ( *fptr1 ) ( ) const\n"), SYNTAX);
     }
 
     void garbageCode82() { // #6761
-        ASSERT_THROW_INTERNAL(checkCode("p(\"Hello \" 14) _yn(const size_t) typedef bool pfunk (*pfunk)(const size_t)"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("p(\"Hello \" 14) _yn(const size_t) typedef bool pfunk (*pfunk)(const size_t)\n"), SYNTAX);
     }
 
     void garbageCode83() { // #6771
-        ASSERT_THROW_INTERNAL(checkCode("namespace A { class } class A { friend C ; } { } ;"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("namespace A { class } class A { friend C ; } { } ;\n"), SYNTAX);
     }
 
     void garbageCode84() { // #6780
-        ASSERT_THROW_INTERNAL(checkCode("int main ( [ ] ) { " " [ ] ; int i = 0 ; do { } ; } ( [ ] ) { }"), SYNTAX); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("int main ( [ ] ) { " " [ ] ; int i = 0 ; do { } ; } ( [ ] ) { }\n"), SYNTAX); // do not crash
     }
 
     void garbageCode85() { // #6784 (segmentation fault)
-        (void)checkCode("{ } { } typedef void ( *VoidFunc() ) ( ) ; VoidFunc"); // do not crash
+        (void)checkCode("{ } { } typedef void ( *VoidFunc() ) ( ) ; VoidFunc\n"); // do not crash
     }
 
     void garbageCode86() { // #6785
-        ASSERT_THROW_INTERNAL(checkCode("{ } typedef char ( *( X ) ( void) , char ) ;"), SYNTAX); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("{ } typedef char ( *( X ) ( void) , char ) ;\n"), SYNTAX); // do not crash
     }
 
     void garbageCode87() { // #6788
-        ASSERT_THROW_INTERNAL(checkCode("((X (128))) (int a) { v[ = {} (x 42) a] += }"), SYNTAX); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("((X (128))) (int a) { v[ = {} (x 42) a] += }\n"), SYNTAX); // do not crash
     }
 
     void garbageCode88() { // #6786
-        ASSERT_THROW_INTERNAL(checkCode("( ) { ( 0 ) { ( ) } } g ( ) { i( ( false ?) ( ) : 1 ) ; } ;"), SYNTAX); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("( ) { ( 0 ) { ( ) } } g ( ) { i( ( false ?) ( ) : 1 ) ; } ;\n"), SYNTAX); // do not crash
     }
 
     void garbageCode90() { // #6790
-        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef int u_array [[ ] ; typedef u_array & u_array_ref] ( ) { } u_array_ref_gbl_obj0"), SYNTAX); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef int u_array [[ ] ; typedef u_array & u_array_ref] ( ) { } u_array_ref_gbl_obj0\n"), SYNTAX); // do not crash
     }
 
     void garbageCode91() { // #6791
-        ASSERT_THROW_INTERNAL(checkCode("typedef __attribute__((vector_size (16))) { return[ (v2df){ } ;] }"), SYNTAX); // throw syntax error
+        ASSERT_THROW_INTERNAL(checkCode("typedef __attribute__((vector_size (16))) { return[ (v2df){ } ;] }\n"), SYNTAX); // throw syntax error
     }
 
     void garbageCode92() { // #6792
-        ASSERT_THROW_INTERNAL(checkCode("template < typename _Tp ( ( ) ; _Tp ) , decltype > { } { ( ) ( ) }"), SYNTAX); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("template < typename _Tp ( ( ) ; _Tp ) , decltype > { } { ( ) ( ) }\n"), SYNTAX); // do not crash
     }
 
     void garbageCode94() { // #6803
         //checkCode("typedef long __m256i __attribute__ ( ( ( ) ) )[ ; ( ) { } typedef __m256i __attribute__ ( ( ( ) ) ) < ] ( ) { ; }");
-        ASSERT_THROW_INTERNAL(checkCode("typedef long __m256i __attribute__ ( ( ( ) ) )[ ; ( ) { } typedef __m256i __attribute__ ( ( ( ) ) ) < ] ( ) { ; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("typedef long __m256i __attribute__ ( ( ( ) ) )[ ; ( ) { } typedef __m256i __attribute__ ( ( ( ) ) ) < ] ( ) { ; }\n"), SYNTAX);
     }
 
     void garbageCode95() { // #6804
-        ASSERT_THROW_INTERNAL(checkCode("{ } x x ; { } h h [ ] ( ) ( ) { struct x ( x ) ; int __attribute__ ( ) f ( ) { h - > first = & x ; struct x * n = h - > first ; ( ) n > } }"), SYNTAX); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("{ } x x ; { } h h [ ] ( ) ( ) { struct x ( x ) ; int __attribute__ ( ) f ( ) { h - > first = & x ; struct x * n = h - > first ; ( ) n > } }\n"), SYNTAX); // do not crash
     }
 
     void garbageCode96() { // #6807
-        ASSERT_THROW_INTERNAL(checkCode("typedef J J[ ; typedef ( ) ( ) { ; } typedef J J ;] ( ) ( J cx ) { n } ;"), SYNTAX); // throw syntax error
+        ASSERT_THROW_INTERNAL(checkCode("typedef J J[ ; typedef ( ) ( ) { ; } typedef J J ;] ( ) ( J cx ) { n } ;\n"), SYNTAX); // throw syntax error
     }
 
     void garbageCode97() { // #6808
-        ASSERT_THROW_INTERNAL(checkCode("namespace A {> } class A{ { }} class A : T< ;"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("namespace A {> } class A{ { }} class A : T< ;\n"), SYNTAX);
     }
 
     void garbageCode98() { // #6838
         ASSERT_THROW_INTERNAL(checkCode("for (cocon To::ta@Taaaaaforconst oken aaaaaaaaaaaa5Dl()\n"
                                         "const unsigned in;\n"
-                                        "fon *tok = f);.s(Token i = d-)L;"), SYNTAX);
+                                        "fon *tok = f);.s(Token i = d-)L;\n"), SYNTAX);
     }
 
     void garbageCode99() { // #6726
         ASSERT_THROW_INTERNAL_EQUALS(checkCode("{ xs :: i(:) ! ! x/5 ! !\n"
                                                "i, :: a :: b integer, } foo2(x) :: j(:)\n"
                                                "b type(*), d(:), a x :: end d(..), foo end\n"
-                                               "foo4 b d(..), a a x type(*), b foo2 b"), SYNTAX, "syntax error");
+                                               "foo4 b d(..), a a x type(*), b foo2 b\n"), SYNTAX, "syntax error");
     }
 
     void garbageCode100() { // #6840
-        ASSERT_THROW_INTERNAL(checkCode("( ) { ( i< ) } int foo ( ) { int i ; ( for ( i => 1 ) ; ) }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("( ) { ( i< ) } int foo ( ) { int i ; ( for ( i => 1 ) ; ) }\n"), SYNTAX);
     }
 
     void garbageCode101() { // #6835
         // Reported case
-        ASSERT_THROW_INTERNAL(checkCode("template < class , =( , int) X = 1 > struct A { } ( ) { = } [ { } ] ( ) { A < void > 0 }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("template < class , =( , int) X = 1 > struct A { } ( ) { = } [ { } ] ( ) { A < void > 0 }\n"), SYNTAX);
         // Reduced case
-        ASSERT_THROW_INTERNAL(checkCode("template < class =( , ) X = 1> struct A {}; A<void> a;"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("template < class =( , ) X = 1> struct A {}; A<void> a;\n"), SYNTAX);
     }
 
     void garbageCode102() { // #6846 (segmentation fault)
-        ASSERT_THROW_INTERNAL(checkCode("struct Object { ( ) ; Object & operator= ( Object ) { ( ) { } if ( this != & b ) } }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("struct Object { ( ) ; Object & operator= ( Object ) { ( ) { } if ( this != & b ) } }\n"), SYNTAX);
     }
 
     void garbageCode103() { // #6824
-        ASSERT_THROW_INTERNAL(checkCode("a f(r) int * r; { { int s[2]; [f(s); if () ]  } }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("a f(r) int * r; { { int s[2]; [f(s); if () ]  } }\n"), SYNTAX);
     }
 
     void garbageCode104() { // #6847
-        ASSERT_THROW_INTERNAL(checkCode("template < Types > struct S {> ( S < ) S >} { ( ) { } } ( ) { return S < void > ( ) } { ( )> >} { ( ) { } } ( ) { ( ) }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("template < Types > struct S {> ( S < ) S >} { ( ) { } } ( ) { return S < void > ( ) } { ( )> >} { ( ) { } } ( ) { ( ) }\n"), SYNTAX);
     }
 
     void garbageCode105() { // #6859
-        ASSERT_THROW_INTERNAL(checkCode("void foo (int i) { int a , for (a 1; a( < 4; a++) if (a) (b b++) (b);) n++; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void foo (int i) { int a , for (a 1; a( < 4; a++) if (a) (b b++) (b);) n++; }\n"), SYNTAX);
     }
 
     void garbageCode106() { // #6880
-        ASSERT_THROW_INTERNAL(checkCode("[ ] typedef typedef b_array b_array_ref [ ; ] ( ) b_array_ref b_array_ref_gbl_obj0 { ; { b_array_ref b_array_ref_gbl_obj0 } }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("[ ] typedef typedef b_array b_array_ref [ ; ] ( ) b_array_ref b_array_ref_gbl_obj0 { ; { b_array_ref b_array_ref_gbl_obj0 } }\n"), SYNTAX);
     }
 
     void garbageCode107() { // #6881
-        TODO_ASSERT_THROW(checkCode("enum { val = 1{ }; { const} }; { } Bar { const int A = val const } ;"), InternalError);
+        TODO_ASSERT_THROW(checkCode("enum { val = 1{ }; { const} }; { } Bar { const int A = val const } ;\n"), InternalError);
     }
 
     void garbageCode108() { //  #6895 "segmentation fault (invalid code) in CheckCondition::isOppositeCond"
-        ASSERT_THROW_INTERNAL(checkCode("A( ) { } bool f( ) { ( ) F; ( ) { ( == ) if ( !=< || ( !A( ) && r[2] ) ) ( !A( ) ) ( ) } }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("A( ) { } bool f( ) { ( ) F; ( ) { ( == ) if ( !=< || ( !A( ) && r[2] ) ) ( !A( ) ) ( ) } }\n"), SYNTAX);
     }
 
     void garbageCode109() { //  #6900 "segmentation fault (invalid code) in CheckStl::runSimplifiedChecks"
-        (void)checkCode("( *const<> (( ) ) { } ( *const ( ) ( ) ) { } ( * const<> ( size_t )) ) { } ( * const ( ) ( ) ) { }");
+        (void)checkCode("( *const<> (( ) ) { } ( *const ( ) ( ) ) { } ( * const<> ( size_t )) ) { } ( * const ( ) ( ) ) { }\n");
     }
 
     void garbageCode110() { //  #6902 "segmentation fault (invalid code) in CheckStl::string_c_str"
-        ASSERT_THROW_INTERNAL(checkCode("( *const<> ( size_t ) ; foo ) { } * ( *const ( size_t ) ( ) ;> foo )< { }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("( *const<> ( size_t ) ; foo ) { } * ( *const ( size_t ) ( ) ;> foo )< { }\n"), SYNTAX);
     }
 
     void garbageCode111() { //  #6907
-        TODO_ASSERT_THROW(checkCode("enum { FOO = 1( ,) } {{ FOO }} ;"), InternalError);
+        TODO_ASSERT_THROW(checkCode("enum { FOO = 1( ,) } {{ FOO }} ;\n"), InternalError);
     }
 
     void garbageCode112() { //  #6909
-        TODO_ASSERT_THROW(checkCode("enum { FOO = ( , ) } {{ }}>> enum { FOO< = ( ) } { { } } ;"), InternalError);
+        TODO_ASSERT_THROW(checkCode("enum { FOO = ( , ) } {{ }}>> enum { FOO< = ( ) } { { } } ;\n"), InternalError);
     }
 
     void garbageCode114() { // #2118
         ASSERT_NO_THROW(checkCode("Q_GLOBAL_STATIC_WITH_INITIALIZER(Qt4NodeStaticData, qt4NodeStaticData, {\n"
                                   "    for (unsigned i = 0 ; i < count; i++) {\n"
                                   "    }\n"
-                                  "});"));
+                                  "});\n"));
     }
 
     void garbageCode115() { // #5506
-        ASSERT_THROW_INTERNAL(checkCode("A template < int { int = -1 ; } template < int N > struct B { int [ A < N > :: zero ] ;  } ; B < 0 > b ;"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(checkCode("A template < int { int = -1 ; } template < int N > struct B { int [ A < N > :: zero ] ;  } ; B < 0 > b ;\n"), UNKNOWN_MACRO);
     }
 
     void garbageCode116() { // #5356
-        ASSERT_THROW_INTERNAL(checkCode("struct template<int { = }; > struct B { }; B < 0 > b;"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("struct template<int { = }; > struct B { }; B < 0 > b;\n"), SYNTAX);
     }
 
     void garbageCode117() { // #6121
         TODO_ASSERT_THROW(checkCode("enum E { f = {} };\n"
-                                    "int a = f;"), InternalError);
+                                    "int a = f;\n"), InternalError);
     }
 
     void garbageCode118() { // #5600 - missing include causes invalid enum
@@ -955,32 +955,32 @@ class TestGarbage : public TestFixture {
                                         "};\n"
                                         "struct bytecode {};\n"
                                         "jv jq_next() { opcode = ((opcode) +NUM_OPCODES);\n"
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
     }
 
     void garbageCode119() { // #5598 (segmentation fault)
-        (void)checkCode("{ { void foo() { struct }; template <typename> struct S { Used x; void bar() } auto f = [this] { }; } };");
+        (void)checkCode("{ { void foo() { struct }; template <typename> struct S { Used x; void bar() } auto f = [this] { }; } };\n");
         ignore_errout(); // we do not care about the output
     }
 
     void garbageCode120() { // #4927 (segmentation fault)
         (void)checkCode("int main() {\n"
                         "   return 0\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void garbageCode121() { // #2585
         ASSERT_THROW_INTERNAL(checkCode("abcdef?" "?<"
                                         "123456?" "?>"
-                                        "+?" "?="), SYNTAX);
+                                        "+?" "?=\n"), SYNTAX);
     }
 
     void garbageCode122() { // #6303 (segmentation fault)
         (void)checkCode("void foo() {\n"
                         "char *a = malloc(10);\n"
                         "a[0]\n"
-                        "}");
+                        "}\n");
         ignore_errout(); // we do not care about the output
     }
 
@@ -989,18 +989,18 @@ class TestGarbage : public TestFixture {
                         "    class C {\n"
                         "        C tpl_mem(T *) { return }\n"
                         "    };\n"
-                        "}");
+                        "}\n");
         ignore_errout(); // we do not care about the output
     }
 
     void garbageCode125() {
-        ASSERT_THROW_INTERNAL(checkCode("{ T struct B : T valueA_AA ; } T : [ T > ( ) { B } template < T > struct A < > : ] { ( ) { return valueA_AC struct { : } } b A < int > AC ( ) a_aa.M ; ( ) ( ) }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("template < Types > struct S :{ ( S < ) S >} { ( ) { } } ( ) { return S < void > ( ) }"),
+        ASSERT_THROW_INTERNAL(checkCode("{ T struct B : T valueA_AA ; } T : [ T > ( ) { B } template < T > struct A < > : ] { ( ) { return valueA_AC struct { : } } b A < int > AC ( ) a_aa.M ; ( ) ( ) }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("template < Types > struct S :{ ( S < ) S >} { ( ) { } } ( ) { return S < void > ( ) }\n"),
                               SYNTAX);
     }
 
     void garbageCode126() {
-        ASSERT_THROW_INTERNAL(checkCode("{ } float __ieee754_sinhf ( float x ) { float t , , do { gf_u ( jx ) { } ( 0 ) return ; ( ) { } t } ( 0x42b17180 ) { } }"),
+        ASSERT_THROW_INTERNAL(checkCode("{ } float __ieee754_sinhf ( float x ) { float t , , do { gf_u ( jx ) { } ( 0 ) return ; ( ) { } t } ( 0x42b17180 ) { } }\n"),
                               SYNTAX);
     }
 
@@ -1013,38 +1013,38 @@ class TestGarbage : public TestFixture {
                         "  ~A() { printf(\"A d'tor\\n\"); }\n"
                         "};\n"
                         " const A& foo(const A& arg) { return arg; }\n"
-                        " foo(A(12)).Var");
+                        " foo(A(12)).Var\n");
         ignore_errout(); // we do not care about the output
     }
 
     void garbageCode128() {
-        TODO_ASSERT_THROW(checkCode("enum { FOO = ( , ) } {{ }} enum {{ FOO << = } ( ) } {{ }} ;"),
+        TODO_ASSERT_THROW(checkCode("enum { FOO = ( , ) } {{ }} enum {{ FOO << = } ( ) } {{ }} ;\n"),
                           InternalError);
     }
 
     void garbageCode129() {
-        ASSERT_THROW_INTERNAL(checkCode("operator - ( { } typedef typename x ; ( ) ) { ( { { ( ( ) ) } ( { } ) } ) }"),
+        ASSERT_THROW_INTERNAL(checkCode("operator - ( { } typedef typename x ; ( ) ) { ( { { ( ( ) ) } ( { } ) } ) }\n"),
                               SYNTAX);
     }
 
     void garbageCode130() {
-        TODO_ASSERT_THROW(checkCode("enum { FOO = ( , ){ } { { } } { { FOO} = } ( ) } { { } } enumL\" ( enumL\" { { FOO } ( ) } { { } } ;"),
+        TODO_ASSERT_THROW(checkCode("enum { FOO = ( , ){ } { { } } { { FOO} = } ( ) } { { } } enumL\" ( enumL\" { { FOO } ( ) } { { } } ;\n"),
                           InternalError);
     }
 
     void garbageCode131() {
-        ASSERT_THROW_INTERNAL(checkCode("( void ) { ( ) } ( ) / { ( ) }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("( void ) { ( ) } ( ) / { ( ) }\n"), SYNTAX);
         // actually the invalid code should trigger an syntax error...
     }
 
     void garbageCode132() { // #7022
-        ASSERT_THROW_INTERNAL(checkCode("() () { } { () () ({}) i() } void i(void(*ptr) ()) { ptr(!) () }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("() () { } { () () ({}) i() } void i(void(*ptr) ()) { ptr(!) () }\n"), SYNTAX);
     }
 
     void garbageCode133() {
-        ASSERT_THROW_INTERNAL(checkCode("void f() {{}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {{}\n"), SYNTAX);
 
-        ASSERT_THROW_INTERNAL(checkCode("void f()) {}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f()) {}\n"), SYNTAX);
 
         ASSERT_THROW_INTERNAL(checkCode("void f()\n"
                                         "{\n"
@@ -1095,32 +1095,32 @@ class TestGarbage : public TestFixture {
 
     void garbageCode134() {
         // Ticket #5605, #5759, #5762, #5774, #5823, #6059
-        ASSERT_THROW_INTERNAL(checkCode("foo() template<typename T1 = T2 = typename = unused, T5 = = unused> struct tuple Args> tuple<Args...> { } main() { foo<int,int,int,int,int,int>(); }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("( ) template < T1 = typename = unused> struct Args { } main ( ) { foo < int > ( ) ; }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("() template < T = typename = x > struct a {} { f <int> () }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("template < T = typename = > struct a { f <int> }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("foo() template<typename T1 = T2 = typename = unused, T5 = = unused> struct tuple Args> tuple<Args...> { } main() { foo<int,int,int,int,int,int>(); }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("( ) template < T1 = typename = unused> struct Args { } main ( ) { foo < int > ( ) ; }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("() template < T = typename = x > struct a {} { f <int> () }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("template < T = typename = > struct a { f <int> }\n"), SYNTAX);
         (void)checkCode("struct S { int i, j; }; "
                         "template<int S::*p, typename U> struct X {}; "
                         "X<&S::i, int> x = X<&S::i, int>(); "
-                        "X<&S::j, int> y = X<&S::j, int>();");
+                        "X<&S::j, int> y = X<&S::j, int>();\n");
         ignore_errout(); // we are not interested in the output
         (void)checkCode("template <typename T> struct A {}; "
                         "template <> struct A<void> {}; "
-                        "void foo(const void* f = 0) {}");
+                        "void foo(const void* f = 0) {}\n");
         (void)checkCode("template<typename... T> struct A { "
                         "  static const int s = 0; "
                         "}; "
-                        "A<int> a;");
+                        "A<int> a;\n");
         (void)checkCode("template<class T, class U> class A {}; "
                         "template<class T = A<int, int> > class B {}; "
                         "template<class T = B<int> > class C { "
                         "    C() : _a(0), _b(0) {} "
                         "    int _a, _b; "
-                        "};");
+                        "};\n");
         (void)checkCode("template<class... T> struct A { "
                         "  static int i; "
                         "}; "
-                        "void f() { A<int>::i = 0; }");
+                        "void f() { A<int>::i = 0; }\n");
         ignore_errout(); // we are not interested in the output
     }
 
@@ -1129,17 +1129,17 @@ class TestGarbage : public TestFixture {
                         "  return a >> extern\n"
                         "}\n"
                         "long a = 1 ;\n"
-                        "long b = 2 ;");
+                        "long b = 2 ;\n");
         ignore_errout(); // we are not interested in the output
     }
 
     void garbageCode136() { // #7033
-        ASSERT_THROW_INTERNAL(checkCode("{ } () { void f() { node_t * n; for (; -n) {} } } { }"),
+        ASSERT_THROW_INTERNAL(checkCode("{ } () { void f() { node_t * n; for (; -n) {} } } { }\n"),
                               SYNTAX);
     }
 
     void garbageCode137() { // #7034
-        ASSERT_THROW_INTERNAL(checkCode("\" \" typedef signed char f; \" \"; void a() { f * s = () &[]; (; ) (; ) }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("\" \" typedef signed char f; \" \"; void a() { f * s = () &[]; (; ) (; ) }\n"), SYNTAX);
     }
 
     void garbageCode138() { // #6660 (segmentation fault)
@@ -1151,7 +1151,7 @@ class TestGarbage : public TestFixture {
                         "      {};\n"
                         "    } halo;\n"
                         "}\n"
-                        "CS_PLUGIN_NAMESPACE_END(csparser)");
+                        "CS_PLUGIN_NAMESPACE_END(csparser)\n");
         ignore_errout(); // we are not interested in the output
     }
 
@@ -1160,19 +1160,19 @@ class TestGarbage : public TestFixture {
                                         "   de_ctrl = (nDirection == RIGHT_TO_LEFT) ?\n"
                                         "    ( (0 & ~(((1 << (1 - (0 ? DE_CONTROL_DIRECTION))) - 1) << (0 ? DE_CONTROL_DIRECTION))) )\n"
                                         "    : 42;\n"
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
     }
 
     void garbageCode140() { // #7035
-        ASSERT_THROW_INTERNAL(checkCode("int foo(int align) { int off(= 0 % align;  return off) ? \\ align - off  :  0;  \\ }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("int foo(int align) { int off(= 0 % align;  return off) ? \\ align - off  :  0;  \\ }\n"), SYNTAX);
     }
 
     void garbageCode141() { // #7043
-        TODO_ASSERT_THROW(checkCode("enum { X = << { X } } enum { X = X } = X ;"), InternalError);
+        TODO_ASSERT_THROW(checkCode("enum { X = << { X } } enum { X = X } = X ;\n"), InternalError);
     }
 
     void garbageCode142() { // #7050
-        ASSERT_THROW_INTERNAL(checkCode("{ } (  ) { void mapGraphs ( ) { node_t * n ; for (!oid n ) { } } } { }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ } (  ) { void mapGraphs ( ) { node_t * n ; for (!oid n ) { } } } { }\n"), SYNTAX);
     }
 
     void garbageCode143() { // #6922
@@ -1186,18 +1186,18 @@ class TestGarbage : public TestFixture {
                                         "            VGAwCR(0x64,0x?? );\n"
                                         "        }\n"
                                         "    }\n"
-                                        "}"), AST);
+                                        "}\n"), AST);
     }
 
     void garbageCode144() { // #6865
-        ASSERT_THROW_INTERNAL(checkCode("template < typename > struct A { } ; template < typename > struct A < INVALID > : A < int[ > { }] ;"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("template < typename > struct A { } ; template < typename > struct A < INVALID > : A < int[ > { }] ;\n"), SYNTAX);
     }
 
     void garbageCode146() { // #7081
         ASSERT_THROW_INTERNAL(checkCode("void foo() {\n"
                                         "    ? std::cout << pow((, 1) << std::endl;\n"
                                         "    double <ip = NUO ip) << std::end;\n"
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
     }
 
     void garbageCode147() { // #7082
@@ -1211,9 +1211,9 @@ class TestGarbage : public TestFixture {
                                         "void est2() {\n"
                                         "    for (int ui = 0; ui < 1z; ui++)\n"
                                         "        ;\n"
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
 
-        ASSERT_THROW_INTERNAL(checkCode("; void f ^ { return } int main ( ) { }"), SYNTAX); // #4941
+        ASSERT_THROW_INTERNAL(checkCode("; void f ^ { return } int main ( ) { }\n"), SYNTAX); // #4941
     }
 
     void garbageCode148() { // #7090
@@ -1221,14 +1221,14 @@ class TestGarbage : public TestFixture {
                                         "    typedef S0 b[][1][1] != 0\n"
                                         "};\n"
                                         "b[K][0] S0 b[][1][1] != 4{ 0 };\n"
-                                        "b[0][0]"), UNKNOWN_MACRO);
+                                        "b[0][0]\n"), UNKNOWN_MACRO);
     }
 
     void garbageCode149() { // #7085 (segmentation fault)
         (void)checkCode("int main() {\n"
                         "    for (j = 0; j < 1; j)\n"
                         "        j6;\n"
-                        "}");
+                        "}\n");
         ignore_errout(); // we do not care about the output
     }
 
@@ -1245,7 +1245,7 @@ class TestGarbage : public TestFixture {
         (void)checkCode("void f() {\n"
                         "    int a;\n"
                         "    do { a=do_something() } while (a);\n"
-                        "}");
+                        "}\n");
     }
 
     void garbageCode152() { // happened in travis, originally from llvm clang code (segmentation fault)
@@ -1256,15 +1256,15 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode153() {
-        TODO_ASSERT_THROW(checkCode("enum { X = << { X } } { X X } enum { X = << { ( X ) } } { } X */"), InternalError);
+        TODO_ASSERT_THROW(checkCode("enum { X = << { X } } { X X } enum { X = << { ( X ) } } { } X */\n"), InternalError);
     }
 
     void garbageCode154() { // #7112 (segmentation fault)
-        (void)checkCode("\"abc\"[];");
+        (void)checkCode("\"abc\"[];\n");
     }
 
     void garbageCode156() { // #7120
-        ASSERT_THROW_INTERNAL(checkCode("struct {}a; d f() { c ? : } {}a.p"), AST);
+        ASSERT_THROW_INTERNAL(checkCode("struct {}a; d f() { c ? : } {}a.p\n"), AST);
     }
 
     void garbageCode157() { // #7131
@@ -1276,24 +1276,24 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode158() { // #3238 (segmentation fault)
-        (void)checkCode("__FBSDID(\"...\");");
+        (void)checkCode("__FBSDID(\"...\");\n");
     }
 
     void garbageCode159() { // #7119
-        ASSERT_THROW_INTERNAL(checkCode("({}typedef typename x;typename x!){({{}()})}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("({}typedef typename x;typename x!){({{}()})}\n"), SYNTAX);
     }
 
     void garbageCode160() { // #7190
-        ASSERT_THROW_INTERNAL(checkCode("f(a,b,c,d)float [  a[],d;int ]  b[],c;{} "), SYNTAX); // don't hang
+        ASSERT_THROW_INTERNAL(checkCode("f(a,b,c,d)float [  a[],d;int ]  b[],c;{} \n"), SYNTAX); // don't hang
     }
 
 
     void garbageCodeFuzzerClientMode1() {
-        ASSERT_THROW_INTERNAL(checkCode("void f() { x= name2 & name3 name2 = | 0.1 , | 0.1 , | 0.1 name4 <= >( ); }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("void f() { x = , * [ | + 0xff | > 0xff]; }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("void f() {  x = , | 0xff , 0.1 < ; }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("void f() { x = [ 1 || ] ; }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("void f1() { x = name6 1 || ? name3 [  ( 1 || +) ] ; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { x= name2 & name3 name2 = | 0.1 , | 0.1 , | 0.1 name4 <= >( ); }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { x = , * [ | + 0xff | > 0xff]; }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {  x = , | 0xff , 0.1 < ; }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { x = [ 1 || ] ; }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f1() { x = name6 1 || ? name3 [  ( 1 || +) ] ; }\n"), SYNTAX);
     }
 
     void garbageValueFlow() {
@@ -1306,46 +1306,46 @@ class TestGarbage : public TestFixture {
         }
 
         { // 6122 survive garbage code
-            const char code[] = "; { int i ; for ( i = 0 ; = 123 ; ) - ; }";
+            const char code[] = "; { int i ; for ( i = 0 ; = 123 ; ) - ; }\n";
             ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
         }
 
         {
-            const char code[] = "void f1() { for (int n = 0 n < 10 n++); }";
+            const char code[] = "void f1() { for (int n = 0 n < 10 n++); }\n";
             ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
         }
     }
 
     void garbageSymbolDatabase() {
-        (void)checkCode("void f( { u = 1 ; } ) { }");
+        (void)checkCode("void f( { u = 1 ; } ) { }\n");
 
-        ASSERT_THROW_INTERNAL(checkCode("{ }; void namespace A::f; { g() { int } }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ }; void namespace A::f; { g() { int } }\n"), SYNTAX);
 
-        ASSERT_THROW_INTERNAL(checkCode("class Foo {}; class Bar : public Foo"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("class Foo {}; class Bar : public Foo\n"), SYNTAX);
 
         // #5663 (segmentation fault)
         (void)checkCode("YY_DECL { switch (yy_act) {\n"
                         "    case 65: YY_BREAK\n"
                         "    case YY_STATE_EOF(block):\n"
                         "        yyterminate();\n"
-                        "} }");
+                        "} }\n");
         ignore_errout(); // we are not interested in the output
     }
 
     void garbageAST() {
         ASSERT_THROW_INTERNAL(checkCode("N 1024 float a[N], b[N + 3], c[N]; void N; (void) i;\n"
                                         "int #define for (i = avx_test i < c[i]; i++)\n"
-                                        "b[i + 3] = a[i] * {}"), SYNTAX); // Don't hang (#5787)
+                                        "b[i + 3] = a[i] * {}\n"), SYNTAX); // Don't hang (#5787)
 
-        (void)checkCode("START_SECTION([EXTRA](bool isValid(const String &filename)))"); // Don't crash (#5991)
+        (void)checkCode("START_SECTION([EXTRA](bool isValid(const String &filename)))\n"); // Don't crash (#5991)
 
         // #8352
         ASSERT_THROW_INTERNAL(checkCode("else return % name5 name2 - =name1 return enum | { - name3 1 enum != >= 1 >= ++ { { || "
-                                        "{ return return { | { - name3 1 enum != >= 1 >= ++ { name6 | ; ++}}}}}}}"), UNKNOWN_MACRO);
+                                        "{ return return { | { - name3 1 enum != >= 1 >= ++ { name6 | ; ++}}}}}}}\n"), UNKNOWN_MACRO);
         ASSERT_THROW_INTERNAL(checkCode("else return % name5 name2 - =name1 return enum | { - name3 1 enum != >= 1 >= ++ { { || "
-                                        "{ return return { | { - name3 1 enum != >= 1 >= ++ { { || ; ++}}}}}}}}"), UNKNOWN_MACRO);
+                                        "{ return return { | { - name3 1 enum != >= 1 >= ++ { { || ; ++}}}}}}}}\n"), UNKNOWN_MACRO);
 
-        ASSERT_THROW_INTERNAL(checkCode("f(*p, requires(x));"), AST); // #14740
+        ASSERT_THROW_INTERNAL(checkCode("f(*p, requires(x));\n"), AST); // #14740
     }
 
     void templateSimplifierCrashes() {
@@ -1369,7 +1369,7 @@ class TestGarbage : public TestFixture {
             "  void f() {\n"
             "    s.operator A<A<int> >();\n"
             "  }\n"
-            "}");
+            "}\n");
 
         ASSERT_NO_THROW(checkCode( // #6034
                             "template<template<typename...> class T, typename... Args>\n"
@@ -1383,7 +1383,7 @@ class TestGarbage : public TestFixture {
                             "\n"
                             "int main() {\n"
                             "  foo<int_<0> >::value;\n"
-                            "}"));
+                            "}\n"));
 
         (void)checkCode( // #6117 (segmentation fault)
             "template <typename ...> struct something_like_tuple\n"
@@ -1401,7 +1401,7 @@ class TestGarbage : public TestFixture {
             "\n"
             "typedef something_like_tuple<char, int, float> something_like_tuple_t;\n"
             "SA ((is_last<float, something_like_tuple_t>::value == false));\n"
-            "SA ((is_last<int, something_like_tuple_t>::value == false));");
+            "SA ((is_last<int, something_like_tuple_t>::value == false));\n");
         ignore_errout(); // we are not interested in the output
 
         (void)checkCode( // #6225 (use-after-free)
@@ -1412,7 +1412,7 @@ class TestGarbage : public TestFixture {
             "        template <typename T>\n"
             "        struct A {};\n"
             "        using AliasA = A<T>;\n"
-            "}");
+            "}\n");
 
         // #3449
         ASSERT_EQUALS("template < typename T > struct A ;\n"
@@ -1420,72 +1420,72 @@ class TestGarbage : public TestFixture {
                       "{ } ;",
                       checkCode("template<typename T> struct A;\n"
                                 "struct B { template<typename T> struct C };\n"
-                                "{};"));
+                                "{};\n"));
     }
     void garbageCode161() {
         //7200
-        ASSERT_THROW_INTERNAL(checkCode("{ }{ if () try { } catch (...)} B : : ~B { }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{ }{ if () try { } catch (...)} B : : ~B { }\n"), SYNTAX);
     }
 
     void garbageCode162() {
         //7208
-        ASSERT_THROW_INTERNAL(checkCode("return <<  >>  x return <<  >>  x ", false), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(checkCode("return <<  >>  x return <<  >>  x \n", false), UNKNOWN_MACRO);
     }
 
     void garbageCode163() {
         //7228
-        ASSERT_THROW_INTERNAL(checkCode("typedef s f[](){typedef d h(;f)}", false), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("typedef s f[](){typedef d h(;f)}\n", false), SYNTAX);
     }
 
     void garbageCode164() {
         //7234
-        ASSERT_THROW_INTERNAL(checkCode("class d{k p;}(){d::d():B<()}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("class d{k p;}(){d::d():B<()}\n"), SYNTAX);
     }
 
     void garbageCode165() {
         //7235
-        ASSERT_THROW_INTERNAL(checkCode("for(;..)", false),SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("for(;..)\n", false),SYNTAX);
     }
 
     void garbageCode167() {
         //7237
-        ASSERT_THROW_INTERNAL(checkCode("class D00i000{:D00i000::}i"),SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("class D00i000{:D00i000::}i\n"),SYNTAX);
     }
 
     void garbageCode168() {
         // #7246 (segmentation fault)
-        (void)checkCode("long foo(void) { return *bar; }", false);
+        (void)checkCode("long foo(void) { return *bar; }\n", false);
         ignore_errout(); // we do not care about the output
     }
 
     void garbageCode169() {
         // 6713
         ASSERT_THROW_INTERNAL(checkCode("( ) { ( ) ; { return } switch ( ) i\n"
-                                        "set case break ; default: ( ) }", false), SYNTAX);
+                                        "set case break ; default: ( ) }\n", false), SYNTAX);
     }
 
     void garbageCode170() {
         // 7255
-        ASSERT_THROW_INTERNAL(checkCode("d i(){{f*s=typeid(()0,)}}", false), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("d i(){{f*s=typeid(()0,)}}\n", false), SYNTAX);
     }
 
     void garbageCode171() {
         // 7270
-        ASSERT_THROW_INTERNAL(checkCode("(){case()?():}:", false), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("(){case()?():}:\n", false), SYNTAX);
     }
 
     void garbageCode172() {
         // #7357
-        ASSERT_THROW_INTERNAL(checkCode("p<e T=l[<]<>>,"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("p<e T=l[<]<>>,\n"), SYNTAX);
     }
 
     void garbageCode173() {
         // #6781  heap corruption ;  TemplateSimplifier::simplifyTemplateInstantiations
-        ASSERT_THROW_INTERNAL(checkCode(" template < Types > struct S : >( S < ...Types... > S <) > { ( ) { } } ( ) { return S < void > ( ) }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode(" template < Types > struct S : >( S < ...Types... > S <) > { ( ) { } } ( ) { return S < void > ( ) }\n"), SYNTAX);
     }
 
     void garbageCode174() { // #7356
-        ASSERT_THROW_INTERNAL(checkCode("{r e() { w*constD = (())D = cast< }}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{r e() { w*constD = (())D = cast< }}\n"), SYNTAX);
     }
 
     void garbageCode175() { // #7027
@@ -1494,32 +1494,32 @@ class TestGarbage : public TestFixture {
                                         "  for ( i = t3 , i < t1 ; i++ )\n"
                                         "    for ( j = 0 ; j < = j++ )\n"
                                         "        return t1 ,\n"
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
     }
 
     void garbageCode176() { // #7257 (segmentation fault)
-        (void)checkCode("class t { { struct } enum class f : unsigned { q } b ; operator= ( T ) { switch ( b ) { case f::q: } } { assert ( b ) ; } } { ; & ( t ) ( f::t ) ; } ;");
+        (void)checkCode("class t { { struct } enum class f : unsigned { q } b ; operator= ( T ) { switch ( b ) { case f::q: } } { assert ( b ) ; } } { ; & ( t ) ( f::t ) ; } ;\n");
         ignore_errout(); // we are not interested in the output
     }
 
     void garbageCode181() {
-        ASSERT_THROW_INTERNAL(checkCode("int test() { int +; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("int test() { int +; }\n"), SYNTAX);
     }
 
     // #4195 - segfault for "enum { int f ( ) { return = } r = f ( ) ; }"
     void garbageCode182() {
-        ASSERT_THROW_INTERNAL(checkCode("enum { int f ( ) { return = } r = f ( ) ; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("enum { int f ( ) { return = } r = f ( ) ; }\n"), SYNTAX);
     }
     // #7505 - segfault
     void garbageCode183() {
-        ASSERT_THROW_INTERNAL(checkCode("= { int } enum return { r = f() f(); }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("= { int } enum return { r = f() f(); }\n"), SYNTAX);
     }
 
     void garbageCode184() { // #7699
         ASSERT_THROW_INTERNAL(checkCode("unsigned int AquaSalSystem::GetDisplayScreenCount() {\n"
                                         "    NSArray* pScreens = [NSScreen screens];\n"
                                         "    return pScreens ? [pScreens count] : 1;\n"
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
     }
 
     void garbageCode185() { // #6011 crash in libreoffice failure to create proper AST
@@ -1531,29 +1531,29 @@ class TestGarbage : public TestFixture {
             "               pOut->CreateObject( nIndex, GDI_BRUSH, new WinMtfFillStyle( ReadColor(), ( nStyle == BS_HOLLOW ) ? TRUE : FALSE ) );\n"
             "               return bStatus;\n"
             "       };\n"
-            "}");
+            "}\n");
         ignore_errout(); // we are not interested in the output
     }
 
     // #8151 - segfault due to incorrect template syntax
     void garbageCode186() {
-        ASSERT_THROW_INTERNAL(checkCode("A<B<><>C"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("A<B<><>C\n"), SYNTAX);
     }
 
     void garbageCode187() { // # 8152 - segfault in handling
         const char inp[] = "0|\0|0>;\n";
         ASSERT_THROW_INTERNAL(checkCode(inp), SYNTAX);
 
-        (void)checkCode("template<class T> struct S : A< B<T> || C<T> > {};"); // No syntax error: #8390
-        (void)checkCode("static_assert(A<x> || B<x>, ab);");
+        (void)checkCode("template<class T> struct S : A< B<T> || C<T> > {};\n"); // No syntax error: #8390
+        (void)checkCode("static_assert(A<x> || B<x>, ab);\n");
     }
 
     void garbageCode188() { // #8255
-        ASSERT_THROW_INTERNAL(checkCode("{z r(){(){for(;<(x);){if(0==0)}}}}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{z r(){(){for(;<(x);){if(0==0)}}}}\n"), SYNTAX);
     }
 
     void garbageCode189() { // #8317 (segmentation fault)
-        (void)checkCode("t&n(){()()[](){()}}$");
+        (void)checkCode("t&n(){()()[](){()}}$\n");
     }
 
     void garbageCode190() { // #8307
@@ -1561,31 +1561,31 @@ class TestGarbage : public TestFixture {
                                         "    int i;\n"
                                         "    i *= 0;\n"
                                         "    !i <;\n"
-                                        "}"),
+                                        "}\n"),
                               AST);
     }
 
     void garbageCode191() { // #8333
-        ASSERT_THROW_INTERNAL(checkCode("struct A { int f(const); };"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("struct A { int f(int, const, char); };"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("struct A { int f(struct); };"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("struct A { int f(const); };\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("struct A { int f(int, const, char); };\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("struct A { int f(struct); };\n"), SYNTAX);
 
         // The following code is valid and should not trigger any error
-        ASSERT_NO_THROW(checkCode("struct A { int f ( char ) ; } ;"));
+        ASSERT_NO_THROW(checkCode("struct A { int f ( char ) ; } ;\n"));
     }
 
     void garbageCode192() { // #8386 (segmentation fault)
-        ASSERT_THROW_INTERNAL(checkCode("{(()[((0||0xf||))]0[])}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{(()[((0||0xf||))]0[])}\n"), SYNTAX);
     }
 
     // #8740
     void garbageCode193() {
-        ASSERT_THROW_INTERNAL(checkCode("d f(){!=[]&&0()!=0}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("d f(){!=[]&&0()!=0}\n"), SYNTAX);
     }
 
     // #8384
     void garbageCode194() {
-        ASSERT_THROW_INTERNAL(checkCode("{((()))(return 1||);}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{((()))(return 1||);}\n"), SYNTAX);
     }
 
     // #8709 - no garbage but to avoid stability regression (segmentation fault)
@@ -1595,19 +1595,19 @@ class TestGarbage : public TestFixture {
                         "  switch (d) { case b:; }\n"
                         "  double e(b);\n"
                         "  if(e <= 0) {}\n"
-                        "}");
+                        "}\n");
         ignore_errout(); // we do not care about the output
     }
 
     // #8265
     void garbageCode196() {
-        ASSERT_THROW_INTERNAL(checkCode("0|,0<<V"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode(";|4|<0;"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("0|,0<<V\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode(";|4|<0;\n"), SYNTAX);
     }
 
     // #8385
     void garbageCode197() {
-        ASSERT_THROW_INTERNAL(checkCode("(){e break,{(case)|{e:[()]}}}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("(){e break,{(case)|{e:[()]}}}\n"), SYNTAX);
     }
 
     // #8383
@@ -1617,38 +1617,38 @@ class TestGarbage : public TestFixture {
                                         "ame5 ( name5 struct ( name5 name5 < ) ) ( default ) { name4 != name5 name5 name5\n"
                                         " ( name5 name5 name5 ( { 1 >= void { ( ()) } 1 name3 return >= >= ( ) >= name5 (\n"
                                         " name5 name6 :nam00 [ ()])}))})})})};\n"
-                                        "}"), SYNTAX);
+                                        "}\n"), SYNTAX);
     }
 
     // #8752 (segmentation fault)
     void garbageCode199() {
-        ASSERT_THROW_INTERNAL(checkCode("d f(){e n00e0[]n00e0&" "0+f=0}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("d f(){e n00e0[]n00e0&" "0+f=0}\n"), SYNTAX);
     }
 
     // #8757
     void garbageCode200() {
-        ASSERT_THROW_INTERNAL(checkCode("(){e break,{(case)!{e:[]}}}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("(){e break,{(case)!{e:[]}}}\n"), SYNTAX);
     }
 
     // #8873
     void garbageCode201() {
-        ASSERT_THROW_INTERNAL(checkCode("void f() { std::string s=\"abc\"; return s + }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { std::string s=\"abc\"; return s + }\n"), SYNTAX);
     }
 
     // #8907
     void garbageCode202() {
-        ASSERT_THROW_INTERNAL(checkCode("void f() { UNKNOWN_MACRO(return); }"), UNKNOWN_MACRO);
-        ASSERT_THROW_INTERNAL(checkCode("void f() { UNKNOWN_MACRO(throw); }"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { UNKNOWN_MACRO(return); }\n"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { UNKNOWN_MACRO(throw); }\n"), UNKNOWN_MACRO);
         ignore_errout();
     }
 
     void garbageCode203() { // #8972 (segmentation fault)
-        ASSERT_THROW_INTERNAL(checkCode("{ > () {} }"), SYNTAX);
-        (void)checkCode("template <> a > ::b();");
+        ASSERT_THROW_INTERNAL(checkCode("{ > () {} }\n"), SYNTAX);
+        (void)checkCode("template <> a > ::b();\n");
     }
 
     void garbageCode204() {
-        ASSERT_THROW_INTERNAL(checkCode("template <a, = b<>()> c; template <a> a as() {} as<c<>>();"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("template <a, = b<>()> c; template <a> a as() {} as<c<>>();\n"), SYNTAX);
     }
 
     void garbageCode205() {
@@ -1667,55 +1667,55 @@ class TestGarbage : public TestFixture {
                                         "CodeSnippetsEvent :: CodeSnippetsEvent ( const CodeSnippetsEvent & Event )\n"
                                         ": wxCommandEvent ( Event )\n"
                                         ", m_SnippetID ( 0 ) {\n"
-                                        "}"),
+                                        "}\n"),
                               INTERNAL);
     }
 
     void garbageCode206() {
-        ASSERT_EQUALS("[test.cpp:1] syntax error: operator", getSyntaxError("void foo() { for (auto operator new : int); }"));
-        ASSERT_EQUALS("[test.cpp:1] syntax error", getSyntaxError("void foo() { for (a operator== :) }"));
+        ASSERT_EQUALS("[test.cpp:1] syntax error: operator", getSyntaxError("void foo() { for (auto operator new : int); }\n"));
+        ASSERT_EQUALS("[test.cpp:1] syntax error", getSyntaxError("void foo() { for (a operator== :) }\n"));
     }
 
     void garbageCode207() { // #8750
-        ASSERT_THROW_INTERNAL(checkCode("d f(){(.n00e0(return%n00e0''('')));}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("d f(){(.n00e0(return%n00e0''('')));}\n"), SYNTAX);
     }
 
     void garbageCode208() { // #8753
-        ASSERT_THROW_INTERNAL(checkCode("d f(){(for(((((0{t b;((((((((()))))))))}))))))}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("d f(){(for(((((0{t b;((((((((()))))))))}))))))}\n"), SYNTAX);
     }
 
     void garbageCode209() { // #8756
-        ASSERT_THROW_INTERNAL(checkCode("{(- -##0xf/-1 0)[]}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{(- -##0xf/-1 0)[]}\n"), SYNTAX);
     }
 
     void garbageCode210() { // #8762
-        ASSERT_THROW_INTERNAL(checkCode("{typedef typedef c n00e0[]c000(;n00e0&c000)}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{typedef typedef c n00e0[]c000(;n00e0&c000)}\n"), SYNTAX);
     }
 
     void garbageCode211() { // #8764
-        ASSERT_THROW_INTERNAL(checkCode("{typedef f typedef[]({typedef e e,>;typedef(((typedef<typedef|)))})}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{typedef f typedef[]({typedef e e,>;typedef(((typedef<typedef|)))})}\n"), SYNTAX);
     }
 
     void garbageCode212() { // #8765
-        ASSERT_THROW_INTERNAL(checkCode("{(){}[]typedef r n00e0[](((n00e0 0((;()))))){(0 typedef n00e0 bre00 n00e0())}[]();typedef n n00e0()[],(bre00)}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{(){}[]typedef r n00e0[](((n00e0 0((;()))))){(0 typedef n00e0 bre00 n00e0())}[]();typedef n n00e0()[],(bre00)}\n"), SYNTAX);
     }
 
     void garbageCode213() { // #8758
-        ASSERT_THROW_INTERNAL(checkCode("{\"\"[(1||)];}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{\"\"[(1||)];}\n"), SYNTAX);
     }
 
     void garbageCode214() { // segmentation fault
-        (void)checkCode("THIS FILE CONTAINS VARIOUS TEXT");
+        (void)checkCode("THIS FILE CONTAINS VARIOUS TEXT\n");
     }
 
     void garbageCode215() { // daca@home script with extension .c
-        ASSERT_THROW_INTERNAL(checkCode("a = [1,2,3];"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("a = [1,2,3];\n"), SYNTAX);
     }
 
     void garbageCode216() { // #7884 (out-of-memory)
         (void)checkCode("template<typename> struct A {};\n"
                         "template<typename...T> struct A<T::T...> {}; \n"
-                        "A<int> a;");
+                        "A<int> a;\n");
     }
 
     void garbageCode217() { // #10011
@@ -1723,11 +1723,11 @@ class TestGarbage : public TestFixture {
                                         "    auto p;\n"
                                         "    if (g(p)) {}\n"
                                         "    assert();\n"
-                                        "}"), AST);
+                                        "}\n"), AST);
     }
 
     void garbageCode218() { // #8763
-        ASSERT_THROW_INTERNAL(checkCode("d f(){t n0000 const[]n0000+0!=n0000,(0)}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("d f(){t n0000 const[]n0000+0!=n0000,(0)}\n"), SYNTAX);
     }
     void garbageCode219() { // #10101
         (void)checkCode("typedef void (*func) (addr) ;\n"
@@ -1747,111 +1747,111 @@ class TestGarbage : public TestFixture {
         ASSERT_THROW_INTERNAL(checkCode("template<template<class>\n"), SYNTAX);  // don't crash
     }
     void garbageCode223() { // #11639
-        ASSERT_THROW_INTERNAL(checkCode("struct{}*"), SYNTAX);  // don't crash
+        ASSERT_THROW_INTERNAL(checkCode("struct{}*\n"), SYNTAX);  // don't crash
     }
     void garbageCode224() {
-        ASSERT_THROW_INTERNAL(checkCode("void f(){ auto* b = dynamic_cast<const }"), SYNTAX);  // don't crash
+        ASSERT_THROW_INTERNAL(checkCode("void f(){ auto* b = dynamic_cast<const }\n"), SYNTAX);  // don't crash
         ASSERT_EQUALS("", errout_str());
-        ASSERT_THROW_INTERNAL(checkCode("void f(){ auto* b = dynamic_cast x; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f(){ auto* b = dynamic_cast x; }\n"), SYNTAX);
         ignore_errout();
     }
     void garbageCode225() {
-        ASSERT_THROW_INTERNAL(checkCode("int n() { c * s0, 0 s0 = c(sizeof = ) }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("int n() { c * s0, 0 s0 = c(sizeof |= ) }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("int n() { c * s0, 0 s0 = c(sizeof = ) }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("int n() { c * s0, 0 s0 = c(sizeof |= ) }\n"), SYNTAX);
     }
     void garbageCode226() {
-        ASSERT_THROW_INTERNAL(checkCode("int a() { (b((c)`)) } {}"), SYNTAX); // #11638
-        ASSERT_THROW_INTERNAL(checkCode("int a() { (b((c)\\)) } {}"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("int a() { (b((c)@)) } {}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("int a() { (b((c)`)) } {}\n"), SYNTAX); // #11638
+        ASSERT_THROW_INTERNAL(checkCode("int a() { (b((c)\\)) } {}\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("int a() { (b((c)@)) } {}\n"), SYNTAX);
     }
     void garbageCode227() { // #12615
-        ASSERT_NO_THROW(checkCode("f(&S::operator=);"));
+        ASSERT_NO_THROW(checkCode("f(&S::operator=);\n"));
     }
     void garbageCode228() {
-        ASSERT_NO_THROW(checkCode("void f() { enum { A = [=]() mutable { return 0; }() }; }"));
-        ASSERT_NO_THROW(checkCode("enum { A = [=](void) mutable -> int { return 0; }() };"));
+        ASSERT_NO_THROW(checkCode("void f() { enum { A = [=]() mutable { return 0; }() }; }\n"));
+        ASSERT_NO_THROW(checkCode("enum { A = [=](void) mutable -> int { return 0; }() };\n"));
     }
     void garbageCode229() { // #14126
-        ASSERT_THROW_INTERNAL(checkCode("void f() {} [[maybe_unused]]"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("void f() {} [[unused]]"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {} [[maybe_unused]]\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {} [[unused]]\n"), SYNTAX);
     }
     void garbageCode230() { // #14432
-        ASSERT_THROW_INTERNAL(checkCode("e U U,i"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("e U U,i\n"), SYNTAX);
     }
     void garbageCode231() {
-        ASSERT_THROW_INTERNAL(checkCode("char char* [] = {\"a\" \"b\"}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("char char* [] = {\"a\" \"b\"}\n"), SYNTAX);
     }
 
 
     void syntaxErrorFirstToken() {
-        ASSERT_THROW_INTERNAL(checkCode("&operator(){[]};"), SYNTAX); // #7818
-        ASSERT_THROW_INTERNAL(checkCode("*(*const<> (size_t); foo) { } *(*const (size_t)() ; foo) { }"), SYNTAX); // #6858
-        ASSERT_THROW_INTERNAL(checkCode(">{ x while (y) z int = }"), SYNTAX); // #4175
-        ASSERT_THROW_INTERNAL(checkCode("&p(!{}e x){({(0?:?){({})}()})}"), SYNTAX); // #7118
-        ASSERT_THROW_INTERNAL(checkCode("<class T> { struct { typename D4:typename Base<T*> }; };"), SYNTAX); // #3533
+        ASSERT_THROW_INTERNAL(checkCode("&operator(){[]};\n"), SYNTAX); // #7818
+        ASSERT_THROW_INTERNAL(checkCode("*(*const<> (size_t); foo) { } *(*const (size_t)() ; foo) { }\n"), SYNTAX); // #6858
+        ASSERT_THROW_INTERNAL(checkCode(">{ x while (y) z int = }\n"), SYNTAX); // #4175
+        ASSERT_THROW_INTERNAL(checkCode("&p(!{}e x){({(0?:?){({})}()})}\n"), SYNTAX); // #7118
+        ASSERT_THROW_INTERNAL(checkCode("<class T> { struct { typename D4:typename Base<T*> }; };\n"), SYNTAX); // #3533
         ASSERT_THROW_INTERNAL(checkCode(" > template < . > struct Y < T > { = } ;\n"), SYNTAX); // #6108
     }
 
     void syntaxErrorLastToken() {
-        ASSERT_THROW_INTERNAL(checkCode("int *"), SYNTAX); // #7821
-        ASSERT_THROW_INTERNAL(checkCode("x[y]"), SYNTAX); // #2986
-        ASSERT_THROW_INTERNAL(checkCode("( ) &"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("|| #if #define <="), SYNTAX); // #2601
-        ASSERT_THROW_INTERNAL(checkCode("f::y:y : <x::"), SYNTAX); // #6613
-        ASSERT_THROW_INTERNAL(checkCode("a \"b\" not_eq \"c\""), SYNTAX); // #6720
-        ASSERT_THROW_INTERNAL(checkCode("(int arg2) { } { } typedef void (func_type) (int, int); typedef func_type&"), SYNTAX); // #6738
-        ASSERT_THROW_INTERNAL(checkCode("&g[0]; { (g[0] 0) } =", false), SYNTAX); // #6744
-        ASSERT_THROW_INTERNAL(checkCode("{ { void foo() { struct }; { }; } }; struct S { } f =", false), SYNTAX); // #6753
-        ASSERT_THROW_INTERNAL(checkCode("{ { ( ) } P ( ) ^ { } { } { } ( ) } 0"), SYNTAX); // #6772
-        ASSERT_THROW_INTERNAL(checkCode("+---+"), SYNTAX); // #6948
+        ASSERT_THROW_INTERNAL(checkCode("int *\n"), SYNTAX); // #7821
+        ASSERT_THROW_INTERNAL(checkCode("x[y]\n"), SYNTAX); // #2986
+        ASSERT_THROW_INTERNAL(checkCode("( ) &\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("|| #if #define <=\n"), SYNTAX); // #2601
+        ASSERT_THROW_INTERNAL(checkCode("f::y:y : <x::\n"), SYNTAX); // #6613
+        ASSERT_THROW_INTERNAL(checkCode("a \"b\" not_eq \"c\"\n"), SYNTAX); // #6720
+        ASSERT_THROW_INTERNAL(checkCode("(int arg2) { } { } typedef void (func_type) (int, int); typedef func_type&\n"), SYNTAX); // #6738
+        ASSERT_THROW_INTERNAL(checkCode("&g[0]; { (g[0] 0) } =\n", false), SYNTAX); // #6744
+        ASSERT_THROW_INTERNAL(checkCode("{ { void foo() { struct }; { }; } }; struct S { } f =\n", false), SYNTAX); // #6753
+        ASSERT_THROW_INTERNAL(checkCode("{ { ( ) } P ( ) ^ { } { } { } ( ) } 0\n"), SYNTAX); // #6772
+        ASSERT_THROW_INTERNAL(checkCode("+---+\n"), SYNTAX); // #6948
         ASSERT_THROW_INTERNAL(checkCode("template<>\n"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("++4++ +  + E++++++++++ + ch " "tp.oed5[.]"), SYNTAX); // #7074
-        ASSERT_THROW_INTERNAL(checkCode("d a(){f s=0()8[]s?():0}*()?:0", false), SYNTAX); // #7236
-        ASSERT_THROW_INTERNAL(checkCode("!2 : #h2 ?:", false), SYNTAX); // #7769
-        ASSERT_THROW_INTERNAL(checkCode("--"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("volatile true , test < test < #ifdef __ppc__ true ,"), SYNTAX); // #4169
+        ASSERT_THROW_INTERNAL(checkCode("++4++ +  + E++++++++++ + ch " "tp.oed5[.]\n"), SYNTAX); // #7074
+        ASSERT_THROW_INTERNAL(checkCode("d a(){f s=0()8[]s?():0}*()?:0\n", false), SYNTAX); // #7236
+        ASSERT_THROW_INTERNAL(checkCode("!2 : #h2 ?:\n", false), SYNTAX); // #7769
+        ASSERT_THROW_INTERNAL(checkCode("--\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("volatile true , test < test < #ifdef __ppc__ true ,\n"), SYNTAX); // #4169
         ASSERT_THROW_INTERNAL(checkCode("a,b--\n"), SYNTAX); // #2847
-        ASSERT_THROW_INTERNAL(checkCode("x a[0] ="), SYNTAX); // #2682
+        ASSERT_THROW_INTERNAL(checkCode("x a[0] =\n"), SYNTAX); // #2682
         ASSERT_THROW_INTERNAL(checkCode("auto_ptr<x>\n"), SYNTAX); // #2967
         ASSERT_THROW_INTERNAL(checkCode("char a[1]\n"), SYNTAX); // #2865
-        ASSERT_THROW_INTERNAL(checkCode("<><<"), SYNTAX); // #2612
-        ASSERT_THROW_INTERNAL(checkCode("z<y<x>"), SYNTAX); // #2831
-        ASSERT_THROW_INTERNAL(checkCode("><,f<i,"), SYNTAX); // #2835
-        ASSERT_THROW_INTERNAL(checkCode("0; (a) < (a)"), SYNTAX); // #2875
-        ASSERT_THROW_INTERNAL(checkCode(" ( * const ( size_t ) ; foo )"), SYNTAX); // #6135
-        ASSERT_THROW_INTERNAL(checkCode("({ (); strcat(strcat(() ()) ()) })"), SYNTAX); // #6686
-        ASSERT_THROW_INTERNAL(checkCode("%: return ; ()"), SYNTAX); // #3441
-        ASSERT_THROW_INTERNAL(checkCode("__attribute__((destructor)) void"), SYNTAX); // #7816
-        ASSERT_THROW_INTERNAL(checkCode("1 *p = const"), SYNTAX); // #3512
-        ASSERT_THROW_INTERNAL(checkCode("sizeof"), SYNTAX); // #2599
-        ASSERT_THROW_INTERNAL(checkCode(" enum struct"), SYNTAX); // #6718
-        ASSERT_THROW_INTERNAL(checkCode("{(){(())}}r&const"), SYNTAX); // #7321
-        ASSERT_THROW_INTERNAL(checkCode("int"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("<><<\n"), SYNTAX); // #2612
+        ASSERT_THROW_INTERNAL(checkCode("z<y<x>\n"), SYNTAX); // #2831
+        ASSERT_THROW_INTERNAL(checkCode("><,f<i,\n"), SYNTAX); // #2835
+        ASSERT_THROW_INTERNAL(checkCode("0; (a) < (a)\n"), SYNTAX); // #2875
+        ASSERT_THROW_INTERNAL(checkCode(" ( * const ( size_t ) ; foo )\n"), SYNTAX); // #6135
+        ASSERT_THROW_INTERNAL(checkCode("({ (); strcat(strcat(() ()) ()) })\n"), SYNTAX); // #6686
+        ASSERT_THROW_INTERNAL(checkCode("%: return ; ()\n"), SYNTAX); // #3441
+        ASSERT_THROW_INTERNAL(checkCode("__attribute__((destructor)) void\n"), SYNTAX); // #7816
+        ASSERT_THROW_INTERNAL(checkCode("1 *p = const\n"), SYNTAX); // #3512
+        ASSERT_THROW_INTERNAL(checkCode("sizeof\n"), SYNTAX); // #2599
+        ASSERT_THROW_INTERNAL(checkCode(" enum struct\n"), SYNTAX); // #6718
+        ASSERT_THROW_INTERNAL(checkCode("{(){(())}}r&const\n"), SYNTAX); // #7321
+        ASSERT_THROW_INTERNAL(checkCode("int\n"), SYNTAX);
         ASSERT_THROW_INTERNAL(checkCode("struct A :\n"), SYNTAX); // #2591
         ASSERT_THROW_INTERNAL(checkCode("{} const const\n"), SYNTAX); // #2637
-        ASSERT_THROW_INTERNAL(checkCode("re2c: error: line 14, column 4: can only difference char sets"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("re2c: error: line 14, column 4: can only difference char sets\n"), SYNTAX);
 
         // ASSERT_THROW(  , InternalError)
     }
 
     void syntaxErrorCase() {
         // case must be inside switch block
-        ASSERT_THROW_INTERNAL(checkCode("void f() { switch (a) {}; case 1: }"), SYNTAX); // #8184
-        ASSERT_THROW_INTERNAL(checkCode("struct V : { public case {} ; struct U : U  void { V *f (int x) (x) } }"), SYNTAX); // #5120
-        ASSERT_THROW_INTERNAL(checkCode("void f() { 0 0; }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("void f() { true 0; }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("void f() { 'a' 0; }"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("void f() { 1 \"\"; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { switch (a) {}; case 1: }\n"), SYNTAX); // #8184
+        ASSERT_THROW_INTERNAL(checkCode("struct V : { public case {} ; struct U : U  void { V *f (int x) (x) } }\n"), SYNTAX); // #5120
+        ASSERT_THROW_INTERNAL(checkCode("void f() { 0 0; }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { true 0; }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { 'a' 0; }\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { 1 \"\"; }\n"), SYNTAX);
     }
 
     void syntaxErrorFuzzerCliType1() {
-        ASSERT_THROW_INTERNAL(checkCode("void f(){x=0,return return''[]()}"), SYNTAX);
-        ASSERT_THROW_INTERNAL(checkCode("void f(){x='0'++'0'(return)[];}"), SYNTAX); // #9063
-        (void)checkCode("void f(){*(int *)42=0;}"); // no syntax error
+        ASSERT_THROW_INTERNAL(checkCode("void f(){x=0,return return''[]()}\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f(){x='0'++'0'(return)[];}\n"), SYNTAX); // #9063
+        (void)checkCode("void f(){*(int *)42=0;}\n"); // no syntax error
         ignore_errout(); // we are not interested in the output
-        ASSERT_THROW_INTERNAL(checkCode("void f() { x= 'x' > typedef name5 | ( , ;){ } (); }"), SYNTAX); // #9067
-        ASSERT_THROW_INTERNAL(checkCode("void f() { x= {}( ) ( 'x')[ ] (); }"), SYNTAX); // #9068
-        ASSERT_THROW_INTERNAL(checkCode("void f() { x= y{ } name5 y[ ] + y ^ name5 ^ name5 for ( ( y y y && y y y && name5 ++ int )); }"), SYNTAX); // #9069
+        ASSERT_THROW_INTERNAL(checkCode("void f() { x= 'x' > typedef name5 | ( , ;){ } (); }\n"), SYNTAX); // #9067
+        ASSERT_THROW_INTERNAL(checkCode("void f() { x= {}( ) ( 'x')[ ] (); }\n"), SYNTAX); // #9068
+        ASSERT_THROW_INTERNAL(checkCode("void f() { x= y{ } name5 y[ ] + y ^ name5 ^ name5 for ( ( y y y && y y y && name5 ++ int )); }\n"), SYNTAX); // #9069
     }
 
     void cliCode() {
@@ -1862,12 +1862,12 @@ class TestGarbage : public TestFixture {
                             "bool GetDeviceInformation(String ^ port, LibCECConfiguration ^configuration, uint32_t timeoutMs) {\n"
                             "bool bReturn(false);\n"
                             "}\n"
-                            "};"));
+                            "};\n"));
         ignore_errout(); // we are not interested in the output
     }
 
     void enumTrailingComma() {
-        ASSERT_THROW_INTERNAL(checkCode("enum ssl_shutdown_t {ssl_shutdown_none = 0,ssl_shutdown_close_notify = , } ;"), SYNTAX); // #8079
+        ASSERT_THROW_INTERNAL(checkCode("enum ssl_shutdown_t {ssl_shutdown_none = 0,ssl_shutdown_close_notify = , } ;\n"), SYNTAX); // #8079
     }
 
     void nonGarbageCode1() {
@@ -1880,25 +1880,25 @@ class TestGarbage : public TestFixture {
                                   "template< class T >\n"
                                   "template< class Predicate > int\n"
                                   "List<T>::DeleteIf( const Predicate &pred )\n"
-                                  "{}"));
+                                  "{}\n"));
         ignore_errout(); // we are not interested in the output
 
         // #8749
         ASSERT_NO_THROW(checkCode(
                             "struct A {\n"
                             "    void operator+=(A&) && = delete;\n"
-                            "};"));
+                            "};\n"));
 
         // #8788
         ASSERT_NO_THROW(checkCode(
                             "struct foo;\n"
                             "void f() {\n"
                             "    auto fn = []() -> foo* { return new foo(); };\n"
-                            "}"));
+                            "}\n"));
         ignore_errout(); // we do not care about the output
 
         // #13892
-        ASSERT_NO_THROW(checkCode("void foovm(int x[const *]);"));
+        ASSERT_NO_THROW(checkCode("void foovm(int x[const *]);\n"));
 
         // #14676
         ASSERT_NO_THROW(checkCode("int main() {\n"
diff --git a/test/testincompletestatement.cpp b/test/testincompletestatement.cpp
index 72a13ee6c42..8e523e3d06e 100644
--- a/test/testincompletestatement.cpp
+++ b/test/testincompletestatement.cpp
@@ -93,7 +93,7 @@ class TestIncompleteStatement : public TestFixture {
               "{\n"
               "    const char def[] =\n"
               "    \"abc\";\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -102,7 +102,7 @@ class TestIncompleteStatement : public TestFixture {
         check("void foo()\n"
               "{\n"
               "    \"abc\";\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Redundant code: Found a statement that begins with string constant. [constStatement]\n", errout_str());
     }
@@ -111,7 +111,7 @@ class TestIncompleteStatement : public TestFixture {
         check("void foo()\n"
               "{\n"
               "    const char *str[] = { \"abc\" };\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -125,7 +125,7 @@ class TestIncompleteStatement : public TestFixture {
               "\"more \"\n"
               "\"world\"\n"
               "};\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -134,7 +134,7 @@ class TestIncompleteStatement : public TestFixture {
         check("void foo()\n"
               "{\n"
               "    50;\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Redundant code: Found a statement that begins with numeric constant. [constStatement]\n", errout_str());
     }
@@ -145,7 +145,7 @@ class TestIncompleteStatement : public TestFixture {
               "  1 == (two + three);\n"
               "  2 != (two + three);\n"
               "  (one + two) != (two + three);\n"
-              "}");
+              "}\n");
     }
 
     void test7() { // #9335
@@ -160,7 +160,7 @@ class TestIncompleteStatement : public TestFixture {
               "  for (C c(S); ; ) {\n"
               "    (void)c;\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -174,7 +174,7 @@ class TestIncompleteStatement : public TestFixture {
               "    {\n"
               "        { 346.1,114.1 }, { 347.1,111.1 }\n"
               "    };\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -186,7 +186,7 @@ class TestIncompleteStatement : public TestFixture {
               "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { (void*)0; }");
+        check("void f() { (void*)0; }\n");
         ASSERT_EQUALS("[test.cpp:1:12]: (warning) Redundant code: Found unused cast in expression '(void*)0'. [constStatement]\n", errout_str());
 
         check("void f() {\n" // #13148
@@ -200,12 +200,12 @@ class TestIncompleteStatement : public TestFixture {
                       errout_str());
 
         check("#define X  0\n"
-              "void f() { X; }");
+              "void f() { X; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void intarray() {
-        check("int arr[] = { 100/2, 1*100 };");
+        check("int arr[] = { 100/2, 1*100 };\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -213,7 +213,7 @@ class TestIncompleteStatement : public TestFixture {
         check("struct st arr[] = {\n"
               "    { 100/2, 1*100 }\n"
               "    { 90, 70 }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -221,14 +221,14 @@ class TestIncompleteStatement : public TestFixture {
         check("struct st arr[] = {\n"
               "    { 100/2, 1*100 }\n"
               "    { 90, 70 }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void conditionalcall() {
         check("void f() {\n"
               "    0==x ? X() : Y();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -236,7 +236,7 @@ class TestIncompleteStatement : public TestFixture {
         // #2462 - C++11 struct initialization
         check("void f() {\n"
               "    ABC abc{1,2,3};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6260 - C++11 array initialization
@@ -244,30 +244,30 @@ class TestIncompleteStatement : public TestFixture {
               "    static const char* a[][2] {\n"
               "        {\"b\", \"\"},\n"
               "    };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #2482 - false positive for empty struct
-        check("struct A {};");
+        check("struct A {};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4387 - C++11 initializer list
-        check("A::A() : abc{0} {}");
+        check("A::A() : abc{0} {}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5042 - C++11 initializer list
-        check("A::A() : abc::def<int>{0} {}");
+        check("A::A() : abc::def<int>{0} {}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4503 - vector init
-        check("void f() { vector<int> v{1}; }");
+        check("void f() { vector<int> v{1}; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void returnstruct() {
         check("struct s foo() {\n"
               "    return (struct s){0,0};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4754
@@ -276,19 +276,19 @@ class TestIncompleteStatement : public TestFixture {
               "        {\"hi\", \"there\"},\n"
               "        {\"happy\", \"sad\"}\n"
               "    };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct s foo() {\n"
               "  return (struct s){0};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void cast() {
         check("void f() {\n"
               "    ((struct foo *)(0x1234))->xy = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(const std::exception& e) {\n" // #10918
@@ -307,14 +307,14 @@ class TestIncompleteStatement : public TestFixture {
         check("void f() {\n"
               "    int x = 1;\n"
               "    x++, x++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void cpp11init() {
         check("void f() {\n"
               "    int x{1};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int> f(int* p) {\n"
@@ -326,7 +326,7 @@ class TestIncompleteStatement : public TestFixture {
     void cpp11init2() {
         check("x<string> handlers{\n"
               "  { \"mode2\", []() { return 2; } },\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -334,33 +334,33 @@ class TestIncompleteStatement : public TestFixture {
         check("struct A { void operator()(int); };\n"
               "void f() {\n"
               "A{}(0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template<class> struct A { void operator()(int); };\n"
               "void f() {\n"
               "A<int>{}(0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void block() {
         check("void f() {\n"
               "    ({ do_something(); 0; });\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "out:\n"
               "    ({ do_something(); 0; });\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void mapindex() {
         check("void f() {\n"
               "  map[{\"1\",\"2\"}]=0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -368,7 +368,7 @@ class TestIncompleteStatement : public TestFixture {
         check("void foo(int,const char*,int);\n" // #8827
               "void f(int value) {\n"
               "    foo(42,\"test\",42),(value&42);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:22]: (warning) Found suspicious operator ',', result is not used. [constStatement]\n", errout_str());
 
         check("int f() {\n" // #11257
@@ -456,13 +456,13 @@ class TestIncompleteStatement : public TestFixture {
                       "[test.cpp:9:5]: (warning, inconclusive) Found suspicious operator '~', result is not used. [constStatement]\n",
                       errout_str());
 
-        check("void f1(int x) { x; }", dinit(CheckOptions, $.inconclusive = true));
+        check("void f1(int x) { x; }\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:1:18]: (warning) Unused variable value 'x' [constStatement]\n", errout_str());
 
-        check("void f() { if (Type t; g(t)) {} }"); // #9776
+        check("void f() { if (Type t; g(t)) {} }\n"); // #9776
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int x) { static_cast<unsigned>(x); }");
+        check("void f(int x) { static_cast<unsigned>(x); }\n");
         ASSERT_EQUALS("[test.cpp:1:38]: (warning) Redundant code: Found unused cast in expression 'static_cast<unsigned int>(x)'. [constStatement]\n", errout_str());
 
         check("void f(int x, int* p) {\n"
@@ -473,7 +473,7 @@ class TestIncompleteStatement : public TestFixture {
               "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { false; }"); // #10856
+        check("void f() { false; }\n"); // #10856
         ASSERT_EQUALS("[test.cpp:1:12]: (warning) Redundant code: Found a statement that begins with bool constant. [constStatement]\n", errout_str());
 
         check("void f(int i) {\n"
@@ -783,55 +783,55 @@ class TestIncompleteStatement : public TestFixture {
 
     void vardecl() {
         // #8984
-        check("void f() { a::b *c = d(); }", dinit(CheckOptions, $.inconclusive = true));
+        check("void f() { a::b *c = d(); }\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { std::vector<b> *c; }", dinit(CheckOptions, $.inconclusive = true));
+        check("void f() { std::vector<b> *c; }\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { a::b &c = d(); }", dinit(CheckOptions, $.inconclusive = true));
+        check("void f() { a::b &c = d(); }\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { std::vector<b> &c; }", dinit(CheckOptions, $.inconclusive = true));
+        check("void f() { std::vector<b> &c; }\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { a::b &&c = d(); }", dinit(CheckOptions, $.inconclusive = true));
+        check("void f() { a::b &&c = d(); }\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { std::vector<b> &&c; }", dinit(CheckOptions, $.inconclusive = true));
+        check("void f() { std::vector<b> &&c; }\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { char * const * a, * const * b; }", dinit(CheckOptions, $.inconclusive = true));
+        check("void f() { char * const * a, * const * b; }\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { char * const * a = 0, * volatile restrict * b; }", dinit(CheckOptions, $.inconclusive = true, $.cpp = false));
+        check("void f() { char * const * a = 0, * volatile restrict * b; }\n", dinit(CheckOptions, $.inconclusive = true, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { char * const * a = 0, * volatile const * b; }", dinit(CheckOptions, $.inconclusive = true));
+        check("void f() { char * const * a = 0, * volatile const * b; }\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
     void archive() {
         check("void f(Archive &ar) {\n"
               "  ar & x;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int ar) {\n"
               "  ar & x;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2:6]: (warning, inconclusive) Found suspicious operator '&', result is not used. [constStatement]\n", errout_str());
     }
 
     void ast() {
-        check("struct c { void a() const { for (int x=0; x;); } };", dinit(CheckOptions, $.inconclusive = true));
+        check("struct c { void a() const { for (int x=0; x;); } };\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
     void oror() {
         check("void foo() {\n"
               "    params_given (params, \"overrides\") || (overrides = \"1\");\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::ifstream& file) {\n" // #10930
diff --git a/test/testio.cpp b/test/testio.cpp
index 16d770bb0bd..ad95345e1fd 100644
--- a/test/testio.cpp
+++ b/test/testio.cpp
@@ -124,50 +124,50 @@ class TestIO : public TestFixture {
         check(
             "void foo() {\n"
             "  std::cout << std::cout;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: (error) Invalid usage of output stream: '<< std::cout'. [coutCerrMisusage]\n", errout_str());
 
         check(
             "void foo() {\n"
             "  std::cout << (std::cout);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: (error) Invalid usage of output stream: '<< std::cout'. [coutCerrMisusage]\n", errout_str());
 
         check(
             "void foo() {\n"
             "  std::cout << \"xyz\" << std::cout;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: (error) Invalid usage of output stream: '<< std::cout'. [coutCerrMisusage]\n", errout_str());
 
         check(
             "void foo(int i) {\n"
             "  std::cout << i << std::cerr;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: (error) Invalid usage of output stream: '<< std::cerr'. [coutCerrMisusage]\n", errout_str());
 
         check(
             "void foo() {\n"
             "  std::cout << \"xyz\";\n"
             "  std::cout << \"xyz\";\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo() {\n"
             "  std::cout << std::cout.good();\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo() {\n"
             "    unknownObject << std::cout;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo() {\n"
             "  MACRO(std::cout <<, << std::cout)\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -180,7 +180,7 @@ class TestIO : public TestFixture {
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
@@ -188,7 +188,7 @@ class TestIO : public TestFixture {
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
@@ -196,7 +196,7 @@ class TestIO : public TestFixture {
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
@@ -204,7 +204,7 @@ class TestIO : public TestFixture {
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
@@ -212,7 +212,7 @@ class TestIO : public TestFixture {
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
@@ -220,7 +220,7 @@ class TestIO : public TestFixture {
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
@@ -228,55 +228,55 @@ class TestIO : public TestFixture {
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = fopen(name, \"r+\");\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _wfopen(name, L\"r+\");\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfopen(name, _T(\"r+\"));\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfopen(name, _T(\"r+\"));\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    _wfopen_s(&f, name, L\"r+\");\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    _tfopen_s(&f, name, _T(\"r+\"));\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    _tfopen_s(&f, name, _T(\"r+\"));\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = tmpfile();\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("", errout_str());
 
         // Write mode
@@ -285,19 +285,19 @@ class TestIO : public TestFixture {
               "    fwrite(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fread(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (error) Read operation on a file that was opened only for writing. [readWriteOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = fopen(name, \"w+\");\n"
               "    fread(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = tmpfile();\n"
               "    fread(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Append mode
@@ -306,14 +306,14 @@ class TestIO : public TestFixture {
               "    fwrite(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fread(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) Repositioning operation performed on a file opened in append mode has no effect. [seekOnAppendedFile]\n"
                       "[test.cpp:5:5]: (error) Read operation on a file that was opened only for writing. [readWriteOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = fopen(name, \"a+\");\n"
               "    fread(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Variable declared locally
@@ -321,7 +321,7 @@ class TestIO : public TestFixture {
               "    FILE* f = fopen(name, \"r\");\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "    fclose(f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         // Call unknown function
@@ -330,60 +330,60 @@ class TestIO : public TestFixture {
               "    fwrite(buffer, 5, 6, f);\n"
               "    bar(f);\n"
               "    fread(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // freopen and tmpfile
         check("void foo(FILE*& f) {\n"
               "    f = freopen(name, \"r\", f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _wfreopen(name, L\"r\", f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfreopen(name, _T(\"r\"), f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfreopen(name, _T(\"r\"), f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _wfreopen_s(&f, name, L\"r\", f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfreopen_s(&f, name, _T(\"r\"), f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfreopen_s(&f, name, _T(\"r\"), f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         // Crash tests
         check("void foo(FILE*& f) {\n"
               "    f = fopen(name, mode);\n" // No assertion failure (#3830)
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void fopen(std::string const &filepath, std::string const &mode);"); // #3832
+        check("void fopen(std::string const &filepath, std::string const &mode);\n"); // #3832
     }
 
     void wrongMode_complex() {
@@ -392,7 +392,7 @@ class TestIO : public TestFixture {
               "    else  f = fopen(name, \"r\");\n"
               "    if(a) fwrite(buffer, 5, 6, f);\n"
               "    else  fread(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -401,14 +401,14 @@ class TestIO : public TestFixture {
               "    else  f = fopen(name, \"r\");\n"
               "    if(a) fwrite(buffer, 5, 6, f);\n"
               "    else  fread(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    FILE* f = fopen(name, \"w\");\n"
               "    if(a) fwrite(buffer, 5, 6, f);\n"
               "    else  fread(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (error) Read operation on a file that was opened only for writing. [readWriteOnlyFile]\n", errout_str());
     }
 
@@ -421,7 +421,7 @@ class TestIO : public TestFixture {
               "    ungetc('a', f);\n"
               "    ungetwc(L'a', f);\n"
               "    rewind(f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Used file that is not opened. [useClosedFile]\n"
                       "[test.cpp:4:5]: (error) Used file that is not opened. [useClosedFile]\n"
                       "[test.cpp:5:5]: (error) Used file that is not opened. [useClosedFile]\n"
@@ -435,40 +435,40 @@ class TestIO : public TestFixture {
               "        return;"
               "    }\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    fclose(f);\n"
               "    f = fopen(name, \"r\");\n"
               "    fread(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = fopen(name, \"r\");\n"
               "    f = g;\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    FILE* f;\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Used file that is not opened. [useClosedFile]\n", errout_str());
 
         check("void foo() {\n"
               "    FILE* f(stdout);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n" // #3965
               "    FILE* f[3];\n"
               "    f[0] = fopen(name, mode);\n"
               "    fclose(f[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4368: multiple functions
@@ -491,7 +491,7 @@ class TestIO : public TestFixture {
               "  dump();\n"
               "  close();\n"
               "  return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("static FILE *fp = NULL;\n"
@@ -505,7 +505,7 @@ class TestIO : public TestFixture {
               "{\n"
               "  fclose(fp);\n"
               "  fprintf(fp, \"Here's the output.\\n\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:11:3]: (error) Used file that is not opened. [useClosedFile]\n", errout_str());
 
         // #4466
@@ -518,7 +518,7 @@ class TestIO : public TestFixture {
               "            fclose(infile);\n"
               "            return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void chdcd_parse_nero(FILE *infile) {\n"
@@ -530,7 +530,7 @@ class TestIO : public TestFixture {
               "            fclose(infile);\n"
               "            return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4649
@@ -540,14 +540,14 @@ class TestIO : public TestFixture {
               "    a.f2 = fopen(name,mode);\n"
               "    fclose(a.f1);\n"
               "    fclose(a.f2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #1473
         check("void foo() {\n"
               "    FILE *a = fopen(\"aa\", \"r\");\n"
               "    while (fclose(a)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (warning) fclose() used as loop condition may skip loop body or double-close file handle. [fcloseInLoopCondition]\n", errout_str());
 
         check("void foo() {\n"
@@ -555,7 +555,7 @@ class TestIO : public TestFixture {
               "    while (fclose(a)) {\n"
               "         break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -563,13 +563,13 @@ class TestIO : public TestFixture {
               "    while (fclose(a)) {\n"
               "        a = fopen(\"aa\", \"r\");\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    FILE *a = fopen(\"aa\", \"r\");\n"
               "    do {} while (fclose(a));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:18]: (warning) fclose() used as loop condition may skip loop body or double-close file handle. [fcloseInLoopCondition]\n", errout_str());
 
         // #6823
@@ -579,7 +579,7 @@ class TestIO : public TestFixture {
               "    f[1] = fopen(\"2\", \"w\");\n"
               "    fclose(f[0]);\n"
               "    fclose(f[1]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #12236
@@ -595,13 +595,13 @@ class TestIO : public TestFixture {
         check("void foo(FILE* f) {\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "    fread(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());
 
         check("void foo(FILE* f) {\n"
               "    fread(buffer, 5, 6, f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());
 
         check("void foo(FILE* f, bool read) {\n"
@@ -609,42 +609,42 @@ class TestIO : public TestFixture {
               "        fread(buffer, 5, 6, f);\n"
               "    else\n"
               "        fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE* f) {\n"
               "    fread(buffer, 5, 6, f);\n"
               "    fflush(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE* f) {\n"
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE* f) {\n"
               "    fread(buffer, 5, 6, f);\n"
               "    fsetpos(f, pos);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE* f) {\n"
               "    fread(buffer, 5, 6, f);\n"
               "    fseek(f, 0, SEEK_SET);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE* f) {\n"
               "    fread(buffer, 5, 6, f);\n"
               "    long pos = ftell(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());
 
         // #6452 - member functions
@@ -657,7 +657,7 @@ class TestIO : public TestFixture {
               "    int bytesRead = fread(aboutToOverwrite.data(), 1, bufferLength, d->file);\n"
               "    seek(writePosition);\n"
               "    fwrite(buffer.data(), sizeof(char), buffer.size(), d->file);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class FileStream {\n"
@@ -668,7 +668,7 @@ class TestIO : public TestFixture {
               "    int bytesRead = fread(aboutToOverwrite.data(), 1, bufferLength, d->file);\n"
               "    unknown(writePosition);\n"
               "    fwrite(buffer.data(), sizeof(char), buffer.size(), d->file);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class FileStream {\n"
@@ -680,7 +680,7 @@ class TestIO : public TestFixture {
               "    int bytesRead = fread(aboutToOverwrite.data(), 1, bufferLength, d->file);\n"
               "    known(writePosition);\n"
               "    fwrite(buffer.data(), sizeof(char), buffer.size(), d->file);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());
 
         check("class FileStream {\n"
@@ -692,7 +692,7 @@ class TestIO : public TestFixture {
               "    int bytesRead = fread(X::data(), 1, bufferLength, d->file);\n"
               "    known(writePosition);\n"
               "    fwrite(X::data(), sizeof(char), buffer.size(), d->file);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());
 
         check("struct MemStream {\n"
@@ -717,25 +717,25 @@ class TestIO : public TestFixture {
         check("void foo() {\n"
               "    FILE* f = fopen(\"\", \"a+\");\n"
               "    fseek(f, 0, SEEK_SET);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    FILE* f = fopen(\"\", \"w\");\n"
               "    fseek(f, 0, SEEK_SET);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    FILE* f = fopen(\"\", \"a\");\n"
               "    fseek(f, 0, SEEK_SET);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Repositioning operation performed on a file opened in append mode has no effect. [seekOnAppendedFile]\n", errout_str());
 
         check("void foo() {\n"
               "    FILE* f = fopen(\"\", \"a\");\n"
               "    fflush(f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // #5578
 
         check("void foo() {\n"
@@ -743,7 +743,7 @@ class TestIO : public TestFixture {
               "    fclose(f);\n"
               "    f = fopen(\"\", \"r\");\n"
               "    fseek(f, 0, SEEK_SET);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // #6566
     }
 
@@ -767,30 +767,30 @@ class TestIO : public TestFixture {
         check("void foo()\n"
               "{\n"
               "    fflush(stdin);\n"
-              "}", dinit(CheckOptions, $.portability = true));
+              "}\n", dinit(CheckOptions, $.portability = true));
         ASSERT_EQUALS("[test.cpp:3:5]: (portability) fflush() called on input stream 'stdin' may result in undefined behaviour on non-linux systems. [fflushOnInputStream]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    fflush(stdout);\n"
-              "}", dinit(CheckOptions, $.portability = true));
+              "}\n", dinit(CheckOptions, $.portability = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = fopen(path, \"r\");\n"
               "    fflush(f);\n"
-              "}", dinit(CheckOptions, $.portability = true));
+              "}\n", dinit(CheckOptions, $.portability = true));
         ASSERT_EQUALS("[test.cpp:3:5]: (portability) fflush() called on input stream 'f' may result in undefined behaviour on non-linux systems. [fflushOnInputStream]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = fopen(path, \"w\");\n"
               "    fflush(f);\n"
-              "}", dinit(CheckOptions, $.portability = true));
+              "}\n", dinit(CheckOptions, $.portability = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    fflush(f);\n"
-              "}", dinit(CheckOptions, $.portability = true));
+              "}\n", dinit(CheckOptions, $.portability = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -798,7 +798,7 @@ class TestIO : public TestFixture {
         check("void foo() {\n"
               "    FILE *f1 = fopen(\"tmp\", \"wt\");\n"
               "    FILE *f2 = fopen(\"tmp\", \"rt\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (warning) The file '\"tmp\"' is opened for read and write access at the same time on different streams [incompatibleFileOpen]\n", errout_str());
     }
 
@@ -810,7 +810,7 @@ class TestIO : public TestFixture {
               "     fgets(line, sizeof(line), fp);\n"
               "     dostuff(line);\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Using feof() as a loop condition causes the last line to be processed twice. [wrongfeofUsage]\n", errout_str());
 
         check("int foo(FILE *fp) {\n"
@@ -819,7 +819,7 @@ class TestIO : public TestFixture {
               "  if (!feof(fp))\n"
               "    return 1;\n"
               "  return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE *fp){\n"
@@ -829,7 +829,7 @@ class TestIO : public TestFixture {
               "    dostuff(line);\n"
               "    fgets(line, sizeof(line), fp);"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE *fp) {\n"
@@ -838,7 +838,7 @@ class TestIO : public TestFixture {
               "    fgets(line, sizeof(line), fp);\n"
               "    dostuff(line);\n"
               "  } while (!feof(fp));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:12]: (warning) Using feof() as a loop condition causes the last line to be processed twice. [wrongfeofUsage]\n", errout_str());
 
         check("void foo(FILE *fp) {\n"
@@ -847,7 +847,7 @@ class TestIO : public TestFixture {
               "    dostuff(line);\n"
               "    fgets(line, sizeof(line), fp);\n"
               "  } while (!feof(fp));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -862,7 +862,7 @@ class TestIO : public TestFixture {
               "    sscanf(foo, \"%[^~]\", bar);\n"
               "    scanf(\"%dx%s\", &b, bar);\n"
               "    fclose(file);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (warning) fscanf() without field width limits can crash with huge input data. [invalidscanf]\n"
                       "[test.cpp:5:9]: (warning) scanf() without field width limits can crash with huge input data. [invalidscanf]\n"
                       "[test.cpp:6:9]: (warning) scanf() without field width limits can crash with huge input data. [invalidscanf]\n"
@@ -878,7 +878,7 @@ class TestIO : public TestFixture {
               "    scanf(\"aa%d\", &a);\n" // No %s
               "    scanf(\"aa%ld\", &a);\n" // No %s
               "    scanf(\"%*[^~]\");\n" // Ignore input
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) scanf format string requires 0 parameters but 1 is given. [wrongPrintfScanfArgNum]\n", errout_str());
     }
 
@@ -888,7 +888,7 @@ class TestIO : public TestFixture {
               "  scanf(\"%7c\", str);\n"
               "  scanf(\"%8c\", str);\n"
               "  scanf(\"%9c\", str);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:3]: (error) Width 9 given in format string (no. 1) is larger than destination buffer 'str[8]', use %8c to prevent overflowing it. [invalidScanfFormatWidth]\n", errout_str());
     }
 
@@ -897,7 +897,7 @@ class TestIO : public TestFixture {
               "{\n"
               "  char str [8];\n"
               "  scanf (\"%70s\",str);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:3]: (error) Width 70 given in format string (no. 1) is larger than destination buffer 'str[8]', use %7s to prevent overflowing it. [invalidScanfFormatWidth]\n", errout_str());
     }
 
@@ -905,7 +905,7 @@ class TestIO : public TestFixture {
         check("char s1[42], s2[42];\n"
               "void test() {\n"
               "    scanf(\"%42s%42[a-z]\", s1, s2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Width 42 given in format string (no. 1) is larger than destination buffer 's1[42]', use %41s to prevent overflowing it. [invalidScanfFormatWidth]\n"
                       "[test.cpp:3:5]: (error) Width 42 given in format string (no. 2) is larger than destination buffer 's2[42]', use %41[a-z] to prevent overflowing it. [invalidScanfFormatWidth]\n", errout_str());
     }
@@ -920,7 +920,7 @@ class TestIO : public TestFixture {
 
 
 #define TEST_SCANF_CODE(format, type) \
-    "void f(){" type " x; scanf(\"" format "\", &x);}"
+    "void f(){" type " x; scanf(\"" format "\", &x);}\n"
 
 #define TEST_SCANF_ERR(format, formatStr, type) \
     "[test.c:1]: (warning) " format " in format string (no. 1) requires '" formatStr " *' but the argument type is '" type " *'.\n"
@@ -935,7 +935,7 @@ class TestIO : public TestFixture {
     TEST_SCANF_ERR_AKA_("test.cpp", format, formatStr, type, akaType)
 
 #define TEST_PRINTF_CODE(format, type) \
-    "void f(" type " x){printf(\"" format "\", x);}"
+    "void f(" type " x){printf(\"" format "\", x);}\n"
 
 #define TEST_PRINTF_ERR(format, requiredType, actualType) \
     "[test.c:1]: (warning) " format " in format string (no. 1) requires '" requiredType "' but the argument type is '" actualType "'.\n"
@@ -1074,7 +1074,7 @@ class TestIO : public TestFixture {
               "    scanf(\"%*1x %1x %29s\", &count, KeyName);\n" // #3373
               "    fscanf(f, \"%7ms\", &ref);\n" // #3461
               "    sscanf(ip_port, \"%*[^:]:%4d\", &port);\n" // #3468
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -1082,7 +1082,7 @@ class TestIO : public TestFixture {
               "    scanf(\"%1d\", &foo, &bar);\n"
               "    fscanf(bar, \"%1d\", &foo, &bar);\n"
               "    scanf(\"%*1x %1x %29s\", &count, KeyName, foo);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) scanf format string requires 0 parameters but 1 is given.\n"
                       "[test.cpp:3]: (warning) scanf format string requires 1 parameter but 2 are given.\n"
                       "[test.cpp:4]: (warning) fscanf format string requires 1 parameter but 2 are given.\n"
@@ -1093,7 +1093,7 @@ class TestIO : public TestFixture {
               "    scanf(\"%1u%1u\", bar());\n"
               "    sscanf(bar, \"%1d%1d\", &foo);\n"
               "    scanf(\"%*1x %1x %29s\", &count);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (error) scanf format string requires 1 parameter but only 0 are given.\n"
                       "[test.cpp:3]: (error) scanf format string requires 2 parameters but only 1 is given.\n"
                       "[test.cpp:4]: (error) sscanf format string requires 2 parameters but only 1 is given.\n"
@@ -1105,7 +1105,7 @@ class TestIO : public TestFixture {
               "    sscanf(input, \"%3s\", output);\n"
               "    sscanf(input, \"%4s\", output);\n"
               "    sscanf(input, \"%5s\", output);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6]: (error) Width 5 given in format string (no. 1) is larger than destination buffer 'output[5]', use %4s to prevent overflowing it.\n", errout_str());
 
         check("void foo() {\n"
@@ -1115,7 +1115,7 @@ class TestIO : public TestFixture {
               "    sscanf(input, \"%3s\", output);\n"
               "    sscanf(input, \"%4s\", output);\n"
               "    sscanf(input, \"%5s\", output);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:5]: (warning, inconclusive) Width 3 given in format string (no. 1) is smaller than destination buffer 'output[5]'.\n"
                       "[test.cpp:7]: (error) Width 5 given in format string (no. 1) is larger than destination buffer 'output[5]', use %4s to prevent overflowing it.\n"
                       "[test.cpp:4]: (warning) sscanf() without field width limits can crash with huge input data.\n", errout_str());
@@ -1127,7 +1127,7 @@ class TestIO : public TestFixture {
               "    bufT projectId= {0};\n"
               "    const int scanrc=sscanf(line, \"Project(\\\"{%36s}\\\")\", projectId);\n"
               "    sscanf(input, \"%5s\", output);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:6]: (warning, inconclusive) Width 36 given in format string (no. 1) is smaller than destination buffer 'projectId[2048]'.\n", errout_str());
 
         check("void foo(unsigned int i) {\n"
@@ -1140,7 +1140,7 @@ class TestIO : public TestFixture {
               "  scanf(\"%t\", &i);\n"
               "  scanf(\"%L\", &i);\n"
               "  scanf(\"%I\", &i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) 'h' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
                       "[test.cpp:3]: (warning) 'hh' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
                       "[test.cpp:4]: (warning) 'l' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
@@ -1196,13 +1196,13 @@ class TestIO : public TestFixture {
         check("void foo() {\n"
               "    scanf(\"%u\", \"s3\");\n"
               "    scanf(\"%u\", L\"s5W\");\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %u in format string (no. 1) requires 'unsigned int *' but the argument type is 'const char *'.\n"
                       "[test.cpp:3]: (warning) %u in format string (no. 1) requires 'unsigned int *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("void foo(long l) {\n"
               "    scanf(\"%u\", l);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %u in format string (no. 1) requires 'unsigned int *' but the argument type is 'signed long'.\n", errout_str());
 
         TEST_SCANF_WARN("%lu","unsigned long","bool");
@@ -1584,13 +1584,13 @@ class TestIO : public TestFixture {
         check("void foo() {\n"
               "    scanf(\"%Ld\", \"s3\");\n"
               "    scanf(\"%Ld\", L\"s5W\");\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %Ld in format string (no. 1) requires 'long long *' but the argument type is 'const char *'.\n"
                       "[test.cpp:3]: (warning) %Ld in format string (no. 1) requires 'long long *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("void foo(int i) {\n"
               "    scanf(\"%Ld\", i);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %Ld in format string (no. 1) requires 'long long *' but the argument type is 'signed int'.\n", errout_str());
 
         TEST_SCANF_WARN("%ju", "uintmax_t", "bool");
@@ -2061,13 +2061,13 @@ class TestIO : public TestFixture {
         check("void foo() {\n"
               "    scanf(\"%d\", \"s3\");\n"
               "    scanf(\"%d\", L\"s5W\");\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 1) requires 'int *' but the argument type is 'const char *'.\n"
                       "[test.cpp:3]: (warning) %d in format string (no. 1) requires 'int *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("void foo(long l) {\n"
               "    scanf(\"%d\", l);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 1) requires 'int *' but the argument type is 'signed long'.\n", errout_str());
 
         TEST_SCANF_WARN("%x", "unsigned int", "bool");
@@ -2105,13 +2105,13 @@ class TestIO : public TestFixture {
         check("void foo() {\n"
               "    scanf(\"%x\", \"s3\");\n"
               "    scanf(\"%x\", L\"s5W\");\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %x in format string (no. 1) requires 'unsigned int *' but the argument type is 'const char *'.\n"
                       "[test.cpp:3]: (warning) %x in format string (no. 1) requires 'unsigned int *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("void foo(long l) {\n"
               "    scanf(\"%x\", l);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %x in format string (no. 1) requires 'unsigned int *' but the argument type is 'signed long'.\n", errout_str());
 
         TEST_SCANF_WARN("%f", "float", "bool");
@@ -2145,13 +2145,13 @@ class TestIO : public TestFixture {
         check("void foo() {\n"
               "    scanf(\"%f\", \"s3\");\n"
               "    scanf(\"%f\", L\"s5W\");\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %f in format string (no. 1) requires 'float *' but the argument type is 'const char *'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 1) requires 'float *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("void foo(float f) {\n"
               "    scanf(\"%f\", f);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %f in format string (no. 1) requires 'float *' but the argument type is 'float'.\n", errout_str());
 
         TEST_SCANF_WARN("%lf", "double", "bool");
@@ -2241,13 +2241,13 @@ class TestIO : public TestFixture {
         check("void foo() {\n"
               "    scanf(\"%n\", \"s3\");\n"
               "    scanf(\"%n\", L\"s5W\");\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'const char *'.\n"
                       "[test.cpp:3]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("void foo(long l) {\n"
               "    scanf(\"%n\", l);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'signed long'.\n", errout_str());
 
         check("void g() {\n" // #5104
@@ -2261,7 +2261,7 @@ class TestIO : public TestFixture {
               "    scanf(\"%lf\",&v4[0]);\n"
               "    myvector<char *> v5(1);\n"
               "    scanf(\"%10s\",v5[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         {
@@ -2293,7 +2293,7 @@ class TestIO : public TestFixture {
             check("void g() {\n"
                   "    const char c[]=\"42\";\n"
                   "    scanf(\"%s\", c);\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("[test.cpp:3]: (warning) %s in format string (no. 1) requires a 'char *' but the argument type is 'const char *'.\n"
                           "[test.cpp:3]: (warning) scanf() without field width limits can crash with huge input data.\n", errout_str());
         }
@@ -2303,7 +2303,7 @@ class TestIO : public TestFixture {
               "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %i in format string (no. 1) requires 'int *' but the argument type is 'const char *'.\n", errout_str());
 
-        check("struct S { unsigned char a[1]; };" // #14302
+        check("struct S { unsigned char a[1]; };\n" // #14302
               "void f(S s) {\n"
               "    scanf(\"%hhu\", s.a);\n"
               "}\n");
@@ -2321,7 +2321,7 @@ class TestIO : public TestFixture {
               "    snprintf(str,10,\"%u%s\");\n"
               "    sprintf(string1, \"%-*.*s\", 32, string2);\n" // #3364
               "    snprintf(a, 9, \"%s%d\", \"11223344\");\n" // #3655
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (error) printf format string requires 1 parameter but only 0 are given.\n"
                       "[test.cpp:3]: (error) printf format string requires 2 parameters but only 1 is given.\n"
                       "[test.cpp:4]: (error) printf format string requires 3 parameters but only 2 are given.\n"
@@ -2336,7 +2336,7 @@ class TestIO : public TestFixture {
               "    printf(\"\", 0);\n"
               "    printf(\"%i\", 123, bar());\n"
               "    printf(\"%i%s\", 0, bar(), 43123);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) printf format string requires 0 parameters but 1 is given.\n"
                       "[test.cpp:3]: (warning) printf format string requires 1 parameter but 2 are given.\n"
                       "[test.cpp:4]: (warning) printf format string requires 2 parameters but 3 are given.\n", errout_str());
@@ -2346,7 +2346,7 @@ class TestIO : public TestFixture {
               "    swprintf(string1, L\"%s%s\", L\"a\", string2);\n" // MSVC implementation
               "    swprintf(string1, 6, L\"%i\", 32, string2);\n" // Standard implementation
               "    swprintf(string1, 6, L\"%i%s\", 32, string2);\n" // Standard implementation
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) swprintf format string requires 1 parameter but 2 are given.\n"
                       "[test.cpp:4]: (warning) swprintf format string requires 1 parameter but 2 are given.\n", errout_str());
 
@@ -2363,7 +2363,7 @@ class TestIO : public TestFixture {
               "    printf(\"string: %.*s\", len, string);\n" // #3311
               "    fprintf(stderr, \"%*cText.\", indent, ' ');\n" // #3313
               "    sprintf(string1, \"%*\", 32);\n" // #3364
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* s, const char* s2, std::string s3, int i) {\n"
@@ -2373,7 +2373,7 @@ class TestIO : public TestFixture {
               "    printf(\"%s\", s3);\n"
               "    printf(\"%s\", \"s4\");\n"
               "    printf(\"%u\", s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %s in format string (no. 1) requires 'char *' but the argument type is 'signed int'.\n"
                       "[test.cpp:4]: (warning) %s in format string (no. 2) requires 'char *' but the argument type is 'signed int'.\n"
                       "[test.cpp:5]: (warning) %s in format string (no. 1) requires 'char *' but the argument type is 'std::string'.\n"
@@ -2386,7 +2386,7 @@ class TestIO : public TestFixture {
               "    printf(\"%jo\", s3);\n"
               "    printf(\"%jx\", i);\n"
               "    printf(\"%jX\", i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %jd in format string (no. 1) requires 'intmax_t' but the argument type is 'char *'.\n"
                       "[test.cpp:3]: (warning) %ji in format string (no. 1) requires 'intmax_t' but the argument type is 'char *'.\n"
                       "[test.cpp:4]: (warning) %ju in format string (no. 1) requires 'uintmax_t' but the argument type is 'const char *'.\n"
@@ -2400,7 +2400,7 @@ class TestIO : public TestFixture {
               "    printf(\"%jd\", ui);\n"
               "    printf(\"%jd\", s3);\n"
               "    printf(\"%jd\", i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %ju in format string (no. 1) requires 'uintmax_t' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:4]: (warning) %jd in format string (no. 1) requires 'intmax_t' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:5]: (warning) %jd in format string (no. 1) requires 'intmax_t' but the argument type is 'std::string'.\n"
@@ -2413,7 +2413,7 @@ class TestIO : public TestFixture {
               "    printf(\"%n\", pi);\n"
               "    printf(\"%n\", s);\n"
               "    printf(\"%n\", \"s4\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'signed int'.\n"
                       "[test.cpp:4]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'signed int'.\n"
                       "[test.cpp:6]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'std::string'.\n"
@@ -2421,7 +2421,7 @@ class TestIO : public TestFixture {
 
         check("void foo() {\n"
               "    printf(\"%n\", L\"s5W\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("class foo {};\n"
@@ -2434,7 +2434,7 @@ class TestIO : public TestFixture {
               "    printf(\"%X\", bp);\n"
               "    printf(\"%X\", u);\n"
               "    printf(\"%X\", i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %X in format string (no. 1) requires 'unsigned int' but the argument type is 'foo'.\n"
                       "[test.cpp:4]: (warning) %c in format string (no. 1) requires 'unsigned int' but the argument type is 'const char *'.\n"
                       "[test.cpp:5]: (warning) %o in format string (no. 1) requires 'unsigned int' but the argument type is 'double'.\n"
@@ -2445,7 +2445,7 @@ class TestIO : public TestFixture {
               "void foo(const char* cpc, char* pc) {\n"
               "    printf(\"%x\", cpc);\n"
               "    printf(\"%x\", pc);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %x in format string (no. 1) requires 'unsigned int' but the argument type is 'const char *'.\n"
                       "[test.cpp:4]: (warning) %x in format string (no. 1) requires 'unsigned int' but the argument type is 'char *'.\n", errout_str());
 
@@ -2455,7 +2455,7 @@ class TestIO : public TestFixture {
               "    printf(\"%X\", L\"s5W\");\n"
               "    printf(\"%c\", L\"s5W\");\n"
               "    printf(\"%o\", L\"s5W\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %x in format string (no. 1) requires 'unsigned int' but the argument type is 'const wchar_t *'.\n"
                       "[test.cpp:4]: (warning) %X in format string (no. 1) requires 'unsigned int' but the argument type is 'const wchar_t *'.\n"
                       "[test.cpp:5]: (warning) %c in format string (no. 1) requires 'unsigned int' but the argument type is 'const wchar_t *'.\n"
@@ -2471,7 +2471,7 @@ class TestIO : public TestFixture {
               "    printf(\"%i\", b);\n"
               "    printf(\"%i\", bp);\n"
               "    printf(\"%i\", uc);\n" // char is smaller than int, so there shouldn't be a problem
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %i in format string (no. 1) requires 'int' but the argument type is 'foo'.\n"
                       "[test.cpp:4]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'const char *'.\n"
                       "[test.cpp:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'double'.\n"
@@ -2483,7 +2483,7 @@ class TestIO : public TestFixture {
               "void foo() {\n"
               "    printf(\"%i\", L\"s5W\");\n"
               "    printf(\"%d\", L\"s5W\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %i in format string (no. 1) requires 'int' but the argument type is 'const wchar_t *'.\n"
                       "[test.cpp:4]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'const wchar_t *'.\n", errout_str());
 
@@ -2497,7 +2497,7 @@ class TestIO : public TestFixture {
               "    printf(\"%u\", b);\n"
               "    printf(\"%u\", bp);\n"
               "    printf(\"%u\", bo);\n" // bool shouldn't have a negative sign
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'foo'.\n"
                       "[test.cpp:4]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'const char *'.\n"
                       "[test.cpp:5]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'double'.\n"
@@ -2508,7 +2508,7 @@ class TestIO : public TestFixture {
         check("class foo {};\n"
               "void foo(const int* cpi, foo f, bar b, bar* bp, double d, int i, bool bo) {\n"
               "    printf(\"%u\", L\"s5W\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("class foo {};\n"
@@ -2518,7 +2518,7 @@ class TestIO : public TestFixture {
               "    printf(\"%p\", bp);\n"
               "    printf(\"%p\", cpi);\n"
               "    printf(\"%p\", b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %p in format string (no. 1) requires an address but the argument type is 'foo'.\n"
                       "[test.cpp:4]: (warning) %p in format string (no. 1) requires an address but the argument type is 'char'.\n", errout_str());
 
@@ -2530,7 +2530,7 @@ class TestIO : public TestFixture {
               "    printf(\"%p\", cpwc);\n"
               "    printf(\"%p\", \"s4\");\n"
               "    printf(\"%p\", L\"s5W\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class foo {};\n"
@@ -2542,7 +2542,7 @@ class TestIO : public TestFixture {
               "    printf(\"%f\", d);\n"
               "    printf(\"%f\", b);\n"
               "    printf(\"%f\", (float)cpi);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %e in format string (no. 1) requires 'double' but the argument type is 'foo'.\n"
                       "[test.cpp:4]: (warning) %E in format string (no. 1) requires 'double' but the argument type is 'const char *'.\n"
                       "[test.cpp:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'const signed int *'.\n"
@@ -2555,7 +2555,7 @@ class TestIO : public TestFixture {
               "    printf(\"%f\", cpc);\n"
               "    printf(\"%G\", pc);\n"
               "    printf(\"%f\", pc);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %e in format string (no. 1) requires 'double' but the argument type is 'const char *'.\n"
                       "[test.cpp:4]: (warning) %E in format string (no. 1) requires 'double' but the argument type is 'char *'.\n"
                       "[test.cpp:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'const char *'.\n"
@@ -2568,7 +2568,7 @@ class TestIO : public TestFixture {
               "    printf(\"%E\", L\"s5W\");\n"
               "    printf(\"%f\", L\"s5W\");\n"
               "    printf(\"%G\", L\"s5W\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %e in format string (no. 1) requires 'double' but the argument type is 'const wchar_t *'.\n"
                       "[test.cpp:4]: (warning) %E in format string (no. 1) requires 'double' but the argument type is 'const wchar_t *'.\n"
                       "[test.cpp:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'const wchar_t *'.\n"
@@ -2579,7 +2579,7 @@ class TestIO : public TestFixture {
               "    printf(\"%u\", f);\n"
               "    printf(\"%f\", f);\n"
               "    printf(\"%p\", f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'foo'.\n"
                       "[test.cpp:4]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'foo'.\n"
                       "[test.cpp:5]: (warning) %p in format string (no. 1) requires an address but the argument type is 'foo'.\n", errout_str());
@@ -2589,14 +2589,14 @@ class TestIO : public TestFixture {
         check("void foo(signed char sc, unsigned char uc, short int si, unsigned short int usi) {\n"
               "  printf(\"%hhx %hhd\", sc, uc);\n"
               "  printf(\"%hd %hu\", si, usi);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %hhx in format string (no. 1) requires 'unsigned char' but the argument type is 'signed char'.\n"
                       "[test.cpp:2]: (warning) %hhd in format string (no. 2) requires 'char' but the argument type is 'unsigned char'.\n", errout_str());
 
         check("void foo(long long int lli, unsigned long long int ulli, long int li, unsigned long int uli) {\n"
               "  printf(\"%llo %llx\", lli, ulli);\n"
               "  printf(\"%ld %lu\", li, uli);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(intmax_t im, uintmax_t uim, size_t s, ptrdiff_t p, long double ld, std::size_t ss, std::ptrdiff_t sp) {\n"
@@ -2606,7 +2606,7 @@ class TestIO : public TestFixture {
               "  printf(\"%Lf\", ld);\n"
               "  printf(\"%zx\", ss);\n"
               "  printf(\"%ti\", sp);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Unrecognized (and non-existent in standard library) specifiers.
@@ -2618,31 +2618,31 @@ class TestIO : public TestFixture {
               "  printf(\"%La\", ld);\n"
               "  printf(\"%zv\", ss);\n"
               "  printf(\"%tp\", sp);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(long long l, ptrdiff_t p, std::ptrdiff_t sp) {\n"
               "  printf(\"%td\", p);\n"
               "  printf(\"%td\", sp);\n"
               "  printf(\"%td\", l);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4]: (warning) %td in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'signed long long'.\n", errout_str());
 
         check("void foo(int i, long double ld) {\n"
               "  printf(\"%zx %zu\", i, ld);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %zx in format string (no. 1) requires 'size_t' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %zu in format string (no. 2) requires 'size_t' but the argument type is 'long double'.\n", errout_str());
 
         check("void foo(unsigned int ui, long double ld) {\n"
               "  printf(\"%zu %zx\", ui, ld);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %zu in format string (no. 1) requires 'size_t' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %zx in format string (no. 2) requires 'size_t' but the argument type is 'long double'.\n", errout_str());
 
         check("void foo(int i, long double ld) {\n"
               "  printf(\"%tx %tu\", i, ld);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %tx in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %tu in format string (no. 2) requires 'unsigned ptrdiff_t' but the argument type is 'long double'.\n", errout_str());
 
@@ -2657,7 +2657,7 @@ class TestIO : public TestFixture {
               "  printf(\"%t\", i);\n"
               "  printf(\"%L\", i);\n"
               "  printf(\"%I\", i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) 'h' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
                       "[test.cpp:3]: (warning) 'hh' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
                       "[test.cpp:4]: (warning) 'l' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
@@ -2673,7 +2673,7 @@ class TestIO : public TestFixture {
               "  printf(\"%hhd\", i);\n"
               "  printf(\"%ld\", i);\n"
               "  printf(\"%lld\", i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %hd in format string (no. 1) requires 'short' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:3]: (warning) %hhd in format string (no. 1) requires 'char' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:4]: (warning) %ld in format string (no. 1) requires 'long' but the argument type is 'unsigned int'.\n"
@@ -2682,56 +2682,56 @@ class TestIO : public TestFixture {
         check("void foo(size_t s, ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix32));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix32));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'size_t {aka unsigned long}'.\n"
                       "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n", errout_str());
 
         check("void foo(std::size_t s, std::ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix32));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix32));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'std::size_t {aka unsigned long}'.\n"
                       "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'std::ptrdiff_t {aka signed long}'.\n", errout_str());
 
         check("void foo(size_t s, ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'size_t {aka unsigned long}'.\n"
                       "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n", errout_str());
 
         check("void foo(std::size_t s, std::ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'std::size_t {aka unsigned long}'.\n"
                       "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'std::ptrdiff_t {aka signed long}'.\n", errout_str());
 
         check("void foo(size_t s, ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'size_t {aka unsigned long}'.\n"
                       "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n", errout_str());
 
         check("void foo(std::size_t s, std::ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'std::size_t {aka unsigned long}'.\n"
                       "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'std::ptrdiff_t {aka signed long}'.\n", errout_str());
 
         check("void foo(size_t s, ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'size_t {aka unsigned long long}'.\n"
                       "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'ptrdiff_t {aka signed long long}'.\n", errout_str());
 
         check("void foo(std::size_t s, std::ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'std::size_t {aka unsigned long long}'.\n"
                       "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'std::ptrdiff_t {aka signed long long}'.\n", errout_str());
 
@@ -2740,7 +2740,7 @@ class TestIO : public TestFixture {
               "  printf(\"%lu\", um);\n"
               "  printf(\"%llu\", s);\n"
               "  printf(\"%llu\", um);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %lu in format string (no. 1) requires 'unsigned long' but the argument type is 'size_t {aka unsigned long long}'.\n"
                       "[test.cpp:3]: (portability) %lu in format string (no. 1) requires 'unsigned long' but the argument type is 'uintmax_t {aka unsigned long long}'.\n"
                       "[test.cpp:4]: (portability) %llu in format string (no. 1) requires 'unsigned long long' but the argument type is 'size_t {aka unsigned long long}'.\n"
@@ -2753,7 +2753,7 @@ class TestIO : public TestFixture {
               "  printf(\"%llu\", i);\n"
               "  printf(\"%lx\", i);\n"
               "  printf(\"%llx\", i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %ld in format string (no. 1) requires 'long' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:3]: (warning) %lld in format string (no. 1) requires 'long long' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:4]: (warning) %lu in format string (no. 1) requires 'unsigned long' but the argument type is 'unsigned int'.\n"
@@ -2765,13 +2765,13 @@ class TestIO : public TestFixture {
               "  printf(\"%lld\", i);\n"
               "  printf(\"%lld\", im);\n"
               "  printf(\"%lld\", p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %lld in format string (no. 1) requires 'long long' but the argument type is 'signed int'.\n", errout_str());
 
         check("void foo(intmax_t im, ptrdiff_t p) {\n"
               "  printf(\"%lld\", im);\n"
               "  printf(\"%lld\", p);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %lld in format string (no. 1) requires 'long long' but the argument type is 'intmax_t {aka signed long long}'.\n"
                       "[test.cpp:3]: (portability) %lld in format string (no. 1) requires 'long long' but the argument type is 'ptrdiff_t {aka signed long long}'.\n", errout_str());
 
@@ -2790,7 +2790,7 @@ class TestIO : public TestFixture {
               "    printf(\"%d %f %f %d %f %f\",\n"
               "        foo->d, foo->bar[0].i, a[0],\n"
               "        f[0].d, f[0].baz.i, f[0].bar[0].i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:13]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'double'.\n"
                       "[test.cpp:13]: (warning) %f in format string (no. 2) requires 'double' but the argument type is 'signed int'.\n"
                       "[test.cpp:13]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'int'.\n"
@@ -2799,7 +2799,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:13]: (warning) %f in format string (no. 6) requires 'double' but the argument type is 'int'.\n", errout_str());
 
         check("short f() { return 0; }\n"
-              "void foo() { printf(\"%d %u %lu %I64u %I64d %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
+              "void foo() { printf(\"%d %u %lu %I64u %I64d %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed short'.\n"
                       "[test.cpp:2]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed short'.\n"
                       "[test.cpp:2]: (warning) %I64u in format string (no. 4) requires 'unsigned __int64' but the argument type is 'signed short'.\n"
@@ -2809,7 +2809,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'signed short'.\n", errout_str());
 
         check("unsigned short f() { return 0; }\n"
-              "void foo() { printf(\"%u %d %ld %I64d %I64u %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
+              "void foo() { printf(\"%u %d %ld %I64d %I64u %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'unsigned short'.\n"
                       "[test.cpp:2]: (warning) %I64d in format string (no. 4) requires '__int64' but the argument type is 'unsigned short'.\n"
                       "[test.cpp:2]: (warning) %I64u in format string (no. 5) requires 'unsigned __int64' but the argument type is 'unsigned short'.\n"
@@ -2818,7 +2818,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'unsigned short'.\n", errout_str());
 
         check("int f() { return 0; }\n"
-              "void foo() { printf(\"%d %u %lu %I64u %I64d %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
+              "void foo() { printf(\"%d %u %lu %I64u %I64d %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %I64u in format string (no. 4) requires 'unsigned __int64' but the argument type is 'signed int'.\n"
@@ -2828,7 +2828,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'signed int'.\n", errout_str());
 
         check("unsigned int f() { return 0; }\n"
-              "void foo() { printf(\"%u %d %ld %I64d %I64u %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
+              "void foo() { printf(\"%u %d %ld %I64d %I64u %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %I64d in format string (no. 4) requires '__int64' but the argument type is 'unsigned int'.\n"
@@ -2838,7 +2838,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'unsigned int'.\n", errout_str());
 
         check("long f() { return 0; }\n"
-              "void foo() { printf(\"%ld %u %lu %I64u %I64d %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
+              "void foo() { printf(\"%ld %u %lu %I64u %I64d %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed long'.\n"
                       "[test.cpp:2]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed long'.\n"
                       "[test.cpp:2]: (warning) %I64u in format string (no. 4) requires 'unsigned __int64' but the argument type is 'signed long'.\n"
@@ -2848,7 +2848,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'signed long'.\n", errout_str());
 
         check("unsigned long f() { return 0; }\n"
-              "void foo() { printf(\"%lu %d %ld %I64d %I64u %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
+              "void foo() { printf(\"%lu %d %ld %I64d %I64u %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'unsigned long'.\n"
                       "[test.cpp:2]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'unsigned long'.\n"
                       "[test.cpp:2]: (warning) %I64d in format string (no. 4) requires '__int64' but the argument type is 'unsigned long'.\n"
@@ -2858,7 +2858,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'unsigned long'.\n", errout_str());
 
         check("long long f() { return 0; }\n"
-              "void foo() { printf(\"%lld %u %lu %I64u %I64d %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
+              "void foo() { printf(\"%lld %u %lu %I64u %I64d %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed long long'.\n"
                       "[test.cpp:2]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed long long'.\n"
                       "[test.cpp:2]: (warning) %I64u in format string (no. 4) requires 'unsigned __int64' but the argument type is 'signed long long'.\n"
@@ -2867,7 +2867,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'signed long long'.\n", errout_str());
 
         check("unsigned long long f() { return 0; }\n"
-              "void foo() { printf(\"%llu %d %ld %I64d %I64u %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
+              "void foo() { printf(\"%llu %d %ld %I64d %I64u %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'unsigned long long'.\n"
                       "[test.cpp:2]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'unsigned long long'.\n"
                       "[test.cpp:2]: (warning) %I64d in format string (no. 4) requires '__int64' but the argument type is 'unsigned long long'.\n"
@@ -2876,7 +2876,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'unsigned long long'.\n", errout_str());
 
         check("float f() { return 0; }\n"
-              "void foo() { printf(\"%f %d %ld %u %lu %I64d %I64u %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f(), f()); }");
+              "void foo() { printf(\"%f %d %ld %u %lu %I64d %I64u %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'float'.\n"
                       "[test.cpp:2]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'float'.\n"
                       "[test.cpp:2]: (warning) %u in format string (no. 4) requires 'unsigned int' but the argument type is 'float'.\n"
@@ -2887,7 +2887,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 9) requires an address but the argument type is 'float'.\n", errout_str());
 
         check("double f() { return 0; }\n"
-              "void foo() { printf(\"%f %d %ld %u %lu %I64d %I64u %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f(), f()); }");
+              "void foo() { printf(\"%f %d %ld %u %lu %I64d %I64u %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'double'.\n"
                       "[test.cpp:2]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'double'.\n"
                       "[test.cpp:2]: (warning) %u in format string (no. 4) requires 'unsigned int' but the argument type is 'double'.\n"
@@ -2898,7 +2898,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 9) requires an address but the argument type is 'double'.\n", errout_str());
 
         check("long double f() { return 0; }\n"
-              "void foo() { printf(\"%Lf %d %ld %u %lu %I64d %I64u %f %p\", f(), f(), f(), f(), f(), f(), f(), f(), f()); }");
+              "void foo() { printf(\"%Lf %d %ld %u %lu %I64d %I64u %f %p\", f(), f(), f(), f(), f(), f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'long double'.\n"
                       "[test.cpp:2]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'long double'.\n"
                       "[test.cpp:2]: (warning) %u in format string (no. 4) requires 'unsigned int' but the argument type is 'long double'.\n"
@@ -2909,37 +2909,37 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 9) requires an address but the argument type is 'long double'.\n", errout_str());
 
         check("int f() { return 0; }\n"
-              "void foo() { printf(\"%I64d %I64u %I64x %d\", f(), f(), f(), f()); }");
+              "void foo() { printf(\"%I64d %I64u %I64x %d\", f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %I64d in format string (no. 1) requires '__int64' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %I64u in format string (no. 2) requires 'unsigned __int64' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %I64x in format string (no. 3) requires 'unsigned __int64' but the argument type is 'signed int'.\n", errout_str());
 
         check("long long f() { return 0; }\n"
-              "void foo() { printf(\"%I32d %I32u %I32x %lld\", f(), f(), f(), f()); }");
+              "void foo() { printf(\"%I32d %I32u %I32x %lld\", f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %I32d in format string (no. 1) requires '__int32' but the argument type is 'signed long long'.\n"
                       "[test.cpp:2]: (warning) %I32u in format string (no. 2) requires 'unsigned __int32' but the argument type is 'signed long long'.\n"
                       "[test.cpp:2]: (warning) %I32x in format string (no. 3) requires 'unsigned __int32' but the argument type is 'signed long long'.\n", errout_str());
 
         check("unsigned long long f() { return 0; }\n"
-              "void foo() { printf(\"%I32d %I32u %I32x %llx\", f(), f(), f(), f()); }");
+              "void foo() { printf(\"%I32d %I32u %I32x %llx\", f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned long long'.\n"
                       "[test.cpp:2]: (warning) %I32u in format string (no. 2) requires 'unsigned __int32' but the argument type is 'unsigned long long'.\n"
                       "[test.cpp:2]: (warning) %I32x in format string (no. 3) requires 'unsigned __int32' but the argument type is 'unsigned long long'.\n", errout_str());
 
         check("signed char f() { return 0; }\n"
-              "void foo() { printf(\"%Id %Iu %Ix %hhi\", f(), f(), f(), f()); }");
+              "void foo() { printf(\"%Id %Iu %Ix %hhi\", f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %Id in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'signed char'.\n"
                       "[test.cpp:2]: (warning) %Iu in format string (no. 2) requires 'size_t' but the argument type is 'signed char'.\n"
                       "[test.cpp:2]: (warning) %Ix in format string (no. 3) requires 'size_t' but the argument type is 'signed char'.\n", errout_str());
 
         check("unsigned char f() { return 0; }\n"
-              "void foo() { printf(\"%Id %Iu %Ix %hho\", f(), f(), f(), f()); }");
+              "void foo() { printf(\"%Id %Iu %Ix %hho\", f(), f(), f(), f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %Id in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'unsigned char'.\n"
                       "[test.cpp:2]: (warning) %Iu in format string (no. 2) requires 'size_t' but the argument type is 'unsigned char'.\n"
                       "[test.cpp:2]: (warning) %Ix in format string (no. 3) requires 'size_t' but the argument type is 'unsigned char'.\n", errout_str());
 
         check("namespace bar { int f() { return 0; } }\n"
-              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar::f(), bar::f(), bar::f(), bar::f(), bar::f(), bar::f()); }");
+              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar::f(), bar::f(), bar::f(), bar::f(), bar::f(), bar::f()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
@@ -2947,7 +2947,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Fred { int i; } f;\n"
-              "void foo() { printf(\"%d %u %lu %f %Lf %p\", f.i, f.i, f.i, f.i, f.i, f.i); }");
+              "void foo() { printf(\"%d %u %lu %f %Lf %p\", f.i, f.i, f.i, f.i, f.i, f.i); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
@@ -2955,7 +2955,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Fred { unsigned int u; } f;\n"
-              "void foo() { printf(\"%u %d %ld %f %Lf %p\", f.u, f.u, f.u, f.u, f.u, f.u); }");
+              "void foo() { printf(\"%u %d %ld %f %Lf %p\", f.u, f.u, f.u, f.u, f.u, f.u); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'unsigned int'.\n"
@@ -2963,7 +2963,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %p in format string (no. 6) requires an address but the argument type is 'unsigned int'.\n", errout_str());
 
         check("struct Fred { unsigned int ui() { return 0; } } f;\n"
-              "void foo() { printf(\"%u %d %ld %f %Lf %p\", f.ui(), f.ui(), f.ui(), f.ui(), f.ui(), f.ui()); }");
+              "void foo() { printf(\"%u %d %ld %f %Lf %p\", f.ui(), f.ui(), f.ui(), f.ui(), f.ui(), f.ui()); }\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'unsigned int'.\n"
@@ -2974,12 +2974,12 @@ class TestIO : public TestFixture {
         check("void f(int len, int newline) {\n"
               "    printf(\"%s\", newline ? a : str + len);\n"
               "    printf(\"%s\", newline + newline);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %s in format string (no. 1) requires 'char *' but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Fred { int i; } f;\n"
               "struct Fred & bar() { };\n"
-              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar().i, bar().i, bar().i, bar().i, bar().i, bar().i); }");
+              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar().i, bar().i, bar().i, bar().i, bar().i, bar().i); }\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
@@ -2988,7 +2988,7 @@ class TestIO : public TestFixture {
 
         check("struct Fred { int i; } f;\n"
               "const struct Fred & bar() { };\n"
-              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar().i, bar().i, bar().i, bar().i, bar().i, bar().i); }");
+              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar().i, bar().i, bar().i, bar().i, bar().i, bar().i); }\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
@@ -2997,7 +2997,7 @@ class TestIO : public TestFixture {
 
         check("struct Fred { int i; } f;\n"
               "static const struct Fred & bar() { };\n"
-              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar().i, bar().i, bar().i, bar().i, bar().i, bar().i); }");
+              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar().i, bar().i, bar().i, bar().i, bar().i, bar().i); }\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
@@ -3006,7 +3006,7 @@ class TestIO : public TestFixture {
 
         check("struct Fred { int i; } f[2];\n"
               "struct Fred * bar() { return f; };\n"
-              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i); }");
+              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i); }\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
@@ -3015,7 +3015,7 @@ class TestIO : public TestFixture {
 
         check("struct Fred { int i; } f[2];\n"
               "const struct Fred * bar() { return f; };\n"
-              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i); }");
+              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i); }\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
@@ -3024,7 +3024,7 @@ class TestIO : public TestFixture {
 
         check("struct Fred { int i; } f[2];\n"
               "static const struct Fred * bar() { return f; };\n"
-              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i); }");
+              "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i, bar()[0].i); }\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
@@ -3033,7 +3033,7 @@ class TestIO : public TestFixture {
 
         check("struct Fred { int32_t i; } f;\n"
               "struct Fred & bar() { };\n"
-              "void foo() { printf(\"%d %ld %u %lu %f %Lf\", bar().i, bar().i, bar().i, bar().i, bar().i, bar().i); }");
+              "void foo() { printf(\"%d %ld %u %lu %f %Lf\", bar().i, bar().i, bar().i, bar().i, bar().i, bar().i); }\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %ld in format string (no. 2) requires 'long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %u in format string (no. 3) requires 'unsigned int' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %lu in format string (no. 4) requires 'unsigned long' but the argument type is 'signed int'.\n"
@@ -3044,27 +3044,27 @@ class TestIO : public TestFixture {
         // #4984
         check("void f(double *x) {\n"
               "    printf(\"%f\", x[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int array[10];\n"
               "int * foo() { return array; }\n"
               "void f() {\n"
               "    printf(\"%f\", foo()[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Base { int length() { } };\n"
               "struct Derived : public Base { };\n"
               "void foo(Derived * d) {\n"
               "    printf(\"%f\", d.length());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'.\n", errout_str());
 
         check("std::vector<int> v;\n"
               "void foo() {\n"
               "    printf(\"%d %u %f\", v[0], v[0], v[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'signed int'.\n", errout_str());
 
@@ -3072,7 +3072,7 @@ class TestIO : public TestFixture {
         check("int bar(int a);\n"
               "void foo() {\n"
               "    printf(\"%d\", bar(0));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int> v;\n"
@@ -3318,20 +3318,20 @@ class TestIO : public TestFixture {
 
         check("void foo() {\n"
               "    printf(\"%f %d\", static_cast<int>(1.0f), reinterpret_cast<const void *>(0));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'const void *'.\n", errout_str());
 
         check("void foo() {\n"
               "    UNKNOWN * u;\n"
               "    printf(\"%d %x %u %f\", u[i], u[i], u[i], u[i]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    long * l;\n"
               "    printf(\"%d %x %u %f\", l[i], l[i], l[i], l[i]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'signed long'.\n"
                       "[test.cpp:3]: (warning) %x in format string (no. 2) requires 'unsigned int' but the argument type is 'signed long'.\n"
                       "[test.cpp:3]: (warning) %u in format string (no. 3) requires 'unsigned int' but the argument type is 'signed long'.\n"
@@ -3352,27 +3352,27 @@ class TestIO : public TestFixture {
               "    printf(\"%u\",v6[0]);\n"
               "    myvector<char *> v7(1,0);\n"
               "    printf(\"%s\",v7[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<char> v;\n" // #5151
               "void foo() {\n"
               "   printf(\"%c %u %f\", v.at(32), v.at(32), v.at(32));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'char'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'char'.\n", errout_str());
 
         // #5195 (segmentation fault)
         check("void T::a(const std::vector<double>& vx) {\n"
               "    printf(\"%f\", vx.at(0));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5486
         check("void foo() {\n"
               "    ssize_t test = 0;\n"
               "    printf(\"%zd\", test);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6009
@@ -3380,7 +3380,7 @@ class TestIO : public TestFixture {
               "extern int         IntByReturnValue();\n"
               "void MyFunction() {\n"
               "    printf( \"%s - %s\", StringByReturnValue(), IntByReturnValue() );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4]: (warning) %s in format string (no. 1) requires 'char *' but the argument type is 'std::string'.\n"
                       "[test.cpp:4]: (warning) %s in format string (no. 2) requires 'char *' but the argument type is 'signed int'.\n", errout_str());
 
@@ -3393,7 +3393,7 @@ class TestIO : public TestFixture {
               "    Array<int, 10> array1;\n"
               "    Array<float, 10> array2;\n"
               "    printf(\"%u %u\", array1[0], array2[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'int'.\n"
                       "[test.cpp:9]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'float'.\n", errout_str());
 
@@ -3401,19 +3401,19 @@ class TestIO : public TestFixture {
         check("struct S { unsigned short x; } s = {0};\n"
               "void foo() {\n"
               "    printf(\"%d\", s.x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #7601
         check("void foo(int i, unsigned int ui, long long ll, unsigned long long ull) {\n"
               "    printf(\"%Ld %Lu %Ld %Lu\", i, ui, ll, ull);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %Ld in format string (no. 1) requires 'long long' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %Lu in format string (no. 2) requires 'unsigned long long' but the argument type is 'unsigned int'.\n", errout_str());
 
         check("void foo(char c, unsigned char uc, short s, unsigned short us, int i, unsigned int ui, long l, unsigned long ul) {\n"
               "    printf(\"%hhd %hhd %hhd %hhd %hhd %hhd %hhd %hhd\", c, uc, s, us, i, ui, l, ul);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %hhd in format string (no. 2) requires 'char' but the argument type is 'unsigned char'.\n"
                       "[test.cpp:2]: (warning) %hhd in format string (no. 3) requires 'char' but the argument type is 'signed short'.\n"
                       "[test.cpp:2]: (warning) %hhd in format string (no. 4) requires 'char' but the argument type is 'unsigned short'.\n"
@@ -3424,7 +3424,7 @@ class TestIO : public TestFixture {
 
         check("void foo(char c, unsigned char uc, short s, unsigned short us, int i, unsigned int ui, long l, unsigned long ul) {\n"
               "    printf(\"%hhu %hhu %hhu %hhu %hhu %hhu %hhu %hhu\", c, uc, s, us, i, ui, l, ul);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %hhu in format string (no. 1) requires 'unsigned char' but the argument type is 'char'.\n"
                       "[test.cpp:2]: (warning) %hhu in format string (no. 3) requires 'unsigned char' but the argument type is 'signed short'.\n"
                       "[test.cpp:2]: (warning) %hhu in format string (no. 4) requires 'unsigned char' but the argument type is 'unsigned short'.\n"
@@ -3435,7 +3435,7 @@ class TestIO : public TestFixture {
 
         check("void foo(char c, unsigned char uc, short s, unsigned short us, int i, unsigned int ui, long l, unsigned long ul) {\n"
               "    printf(\"%hhx %hhx %hhx %hhx %hhx %hhx %hhx %hhx\", c, uc, s, us, i, ui, l, ul);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %hhx in format string (no. 1) requires 'unsigned char' but the argument type is 'char'.\n"
                       "[test.cpp:2]: (warning) %hhx in format string (no. 3) requires 'unsigned char' but the argument type is 'signed short'.\n"
                       "[test.cpp:2]: (warning) %hhx in format string (no. 4) requires 'unsigned char' but the argument type is 'unsigned short'.\n"
@@ -3446,7 +3446,7 @@ class TestIO : public TestFixture {
 
         check("void foo(char c, unsigned char uc, short s, unsigned short us, int i, unsigned int ui, long l, unsigned long ul) {\n"
               "    printf(\"%hd %hd %hd %hd %hd %hd %hd %hd\", c, uc, s, us, i, ui, l, ul);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %hd in format string (no. 1) requires 'short' but the argument type is 'char'.\n"
                       "[test.cpp:2]: (warning) %hd in format string (no. 2) requires 'short' but the argument type is 'unsigned char'.\n"
                       "[test.cpp:2]: (warning) %hd in format string (no. 4) requires 'short' but the argument type is 'unsigned short'.\n"
@@ -3457,7 +3457,7 @@ class TestIO : public TestFixture {
 
         check("void foo(char c, unsigned char uc, short s, unsigned short us, int i, unsigned int ui, long l, unsigned long ul) {\n"
               "    printf(\"%hu %hu %hu %hu %hu %hu %hu %hu\", c, uc, s, us, i, ui, l, ul);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %hu in format string (no. 1) requires 'unsigned short' but the argument type is 'char'.\n"
                       "[test.cpp:2]: (warning) %hu in format string (no. 2) requires 'unsigned short' but the argument type is 'unsigned char'.\n"
                       "[test.cpp:2]: (warning) %hu in format string (no. 3) requires 'unsigned short' but the argument type is 'signed short'.\n"
@@ -3468,7 +3468,7 @@ class TestIO : public TestFixture {
 
         check("void foo(char c, unsigned char uc, short s, unsigned short us, int i, unsigned int ui, long l, unsigned long ul) {\n"
               "    printf(\"%hx %hx %hx %hx %hx %hx %hx %hx\", c, uc, s, us, i, ui, l, ul);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %hx in format string (no. 1) requires 'unsigned short' but the argument type is 'char'.\n"
                       "[test.cpp:2]: (warning) %hx in format string (no. 2) requires 'unsigned short' but the argument type is 'unsigned char'.\n"
                       "[test.cpp:2]: (warning) %hx in format string (no. 3) requires 'unsigned short' but the argument type is 'signed short'.\n"
@@ -3484,19 +3484,19 @@ class TestIO : public TestFixture {
               "\n"
               "void foo(struct S x) {\n"
               "  printf(\"%f\", x.f(4.0));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("enum E : uint8_t { E0 }; \n" // #7959
               "void f(E e) {\n"
               "    printf(\"%hhu\", e);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("enum E : uint8_t { E0 }; \n"
               "void f(E e) {\n"
               "    printf(\"%lu\", e);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3]: (warning) %lu in format string (no. 1) requires 'unsigned long' but the argument type is 'uint8_t'.\n",
                            "",
                            errout_str());
@@ -4259,7 +4259,7 @@ class TestIO : public TestFixture {
               "  printf(\"%1$d\", 1);"
               "  printf(\"%1$d, %d, %1$d\", 1, 2);"
               "  scanf(\"%1$d\", &bar);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -4268,7 +4268,7 @@ class TestIO : public TestFixture {
               "  printf(\"%1$d, %d, %4$d\", 1, 2, 3);\n"
               "  scanf(\"%2$d\", &bar);\n"
               "  printf(\"%0$f\", 0.0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3]: (error) printf format string requires 1 parameter but only 0 are given. [wrongPrintfScanfArgNum]\n"
                       "[test.cpp:4:3]: (warning) printf: referencing parameter 4 while 3 arguments given [wrongPrintfScanfParameterPositionError]\n"
                       "[test.cpp:5:3]: (warning) scanf: referencing parameter 2 while 1 arguments given [wrongPrintfScanfParameterPositionError]\n"
@@ -4291,7 +4291,7 @@ class TestIO : public TestFixture {
               "    printf(\"%I32d %I32u %I32x\", u32, u32, u32);\n"
               "    printf(\"%I64d %I64u %I64x\", i64, i64, i64);\n"
               "    printf(\"%I64d %I64u %I64x\", u64, u64, u64);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:8:5]: (portability) %Id in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'size_t {aka unsigned long}'. [invalidPrintfArgType_sint]\n"
                       "[test.cpp:9:5]: (portability) %Iu in format string (no. 2) requires 'size_t' but the argument type is 'ptrdiff_t {aka signed long}'. [invalidPrintfArgType_uint]\n"
                       "[test.cpp:9:5]: (portability) %Ix in format string (no. 3) requires 'size_t' but the argument type is 'ptrdiff_t {aka signed long}'. [invalidPrintfArgType_uint]\n"
@@ -4313,7 +4313,7 @@ class TestIO : public TestFixture {
               "    printf(\"%I32d %I32u %I32x\", u32, u32, u32);\n"
               "    printf(\"%I64d %I64u %I64x\", i64, i64, i64);\n"
               "    printf(\"%I64d %I64u %I64x\", u64, u64, u64);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:8:5]: (portability) %Id in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'size_t {aka unsigned long long}'. [invalidPrintfArgType_sint]\n"
                       "[test.cpp:9:5]: (portability) %Iu in format string (no. 2) requires 'size_t' but the argument type is 'ptrdiff_t {aka signed long long}'. [invalidPrintfArgType_uint]\n"
                       "[test.cpp:9:5]: (portability) %Ix in format string (no. 3) requires 'size_t' but the argument type is 'ptrdiff_t {aka signed long long}'. [invalidPrintfArgType_uint]\n"
@@ -4339,7 +4339,7 @@ class TestIO : public TestFixture {
               "    printf(\"%I16x%i\", s, i);\n"
               "    printf(\"%I32%i\", s, i);\n"
               "    printf(\"%I64%i\", s, i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
                       "[test.cpp:5:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
                       "[test.cpp:6:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
@@ -4384,7 +4384,7 @@ class TestIO : public TestFixture {
               "    printf(\"%zd\", s);\n"
               "    printf(\"%zd%i\", s, i);\n"
               "    printf(\"%zu\", s);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:6:5]: (portability) %zu in format string (no. 1) requires 'size_t' but the argument type is 'SSIZE_T {aka signed long}'. [invalidPrintfArgType_uint]\n", errout_str());
 
         check("void foo() {\n"
@@ -4393,7 +4393,7 @@ class TestIO : public TestFixture {
               "    printf(\"%zd\", s);\n"
               "    printf(\"%zd%i\", s, i);\n"
               "    printf(\"%zu\", s);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:6:5]: (portability) %zu in format string (no. 1) requires 'size_t' but the argument type is 'SSIZE_T {aka signed long long}'. [invalidPrintfArgType_uint]\n", errout_str());
 
         check("void foo() {\n"
@@ -4402,7 +4402,7 @@ class TestIO : public TestFixture {
               "    printf(\"%zd\", s);\n"
               "    printf(\"%zd%i\", s, i);\n"
               "    printf(\"%zu\", s);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -4412,7 +4412,7 @@ class TestIO : public TestFixture {
               "    printf(\"%zd\", s);\n"
               "    printf(\"%zd%i\", s, i);\n"
               "    printf(\"%zu\", s);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:7:5]: (portability) %zu in format string (no. 1) requires 'size_t' but the argument type is 'SSIZE_T {aka signed long long}'. [invalidPrintfArgType_uint]\n", errout_str());
 
     }
@@ -4431,7 +4431,7 @@ class TestIO : public TestFixture {
               "    scanf(\"%I32d %I32u %I32x\", &u32, &u32, &u32);\n"
               "    scanf(\"%I64d %I64u %I64x\", &i64, &i64, &i64);\n"
               "    scanf(\"%I64d %I64u %I64x\", &u64, &u64, &u64);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:8:5]: (portability) %Id in format string (no. 1) requires 'ptrdiff_t *' but the argument type is 'size_t * {aka unsigned long *}'. [invalidScanfArgType_int]\n"
                       "[test.cpp:9:5]: (portability) %Iu in format string (no. 2) requires 'size_t *' but the argument type is 'ptrdiff_t * {aka signed long *}'. [invalidScanfArgType_int]\n"
                       "[test.cpp:9:5]: (portability) %Ix in format string (no. 3) requires 'size_t *' but the argument type is 'ptrdiff_t * {aka signed long *}'. [invalidScanfArgType_int]\n"
@@ -4455,7 +4455,7 @@ class TestIO : public TestFixture {
               "    scanf(\"%I32d %I32u %I32x\", &u32, &u32, &u32);\n"
               "    scanf(\"%I64d %I64u %I64x\", &i64, &i64, &i64);\n"
               "    scanf(\"%I64d %I64u %I64x\", &u64, &u64, &u64);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:8:5]: (portability) %Id in format string (no. 1) requires 'ptrdiff_t *' but the argument type is 'size_t * {aka unsigned long long *}'. [invalidScanfArgType_int]\n"
                       "[test.cpp:9:5]: (portability) %Iu in format string (no. 2) requires 'size_t *' but the argument type is 'ptrdiff_t * {aka signed long long *}'. [invalidScanfArgType_int]\n"
                       "[test.cpp:9:5]: (portability) %Ix in format string (no. 3) requires 'size_t *' but the argument type is 'ptrdiff_t * {aka signed long long *}'. [invalidScanfArgType_int]\n"
@@ -4483,7 +4483,7 @@ class TestIO : public TestFixture {
               "    scanf(\"%I16x%i\", &s, &i);\n"
               "    scanf(\"%I32%i\", &s, &i);\n"
               "    scanf(\"%I64%i\", &s, &i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
                       "[test.cpp:5:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
                       "[test.cpp:6:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
@@ -4505,7 +4505,7 @@ class TestIO : public TestFixture {
               "    scanf(\"%zd\", &s);\n"
               "    scanf(\"%zd%i\", &s, &i);\n"
               "    scanf(\"%zu\", &s);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:6:5]: (portability) %zu in format string (no. 1) requires 'size_t *' but the argument type is 'SSIZE_T * {aka signed long *}'. [invalidScanfArgType_int]\n", errout_str());
 
         check("void foo() {\n"
@@ -4514,7 +4514,7 @@ class TestIO : public TestFixture {
               "    scanf(\"%zd\", &s);\n"
               "    scanf(\"%zd%i\", &s, &i);\n"
               "    scanf(\"%zu\", &s);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:6:5]: (portability) %zu in format string (no. 1) requires 'size_t *' but the argument type is 'SSIZE_T * {aka signed long long *}'. [invalidScanfArgType_int]\n", errout_str());
 
         check("void foo() {\n"
@@ -4523,7 +4523,7 @@ class TestIO : public TestFixture {
               "    scanf(\"%zd\", &s);\n"
               "    scanf(\"%zd%i\", &s, &i);\n"
               "    scanf(\"%zu\", &s);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -4533,7 +4533,7 @@ class TestIO : public TestFixture {
               "    scanf(\"%zd\", &s);\n"
               "    scanf(\"%zd%i\", &s, &i);\n"
               "    scanf(\"%zu\", &s);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:7:5]: (portability) %zu in format string (no. 1) requires 'size_t *' but the argument type is 'SSIZE_T * {aka signed long long *}'. [invalidScanfArgType_int]\n", errout_str());
 
     }
@@ -4544,7 +4544,7 @@ class TestIO : public TestFixture {
               "    String string;\n"
               "    string.Format(\"%I32d\", u32);\n"
               "    string.AppendFormat(\"%I32d\", u32);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -4552,7 +4552,7 @@ class TestIO : public TestFixture {
               "    CString string;\n"
               "    string.Format(\"%I32d\", u32);\n"
               "    string.AppendFormat(\"%I32d\", u32);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix32));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix32));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -4561,7 +4561,7 @@ class TestIO : public TestFixture {
               "    string.Format(\"%I32d\", u32);\n"
               "    string.AppendFormat(\"%I32d\", u32);\n"
               "    CString::Format(\"%I32d\", u32);\n"
-              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:4:12]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'. [invalidPrintfArgType_sint]\n"
                       "[test.cpp:5:12]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'. [invalidPrintfArgType_sint]\n"
                       "[test.cpp:6:14]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'. [invalidPrintfArgType_sint]\n", errout_str());
@@ -4955,20 +4955,20 @@ class TestIO : public TestFixture {
         check("void foo(float f) {\n"
               "    QString string;\n"
               "    string.sprintf(\"%d\", f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:3:12]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'float'. [invalidPrintfArgType_sint]\n", errout_str());
 
         check("void foo(float f) {\n"
               "    QString string;\n"
               "    string = QString::asprintf(\"%d\", f);\n"
-              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:3:23]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'float'. [invalidPrintfArgType_sint]\n", errout_str());
     }
 
     void testTernary() {  // ticket #6182
         check("void test(const std::string &val) {\n"
               "    printf(\"%s\", val.empty() ? \"I like to eat bananas\" : val.c_str());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4976,30 +4976,30 @@ class TestIO : public TestFixture {
         check("void test() {\n"
               "    unsigned const x = 5;\n"
               "    printf(\"%u\", x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void testAstType() { // ticket #7014
         check("void test() {\n"
               "    printf(\"%c\", \"hello\"[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void test() {\n"
               "    printf(\"%lld\", (long long)1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void test() {\n"
               "    printf(\"%i\", (short *)x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) %i in format string (no. 1) requires 'int' but the argument type is 'signed short *'. [invalidPrintfArgType_sint]\n", errout_str());
 
         check("int (*fp)();\n" // #7178 - function pointer call
               "void test() {\n"
               "    printf(\"%i\", fp());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5007,7 +5007,7 @@ class TestIO : public TestFixture {
         check("void foo() {\n"
               "    printf(\"%u %lu %llu\", 0U, 0UL, 0ULL);\n"
               "    printf(\"%u %lu %llu\", 0u, 0ul, 0ull);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5015,7 +5015,7 @@ class TestIO : public TestFixture {
         check("void f() {\n"
               "   const char *s = \"0\";\n"
               "   printf(\"%ld%lld\", atol(s), atoll(s));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // 8141
@@ -5034,7 +5034,7 @@ class TestIO : public TestFixture {
               "PCINT pci;"
               "void foo() {\n"
               "    printf(\"%d %p %p\", i, pi, pci);\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("using INT = int;\n\n"
@@ -5045,7 +5045,7 @@ class TestIO : public TestFixture {
               "PCINT pci;"
               "void foo() {\n"
               "    printf(\"%f %f %f\", i, pi, pci);\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:8:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'. [invalidPrintfArgType_float]\n"
                       "[test.cpp:8:5]: (warning) %f in format string (no. 2) requires 'double' but the argument type is 'signed int *'. [invalidPrintfArgType_float]\n"
                       "[test.cpp:8:5]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'const signed int *'. [invalidPrintfArgType_float]\n", errout_str());
@@ -5063,17 +5063,17 @@ class TestIO : public TestFixture {
     void testPrintfParenthesis() { // #8489
         check("void f(int a) {\n"
               "    printf(\"%f\", (a >> 24) & 0xff);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'. [invalidPrintfArgType_float]\n", errout_str());
 
         check("void f(int a) {\n"
               "    printf(\"%f\", 0xff & (a >> 24));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'. [invalidPrintfArgType_float]\n", errout_str());
 
         check("void f(int a) {\n"
               "    printf(\"%f\", ((a >> 24) + 1) & 0xff);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'. [invalidPrintfArgType_float]\n", errout_str());
     }
 
@@ -5081,7 +5081,7 @@ class TestIO : public TestFixture {
         check("void foo(const std::vector<int>& IO, const int* pio) {\n"
               "const auto Idx = std::distance(&IO.front(), pio);\n"
               "printf(\"Idx = %td\", Idx);\n"
-              "}", dinit(CheckOptions, $.portability = true));
+              "}\n", dinit(CheckOptions, $.portability = true));
         ASSERT_EQUALS("", errout_str());
     }
 
diff --git a/test/testleakautovar.cpp b/test/testleakautovar.cpp
index 6b6397851fb..cb5f9d53c8a 100644
--- a/test/testleakautovar.cpp
+++ b/test/testleakautovar.cpp
@@ -245,7 +245,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    p = NULL;\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:5]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
@@ -254,7 +254,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    char *q = p;\n"
               "    free(q);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -263,7 +263,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    char *q = p + 1;\n"
               "    free(q - 1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -272,7 +272,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *a = malloc(10);\n"
               "    a += 10;\n"
               "    free(a - 10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -281,7 +281,7 @@ class TestLeakAutoVar : public TestFixture {
               "{\n"
               "    char *p = new char[100];\n"
               "    list += p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -290,7 +290,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    p = strcpy(p,q);\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -298,7 +298,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void foo(struct str *d) {\n"
               "    struct str *p = malloc(10);\n"
               "    d->p = p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -306,7 +306,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void foo(struct str *d) {\n"
               "    struct str *p = malloc(10);\n"
               "    d->p = &p->x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -315,7 +315,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = x();\n"
               "    free(p);\n"
               "    p = NULL;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -325,7 +325,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (x) { p = malloc(10); }\n"
               "    if (!x) { p = NULL; }\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -333,7 +333,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    x = a(b(p));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:4:1]: (information) --check-library: Function b() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
     }
 
@@ -343,7 +343,7 @@ class TestLeakAutoVar : public TestFixture {
               "    free(p);\n"
               "    bar(&p);\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -353,22 +353,22 @@ class TestLeakAutoVar : public TestFixture {
               "    char * &ref = p;\n"
               "    p = malloc(10);\n"
               "    free(ref);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         TODO_ASSERT_EQUALS("", "[test.cpp:6:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void assign14() {
         check("void f(int x) {\n"
               "    char *p;\n"
-              "    if (x && (p = malloc(10))) { }"
-              "}");
-        ASSERT_EQUALS("[test.c:3:35]: (error) Memory leak: p [memleak]\n", errout_str());
+              "    if (x && (p = malloc(10))) { }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:4:1]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("void f(int x) {\n"
               "    char *p;\n"
-              "    if (x && (p = new char[10])) { }"
-              "}", dinit(CheckOptions, $.cpp = true));
-        ASSERT_EQUALS("[test.cpp:3:37]: (error) Memory leak: p [memleak]\n", errout_str());
+              "    if (x && (p = new char[10])) { }\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void assign15() {
@@ -379,7 +379,7 @@ class TestLeakAutoVar : public TestFixture {
               "   free(p);\n"
               "   p = malloc(sizeof *p);\n"
               "   free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -388,48 +388,48 @@ class TestLeakAutoVar : public TestFixture {
               "   char *p = malloc(10);\n"
               "   free(p);\n"
               "   if (p=dostuff()) *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void assign17() { // #9047
         check("void f() {\n"
               "    char *p = (char*)malloc(10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:1]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("void f() {\n"
               "    char *p = (char*)(int*)malloc(10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void assign18() {
         check("void f(int x) {\n"
               "    char *p;\n"
-              "    if (x && (p = (char*)malloc(10))) { }"
-              "}");
-        ASSERT_EQUALS("[test.c:3:42]: (error) Memory leak: p [memleak]\n", errout_str());
+              "    if (x && (p = (char*)malloc(10))) { }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:4:1]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("void f(int x) {\n"
               "    char *p;\n"
-              "    if (x && (p = (char*)(int*)malloc(10))) { }"
-              "}");
-        ASSERT_EQUALS("[test.c:3:48]: (error) Memory leak: p [memleak]\n", errout_str());
+              "    if (x && (p = (char*)(int*)malloc(10))) { }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:4:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void assign19() {
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    free((void*)p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void assign20() { // #9187
         check("void f() {\n"
               "    char *p = static_cast<int>(malloc(10));\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:3:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
@@ -437,14 +437,14 @@ class TestLeakAutoVar : public TestFixture {
         check("void f(int **x) {\n" // #10186
               "    void *p = malloc(10);\n"
               "    *x = (int*)p;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("struct S { int i; };\n" // #10996
               "void f() {\n"
               "    S* s = new S();\n"
               "    (void)s;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:5:1]: (error) Memory leak: s [memleak]\n", errout_str());
     }
 
@@ -452,12 +452,12 @@ class TestLeakAutoVar : public TestFixture {
         const Settings s = settingsBuilder().library("posix.cfg").checkLibrary().build();
         check("void f(char tempFileName[256]) {\n"
               "    const int fd = socket(AF_INET, SOCK_PACKET, 0 );\n"
-              "}", dinit(CheckOptions, $.cpp = true, $.s = &s));
+              "}\n", dinit(CheckOptions, $.cpp = true, $.s = &s));
         ASSERT_EQUALS("[test.cpp:3:1]: (error) Resource leak: fd [resourceLeak]\n", errout_str());
 
         check("void f() {\n"
               "    const void * const p = malloc(10);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:3:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
@@ -565,7 +565,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n" // #11796
               "    int* p{ new int };\n"
               "    int* q(new int);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:4:1]: (error) Memory leak: p [memleak]\n"
                       "[test.cpp:4:1]: (error) Memory leak: q [memleak]\n",
                       errout_str());
@@ -629,13 +629,13 @@ class TestLeakAutoVar : public TestFixture {
         check("void f(int*& x) {\n" // #8235
               "    int* p = (int*)malloc(10);\n"
               "    x = p ? p : nullptr;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int*& x) {\n"
               "    int* p = (int*)malloc(10);\n"
               "    x = p != nullptr ? p : nullptr;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const char* n) {\n" // #12724
@@ -666,17 +666,17 @@ class TestLeakAutoVar : public TestFixture {
     void isAutoDealloc() {
         check("void f() {\n"
               "    char *p = new char[100];"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:2:29]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("void f() {\n"
               "    Fred *fred = new Fred;"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    std::string *str = new std::string;"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:2:40]: (error) Memory leak: str [memleak]\n", errout_str());
 
         check("class TestType {\n" // #9028
@@ -685,13 +685,13 @@ class TestLeakAutoVar : public TestFixture {
               "};\n"
               "void f() {\n"
               "    TestType *tt = new TestType();\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:7:1]: (error) Memory leak: tt [memleak]\n", errout_str());
 
         check("void f(Bar& b) {\n" // #7622
               "    char* data = new char[10];\n"
               "    b = Bar(*new Foo(data));\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:4:1]: (information) --check-library: Function Foo() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
 
         check("class B {};\n"
@@ -699,7 +699,7 @@ class TestLeakAutoVar : public TestFixture {
               "    void g() {\n"
               "        auto d = new D();\n"
               "        if (d) {}\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:6:1]: (error) Memory leak: d [memleak]\n", errout_str());
 
         check("struct S {\n" // #12354
@@ -710,7 +710,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (b)\n"
               "        p = new S();\n"
               "    p->f();\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:9:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
@@ -719,7 +719,7 @@ class TestLeakAutoVar : public TestFixture {
               "    void *p = malloc(10);\n"
               "    void *q = realloc(p, 20);\n"
               "    free(q)\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -727,7 +727,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    void *p = malloc(10);\n"
               "    void *q = realloc(p, 20);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:4:1]: (error) Memory leak: q [memleak]\n", errout_str());
     }
 
@@ -735,7 +735,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    char *q = (char*) realloc(p, 20);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:4:1]: (error) Memory leak: q [memleak]\n", errout_str());
     }
 
@@ -744,7 +744,7 @@ class TestLeakAutoVar : public TestFixture {
               "    void * q = realloc(p, 10);\n"
               "    if (q == NULL)\n"
               "        return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:5:1]: (error) Memory leak: q [memleak]\n", errout_str());
     }
 
@@ -755,7 +755,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (size && !datap)\n"
               "        free(ptr);\n"
               "    return datap;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9990
@@ -769,7 +769,7 @@ class TestLeakAutoVar : public TestFixture {
               "        return;\n"
               "    }\n"
               "    free(p2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -778,7 +778,7 @@ class TestLeakAutoVar : public TestFixture {
               "    void *p = fopen(name,a);\n"
               "    void *q = freopen(name, b, p);\n"
               "    fclose(q)\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -786,7 +786,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    void *p = fopen(name,a);\n"
               "    void *q = freopen(name, b, p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:4:1]: (error) Resource leak: q [resourceLeak]\n", errout_str());
     }
 
@@ -794,13 +794,13 @@ class TestLeakAutoVar : public TestFixture {
         check("void f(char *p) {\n"
               "    free(p);\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:6]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n", errout_str());
 
         check("void f(char *p) {\n"
               "    free(p);\n"
               "    char c = *p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:15]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n", errout_str());
     }
 
@@ -808,7 +808,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f(struct str *p) {\n"
               "    free(p);\n"
               "    p = p->next;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:9]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n", errout_str());
     }
 
@@ -816,25 +816,25 @@ class TestLeakAutoVar : public TestFixture {
         check("void f(char *p) {\n"
               "    free(p);\n"
               "    return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:2:5] -> [test.c:3:5]: (error) Returning/dereferencing 'p' after it is deallocated / released [deallocret]\n", errout_str());
 
         check("void f(char *p) {\n"
               "  if (!p) free(p);\n"
               "  return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char *p) {\n"
               "  if (!p) delete p;\n"
               "  return p;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char *p) {\n"
               "  if (!p) delete [] p;\n"
               "  return p;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(void* p) {\n"
@@ -844,7 +844,7 @@ class TestLeakAutoVar : public TestFixture {
               "   }\n"
               "   g(p);\n"
               "   return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -852,7 +852,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f(char *p) {\n"
               "    free(p), p = 0;\n"
               "    *p = 0;\n"  // <- Make sure pointer info is reset. It is NOT a freed pointer dereference
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -860,7 +860,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f(char *p) {\n"
               "    free(p);\n"
               "    x = p = foo();\n"  // <- p is not dereferenced
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -869,14 +869,14 @@ class TestLeakAutoVar : public TestFixture {
               "void f(Foo* foo) {\n"
               "    delete foo->ptr;\n"
               "    foo->ptr = new Foo;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("struct Foo { int* ptr; };\n"
               "void f(Foo* foo) {\n"
               "    delete foo->ptr;\n"
               "    x = *foo->ptr;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         TODO_ASSERT_EQUALS("[test.cpp:4:6]: (error) Dereferencing 'ptr' after it is deallocated / released [deallocuse]\n", "", errout_str());
 
         check("void parse() {\n"
@@ -885,7 +885,7 @@ class TestLeakAutoVar : public TestFixture {
               "        ~Buf() { delete[]m_buf; }\n"
               "        uint8_t *m_buf;\n"
               "    };\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("struct Foo {\n"
@@ -897,14 +897,14 @@ class TestLeakAutoVar : public TestFixture {
               "    delete foo->ptr;\n"
               "    foo->ptr = new Foo;\n"
               "    foo->ptr->func();\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(void (*conv)(char**)) {\n"
               "  char * ptr=(char*)malloc(42);\n"
               "  free(ptr);\n"
               "  (*conv)(&ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -913,7 +913,7 @@ class TestLeakAutoVar : public TestFixture {
               "    int *ptr = new int;\n"
               "    delete(ptr);\n"
               "    *ptr = 0;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Dereferencing 'ptr' after it is deallocated / released [deallocuse]\n", errout_str());
     }
 
@@ -964,14 +964,14 @@ class TestLeakAutoVar : public TestFixture {
               "  int *array = new int[42];\n"
               "  delete [] array;\n"
               "  return array[1];" // <<
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:3:3] -> [test.cpp:4:3]: (error) Returning/dereferencing 'array' after it is deallocated / released [deallocret]\n", errout_str());
 
         check("int f() {\n"
               "  int *array = (int*)malloc(40);\n"
               "  free(array);\n"
               "  return array[1];" // <<
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:3] -> [test.c:4:3]: (error) Returning/dereferencing 'array' after it is deallocated / released [deallocret]\n", errout_str());
     }
 
@@ -982,7 +982,7 @@ class TestLeakAutoVar : public TestFixture {
               "}\n"
               "void f2(struct foo *f, int *out) {\n"
               "  *out = f->x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1120,35 +1120,35 @@ class TestLeakAutoVar : public TestFixture {
               "    else\n"
               "        p = 0;\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:9] -> [test.c:6:5]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(char *p) {\n"
             "  free(p);\n"
             "  free(p);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.c:2:3] -> [test.c:3:3]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(char *p, char *r) {\n"
             "  free(p);\n"
             "  free(r);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo() {\n"
             "  free(p);\n"
             "  free(r);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(char *p) {\n"
             "  if (x < 3) free(p);\n"
             "  else { if (x > 9) free(p); }\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1156,7 +1156,7 @@ class TestLeakAutoVar : public TestFixture {
             "  free(p);\n"
             "  getNext(&p);\n"
             "  free(p);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1164,7 +1164,7 @@ class TestLeakAutoVar : public TestFixture {
             "  free(p);\n"
             "  bar();\n"
             "  free(p);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.c:2:3] -> [test.c:4:3]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
@@ -1172,7 +1172,7 @@ class TestLeakAutoVar : public TestFixture {
             "  free(p);\n"
             "  printf(\"Freed memory at location %x\", p);\n"
             "  free(p);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.c:3:41]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n"
                       "[test.c:2:3] -> [test.c:4:3]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n",
                       errout_str());
@@ -1181,21 +1181,21 @@ class TestLeakAutoVar : public TestFixture {
             "void foo(FILE *p) {\n"
             "  fclose(p);\n"
             "  fclose(p);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.c:2:3] -> [test.c:3:3]: (error) Resource handle 'p' freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(FILE *p, FILE *r) {\n"
             "  fclose(p);\n"
             "  fclose(r);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(FILE *p) {\n"
             "  if (x < 3) fclose(p);\n"
             "  else { if (x > 9) fclose(p); }\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1203,7 +1203,7 @@ class TestLeakAutoVar : public TestFixture {
             "  fclose(p);\n"
             "  gethandle(&p);\n"
             "  fclose(p);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1211,14 +1211,14 @@ class TestLeakAutoVar : public TestFixture {
             "  fclose(p);\n"
             "  gethandle();\n"
             "  fclose(p);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.c:2:3] -> [test.c:4:3]: (error) Resource handle 'p' freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(Data* p) {\n"
             "  free(p->a);\n"
             "  free(p->b);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1229,7 +1229,7 @@ class TestLeakAutoVar : public TestFixture {
             "        exit();\n"
             "    }\n"
             "    free(p);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1240,7 +1240,7 @@ class TestLeakAutoVar : public TestFixture {
             "        x = 0;\n"
             "    }\n"
             "    free(p);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.c:4:9] -> [test.c:7:5]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
@@ -1249,35 +1249,35 @@ class TestLeakAutoVar : public TestFixture {
             "    free(p);\n"
             "    p = do_something();\n"
             "    free(p);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(char *p) {\n"
             "  delete p;\n"
             "  delete p;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:3:10]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(char *p, char *r) {\n"
             "  delete p;\n"
             "  delete r;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(P p) {\n"
             "  delete p.x;\n"
             "  delete p;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(char **p) {\n"
             "  delete p[0];\n"
             "  delete p[1];\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1285,7 +1285,7 @@ class TestLeakAutoVar : public TestFixture {
             "  delete p;\n"
             "  getNext(&p);\n"
             "  delete p;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1293,21 +1293,21 @@ class TestLeakAutoVar : public TestFixture {
             "  delete p;\n"
             "  bar();\n"
             "  delete p;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:4:10]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(char *p) {\n"
             "  delete[] p;\n"
             "  delete[] p;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:3:12]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(char *p, char *r) {\n"
             "  delete[] p;\n"
             "  delete[] r;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1315,7 +1315,7 @@ class TestLeakAutoVar : public TestFixture {
             "  delete[] p;\n"
             "  getNext(&p);\n"
             "  delete[] p;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1323,7 +1323,7 @@ class TestLeakAutoVar : public TestFixture {
             "  delete[] p;\n"
             "  bar();\n"
             "  delete[] p;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:4:12]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
@@ -1334,7 +1334,7 @@ class TestLeakAutoVar : public TestFixture {
             "  delete pxpm;\n"
             "  pxpm = NULL;\n"
             "  return *this;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1351,7 +1351,7 @@ class TestLeakAutoVar : public TestFixture {
             "      throw;\n"
             "    }\n"
             "  delete ptr;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1367,7 +1367,7 @@ class TestLeakAutoVar : public TestFixture {
             "   if(doDelete)\n"
             "       delete a;\n"
             "   return 0;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         TODO_ASSERT_EQUALS("", "[test.cpp:8:8] -> [test.cpp:11:15]: (error) Memory pointed to by 'a' is freed twice. [doubleFree]\n", errout_str());
 
         check(
@@ -1381,7 +1381,7 @@ class TestLeakAutoVar : public TestFixture {
             "        delete[] x;\n"
             "    }\n"
             "    delete[] x;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1393,7 +1393,7 @@ class TestLeakAutoVar : public TestFixture {
             "        delete[] x;\n"
             "    }\n"
             "    delete[] x;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         TODO_ASSERT_EQUALS("[test.cpp:8]: (error) Memory pointed to by 'x' is freed twice.\n", "", errout_str());
 
         check(
@@ -1405,7 +1405,7 @@ class TestLeakAutoVar : public TestFixture {
             "        delete[] x;\n"
             "    }\n"
             "    delete[] x;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         TODO_ASSERT_EQUALS("[test.cpp:8]: (error) Memory pointed to by 'x' is freed twice.\n", "", errout_str());
 
         check(
@@ -1417,7 +1417,7 @@ class TestLeakAutoVar : public TestFixture {
             "        free(x);\n"
             "    }\n"
             "    free(x);\n"
-            "}");
+            "}\n");
         TODO_ASSERT_EQUALS("[test.c:8]: (error) Memory pointed to by 'x' is freed twice.\n", "", errout_str());
 
         check(
@@ -1431,7 +1431,7 @@ class TestLeakAutoVar : public TestFixture {
             "        delete[] x;\n"
             "    }\n"
             "    delete[] x;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1445,7 +1445,7 @@ class TestLeakAutoVar : public TestFixture {
             "        delete[] x;\n"
             "    } while (true);\n"
             "    delete[] x;\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1457,7 +1457,7 @@ class TestLeakAutoVar : public TestFixture {
             "        free(p);\n"
             "    }\n"
             "    free(p);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.c:6:9] -> [test.c:8:5]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
@@ -1478,7 +1478,7 @@ class TestLeakAutoVar : public TestFixture {
             "void MyThrow(err)\n"
             "{\n"
             "    throw(err);\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -1499,7 +1499,7 @@ class TestLeakAutoVar : public TestFixture {
             "void MyExit(err)\n"
             "{\n"
             "    exit(err);\n"
-            "}", dinit(CheckOptions, $.cpp = true));
+            "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check( // #6252
@@ -1514,14 +1514,14 @@ class TestLeakAutoVar : public TestFixture {
             "        delete m_thing;\n"
             "        m_thing = new Thing;\n"
             "    }\n"
-            "};", dinit(CheckOptions, $.cpp = true));
+            "};\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         // #7401
         check("void pCodeLabelDestruct(pCode *pc) {\n"
               "    free(PCL(pc)->label);\n"
               "    free(pc);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1531,7 +1531,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (a == 2) { free(p); return ((void*)1); }\n"
               "    free(p);\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1548,7 +1548,7 @@ class TestLeakAutoVar : public TestFixture {
               "       free(bar)\n"
               "   } while(!done);\n"
               "   return;"
-              "}"
+              "}\n"
               );
         ASSERT_EQUALS("", errout_str());
     }
@@ -1560,7 +1560,7 @@ class TestLeakAutoVar : public TestFixture {
               "    exit(1);\n"
               "  }\n"
               "  free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(void* p, int i) {\n" // #11391
@@ -1580,7 +1580,7 @@ class TestLeakAutoVar : public TestFixture {
               "  free(p);\n"
               "  x = (q == p);\n"
               "  free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:2:3] -> [test.c:4:3]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
     }
 
@@ -1588,7 +1588,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void do_wordexp(FILE *f) {\n"
               "  free(getword(f));\n"
               "  fclose(f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1597,14 +1597,14 @@ class TestLeakAutoVar : public TestFixture {
               "    free(p);\n"
               "    if (x && (p = malloc(10)))\n"
               "        free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char *p, int x) {\n"
               "    delete[] p;\n"
               "    if (x && (p = new char[10]))\n"
               "        delete[] p;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1717,7 +1717,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (q == NULL)\n"
               "        return;\n"
               "    free(q);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:16] -> [test.c:8:5]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
     }
 
@@ -1753,7 +1753,7 @@ class TestLeakAutoVar : public TestFixture {
               "    int *i = new int;\n"
               "    unique_ptr<int> x(i);\n"
               "    delete i;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:6:5] -> [test.cpp:7:12]: (error) Memory pointed to by 'i' is freed twice. [doubleFree]\n", errout_str());
 
         check("using namespace std;\n"
@@ -1762,14 +1762,14 @@ class TestLeakAutoVar : public TestFixture {
               "{\n"
               "    int *i = new int;\n"
               "    unique_ptr<int> x(i);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
     void doublefree15() { // #11966
         check("void f(FILE* fp) {\n"
               "    static_cast<void>(fclose(fp));\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1831,7 +1831,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    exit(0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1839,7 +1839,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    fatal_error();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:18]: (information) --check-library: Function fatal_error() should have <noreturn> configuration [checkLibraryNoReturn]\n",
                       errout_str());
     }
@@ -1850,9 +1850,9 @@ class TestLeakAutoVar : public TestFixture {
               "  if (x) {\n"
               "    free(p);\n"
               "    ::exit(0);\n"
-              "  }"
+              "  }\n"
               "  free(p);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -1860,9 +1860,9 @@ class TestLeakAutoVar : public TestFixture {
               "  if (x) {\n"
               "    free(p);\n"
               "    std::exit(0);\n"
-              "  }"
+              "  }\n"
               "  free(p);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1875,7 +1875,7 @@ class TestLeakAutoVar : public TestFixture {
               "        func_notret();\n"
               "    }\n"
               "    free(ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1884,7 +1884,7 @@ class TestLeakAutoVar : public TestFixture {
               "  p->x = malloc(10);\n"
               "  free(p->x);\n"
               "  p->x = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(s_t s) {\n" // #11061
@@ -1906,7 +1906,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void g(size_t len) {\n" // #12365
               "    char* b = new char[len + 1]{};\n"
               "    std::string str = std::string(b);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:4:1]: (error) Memory leak: b [memleak]\n", errout_str());
     }
 
@@ -1917,7 +1917,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (err) {\n"
               "        free(reg);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1930,7 +1930,7 @@ class TestLeakAutoVar : public TestFixture {
               "        goto x;\n"
               "    }\n"
               "    return p;\n"  // no error since there is a goto
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1955,7 +1955,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (x) { p = malloc(10); }\n"
               "    else { return 0; }\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1964,7 +1964,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = NULL;\n"
               "    if (x) { p = malloc(10); }\n"
               "    else { return 0; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:5:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
@@ -1973,7 +1973,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    if (!p) { return; }\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("char * f(size_t size) {"
@@ -1981,14 +1981,14 @@ class TestLeakAutoVar : public TestFixture {
               "    if (!p && size != 0)"
               "        return NULL;"
               "    return p;"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    if (p) { } else { return; }\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3866 - UNLIKELY
@@ -1996,7 +1996,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    if (UNLIKELY(!p)) { return; }\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2005,7 +2005,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p;\n"
               "    if (x) { p = malloc(10); }\n"
               "    if (x) { free(p); }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
@@ -2013,7 +2013,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (x) { p = malloc(10); }\n"
               "    if (!x) { return; }\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2022,7 +2022,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    if (!p && x) { p = malloc(10); }\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2033,7 +2033,7 @@ class TestLeakAutoVar : public TestFixture {
               "        free(a);\n"
               "    else\n"
               "        a = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:6:9]: (error) Memory leak: a [memleak]\n", errout_str());
     }
 
@@ -2043,7 +2043,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (x < 0)\n"  // assume negative value indicates its unallocated
               "        return;\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2053,7 +2053,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (fd == -1)\n"
               "        return -1;\n"
               "    return fd;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
@@ -2061,7 +2061,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (fd != -1)\n"
               "        return fd;\n"
               "    return -1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2071,7 +2071,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (dostuff(p==NULL,0))\n"
               "        return;\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2081,7 +2081,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (!(x != NULL))\n"
               "        return;\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2091,7 +2091,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (NULL == (p = malloc(4)))\n"
               "        return;\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2099,7 +2099,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f(char **p) {\n"
               "    if ((*p = malloc(4)) == NULL)\n"
               "        return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2110,7 +2110,7 @@ class TestLeakAutoVar : public TestFixture {
               "        return 1;\n"
               "    free(path);\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int fd, const char *mode) {\n"
@@ -2119,7 +2119,7 @@ class TestLeakAutoVar : public TestFixture {
               "        return 1;\n" // <- memory leak
               "    free(path);\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4] memory leak", "", errout_str());
     }
 
@@ -2129,7 +2129,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (buf == (char*)NULL)\n"
               "        return NULL;\n"
               "    return buf;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2139,14 +2139,14 @@ class TestLeakAutoVar : public TestFixture {
               "void test_alloc() {\n"
               "   if ( global_ptr = new SSS()) {}\n"
               "   return;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("FILE* hFile;\n"
               "int openFile( void ) {\n"
               "   if ((hFile = fopen(\"1.txt\", \"wb\" )) == NULL) return 0;\n"
               "   return 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2157,7 +2157,7 @@ class TestLeakAutoVar : public TestFixture {
               "        return;\n"
               "    free(p);\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(void) {\n"
@@ -2166,7 +2166,7 @@ class TestLeakAutoVar : public TestFixture {
               "        return;\n"
               "    free(p);\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2176,7 +2176,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (!p)\n"
               "        return NULL;\n"
               "    return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int *f() {\n"
@@ -2184,7 +2184,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (!!(!p))\n"
               "        return NULL;\n"
               "    return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2195,7 +2195,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (q == 0)\n"
               "        return;\n"
               "    free(q);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:5:9]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("void f() {\n"
@@ -2206,7 +2206,7 @@ class TestLeakAutoVar : public TestFixture {
               "        return;\n"
               "    } else\n"
               "        return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:8:9]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
@@ -2217,7 +2217,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (!b)\n"
               "        return;\n"
               "    a = b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2228,7 +2228,7 @@ class TestLeakAutoVar : public TestFixture {
               "    else\n"
               "        void * p2 = malloc(2);\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:30]: (error) Memory leak: p1 [memleak]\n"
                       "[test.c:5:30]: (error) Memory leak: p2 [memleak]\n", errout_str());
 
@@ -2237,7 +2237,7 @@ class TestLeakAutoVar : public TestFixture {
               "        void * p1 = malloc(5);\n"
               "    else\n"
               "        void * p2 = malloc(2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:30]: (error) Memory leak: p1 [memleak]\n"
                       "[test.c:5:30]: (error) Memory leak: p2 [memleak]\n", errout_str());
     }
@@ -2250,7 +2250,7 @@ class TestLeakAutoVar : public TestFixture {
               "            p = malloc(5);\n"
               "    }\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:6:5]: (error) Memory leak: p [memleak]\n",  errout_str());
     }
 
@@ -2260,7 +2260,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (fd >= 0)\n"
               "        return fd;\n"
               "    return -1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(const char * pathname, int flags) {\n"
@@ -2268,7 +2268,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (fd <= -1)\n"
               "        return -1;\n"
               "    return fd;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2410,7 +2410,7 @@ class TestLeakAutoVar : public TestFixture {
               "    default: return;\n"
               "    }\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2421,7 +2421,7 @@ class TestLeakAutoVar : public TestFixture {
               "    for (i=0;i<5;i++) { }\n"
               "    if (x) { free(p) }\n"
               "    else { a = p; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2456,13 +2456,13 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    free(f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:2:12] -> [test.c:3:5]: (error) Mismatching allocation and deallocation: f [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    free((void*)f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:2:12] -> [test.c:3:5]: (error) Mismatching allocation and deallocation: f [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
@@ -2472,18 +2472,18 @@ class TestLeakAutoVar : public TestFixture {
               "    delete[] cPtr;\n"
               "    cPtr = new char[100];\n"
               "    delete cPtr;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:6:12] -> [test.cpp:7:12]: (error) Mismatching allocation and deallocation: cPtr [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "    char *cPtr = new char[100];\n"
               "    free(cPtr);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:2:18] -> [test.cpp:3:5]: (error) Mismatching allocation and deallocation: cPtr [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "    char *cPtr = new (buf) char[100];\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -2502,7 +2502,7 @@ class TestLeakAutoVar : public TestFixture {
               "   void* a = malloc(1);\n"
               "   void* b = freopen(f, p, a);\n"
               "   free(b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:2:14] -> [test.c:3:14]: (error) Mismatching allocation and deallocation: a [mismatchAllocDealloc]\n"
                       "[test.c:3:14] -> [test.c:4:4]: (error) Mismatching allocation and deallocation: b [mismatchAllocDealloc]\n", errout_str());
 
@@ -2510,14 +2510,14 @@ class TestLeakAutoVar : public TestFixture {
               "   void* a;\n"
               "   void* b = realloc(a, 10);\n"
               "   free(b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "   int * i = new int;\n"
               "   int * j = realloc(i, 2 * sizeof(int));\n"
               "   delete[] j;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:2:14] -> [test.cpp:3:14]: (error) Mismatching allocation and deallocation: i [mismatchAllocDealloc]\n"
                       "[test.cpp:3:14] -> [test.cpp:4:13]: (error) Mismatching allocation and deallocation: j [mismatchAllocDealloc]\n", errout_str());
 
@@ -2547,26 +2547,26 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::unique_ptr<FILE> fp{f};\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:3:30]: (error) Mismatching allocation and deallocation: f [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::unique_ptr<FILE, decltype(&fclose)> fp{f, &fclose};\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::shared_ptr<FILE> fp{f, &fclose};\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("struct deleter { void operator()(FILE* f) { fclose(f); }};\n"
               "void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::unique_ptr<FILE, deleter> fp{f};\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("int * create();\n"
@@ -2588,39 +2588,39 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::shared_ptr<FILE> fp{f, [](FILE* x) { fclose(x); }};\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::shared_ptr<FILE> fp{f, +[](FILE* x) { fclose(x); }};\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::shared_ptr<FILE> fp{f, [](FILE* x) { free(f); }};\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:3:30]: (error) Mismatching allocation and deallocation: f [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::shared_ptr<FILE> fp{f, [](FILE* x) {}};\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:3:30]: (error) Mismatching allocation and deallocation: f [mismatchAllocDealloc]\n", errout_str());
 
         check("class C;\n"
               "void f() {\n"
               "  C* c = new C{};\n"
               "  std::shared_ptr<C> a{c, [](C*) {}};\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("class C;\n"
               "void f() {\n"
               "  C* c = new C{};\n"
               "  std::shared_ptr<C> a{c, [](C* x) { delete x; }};\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("struct DirDeleter {\n" // #12544
@@ -2652,7 +2652,7 @@ class TestLeakAutoVar : public TestFixture {
         check("int f() {\n"
               "    char *p = malloc(100);\n"
               "    return 123;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:5]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
@@ -2660,7 +2660,7 @@ class TestLeakAutoVar : public TestFixture {
         check("char *f() {\n"
               "    char *p = malloc(100);\n"
               "    return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2668,7 +2668,7 @@ class TestLeakAutoVar : public TestFixture {
         check("struct dev * f() {\n"
               "    struct ABC *abc = malloc(100);\n"
               "    return &abc->dev;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2680,7 +2680,7 @@ class TestLeakAutoVar : public TestFixture {
               "        throw 1;\n"
               "    }\n"
               "    free(p);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char *p, int x) {\n"
@@ -2689,7 +2689,7 @@ class TestLeakAutoVar : public TestFixture {
               "        throw 1;\n"
               "    }\n"
               "    delete p;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char *p, int x) {\n"
@@ -2698,7 +2698,7 @@ class TestLeakAutoVar : public TestFixture {
               "        throw 1;\n"
               "    }\n"
               "    delete [] p;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2712,7 +2712,7 @@ class TestLeakAutoVar : public TestFixture {
               "        return;\n"
               "    }\n"
               "    *p = 0;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2720,7 +2720,7 @@ class TestLeakAutoVar : public TestFixture {
         check("std::pair<char*, char*> f(size_t n) {\n"
               "   char* p = (char* )malloc(n);\n"
               "   return {p, p};\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2728,43 +2728,43 @@ class TestLeakAutoVar : public TestFixture {
         check("uint8_t *f() {\n"
               "    void *x = malloc(1);\n"
               "    return (uint8_t *)x;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("uint8_t f() {\n"
               "    void *x = malloc(1);\n"
               "    return (uint8_t)x;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Memory leak: x [memleak]\n", errout_str());
 
         check("void** f() {\n"
               "    void *x = malloc(1);\n"
               "    return (void**)x;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void* f() {\n"
               "    void *x = malloc(1);\n"
               "    return (long long)x;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void* f() {\n"
               "    void *x = malloc(1);\n"
               "    return (void*)(short)x;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Memory leak: x [memleak]\n", errout_str());
 
         check("void* f() {\n"
               "    void *x = malloc(1);\n"
               "    return (mytype)x;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void* f() {\n" // Do not crash
               "    void *x = malloc(1);\n"
               "    return (mytype)y;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Memory leak: x [memleak]\n", errout_str());
     }
 
@@ -2772,25 +2772,25 @@ class TestLeakAutoVar : public TestFixture {
         check("void* f() {\n"
               "    void *x = malloc(1);\n"
               "    return (x);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void* f() {\n"
               "    void *x = malloc(1);\n"
               "    return ((x));\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void* f() {\n"
               "    void *x = malloc(1);\n"
               "    return ((((x))));\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("char* f() {\n"
               "    void *x = malloc(1);\n"
               "    return (char*)(x);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2798,7 +2798,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void* f() {\n"
               "    void *x = malloc (sizeof (struct alloc));\n"
               "    return x + sizeof (struct alloc);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2807,7 +2807,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char* p = (char*)malloc(1);\n"
               "    p[0] = 'x';\n"
               "    return p[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:4:5]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("struct S { int f(); };\n" // #11746
@@ -2815,14 +2815,14 @@ class TestLeakAutoVar : public TestFixture {
               "    S* s = new S;\n"
               "    delete s;\n"
               "    return s->f();\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:5:5]: (error) Returning/dereferencing 's' after it is deallocated / released [deallocret]\n", errout_str());
 
         check("int f() {\n"
               "    int* p = new int(3);\n"
               "    delete p;\n"
               "    return *p;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:4:5]: (error) Returning/dereferencing 'p' after it is deallocated / released [deallocret]\n", errout_str());
     }
 
@@ -2878,7 +2878,7 @@ class TestLeakAutoVar : public TestFixture {
     void test1() {
         check("void f(double*&p) {\n" // 3809
               "    p = malloc(0x100);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int*& p) {\n" // #4400
@@ -2907,7 +2907,7 @@ class TestLeakAutoVar : public TestFixture {
         check("struct Fred {\n"
               "    char *p;\n"
               "    void f1() { free(p); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2915,7 +2915,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    char *&p = x();\n"
               "    p = malloc(10);\n"
-              "};", dinit(CheckOptions, $.cpp = true));
+              "};\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2924,21 +2924,21 @@ class TestLeakAutoVar : public TestFixture {
               "    static char *p;\n"
               "    if (!p) p = malloc(10);\n"
               "    if (x) { free(p); p = 0; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void test5() { // unknown type
-        check("void f() { Fred *p = malloc(10); }", dinit(CheckOptions, $.cpp = true));
+        check("void f() { Fred *p = malloc(10); }\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:1:34]: (error) Memory leak: p [memleak]\n", errout_str());
 
-        check("void f() { Fred *p = malloc(10); }");
+        check("void f() { Fred *p = malloc(10); }\n");
         ASSERT_EQUALS("[test.c:1:34]: (error) Memory leak: p [memleak]\n", errout_str());
 
-        check("void f() { Fred *p = new Fred; }", dinit(CheckOptions, $.cpp = true));
+        check("void f() { Fred *p = new Fred; }\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { Fred fred = malloc(10); }", dinit(CheckOptions, $.cpp = true));
+        check("void f() { Fred fred = malloc(10); }\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2946,7 +2946,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    throw 123;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("void f() {\n"
@@ -2956,7 +2956,7 @@ class TestLeakAutoVar : public TestFixture {
               "        throw 123;\n"
               "    } catch (...) { }\n"
               "    free(p);\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2973,7 +2973,7 @@ class TestLeakAutoVar : public TestFixture {
               "        throw ::NS::Except();\n"
               "    }\n"
               "    delete pi;\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2986,7 +2986,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    x(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:9]: (information) --check-library: Function x() should have <noreturn> configuration [checkLibraryNoReturn]\n"
                       "[test.c:4:1]: (information) --check-library: Function x() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n",
                       errout_str());
@@ -3004,7 +3004,7 @@ class TestLeakAutoVar : public TestFixture {
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    x(&p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:10]: (information) --check-library: Function x() should have <noreturn> configuration [checkLibraryNoReturn]\n"
                       "[test.c:4:1]: (information) --check-library: Function x() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n",
                       errout_str());
@@ -3015,7 +3015,7 @@ class TestLeakAutoVar : public TestFixture {
             const char code[] = "void f() {\n"
                                 "    char *p = malloc(10);\n"
                                 "    if (set_data(p)) { }\n"
-                                "}";
+                                "}\n";
             check(code);
             ASSERT_EQUALS("[test.c:4:1]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
             check(code, dinit(CheckOptions, $.cpp = true));
@@ -3026,7 +3026,7 @@ class TestLeakAutoVar : public TestFixture {
             const char code[] = "void f() {\n"
                                 "    char *p = malloc(10);\n"
                                 "    if (set_data(p)) { return; }\n"
-                                "}";
+                                "}\n";
             check(code);
             ASSERT_EQUALS("[test.c:3:24]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n"
                           "[test.c:4:1]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n"
@@ -3043,7 +3043,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    int ret = set_data(p);\n"
               "    return ret;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:4:5]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
     }
 
@@ -3121,7 +3121,7 @@ class TestLeakAutoVar : public TestFixture {
     void ptrptr() {
         check("void f() {\n"
               "    char **p = malloc(10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.c:3:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
@@ -3129,19 +3129,19 @@ class TestLeakAutoVar : public TestFixture {
         check("void QueueDSMCCPacket(unsigned char *data, int length) {\n"
               "    unsigned char *dataCopy = malloc(length * sizeof(unsigned char));\n"
               "    m_dsmccQueue.enqueue(new DSMCCPacket(dataCopy));\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:4:1]: (information) --check-library: Function DSMCCPacket() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
 
         check("void QueueDSMCCPacket(unsigned char *data, int length) {\n"
               "    unsigned char *dataCopy = malloc(length * sizeof(unsigned char));\n"
               "    m_dsmccQueue.enqueue(new DSMCCPacket(somethingunrelated));\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:4:1]: (error) Memory leak: dataCopy [memleak]\n", errout_str());
 
         check("void f() {\n"
               "  char *buf = new char[1000];\n"
               "  clist.push_back(new (std::nothrow) C(buf));\n"
-              "}", dinit(CheckOptions, $.cpp = true));
+              "}\n", dinit(CheckOptions, $.cpp = true));
         ASSERT_EQUALS("[test.cpp:4:1]: (information) --check-library: Function C() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
     }
 
@@ -3150,7 +3150,7 @@ class TestLeakAutoVar : public TestFixture {
               "  double *new = malloc(1*sizeof(double));\n"
               "  free(new);\n"
               "  return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3163,7 +3163,7 @@ class TestLeakAutoVar : public TestFixture {
               "    }\n"
               "    c = malloc(128);\n"
               "    return ret();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3226,7 +3226,7 @@ class TestLeakAutoVar : public TestFixture {
               "{\n"
               "    char * buf = malloc(4);\n"
               "    free_func((void *)(1), buf);\n"
-              "}", settingsFunctionCall);
+              "}\n", settingsFunctionCall);
         ASSERT_EQUALS("[test.cpp:5:1]: (information) --check-library: Function free_func() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
 
         check("void g(void*);\n"
@@ -3312,7 +3312,7 @@ class TestLeakAutoVarRecursiveCountLimit : public TestFixture {
                                             "void foo() {\n"
                                             "  if (0) { }\n"
                                             "  THOU THOU\n"
-                                            "}"), LIMIT, "Internal limit: CheckLeakAutoVar::checkScope() Maximum recursive count of 1000 reached.");
+                                            "}\n"), LIMIT, "Internal limit: CheckLeakAutoVar::checkScope() Maximum recursive count of 1000 reached.");
         ASSERT_NO_THROW(checkP("#define ONE     if (0) { }\n"
                                "#define TEN     ONE ONE ONE ONE ONE ONE ONE ONE ONE ONE\n"
                                "#define HUN     TEN TEN TEN TEN TEN TEN TEN TEN TEN TEN\n"
@@ -3320,7 +3320,7 @@ class TestLeakAutoVarRecursiveCountLimit : public TestFixture {
                                "void foo() {\n"
                                "  if (0) { }\n"
                                "  THOU THOU\n"
-                               "}"));
+                               "}\n"));
     }
 };
 
@@ -3362,7 +3362,7 @@ class TestLeakAutoVarStrcpy : public TestFixture {
               "{\n"
               "    char* ptr = new char[strlen(str)+1];\n"
               "    m = strcpy(ptr, str);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3370,7 +3370,7 @@ class TestLeakAutoVarStrcpy : public TestFixture {
         check("void f(char *p) {\n"
               "    free(p);\n"
               "    strcpy(a, p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n", errout_str());
 
         check("void f(char *p, const char *q) {\n" // #11665
@@ -3383,12 +3383,12 @@ class TestLeakAutoVarStrcpy : public TestFixture {
         check("void f(char *p) {\n"   // #3041 - assigning pointer when it's used
               "    free(p);\n"
               "    strcpy(a, p=b());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void fclose_false_positive() { // #9575
-        check("int  f(FILE *fp) { return fclose(fp); }");
+        check("int  f(FILE *fp) { return fclose(fp); }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3418,7 +3418,7 @@ class TestLeakAutoVarStrcpy : public TestFixture {
               "    if (b)\n"
               "        p = new S();\n"
               "    p->f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:1]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("class B { std::string s; };\n" // #12062
diff --git a/test/testlibrary.cpp b/test/testlibrary.cpp
index a531ac4cba9..28264a02a53 100644
--- a/test/testlibrary.cpp
+++ b/test/testlibrary.cpp
@@ -109,7 +109,7 @@ class TestLibrary : public TestFixture {
                                    "  </function>\n"
                                    "</def>";
 
-        const char code[] = "foo();";
+        const char code[] = "foo();\n";
         SimpleTokenList tokenList(code);
         tokenList.front()->next()->astOperand1(tokenList.front());
 
@@ -131,13 +131,13 @@ class TestLibrary : public TestFixture {
         Library library;
         ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
         {
-            const char code[] = "fred.foo(123);"; // <- wrong scope, not library function
+            const char code[] = "fred.foo(123);\n"; // <- wrong scope, not library function
             const SimpleTokenList tokenList(code);
 
             ASSERT(library.isNotLibraryFunction(tokenList.front()->tokAt(2)));
         }
         {
-            const char code[] = "Fred::foo(123);"; // <- wrong scope, not library function
+            const char code[] = "Fred::foo(123);\n"; // <- wrong scope, not library function
             const SimpleTokenList tokenList(code);
 
             ASSERT(library.isNotLibraryFunction(tokenList.front()->tokAt(2)));
@@ -153,7 +153,7 @@ class TestLibrary : public TestFixture {
                                    "</def>";
 
         TokenList tokenList(settingsDefault, Standards::Language::CPP);
-        const char code[] = "foo();"; // <- too few arguments, not library function
+        const char code[] = "foo();\n"; // <- too few arguments, not library function
         ASSERT(tokenList.createTokensFromString(code));
         Token::createMutualLinks(tokenList.front()->next(), tokenList.back()->previous());
         tokenList.createAst();
@@ -177,7 +177,7 @@ class TestLibrary : public TestFixture {
 
         {
             TokenList tokenList(settingsDefault, Standards::Language::CPP);
-            const char code[] = "foo();"; // <- too few arguments, not library function
+            const char code[] = "foo();\n"; // <- too few arguments, not library function
             ASSERT(tokenList.createTokensFromString(code));
             Token::createMutualLinks(tokenList.front()->next(), tokenList.back()->previous());
             tokenList.createAst();
@@ -186,7 +186,7 @@ class TestLibrary : public TestFixture {
         }
         {
             TokenList tokenList(settingsDefault, Standards::Language::CPP);
-            const char code[] = "foo(a);"; // <- library function
+            const char code[] = "foo(a);\n"; // <- library function
             ASSERT(tokenList.createTokensFromString(code));
             Token::createMutualLinks(tokenList.front()->next(), tokenList.back()->previous());
             tokenList.createAst();
@@ -197,7 +197,7 @@ class TestLibrary : public TestFixture {
         }
         {
             TokenList tokenList(settingsDefault, Standards::Language::CPP);
-            const char code[] = "foo(a, b);"; // <- library function
+            const char code[] = "foo(a, b);\n"; // <- library function
             ASSERT(tokenList.createTokensFromString(code));
             Token::createMutualLinks(tokenList.front()->next(), tokenList.back()->previous());
             tokenList.createAst();
@@ -208,7 +208,7 @@ class TestLibrary : public TestFixture {
         }
         {
             TokenList tokenList(settingsDefault, Standards::Language::CPP);
-            const char code[] = "foo(a, b, c);"; // <- too much arguments, not library function
+            const char code[] = "foo(a, b, c);\n"; // <- too much arguments, not library function
             ASSERT(tokenList.createTokensFromString(code));
             Token::createMutualLinks(tokenList.front()->next(), tokenList.back()->previous());
             tokenList.createAst();
@@ -225,7 +225,7 @@ class TestLibrary : public TestFixture {
                                    "  </function>\n"
                                    "</def>";
 
-        const char code[] = "Fred foo(123);"; // <- Variable declaration, not library function
+        const char code[] = "Fred foo(123);\n"; // <- Variable declaration, not library function
         SimpleTokenList tokenList(code);
         tokenList.front()->next()->astOperand1(tokenList.front());
         tokenList.front()->next()->varId(1);
@@ -285,7 +285,7 @@ class TestLibrary : public TestFixture {
         ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
         ASSERT_EQUALS(0, library.functions().at("foo").argumentChecks.at(-1).notuninit);
 
-        const char code[] = "foo(a,b,c,d,e);";
+        const char code[] = "foo(a,b,c,d,e);\n";
         SimpleTokenList tokenList(code);
         tokenList.front()->next()->astOperand1(tokenList.front());
 
@@ -309,7 +309,7 @@ class TestLibrary : public TestFixture {
         Library library;
         ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
-        const char code[] = "foo(a,b,c,d);";
+        const char code[] = "foo(a,b,c,d);\n";
         SimpleTokenList tokenList(code);
         tokenList.front()->next()->astOperand1(tokenList.front());
 
@@ -340,7 +340,7 @@ class TestLibrary : public TestFixture {
         Library library;
         ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
-        const char code[] = "foo(a,b,c,d,e,f,g,h,i,j,k);";
+        const char code[] = "foo(a,b,c,d,e,f,g,h,i,j,k);\n";
         SimpleTokenList tokenList(code);
         tokenList.front()->next()->astOperand1(tokenList.front());
 
@@ -481,7 +481,7 @@ class TestLibrary : public TestFixture {
         Library library;
         ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
-        const char code[] = "foo(a,b,c,d,e);";
+        const char code[] = "foo(a,b,c,d,e);\n";
         SimpleTokenList tokenList(code);
         tokenList.front()->next()->astOperand1(tokenList.front());
 
@@ -543,13 +543,13 @@ class TestLibrary : public TestFixture {
         ASSERT(library.functions().at("bar").argumentChecks.empty());
 
         {
-            const char code[] = "Foo::foo();";
+            const char code[] = "Foo::foo();\n";
             const SimpleTokenList tokenList(code);
             ASSERT(library.isnotnoreturn(tokenList.front()->tokAt(2)));
         }
 
         {
-            const char code[] = "bar();";
+            const char code[] = "bar();\n";
             const SimpleTokenList tokenList(code);
             ASSERT(library.isnotnoreturn(tokenList.front()));
         }
@@ -569,14 +569,14 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer tokenizer(settingsDefault, *this);
-            const char code[] = "CString str; str.Format();";
+            const char code[] = "CString str; str.Format();\n";
             ASSERT(tokenizer.tokenize(code));
             ASSERT(library.isnotnoreturn(Token::findsimplematch(tokenizer.tokens(), "Format")));
         }
 
         {
             SimpleTokenizer tokenizer(settingsDefault, *this);
-            const char code[] = "HardDrive hd; hd.Format();";
+            const char code[] = "HardDrive hd; hd.Format();\n";
             ASSERT(tokenizer.tokenize(code));
             ASSERT(!library.isnotnoreturn(Token::findsimplematch(tokenizer.tokens(), "Format")));
         }
@@ -595,14 +595,14 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer tokenizer(settingsDefault, *this);
-            const char code[] = "struct X : public Base { void dostuff() { f(0); } };";
+            const char code[] = "struct X : public Base { void dostuff() { f(0); } };\n";
             ASSERT(tokenizer.tokenize(code));
             ASSERT(library.isnullargbad(Token::findsimplematch(tokenizer.tokens(), "f"),1));
         }
 
         {
             SimpleTokenizer tokenizer(settingsDefault, *this);
-            const char code[] = "struct X : public Base { void dostuff() { f(1,2); } };";
+            const char code[] = "struct X : public Base { void dostuff() { f(1,2); } };\n";
             ASSERT(tokenizer.tokenize(code));
             ASSERT(!library.isnullargbad(Token::findsimplematch(tokenizer.tokens(), "f"),1));
         }
@@ -622,7 +622,7 @@ class TestLibrary : public TestFixture {
         Library library;
         ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
-        const char code[] = "a(); b();";
+        const char code[] = "a(); b();\n";
         const SimpleTokenList tokenList(code);
 
         const Library::WarnInfo* a = library.getWarnInfo(tokenList.front());
@@ -872,7 +872,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("std::A<int> a;"));
+            ASSERT(var.tokenize("std::A<int> a;\n"));
             ASSERT_EQUALS(&A, library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             bool isIterator;
@@ -882,7 +882,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("std::A<int>::size_type a_s;"));
+            ASSERT(var.tokenize("std::A<int>::size_type a_s;\n"));
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             ASSERT(!library.detectContainerOrIterator(var.tokens()));
@@ -890,7 +890,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("std::A<int>::iterator a_it;"));
+            ASSERT(var.tokenize("std::A<int>::iterator a_it;\n"));
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT_EQUALS(&A, library.detectIterator(var.tokens()));
             bool isIterator;
@@ -900,7 +900,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("std::B<int> b;"));
+            ASSERT(var.tokenize("std::B<int> b;\n"));
             ASSERT_EQUALS(&B, library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             bool isIterator;
@@ -910,7 +910,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("std::B<int>::size_type b_s;"));
+            ASSERT(var.tokenize("std::B<int>::size_type b_s;\n"));
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             ASSERT(!library.detectContainerOrIterator(var.tokens()));
@@ -918,7 +918,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("std::B<int>::iterator b_it;"));
+            ASSERT(var.tokenize("std::B<int>::iterator b_it;\n"));
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT_EQUALS(&B, library.detectIterator(var.tokens()));
             bool isIterator;
@@ -928,7 +928,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("C c;"));
+            ASSERT(var.tokenize("C c;\n"));
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             ASSERT(!library.detectContainerOrIterator(var.tokens()));
@@ -936,7 +936,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("D d;"));
+            ASSERT(var.tokenize("D d;\n"));
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             ASSERT(!library.detectContainerOrIterator(var.tokens()));
@@ -944,7 +944,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("std::E e;"));
+            ASSERT(var.tokenize("std::E e;\n"));
             ASSERT(library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             bool isIterator;
@@ -955,7 +955,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("E e;"));
+            ASSERT(var.tokenize("E e;\n"));
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             ASSERT(!library.detectContainerOrIterator(var.tokens()));
@@ -964,7 +964,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("std::E::iterator I;"));
+            ASSERT(var.tokenize("std::E::iterator I;\n"));
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             ASSERT(!library.detectContainerOrIterator(var.tokens()));
@@ -973,7 +973,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("std::E::size_type p;"));
+            ASSERT(var.tokenize("std::E::size_type p;\n"));
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             ASSERT(!library.detectContainerOrIterator(var.tokens()));
@@ -982,7 +982,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("std::F f;"));
+            ASSERT(var.tokenize("std::F f;\n"));
             ASSERT(library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             bool isIterator;
@@ -992,7 +992,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("std::F::iterator I;"));
+            ASSERT(var.tokenize("std::F::iterator I;\n"));
             ASSERT(!library.detectContainer(var.tokens()));
             TODO_ASSERT(library.detectIterator(var.tokens()));
             bool isIterator = false;
@@ -1002,7 +1002,7 @@ class TestLibrary : public TestFixture {
 
         {
             SimpleTokenizer var(*this);
-            ASSERT(var.tokenize("F::iterator I;"));
+            ASSERT(var.tokenize("F::iterator I;\n"));
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             ASSERT(!library.detectContainerOrIterator(var.tokens()));
diff --git a/test/testmemleak.cpp b/test/testmemleak.cpp
index 2999fd3f441..e05698ae23e 100644
--- a/test/testmemleak.cpp
+++ b/test/testmemleak.cpp
@@ -51,19 +51,19 @@ class TestMemleak : public TestFixture {
     void testFunctionReturnType() {
         {
             const char code[] = "const char *foo()\n"
-                                "{ return 0; }";
+                                "{ return 0; }\n";
             ASSERT_EQUALS(CheckMemoryLeakImpl::No, functionReturnType(code));
         }
 
         {
             const char code[] = "Fred *newFred()\n"
-                                "{ return new Fred; }";
+                                "{ return new Fred; }\n";
             ASSERT_EQUALS(CheckMemoryLeakImpl::New, functionReturnType(code));
         }
 
         {
             const char code[] = "char *foo()\n"
-                                "{ return new char[100]; }";
+                                "{ return new char[100]; }\n";
             ASSERT_EQUALS(CheckMemoryLeakImpl::NewArray, functionReturnType(code));
         }
 
@@ -72,7 +72,7 @@ class TestMemleak : public TestFixture {
                                 "{\n"
                                 "    char *p = new char[100];\n"
                                 "    return p;\n"
-                                "}";
+                                "}\n";
             ASSERT_EQUALS(CheckMemoryLeakImpl::NewArray, functionReturnType(code));
         }
     }
@@ -157,7 +157,7 @@ class TestMemleakInFunction : public TestFixture {
               "{\n"
               "    char *a = (char *)malloc(10);\n"
               "    a = realloc(a, 100);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
@@ -167,7 +167,7 @@ class TestMemleakInFunction : public TestFixture {
               "    char *a = (char *)malloc(10);\n"
               "    a = (char *)realloc(a, 100);\n"
               "    free(a);\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
@@ -179,7 +179,7 @@ class TestMemleakInFunction : public TestFixture {
               "    if ((a = realloc(a, 100)) == NULL)\n"
               "        return;\n"
               "    free(a);\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -191,7 +191,7 @@ class TestMemleakInFunction : public TestFixture {
               "    if ((a = realloc(a, 100)) == NULL)\n"
               "        return;\n"
               "    free(a);\n"
-              "}");
+              "}\n");
 
         TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Memory leak: a\n",
                            "[test.cpp:4:10]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n",
@@ -209,7 +209,7 @@ class TestMemleakInFunction : public TestFixture {
               "        free(buf);\n"
               "    else\n"
               "        free(new_buf);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -223,7 +223,7 @@ class TestMemleakInFunction : public TestFixture {
               "    }\n"
               "    free(pData);\n"
               "    return true;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -235,7 +235,7 @@ class TestMemleakInFunction : public TestFixture {
               "    if (!m_buf) {\n"
               "        m_buf = origBuf;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -243,7 +243,7 @@ class TestMemleakInFunction : public TestFixture {
         check("void foo()\n"
               "{\n"
               "    x = realloc(x,100);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -253,7 +253,7 @@ class TestMemleakInFunction : public TestFixture {
               "    pa = pb = malloc(10);\n"
               "    pa = realloc(pa, 20);"
               "    exit();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -264,7 +264,7 @@ class TestMemleakInFunction : public TestFixture {
               "    if (!p)\n"
               "        error();\n"
               "    usep(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -275,7 +275,7 @@ class TestMemleakInFunction : public TestFixture {
               "    if ((a = realloc(a, x + 100)) == NULL)\n"
               "        return;\n"
               "    free(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -285,7 +285,7 @@ class TestMemleakInFunction : public TestFixture {
               "    char **str;\n"
               "    *str = realloc(*str,100);\n"
               "    free (*str);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Common realloc mistake: \'str\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
@@ -296,7 +296,7 @@ class TestMemleakInFunction : public TestFixture {
               "    if (!p)\n"
               "        error();\n"
               "    usep(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -307,7 +307,7 @@ class TestMemleakInFunction : public TestFixture {
               "    if( m_options == NULL )\n"
               "        return false;\n"
               "    return true;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Common realloc mistake: \'m_options\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
@@ -317,7 +317,7 @@ class TestMemleakInFunction : public TestFixture {
               "  if (zLine) {\n"
               "    free(zLine);\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -326,7 +326,7 @@ class TestMemleakInFunction : public TestFixture {
               "{\n"
               "    void ***a = malloc(sizeof(a));\n"
               "    ***a = realloc(***(a), sizeof(a) * 2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:8]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
@@ -335,7 +335,7 @@ class TestMemleakInFunction : public TestFixture {
               "{\n"
               "    void *a = malloc(sizeof(a));\n"
               "    a = realloc((void*)a, sizeof(a) * 2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
@@ -344,7 +344,7 @@ class TestMemleakInFunction : public TestFixture {
               "{\n"
               "    void *a = malloc(sizeof(a));\n"
               "    a = (realloc((void*)((a)), sizeof(a) * 2));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
@@ -353,7 +353,7 @@ class TestMemleakInFunction : public TestFixture {
               "{\n"
               "    void *a = malloc(sizeof(a));\n"
               "    a = realloc((a) + 1, sizeof(a) * 2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -364,7 +364,7 @@ class TestMemleakInFunction : public TestFixture {
               "    bs = realloc(bs, 100);\n"
               "    if (bs == NULL) return bs0;\n"
               "    return bs;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -375,7 +375,7 @@ class TestMemleakInFunction : public TestFixture {
               "    bs = realloc(bs, 100);\n"
               "    if (bs == NULL) return;\n"
               "    *bsp = bs;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -386,7 +386,7 @@ class TestMemleakInFunction : public TestFixture {
               "    if (!(cigar = realloc(cigar, 100 * sizeof(*cigar))))\n"
               "        return;\n"
               "    s->cigar = cigar;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -394,28 +394,28 @@ class TestMemleakInFunction : public TestFixture {
         check("void f() {\n"
               "void *a = NULL;\n"
               "a = realloc(a, 20);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "void *a = NULL;\n"
               "a = malloc(10);\n"
               "a = realloc(a, 20);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:1]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
 
         check("void f() {\n"
               "void *a = nullptr;\n"
               "a = malloc(10);\n"
               "a = realloc(a, 20);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:1]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
 
         check("void f(char *b) {\n"
               "void *a = NULL;\n"
               "a = b;\n"
               "a = realloc(a, 20);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -568,7 +568,7 @@ class TestMemleakInClass : public TestFixture {
               "Fred::~Fred()\n"
               "{\n"
               "    delete [] str2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("class Fred\n"
@@ -586,7 +586,7 @@ class TestMemleakInClass : public TestFixture {
               "    {\n"
               "        delete [] str2;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
@@ -608,7 +608,7 @@ class TestMemleakInClass : public TestFixture {
               "Fred::~Fred()\n"
               "{\n"
               "    free(str1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:17:5]: (error) Mismatching allocation and deallocation: Fred::str1 [mismatchAllocDealloc]\n", errout_str());
 
         check("class Fred\n"
@@ -624,7 +624,7 @@ class TestMemleakInClass : public TestFixture {
               "    {\n"
               "        free(str1);\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:12:9]: (error) Mismatching allocation and deallocation: Fred::str1 [mismatchAllocDealloc]\n", errout_str());
     }
 
@@ -660,7 +660,7 @@ class TestMemleakInClass : public TestFixture {
               "        delete tok;\n"
               "        tok = next;\n"
               "    }\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -689,7 +689,7 @@ class TestMemleakInClass : public TestFixture {
               "            tok = next;\n"
               "        }\n"
               "    }\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -713,7 +713,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    ABC *p = new ABC;\n"
               "    addAbc( p );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct ABC;\n"
@@ -730,7 +730,7 @@ class TestMemleakInClass : public TestFixture {
               "        ABC *p = new ABC;\n"
               "        addAbc( p );\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -746,7 +746,7 @@ class TestMemleakInClass : public TestFixture {
               "    char *str = new char[100];\n"
               "    delete [] str;\n"
               "    hello();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
@@ -758,7 +758,7 @@ class TestMemleakInClass : public TestFixture {
               "        delete [] str;\n"
               "        hello();\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -778,7 +778,7 @@ class TestMemleakInClass : public TestFixture {
               "Fred::~Fred()\n"
               "{\n"
               "    delete this->i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
@@ -793,7 +793,7 @@ class TestMemleakInClass : public TestFixture {
               "    {\n"
               "        delete this->i;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -810,7 +810,7 @@ class TestMemleakInClass : public TestFixture {
               "    int* c = new int(1);\n"
               "    delete c;\n"
               "    doNothing(c);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
@@ -823,7 +823,7 @@ class TestMemleakInClass : public TestFixture {
               "        doNothing(c);\n"
               "    }\n"
               "    void doNothing() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -840,7 +840,7 @@ class TestMemleakInClass : public TestFixture {
               "{ p = new int; }\n"
               "\n"
               "A::~A()\n"
-              "{ delete (p); }");
+              "{ delete (p); }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
@@ -851,7 +851,7 @@ class TestMemleakInClass : public TestFixture {
               "    { p = new int; }\n"
               "    ~A()\n"
               "    { delete (p); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -863,7 +863,7 @@ class TestMemleakInClass : public TestFixture {
               "    A();\n"
               "};\n"
               "A::A()\n"
-              "{ p = new int; }");
+              "{ p = new int; }\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("class A\n"
@@ -871,7 +871,7 @@ class TestMemleakInClass : public TestFixture {
               "public:\n"
               "    int * p;\n"
               "    A() { p = new int; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
@@ -881,8 +881,8 @@ class TestMemleakInClass : public TestFixture {
               "public:\n"
               "    int * p;\n"
               "    A() : p(new int[10])\n"
-              "    { }"
-              "};");
+              "    { }\n"
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("class A\n"
@@ -892,7 +892,7 @@ class TestMemleakInClass : public TestFixture {
               "    A();\n"
               "};\n"
               "A::A() : p(new int[10])\n"
-              "{ }");
+              "{ }\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
@@ -914,7 +914,7 @@ class TestMemleakInClass : public TestFixture {
               "{ }\n"
               "\n"
               "void A::cleanup()\n"
-              "{ delete [] p; }");
+              "{ delete [] p; }\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("class A\n"
@@ -928,7 +928,7 @@ class TestMemleakInClass : public TestFixture {
               "    { }\n"
               "    void cleanup()\n"
               "    { delete [] p; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
@@ -950,7 +950,7 @@ class TestMemleakInClass : public TestFixture {
               "{ }\n"
               "\n"
               "void A::foo()\n"
-              "{ p = new int[10]; delete [] p; }");
+              "{ p = new int[10]; delete [] p; }\n");
         ASSERT_EQUALS("[test.cpp:17:3]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
 
         check("class A\n"
@@ -964,7 +964,7 @@ class TestMemleakInClass : public TestFixture {
               "    { }\n"
               "    void foo()\n"
               "    { p = new int[10]; delete [] p; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:11:7]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
     }
 
@@ -977,7 +977,7 @@ class TestMemleakInClass : public TestFixture {
               "};\n"
               "\n"
               "void A::init()\n"
-              "{ p = new int[10]; }");
+              "{ p = new int[10]; }\n");
         ASSERT_EQUALS("[test.cpp:9:3]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"
                       "[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
@@ -987,7 +987,7 @@ class TestMemleakInClass : public TestFixture {
               "public:\n"
               "    void init()\n"
               "    { p = new int[10]; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:6:7]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"
                       "[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
@@ -1000,7 +1000,7 @@ class TestMemleakInClass : public TestFixture {
               "};\n"
               "\n"
               "void A::init()\n"
-              "{ p = new int; }");
+              "{ p = new int; }\n");
         ASSERT_EQUALS("[test.cpp:9:3]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"
                       "[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
@@ -1010,7 +1010,7 @@ class TestMemleakInClass : public TestFixture {
               "public:\n"
               "    void init()\n"
               "    { p = new int; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:6:7]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"
                       "[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
@@ -1023,7 +1023,7 @@ class TestMemleakInClass : public TestFixture {
               "};\n"
               "\n"
               "void A::init()\n"
-              "{ p = malloc(sizeof(int)*10); }");
+              "{ p = malloc(sizeof(int)*10); }\n");
         ASSERT_EQUALS("[test.cpp:9:3]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"
                       "[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
@@ -1033,7 +1033,7 @@ class TestMemleakInClass : public TestFixture {
               "public:\n"
               "    void init()\n"
               "    { p = malloc(sizeof(int)*10); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:6:7]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"
                       "[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
@@ -1047,7 +1047,7 @@ class TestMemleakInClass : public TestFixture {
               "    ~A() { delete [] p; }\n"
               "};\n"
               "A::A()\n"
-              "{ p = new int[10]; }");
+              "{ p = new int[10]; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
@@ -1057,7 +1057,7 @@ class TestMemleakInClass : public TestFixture {
               "    A()\n"
               "    { p = new int[10]; }\n"
               "    ~A() { delete [] p; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -1069,7 +1069,7 @@ class TestMemleakInClass : public TestFixture {
               "    ~A() { delete p; }\n"
               "};\n"
               "A::A()\n"
-              "{ p = new int; }");
+              "{ p = new int; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
@@ -1079,7 +1079,7 @@ class TestMemleakInClass : public TestFixture {
               "    A()\n"
               "    { p = new int; }\n"
               "    ~A() { delete p; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -1091,7 +1091,7 @@ class TestMemleakInClass : public TestFixture {
               "    ~A() { free(p); }\n"
               "};\n"
               "A::A()\n"
-              "{ p = malloc(sizeof(int)*10); }");
+              "{ p = malloc(sizeof(int)*10); }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
@@ -1101,7 +1101,7 @@ class TestMemleakInClass : public TestFixture {
               "    A()\n"
               "    { p = malloc(sizeof(int)*10); }\n"
               "    ~A() { free(p); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1114,7 +1114,7 @@ class TestMemleakInClass : public TestFixture {
               "public:\n"
               "    A() { a = b = new int[10]; }\n"
               "    ~A() { delete [] a; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1131,7 +1131,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    A::pd = new char[12];\n"
               "    delete [] A::pd;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:5]: (warning) Possible leak in public function. The pointer 'pd' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
 
         check("class A {\n"
@@ -1143,7 +1143,7 @@ class TestMemleakInClass : public TestFixture {
               "        pd = new char[12];\n"
               "        delete [] pd;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:7:9]: (warning) Possible leak in public function. The pointer 'pd' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
 
         check("class A {\n"
@@ -1157,7 +1157,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    pd = new char[12];\n"
               "    delete [] pd;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:5]: (warning) Possible leak in public function. The pointer 'pd' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
     }
 
@@ -1173,7 +1173,7 @@ class TestMemleakInClass : public TestFixture {
               "  }\n"
               "private:\n"
               "  char *a;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class  A : public x\n"
@@ -1187,7 +1187,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "  a = new char[10];\n"
               "  foo(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1205,7 +1205,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    rp1 = new TRadioButton(this);\n"
               "    rp2 = new TRadioButton(this);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class TRadioButton { };\n"
@@ -1221,7 +1221,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    rp1 = new TRadioButton;\n"
               "    rp2 = new TRadioButton;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:19]: (style) Class 'Foo' is unsafe, 'Foo::rp1' can leak by wrong usage. [unsafeClassCanLeak]\n"
                       "[test.cpp:6:19]: (style) Class 'Foo' is unsafe, 'Foo::rp2' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
@@ -1244,7 +1244,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    delete rp1;\n"
               "    delete rp2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1266,7 +1266,7 @@ class TestMemleakInClass : public TestFixture {
               "            delete [] str2;\n"
               "        }\n"
               "    };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:15]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("namespace ns1 {\n"
@@ -1290,7 +1290,7 @@ class TestMemleakInClass : public TestFixture {
               "    {\n"
               "        delete [] str2;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:15]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("namespace ns1 {\n"
@@ -1313,7 +1313,7 @@ class TestMemleakInClass : public TestFixture {
               "ns1::Fred::~Fred()\n"
               "{\n"
               "    delete [] str2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:15]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("namespace ns1 {\n"
@@ -1338,7 +1338,7 @@ class TestMemleakInClass : public TestFixture {
               "ns1::ns2::Fred::~Fred()\n"
               "{\n"
               "    delete [] str2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:19]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("namespace ns1 {\n"
@@ -1365,7 +1365,7 @@ class TestMemleakInClass : public TestFixture {
               "ns1::ns2::ns3::Fred::~Fred()\n"
               "{\n"
               "    delete [] str2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:23]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
@@ -1382,7 +1382,7 @@ class TestMemleakInClass : public TestFixture {
               "    C *c;\n"
               "public:\n"
               "    A() : b(new B()), c(new C(b)) { }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:9:8]: (style) Class 'A' is unsafe, 'A::b' can leak by wrong usage. [unsafeClassCanLeak]\n"
                            "[test.cpp:10]: (style) Class 'A' is unsafe, 'A::c' can leak by wrong usage.\n",
                            "[test.cpp:9:8]: (style) Class 'A' is unsafe, 'A::b' can leak by wrong usage. [unsafeClassCanLeak]\n",
@@ -1404,7 +1404,7 @@ class TestMemleakInClass : public TestFixture {
               "       b = new B();\n"
               "       c = new C(b);\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:9:8]: (style) Class 'A' is unsafe, 'A::b' can leak by wrong usage. [unsafeClassCanLeak]\n"
                            "[test.cpp:10]: (style) Class 'A' is unsafe, 'A::c' can leak by wrong usage.\n",
                            "[test.cpp:9:8]: (style) Class 'A' is unsafe, 'A::b' can leak by wrong usage. [unsafeClassCanLeak]\n",
@@ -1418,7 +1418,7 @@ class TestMemleakInClass : public TestFixture {
               "private:\n"
               "    Fred() { a = new int; }\n"
               "    ~Fred() { (delete(a), (a)=NULL); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1437,7 +1437,7 @@ class TestMemleakInClass : public TestFixture {
               "    ~CData() { if (m_impl) m_impl->Release(); }\n"
               "private:\n"
               "    CDataImpl *m_impl;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1448,7 +1448,7 @@ class TestMemleakInClass : public TestFixture {
               "public:\n"
               "    Fred(const Fred &fred) { a = new int; }\n"
               "    ~Fred() { delete a; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1459,7 +1459,7 @@ class TestMemleakInClass : public TestFixture {
               "public:\n"
               "    Fred() { a = new int; }\n"
               "    ~Fred();\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1505,7 +1505,7 @@ class TestMemleakInClass : public TestFixture {
               "        if (!p)\n"
               "            p = new int[100];\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1537,7 +1537,7 @@ class TestMemleakInClass : public TestFixture {
               "void Tokenizer::deleteTokens(int *tok)\n"
               "{\n"
               "    delete tok;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Global function
@@ -1564,7 +1564,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    deleteTokens(_tokens);\n"
               "    _tokens = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1589,7 +1589,7 @@ class TestMemleakInClass : public TestFixture {
               "\n"
               "A::~A() {\n"
               "    delete [] pkt_buffer;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:14:9]: (error) Mismatching allocation and deallocation: A::pkt_buffer [mismatchAllocDealloc]\n", errout_str());
 
         check("struct S {\n" // 5678
@@ -1625,7 +1625,7 @@ class TestMemleakInClass : public TestFixture {
               "  data_ = new char[42];\n"
               "  delete data_;\n"
               "  data_ = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:17:3]: (warning) Possible leak in public function. The pointer 'data_' is not deallocated before it is allocated. [publicAllocationError]\n"
                       "[test.cpp:18:3]: (error) Mismatching allocation and deallocation: Foo::data_ [mismatchAllocDealloc]\n", errout_str());
 
@@ -1648,7 +1648,7 @@ class TestMemleakInClass : public TestFixture {
               "  data_ = new char[42];\n"
               "  delete data_;\n"
               "  data_ = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:17:3]: (warning) Possible leak in public function. The pointer 'data_' is not deallocated before it is allocated. [publicAllocationError]\n"
                       "[test.cpp:18:3]: (error) Mismatching allocation and deallocation: Foo::data_ [mismatchAllocDealloc]\n", errout_str());
     }
@@ -1663,7 +1663,7 @@ class TestMemleakInClass : public TestFixture {
               "    ~Fred() { free(s); }\n"
               "    void xy()\n"
               "    { s = malloc(100); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:9:7]: (warning) Possible leak in public function. The pointer 's' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
 
         check("class Fred\n"
@@ -1675,7 +1675,7 @@ class TestMemleakInClass : public TestFixture {
               "    { s = malloc(100); }\n"
               "private:\n"
               "    char *s;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:7:7]: (warning) Possible leak in public function. The pointer 's' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
     }
 
@@ -1689,7 +1689,7 @@ class TestMemleakInClass : public TestFixture {
               "    ~Fred() { free(s); }\n"
               "    const Fred & operator = (const Fred &f)\n"
               "    { s = malloc(100); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:9:7]: (warning) Possible leak in public function. The pointer 's' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
     }
 };
@@ -1782,14 +1782,14 @@ class TestMemleakStructMember : public TestFixture {
               "    struct ABC *abc = malloc(sizeof(struct ABC));\n"
               "    abc->a = malloc(10);\n"
               "    free(abc);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (error) Memory leak: abc.a [memleak]\n", errout_str());
 
         check("static void foo()\n"
               "{\n"
               "    struct ABC *abc = malloc(sizeof(struct ABC));\n"
               "    abc->a = malloc(10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:1]: (error) Memory leak: abc.a [memleak]\n", errout_str());
 
         check("static ABC * foo()\n"
@@ -1802,7 +1802,7 @@ class TestMemleakStructMember : public TestFixture {
               "        return 0;\n"
               "    }\n"
               "    return abc;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:9]: (error) Memory leak: abc.a [memleak]\n", errout_str());
 
         check("static void foo(int a)\n"
@@ -1814,7 +1814,7 @@ class TestMemleakStructMember : public TestFixture {
               "        free(abc->a);\n"
               "        return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:1]: (error) Memory leak: abc.a [memleak]\n", errout_str());
     }
 
@@ -1830,7 +1830,7 @@ class TestMemleakStructMember : public TestFixture {
               "out:\n"
               "    free(abc->a);\n"
               "    free(abc);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1840,13 +1840,13 @@ class TestMemleakStructMember : public TestFixture {
               "    struct ABC *abc = malloc(sizeof(struct ABC));\n"
               "    abc->a = malloc(10);\n"
               "    return abc;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("static void foo(struct ABC *abc)\n"
               "{\n"
               "    abc->a = malloc(10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7302
@@ -1854,14 +1854,14 @@ class TestMemleakStructMember : public TestFixture {
               "    struct ABC abc;\n"
               "    abc.a = malloc(10);\n"
               "    return abc.a;\n"
-              "}", false);
+              "}\n", false);
         ASSERT_EQUALS("", errout_str());
 
         check("void* foo() {\n"
               "    struct ABC abc;\n"
               "    abc.a = malloc(10);\n"
               "    return abc.b;\n"
-              "}", false);
+              "}\n", false);
         ASSERT_EQUALS("[test.c:4:5]: (error) Memory leak: abc.a [memleak]\n", errout_str());
     }
 
@@ -1871,7 +1871,7 @@ class TestMemleakStructMember : public TestFixture {
               "    struct ABC *abc = malloc(sizeof(struct ABC));\n"
               "    abc->a = malloc(10);\n"
               "    return &abc->self;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1880,7 +1880,7 @@ class TestMemleakStructMember : public TestFixture {
               "{\n"
               "    struct ABC *abc = abc1;\n"
               "    abc->a = malloc(10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("static void foo()\n"
@@ -1888,7 +1888,7 @@ class TestMemleakStructMember : public TestFixture {
               "    struct ABC *abc;\n"
               "    abc1 = abc = malloc(sizeof(ABC));\n"
               "    abc->a = malloc(10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("static void foo()\n"
@@ -1897,7 +1897,7 @@ class TestMemleakStructMember : public TestFixture {
               " ptr = malloc(sizeof(struct msn_entry));\n"
               " ptr->msn = malloc(100);\n"
               " back = ptr;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
     }
@@ -1906,7 +1906,7 @@ class TestMemleakStructMember : public TestFixture {
         check("static void foo() {\n"
               "    struct ABC *abc = malloc(123);\n"
               "    abc->a = abc->b = malloc(10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1915,7 +1915,7 @@ class TestMemleakStructMember : public TestFixture {
               "    struct s f2;\n"
               "    f2.a = malloc(100);\n"
               "    *f1 = f2;\n"
-              "}", false);
+              "}\n", false);
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2041,7 +2041,7 @@ class TestMemleakStructMember : public TestFixture {
               "        return 0;\n"
               "    }\n"
               "    return abc;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2052,7 +2052,7 @@ class TestMemleakStructMember : public TestFixture {
               "    struct ABC *abc = malloc(sizeof(struct ABC));\n"
               "    abc->a = malloc(10);\n"
               "    func(abc);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("static void foo()\n"
@@ -2060,7 +2060,7 @@ class TestMemleakStructMember : public TestFixture {
               "    struct ABC *abc = malloc(sizeof(struct ABC));\n"
               "    abclist.push_back(abc);\n"
               "    abc->a = malloc(10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2070,7 +2070,7 @@ class TestMemleakStructMember : public TestFixture {
               "  A a = { 0 };\n"
               "  a.foo = (char *) malloc(10);\n"
               "  assign(&a);\n"
-              "}", false);
+              "}\n", false);
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2080,7 +2080,7 @@ class TestMemleakStructMember : public TestFixture {
               "  struct ABC *abc = malloc(100);\n"
               "  abc.a = (char *) malloc(10);\n"
               "  list_add_tail(&abc->list, head);\n"
-              "}", false);
+              "}\n", false);
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2091,7 +2091,7 @@ class TestMemleakStructMember : public TestFixture {
               "  struct ABC abc;\n"
               "  abc.a = (char *) malloc(10);\n"
               "  a(abc.a);\n"
-              "}", false);
+              "}\n", false);
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2100,14 +2100,14 @@ class TestMemleakStructMember : public TestFixture {
               "    struct s s1;\n"
               "    s1->x = malloc(1);\n"
               "    return (s1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct nc_rpc nc_rpc_getconfig() {\n" // #10382
               "    struct nc_rpc rpc;\n"
               "    rpc->filter = malloc(1);\n"
               "    return (nc_rpc)rpc;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("T* f(const char *str) {\n" // #10158
@@ -2154,7 +2154,7 @@ class TestMemleakStructMember : public TestFixture {
               "    S* s = new S();\n"
               "    s->p = new int();\n"
               "    g((void*)s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2173,7 +2173,7 @@ class TestMemleakStructMember : public TestFixture {
               "    }\n"
               "    free(abc->a);\n"
               "    free(abc);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2189,7 +2189,7 @@ class TestMemleakStructMember : public TestFixture {
               "        free(abc);\n"
               "        abc = next;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2201,7 +2201,7 @@ class TestMemleakStructMember : public TestFixture {
               "    abc = malloc(sizeof(struct ABC));\n"
               "    abc->a = malloc(10);\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2219,7 +2219,7 @@ class TestMemleakStructMember : public TestFixture {
                              "    a.f = fopen(\"test\", \"r\");\n"
                              "    a.c = new char[12];\n"
                              "    a.m = malloc(12);\n"
-                             "}";
+                             "}\n";
 
         check(code1, true);
         ASSERT_EQUALS("[test.cpp:12:1]: (error) Resource leak: a.f [resourceLeak]\n"
@@ -2244,7 +2244,7 @@ class TestMemleakStructMember : public TestFixture {
                              "    fclose(a.f);\n"
                              "    delete [] a.c;\n"
                              "    free(a.m);\n"
-                             "}";
+                             "}\n";
 
         check(code2, true);
         ASSERT_EQUALS("", errout_str());
@@ -2253,7 +2253,7 @@ class TestMemleakStructMember : public TestFixture {
         const char code3[] = "void func() {\n"
                              "    struct A a;\n"
                              "    a.f = fopen(\"test\", \"r\");\n"
-                             "}";
+                             "}\n";
 
         check(code3, true);
         ASSERT_EQUALS("", errout_str());
@@ -2268,7 +2268,7 @@ class TestMemleakStructMember : public TestFixture {
                              "void func() {\n"
                              "    struct A a;\n"
                              "    a.f = fopen(\"test\", \"r\");\n"
-                             "}";
+                             "}\n";
 
         check(code4, true);
         ASSERT_EQUALS("", errout_str());
@@ -2284,7 +2284,7 @@ class TestMemleakStructMember : public TestFixture {
               "{\n"
               "  Test& y = *x;\n"
               "  y.data = malloc(10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2294,7 +2294,7 @@ class TestMemleakStructMember : public TestFixture {
               "unique_ptr<char[]>otherbuffer{new char[otherbufsize+1]};\n"
               "char *const oldbuffer = otherbuffer.get();\n"
               "int const oldbufsize = otherbufsize;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2307,7 +2307,7 @@ class TestMemleakStructMember : public TestFixture {
               "  (s).state_check_buff = (void* )malloc(1);\n"
               "  if (s.state_check_buff == 0)\n"
               "    return;\n"
-              "}", false);
+              "}\n", false);
         ASSERT_EQUALS("[test.c:9:1]: (error) Memory leak: s.state_check_buff [memleak]\n", errout_str());
     }
 
@@ -2317,7 +2317,7 @@ class TestMemleakStructMember : public TestFixture {
               "  foo f;\n"
               "  ((f)->realm) = strdup(realm);\n"
               "  if(f->realm == NULL) {}\n"
-              "}", false);
+              "}\n", false);
         ASSERT_EQUALS("[test.c:6:1]: (error) Memory leak: f.realm [memleak]\n", errout_str());
     }
 
@@ -2328,7 +2328,7 @@ class TestMemleakStructMember : public TestFixture {
               "void func() {\n"
               "    struct ABC abc;\n"
               "    abc.a = myalloc();\n"
-              "}", false);
+              "}\n", false);
         ASSERT_EQUALS("[test.c:7:1]: (error) Memory leak: abc.a [memleak]\n", errout_str());
     }
 
@@ -2344,7 +2344,7 @@ class TestMemleakStructMember : public TestFixture {
             "    }\n"
             "    delete[] s.p;\n"
             "    return 0;\n"
-            "}", true);
+            "}\n", true);
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -2425,23 +2425,23 @@ class TestMemleakNoVar : public TestFixture {
         // standard function..
         check("void x() {\n"
               "    strcpy(a, strdup(p));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (error) Allocation with strdup, strcpy doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("char *x() {\n"
               "    char *ret = strcpy(malloc(10), \"abc\");\n"
               "    return ret;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("char *x() {\n"
               "    return strcpy(malloc(10), \"abc\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void x() {\n"
               "    free(malloc(10));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // user function..
@@ -2450,7 +2450,7 @@ class TestMemleakNoVar : public TestFixture {
               "\n"
               "void x() {\n"
               "    set_error(strdup(p));\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:15]: (error) Allocation with strdup, set_error doesn't release it. [leakNoVarFunctionCall]\n", "", errout_str());
 
         check("void f()\n"
@@ -2458,68 +2458,68 @@ class TestMemleakNoVar : public TestFixture {
               "    int fd;\n"
               "    fd = mkstemp(strdup(\"/tmp/file.XXXXXXXX\"));\n"
               "    close(fd);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Allocation with strdup, mkstemp doesn't release it.\n", "", errout_str());
 
         check("void f()\n"
               "{\n"
               "    if(TRUE || strcmp(strdup(a), b));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:23]: (error) Allocation with strdup, strcmp doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    if(!strcmp(strdup(a), b) == 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Allocation with strdup, strcmp doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    42, strcmp(strdup(a), b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Allocation with strdup, strcmp doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("void f() {\n"
               "   assert(freopen(\"/dev/null\", \"r\", stdin));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void x() {\n"
               "    strcpy(a, (void*)strdup(p));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (error) Allocation with strdup, strcpy doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("void* malloc1() {\n"
               "    return (malloc(1));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("char *x() {\n"
               "    char *ret = (char*)strcpy(malloc(10), \"abc\");\n"
               "    return ret;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    free(malloc(1));\n"
               "    strcpy(a, strdup(p));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (error) Allocation with strdup, strcpy doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("void f() {\n"
               "    memcmp(calloc(10, 10), strdup(q), 100);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (error) Allocation with calloc, memcmp doesn't release it. [leakNoVarFunctionCall]\n"
                       "[test.cpp:2:28]: (error) Allocation with strdup, memcmp doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("void* f(int size) {\n"
               "    return (void*) malloc(size);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int* f(int size) {\n"
               "    return static_cast<int*>(malloc(size));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() { if (new int[42]) {} }\n" // #10857
@@ -2644,25 +2644,25 @@ class TestMemleakNoVar : public TestFixture {
         check("void x()\n"
               "{\n"
               "    malloc(10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void x()\n"
               "{\n"
               "    calloc(10, 1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Return value of allocation function 'calloc' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void x()\n"
               "{\n"
               "    strdup(\"Test\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Return value of allocation function 'strdup' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void x()\n"
               "{\n"
               "    (char*) malloc(10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void x()\n"
@@ -2670,7 +2670,7 @@ class TestMemleakNoVar : public TestFixture {
               "    char* ptr = malloc(10);\n"
               "    foo(ptr);\n"
               "    free(ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f( void ) {\n" // FP: #11246
@@ -2679,19 +2679,19 @@ class TestMemleakNoVar : public TestFixture {
               "  if ( ok )\n"
               "    free( address ), address = 0;\n"
               "  return 0;\n"
-              "} ");
+              "} \n");
         ASSERT_EQUALS("", errout_str());
 
         check("char** x(const char* str) {\n"
               "    char* ptr[] = { malloc(10), malloc(5), strdup(str) };\n"
               "    return ptr;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void x()\n"
               "{\n"
               "    42,malloc(42);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void *f()\n"
@@ -2701,7 +2701,7 @@ class TestMemleakNoVar : public TestFixture {
               "void x()\n"
               "{\n"
               "    f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (error) Return value of allocation function 'f' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void f()\n" // #8100
@@ -2711,7 +2711,7 @@ class TestMemleakNoVar : public TestFixture {
               "void x()\n"
               "{\n"
               "    f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void *f() {\n" // #8848
@@ -2720,26 +2720,26 @@ class TestMemleakNoVar : public TestFixture {
               "void x()\n"
               "{\n"
               "    f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void x()\n"
               "{\n"
               "    if(!malloc(5)) fail();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("FOO* factory() {\n"
               "    FOO* foo = new (std::nothrow) FOO;\n"
               "    return foo;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #6536
         check("struct S { S(int) {} };\n"
               "void foo(int i) {\n"
               "  S socket(i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #6693
@@ -2749,12 +2749,12 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void CTest::Initialise() {\n"
               "    malloc();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n" // #7348 - cast
               "    p = (::X*)malloc(42);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7182 "crash: CheckMemoryLeak::functionReturnType()"
@@ -2762,7 +2762,7 @@ class TestMemleakNoVar : public TestFixture {
               "template<typename T, typename... Ts> auto binary_left_comma (T x, Ts... ts) { return (x , ... , ts); }\n"
               "int main() {\n"
               "  unary_right_comma (a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -2778,7 +2778,7 @@ class TestMemleakNoVar : public TestFixture {
               "    new int{};\n"
               "    new int{ 1 };\n"
               "    new uint8_t[4];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
                       "[test.cpp:3:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
                       "[test.cpp:4:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
@@ -2796,7 +2796,7 @@ class TestMemleakNoVar : public TestFixture {
         check("void f(int* p) {\n"
               "    new auto('c');\n"
               "    new(p) int;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:1:29]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
                            "[test.cpp:3]: (error) Return value of allocation function 'new' is not stored.\n",
                            "",
@@ -2833,7 +2833,7 @@ class TestMemleakNoVar : public TestFixture {
               "    C{ new int(1), 1 };\n"
               "    C{ new(p) int, 1 };\n"
               "    C{ new QWidget, 1 };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b) { if (b && malloc(42)) {} }\n" //  // #10858
@@ -2896,54 +2896,54 @@ class TestMemleakNoVar : public TestFixture {
     void smartPointerFunctionParam() {
         check("void x() {\n"
               "    f(shared_ptr<int>(new int(42)), g());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_shared<int>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    h(12, f(shared_ptr<int>(new int(42)), g()));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_shared<int>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    f(unique_ptr<int>(new int(42)), g());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_unique<int>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    f(g(), shared_ptr<int>(new int(42)));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_shared<int>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    f(g(), unique_ptr<int>(new int(42)));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_unique<int>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    f(shared_ptr<char>(new char), make_unique<int>(32));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If make_unique<int>() throws, memory could be leaked. Use make_shared<char>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    f(g(124), h(\"test\", 234), shared_ptr<char>(new char));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If h() throws, memory could be leaked. Use make_shared<char>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    f(shared_ptr<std::string>(new std::string(\"\")), g<std::string>());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If g<std::string>() throws, memory could be leaked. Use make_shared<std::string>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void g(int x) throw() { }\n"
               "void x() {\n"
               "    f(g(124), shared_ptr<char>(new char));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void __declspec(nothrow) g(int x) { }\n"
               "void x() {\n"
               "    f(g(124), shared_ptr<char>(new char));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
     void resourceLeak() {
@@ -2954,23 +2954,23 @@ class TestMemleakNoVar : public TestFixture {
               "    if (result) return !result;\n"
               "    fclose(fp);\n"
               "    return result;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "  fopen(\"file.txt\", \"r\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: (error) Return value of allocation function 'fopen' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void foo() {\n"
               "  FILE *f = fopen(\"file.txt\", \"r\");\n"
               "  freopen(\"file.txt\", \"r\", f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3]: (error) Return value of allocation function 'freopen' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void foo() {\n"
               "  freopen(\"file.txt\", \"r\", stdin);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Holder {\n"
@@ -2980,7 +2980,7 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void foo() {\n"
               "  Holder h ( fopen(\"file.txt\", \"r\"));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Holder {\n"
@@ -2990,7 +2990,7 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void foo() {\n"
               "  Holder ( fopen(\"file.txt\", \"r\"));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Holder {\n"
@@ -3000,7 +3000,7 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void foo() {\n"
               "  Holder h { fopen(\"file.txt\", \"r\")};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Holder {\n"
@@ -3010,7 +3010,7 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void foo() {\n"
               "  Holder h = fopen(\"file.txt\", \"r\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Holder {\n"
@@ -3020,7 +3020,7 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void foo() {\n"
               "  Holder { fopen(\"file.txt\", \"r\")};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Holder {\n"
@@ -3030,7 +3030,7 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void foo() {\n"
               "  Holder { 0, fopen(\"file.txt\", \"r\")};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3041,7 +3041,7 @@ class TestMemleakNoVar : public TestFixture {
               "\n"
               "void f() {\n"
               "  makeThing();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #10631
@@ -3068,12 +3068,12 @@ class TestMemleakNoVar : public TestFixture {
     void crash1() { // #10729
         check("void foo() {\n"
               "    extern void *realloc (void *ptr, size_t size);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    extern void *malloc (size_t size);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
diff --git a/test/testnullpointer.cpp b/test/testnullpointer.cpp
index c1bf766b8bb..81c44d58811 100644
--- a/test/testnullpointer.cpp
+++ b/test/testnullpointer.cpp
@@ -228,7 +228,7 @@ class TestNullPointer : public TestFixture {
               "{\n"
               "    while (tok);\n"
               "    tok = tok->next();\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:3:12] -> [test.cpp:4:11]: (warning) Either the condition 'tok' is redundant or there is possible null pointer dereference: tok. [nullPointerRedundantCheck]\n", errout_str());
 
         // #2681
@@ -253,7 +253,7 @@ class TestNullPointer : public TestFixture {
               "        while (tok && tok->str() != \";\")\n"
               "            tok = tok->next();\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (warning) Either the condition 'while' is redundant or there is possible null pointer dereference: tok.\n", "", errout_str());
 
         check("void foo(Token &tok)\n"
@@ -263,7 +263,7 @@ class TestNullPointer : public TestFixture {
               "        while (!tok)\n"
               "            char c = tok.read();\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -274,7 +274,7 @@ class TestNullPointer : public TestFixture {
               "            tok = tok->next();\n"
               "        if( !tok ) break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -284,7 +284,7 @@ class TestNullPointer : public TestFixture {
               "        while (tok && tok->str() != \";\")\n"
               "            tok = tok->next();\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(A*a)\n"
@@ -299,7 +299,7 @@ class TestNullPointer : public TestFixture {
               "      a->b();\n"
               "      break;\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // dereference in outer scope..
@@ -308,7 +308,7 @@ class TestNullPointer : public TestFixture {
               "        while (tok) tok = tok->next();\n"
               "    }\n"
               "    tok->str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:5:5]: (warning) Either the condition 'tok' is redundant or there is possible null pointer dereference: tok. [nullPointerRedundantCheck]\n", errout_str());
 
         check("int foo(const Token *tok)\n"
@@ -333,7 +333,7 @@ class TestNullPointer : public TestFixture {
               "    while (d && d->i == 0)\n"
               "      d = d->c;\n"
               "  if (!d) throw;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct b {\n"
@@ -358,7 +358,7 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    else if (a->x == 2) { }\n"
               "    if (a) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #2134 - sizeof doesn't dereference
@@ -368,7 +368,7 @@ class TestNullPointer : public TestFixture {
               "    sizeof(*list);\n"
               "    if (!list)\n"
               "        ;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         // ticket #2245 - sizeof doesn't dereference
@@ -376,7 +376,7 @@ class TestNullPointer : public TestFixture {
               "    if (!p) {\n"
               "        int sz = sizeof(p->x);\n"
               "    }\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
     }
@@ -388,7 +388,7 @@ class TestNullPointer : public TestFixture {
               "    Fred fred;\n"
               "    while (fred);\n"
               "    fred.hello();\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -404,7 +404,7 @@ class TestNullPointer : public TestFixture {
               "    int a = abc->a;\n"
               "    if (!abc)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:13]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(struct ABC *abc) {\n"
@@ -413,7 +413,7 @@ class TestNullPointer : public TestFixture {
               "    bar(x, y, abc->a);\n"
               "    if (!abc)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:2:9]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n"
                       "[test.cpp:5:9] -> [test.cpp:3:12]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n"
                       "[test.cpp:5:9] -> [test.cpp:4:15]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n", errout_str());
@@ -423,7 +423,7 @@ class TestNullPointer : public TestFixture {
               "        return;\n"
               "    }\n"
               "    if (abc) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:5:9] -> [test.cpp:2:9]: (warning) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -433,7 +433,7 @@ class TestNullPointer : public TestFixture {
               "        return;\n"
               "    }\n"
               "    if (!abc);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:2:9]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n", errout_str());
 
         // TODO: False negative if member of member is dereferenced
@@ -441,14 +441,14 @@ class TestNullPointer : public TestFixture {
               "    abc->next->a = 0;\n"
               "    if (abc->next)\n"
               "        ;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Possible null pointer dereference: abc - otherwise it is redundant to check it against null.\n", "", errout_str());
 
         check("void foo(ABC *abc) {\n"
               "    abc->a = 0;\n"
               "    if (abc && abc->b == 0)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:9] -> [test.cpp:2:5]: (warning) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -459,13 +459,13 @@ class TestNullPointer : public TestFixture {
               "    if (abc && abc->a);\n"
               "    if (!abc)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(struct ABC *abc) {\n"
               "    int x = abc && a(abc->x);\n"
               "    if (abc) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ok to use a linked list..
@@ -474,13 +474,13 @@ class TestNullPointer : public TestFixture {
               "    abc = abc->next;\n"
               "    if (!abc)\n"
               "        ;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(struct ABC *abc) {\n"
               "    abc = (ABC *)(abc->_next);\n"
-              "    if (abc) { }"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "    if (abc) { }\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         // reassign struct..
@@ -490,7 +490,7 @@ class TestNullPointer : public TestFixture {
               "    abc = abc->next;\n"
               "    if (!abc)\n"
               "        ;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(struct ABC *abc)\n"
@@ -499,7 +499,7 @@ class TestNullPointer : public TestFixture {
               "    f(&abc);\n"
               "    if (!abc)\n"
               "        ;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         // goto..
@@ -513,7 +513,7 @@ class TestNullPointer : public TestFixture {
               "out:\n"
               "    if (!abc)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // loops..
@@ -527,7 +527,7 @@ class TestNullPointer : public TestFixture {
               "        --a;\n"
               "    }\n"
               "    while (a > 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -539,7 +539,7 @@ class TestNullPointer : public TestFixture {
               "        if (!tok)\n"
               "            return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // dynamic_cast..
@@ -548,7 +548,7 @@ class TestNullPointer : public TestFixture {
               "    int a = abc->a;\n"
               "    if (!dynamic_cast<DEF *>(abc))\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #2641 - global pointer, function call
@@ -557,14 +557,14 @@ class TestNullPointer : public TestFixture {
               "    abc->a = 0;\n"
               "    do_stuff();\n"
               "    if (abc) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("",errout_str());
 
         check("Fred *fred;\n"
               "void f() {\n"
               "    fred->foo();\n"
               "    if (fred) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("",errout_str());
 
         // #2641 - local pointer, function call
@@ -573,7 +573,7 @@ class TestNullPointer : public TestFixture {
               "    abc->a = 0;\n"
               "    do_stuff();\n"
               "    if (abc) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:5:9] -> [test.cpp:3:5]: (warning) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -583,7 +583,7 @@ class TestNullPointer : public TestFixture {
               "    abc->a = 0;\n"
               "    do_stuff();\n"
               "    if (abc) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:9] -> [test.cpp:2:5]: (warning) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -598,32 +598,32 @@ class TestNullPointer : public TestFixture {
               "            if ( abc ) {}\n"
               "            break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3128
         check("void f(ABC *abc) {\n"
               "    x(!abc || y(abc->a));\n"
               "    if (abc) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(ABC *abc) {\n"
               "  x(def || !abc || y(def, abc->a));\n"
               "  if (abc) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(ABC *abc) {\n"
               "  x(abc && y(def, abc->a));\n"
               "  if (abc) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(ABC *abc) {\n"
               "    x(def && abc && y(def, abc->a));\n"
               "    if (abc) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3228 - calling function with null object
@@ -631,7 +631,7 @@ class TestNullPointer : public TestFixture {
             const char code[] = "void f(Fred *fred) {\n"
                                 "    fred->x();\n"
                                 "    if (fred) { }\n"
-                                "}";
+                                "}\n";
             check(code);
             ASSERT_EQUALS(
                 "[test.cpp:3:9] -> [test.cpp:2:5]: (warning) Either the condition 'fred' is redundant or there is possible null pointer dereference: fred. [nullPointerRedundantCheck]\n",
@@ -643,7 +643,7 @@ class TestNullPointer : public TestFixture {
                "void f(struct FRED *fred) {\n"
                "    fred->x = 0;\n"
                "    IF(!fred){}\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -651,7 +651,7 @@ class TestNullPointer : public TestFixture {
               "  if (!buffer)\n"
               "    uv_fatal_error();\n"
               "  buffer->x = 11;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -665,14 +665,14 @@ class TestNullPointer : public TestFixture {
               "    *p = 0;\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:6]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(int *p)\n"
               "{\n"
               "    *p = 0;\n"
               "    if (p) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:9] -> [test.cpp:3:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -681,7 +681,7 @@ class TestNullPointer : public TestFixture {
               "{\n"
               "    *p = 0;\n"
               "    if (p || q) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:9] -> [test.cpp:3:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -691,7 +691,7 @@ class TestNullPointer : public TestFixture {
               "    bar(*p);\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:10]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(char *p)\n"
@@ -699,14 +699,14 @@ class TestNullPointer : public TestFixture {
               "    strcpy(p, \"abc\");\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:12]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(char *p)\n"
               "{\n"
               "    if (*p == 0) { }\n"
               "    if (!p) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:10]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // no error
@@ -716,7 +716,7 @@ class TestNullPointer : public TestFixture {
               "    f(&p);\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -724,7 +724,7 @@ class TestNullPointer : public TestFixture {
               "    int **p = f();\n"
               "    if (!p)\n"
               "        ;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int *p)\n"
@@ -735,7 +735,7 @@ class TestNullPointer : public TestFixture {
               "        *p = 0;\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int x)\n"
@@ -743,7 +743,7 @@ class TestNullPointer : public TestFixture {
               "    int a = 2 * x;"
               "    if (x == 0)\n"
               "        ;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int *p)\n"
@@ -751,7 +751,7 @@ class TestNullPointer : public TestFixture {
               "    int var1 = p ? *p : 0;\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int *p, bool x)\n"
@@ -759,7 +759,7 @@ class TestNullPointer : public TestFixture {
               "    int var1 = x ? *p : 5;\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:9] -> [test.cpp:3:21]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -768,13 +768,13 @@ class TestNullPointer : public TestFixture {
         check("void f(int *p) {\n"
               "    *p = 0;\n"
               "    while (p) { p = 0; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p) {\n"
               "    *p = 0;\n"
               "    while (p) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:12] -> [test.cpp:2:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -785,7 +785,7 @@ class TestNullPointer : public TestFixture {
               "    int var1 = p ? (p->a) : 0;\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(ABC *p)\n"
@@ -793,7 +793,7 @@ class TestNullPointer : public TestFixture {
               "    int var1 = p ? (1 + p->a) : 0;\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -825,7 +825,7 @@ class TestNullPointer : public TestFixture {
               "      break;\n"
               "    else\n"
               "      p = p->next();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(Document *doc) {\n"
@@ -833,27 +833,27 @@ class TestNullPointer : public TestFixture {
               "    if (!doc) {\n"
               "        return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3128 - false positive
         check("void f(int *p) {\n"
               "    assert(!p || (*p<=6));\n"
               "    if (p) { *p = 0; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p) {\n"
               "    assert(p && (*p<=6));\n"
               "    if (p) { *p = 0; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p) {\n"
               "    *p = 12;\n"
               "    assert(p && (*p<=6));\n"
               "    if (p) { *p = 0; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:12] -> [test.cpp:2:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -863,7 +863,7 @@ class TestNullPointer : public TestFixture {
               "    p = p->next;\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(x *p)\n"
@@ -871,7 +871,7 @@ class TestNullPointer : public TestFixture {
               "    p = bar(p->next);\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(x *p)\n"
@@ -879,7 +879,7 @@ class TestNullPointer : public TestFixture {
               "    p = aa->bar(p->next);\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(x *p)\n"
@@ -887,7 +887,7 @@ class TestNullPointer : public TestFixture {
               "    p = *p2 = p->next;\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(struct ABC *abc)\n"
@@ -895,32 +895,32 @@ class TestNullPointer : public TestFixture {
               "    abc = abc ? abc->next : 0;\n"
               "    if (!abc)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(struct ABC *abc) {\n" // #4523
               "    abc = (*abc).next;\n"
               "    if (abc) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(struct ABC *abc) {\n" // #4523
               "    abc = (*abc->ptr);\n"
               "    if (abc) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(Item *item) {\n"
               "    x = item ? ab(item->x) : 0;\n"
               "    if (item) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(Item *item) {\n"
               "    item->x = 0;\n"
               "    a = b ? c : d;\n"
               "    if (item) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:9] -> [test.cpp:2:5]: (warning) Either the condition 'item' is redundant or there is possible null pointer dereference: item. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -934,7 +934,7 @@ class TestNullPointer : public TestFixture {
               "\n"
               "    if( !pFrm )\n"
               "        return FALSE;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #2463
@@ -954,7 +954,7 @@ class TestNullPointer : public TestFixture {
               "                break;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #2525 - sizeof
@@ -963,26 +963,26 @@ class TestNullPointer : public TestFixture {
               "    int c = sizeof(test[0]);\n"
               "    if (!test)\n"
               "        ;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(type* p) {\n" // #4983
               "    x(sizeof p[0]);\n"
               "    if (!p)\n"
               "        ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3023 - checked deref
         check("void f(struct ABC *abc) {\n"
               "  WARN_ON(!abc || abc->x == 0);\n"
               "  if (!abc) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(struct ABC *abc) {\n"
               "  WARN_ON(!abc || abc->x == 7);\n"
               "  if (!abc) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3425 - false positives when there are macros
@@ -990,14 +990,14 @@ class TestNullPointer : public TestFixture {
                "void f(int *p) {\n"
                "    *p = 0;\n"
                "    IF(!p){}\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #3914 - false positive
               "    int *p;\n"
               "    ((p=ret()) && (x=*p));\n"
               "    if (p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S { struct T { char c; } *p; };\n" // #6541
@@ -1021,7 +1021,7 @@ class TestNullPointer : public TestFixture {
               " char c = a.c();\n"
               " if (!a)\n"
               "   return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1036,18 +1036,18 @@ class TestNullPointer : public TestFixture {
               "    } else { if (a == 2) {\n"
               "        p = new FooCar; } }\n"
               "    p->abcd();\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:8]: (error) Possible null pointer dereference: p\n",
                            "", errout_str());
 
         check("static void foo() {\n"
               "    int &r = *(int*)0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
 
         check("static void foo(int x) {\n"
               "    int y = 5 + *(int*)0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
 
         {
@@ -1062,7 +1062,7 @@ class TestNullPointer : public TestFixture {
 
         check("static void foo() {\n"
               "    std::cout << *(int*)0;"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:19]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
 
         check("void f()\n"
@@ -1072,12 +1072,12 @@ class TestNullPointer : public TestFixture {
               "        delete c;\n"
               "    }\n"
               "    c[0] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (error) Null pointer dereference: c [nullPointer]\n", errout_str());
 
         check("static void foo() {\n"
               "    if (3 > *(int*)0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
 
         // no false positive..
@@ -1086,20 +1086,20 @@ class TestNullPointer : public TestFixture {
               "    Foo *p = 0;\n"
               "    p = new Foo;\n"
               "    p->abcd();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    int sz = sizeof((*(struct dummy *)0).x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void get_offset(long &offset)\n"
               "{\n"
               "    mystruct * temp; temp = 0;\n"
               "    offset = (long)(&(temp->z));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #1893 - try/catch inside else
@@ -1118,7 +1118,7 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    *Q=1;\n"
               "    return Q;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int *test(int *Z)\n"
@@ -1134,7 +1134,7 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    *Q=1;\n"
               "    return Q;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:12:6]: (warning) Possible null pointer dereference: Q [nullPointer]\n", errout_str());
 
         // Ticket #2052 (false positive for 'else continue;')
@@ -1145,7 +1145,7 @@ class TestNullPointer : public TestFixture {
               "        else continue;\n"
               "        *p = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // function pointer..
@@ -1154,7 +1154,7 @@ class TestNullPointer : public TestFixture {
               "    void (*f)();\n"
               "    f = 0;\n"
               "    f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (error) Null pointer dereference: f [nullPointer]\n", errout_str());
 
         check("int* g();\n" // #11007
@@ -1172,7 +1172,7 @@ class TestNullPointer : public TestFixture {
               "    for (int i = 0; i < 10; ++i) {\n"
               "        int x = *p + 1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("void f(int a) {\n"
@@ -1183,21 +1183,21 @@ class TestNullPointer : public TestFixture {
               "    for (int i = 0; i < 3; i++) {\n"
               "        if (a && (p[i] == '1'));\n"
               "    }\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         // ticket #2251: taking the address of member
         check("void f() {\n"
               "    Fred *fred = 0;\n"
               "    int x = &fred->x;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         // ticket #3220: dereferencing a null pointer is UB
         check("void f() {\n"
               "    Fred *fred = NULL;\n"
               "    fred->do_something();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Null pointer dereference: fred [nullPointer]\n", errout_str());
 
         // ticket #3570 - parsing of conditions
@@ -1207,21 +1207,21 @@ class TestNullPointer : public TestFixture {
                   "    if (x)\n"
                   "        p = q;\n"
                   "    if (p && *p) { }\n"
-                  "}", dinit(CheckOptions, $.inconclusive = true));
+                  "}\n", dinit(CheckOptions, $.inconclusive = true));
             ASSERT_EQUALS("", errout_str());
             check("void f() {\n"
                   "    int *p = NULL;\n"
                   "    if (x)\n"
                   "        p = q;\n"
                   "    if (!p || *p) { }\n"
-                  "}", dinit(CheckOptions, $.inconclusive = true));
+                  "}\n", dinit(CheckOptions, $.inconclusive = true));
             ASSERT_EQUALS("", errout_str());
             check("void f() {\n"
                   "    int *p = NULL;\n"
                   "    if (x)\n"
                   "        p = q;\n"
                   "    if (p || *p) { }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("[test.cpp:5:15]: (warning) Possible null pointer dereference: p [nullPointer]\n", errout_str());
         }
 
@@ -1237,7 +1237,7 @@ class TestNullPointer : public TestFixture {
                   "\n"
                   "void g() {\n"
                   "    f(NULL, NULL);\n"
-                  "}", dinit(CheckOptions, $.inconclusive = true));
+                  "}\n", dinit(CheckOptions, $.inconclusive = true));
             ASSERT_EQUALS("", errout_str());
         }
 
@@ -1262,7 +1262,7 @@ class TestNullPointer : public TestFixture {
               "    for (int i = 0; i < n; i++) {\n"
               "        argv32[i] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // No false negative:
@@ -1277,7 +1277,7 @@ class TestNullPointer : public TestFixture {
               "    for (int i = 0; i < n; i++) {\n"
               "        argv32[i] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:9]: (warning) Possible null pointer dereference: argv32 [nullPointer]\n", errout_str());
 
         // #2231 - error if assignment in loop is not used
@@ -1293,7 +1293,7 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:11:6]: (warning) Possible null pointer dereference: p [nullPointer]\n", errout_str());
     }
 
@@ -1302,7 +1302,7 @@ class TestNullPointer : public TestFixture {
               "{\n"
               "  wxLongLong x = 0;\n"
               "  int y = x.GetValue();\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1311,7 +1311,7 @@ class TestNullPointer : public TestFixture {
               "{\n"
               "  std::string * x = 0;\n"
               "  *x = \"test\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:4]: (error) Null pointer dereference: x [nullPointer]\n", errout_str());
     }
 
@@ -1321,7 +1321,7 @@ class TestNullPointer : public TestFixture {
               "{\n"
               "  struct my_type* p = 0;\n"
               "  p->x = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:3]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
     }
 
@@ -1333,7 +1333,7 @@ class TestNullPointer : public TestFixture {
               "  struct my_type* p;\n"
               "  p = 0;\n"
               "  return p->x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
     }
 
@@ -1360,7 +1360,7 @@ class TestNullPointer : public TestFixture {
               "    char *p = 0;\n"
               "    if (x) p = \"abcd\";\n"
               "    return p ? f(*p) : f(0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1369,7 +1369,7 @@ class TestNullPointer : public TestFixture {
               "    int *p = 0;\n"
               "    bar(&p);\n"
               "    *p = 0;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1378,14 +1378,14 @@ class TestNullPointer : public TestFixture {
               "    int *p = 0;\n"
               "    if (x) { return 0; }\n"
               "    return !p || *p;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("int foo() {\n"
               "    int *p = 0;\n"
               "    if (x) { return 0; }\n"
               "    return p && *p;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1398,14 +1398,14 @@ class TestNullPointer : public TestFixture {
               "  {\n"
               "    i++;\n"
               "  };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) Null pointer dereference: str [nullPointer]\n", errout_str());
     }
 
     void nullpointer19() { // #3811
         check("int foo() {\n"
               "    perror(0);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1414,14 +1414,14 @@ class TestNullPointer : public TestFixture {
               "    struct xy *p = 0;\n"
               "    if (x) p = q;\n"
               "    if (p ? p->x || p->y : 0) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"   // false negative
               "    struct xy *p = 0;\n"
               "    if (x) p = q;\n"
               "    if (y ? p->x : p->y) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (warning) Possible null pointer dereference: p [nullPointer]\n"
                       "[test.cpp:4:20]: (warning) Possible null pointer dereference: p [nullPointer]\n",
                       errout_str());
@@ -1433,7 +1433,7 @@ class TestNullPointer : public TestFixture {
               "    if (x) p = q;\n"
               "    else return;\n"
               "    *p = 0;\n" // <- p is not NULL
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1442,7 +1442,7 @@ class TestNullPointer : public TestFixture {
               "    char *c = NULL;\n"
               "    char cBuf[10];\n"
               "    sprintf(cBuf, \"%s\", c ? c : \"0\" );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("",errout_str());
     }
 
@@ -1451,7 +1451,7 @@ class TestNullPointer : public TestFixture {
               "    char *c = NULL;\n"
               "    x = c = new char[10];\n"
               "    *c = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1461,7 +1461,7 @@ class TestNullPointer : public TestFixture {
               "    int *array = NULL;\n"
               "    if (data == 1 && array[i] == 0)\n"
               "        std::cout << \"test\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:22]: (error) Null pointer dereference: array [nullPointer]\n", errout_str());
     }
 
@@ -1478,7 +1478,7 @@ class TestNullPointer : public TestFixture {
               "    if (t2 && (!t1))\n"
               "        return 0.0;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1492,7 +1492,7 @@ class TestNullPointer : public TestFixture {
               "    pointer_=NULL;\n"
               "    *pointer_=0;\n"
               "    return *this;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:6]: (error) Null pointer dereference: pointer_ [nullPointer]\n", errout_str());
     }
 
@@ -1502,7 +1502,7 @@ class TestNullPointer : public TestFixture {
               "  int i = s ? s->value + 1\n"
               "            : s->value - 1; // <-- null ptr dereference\n"
               "  return i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:11] -> [test.cpp:4:15]: (warning) Either the condition 's' is redundant or there is possible null pointer dereference: s. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -1553,7 +1553,7 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "\n"
               "    (void)f->x;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1665,7 +1665,7 @@ class TestNullPointer : public TestFixture {
               "void f(struct A *a) {\n"
               "    if (a->x == NULL) {}\n"
               "    *(a->x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:14] -> [test.cpp:4:8]: (warning) Either the condition 'a->x==NULL' is redundant or there is possible null pointer dereference: a->x. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -1676,7 +1676,7 @@ class TestNullPointer : public TestFixture {
               "void f(struct A *a) {\n"
               "    if (a->x == nullptr) {}\n"
               "    *(a->x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:14] -> [test.cpp:4:8]: (warning) Either the condition 'a->x==nullptr' is redundant or there is possible null pointer dereference: a->x. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -1687,7 +1687,7 @@ class TestNullPointer : public TestFixture {
               "void f(struct A *a) {\n"
               "    if (a->g() == nullptr) {}\n"
               "    *(a->g());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:16] -> [test.cpp:4:11]: (warning) Either the condition 'a->g()==nullptr' is redundant or there is possible null pointer dereference: a->g(). [nullPointerRedundantCheck]\n",
             errout_str());
@@ -1696,7 +1696,7 @@ class TestNullPointer : public TestFixture {
               "void f(struct A *a) {\n"
               "    if (a->g() == nullptr) {}\n"
               "    *(a->g());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1705,7 +1705,7 @@ class TestNullPointer : public TestFixture {
               "void f(struct A *a) {\n"
               "    if (a->g() == nullptr) {}\n"
               "    *(a->g());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:16] -> [test.cpp:4:11]: (warning) Either the condition 'a->g()==nullptr' is redundant or there is possible null pointer dereference: a->g(). [nullPointerRedundantCheck]\n",
             errout_str());
@@ -1718,7 +1718,7 @@ class TestNullPointer : public TestFixture {
               "    if (x) {\n"
               "        (void)*a->x;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1730,7 +1730,7 @@ class TestNullPointer : public TestFixture {
               "    if ( w == 0.0 )\n"
               "        return 0;\n"
               "    return b->get();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         // #9423
         check("extern F* GetF();\n"
@@ -1747,7 +1747,7 @@ class TestNullPointer : public TestFixture {
               "    if (!lPtrOk)\n"
               "        return;\n"
               "    lPtr->Clear();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1764,7 +1764,7 @@ class TestNullPointer : public TestFixture {
               "    g();\n"
               "  a d = *c->b();\n"
               "  return d;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct a {\n"
@@ -1780,7 +1780,7 @@ class TestNullPointer : public TestFixture {
               "    e();\n"
               "  a d = *c->b();\n"
               "  return d;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1788,7 +1788,7 @@ class TestNullPointer : public TestFixture {
         check("void f() {\n"
               "    char* p = new(std::nothrow) char[1];\n"
               "    if( p ) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1797,7 +1797,7 @@ class TestNullPointer : public TestFixture {
               "   if(!p[0]) {}\n"
               "   const int *const a = p;\n"
               "   if(!a){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7] -> [test.cpp:2:8]: (warning) Either the condition '!a' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
     }
 
@@ -1806,7 +1806,7 @@ class TestNullPointer : public TestFixture {
               "auto f(T& x) -> decltype(x);\n"
               "int& g(int* x) {\n"
               "    return f(*x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1816,7 +1816,7 @@ class TestNullPointer : public TestFixture {
               "    if(n > 10) q = p;\n"
               "    *p +=2;\n"
               "    if(n < 120) *q+=12;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:18]: (warning) Possible null pointer dereference: q [nullPointer]\n", errout_str());
 
         check("void f(int *p, int n) {\n"
@@ -1824,7 +1824,7 @@ class TestNullPointer : public TestFixture {
               "    if(n > 10) q = p;\n"
               "    *p +=2;\n"
               "    if(n > 10) *q+=12;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1838,7 +1838,7 @@ class TestNullPointer : public TestFixture {
               "            }\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:8] -> [test.cpp:6:18]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -1854,7 +1854,7 @@ class TestNullPointer : public TestFixture {
               "  if (c(e, \"\"))\n"
               "    return nullptr;\n"
               "  return e->b();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1864,7 +1864,7 @@ class TestNullPointer : public TestFixture {
               "    if(b) c = b;\n"
               "    if (!c) c = &a;\n"
               "    return *c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int a, int* b) {\n"
@@ -1873,7 +1873,7 @@ class TestNullPointer : public TestFixture {
               "    bool d = !c;\n"
               "    if (d) c = &a;\n"
               "    return *c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { int* x; };\n"
@@ -1883,7 +1883,7 @@ class TestNullPointer : public TestFixture {
               "    if(b) c.x = b;\n"
               "    if (!c.x) c.x = &a;\n"
               "    return *c.x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { int* x; };\n"
@@ -1894,7 +1894,7 @@ class TestNullPointer : public TestFixture {
               "    bool d = !c.x;\n"
               "    if (d) c.x = &a;\n"
               "    return *c.x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { int* x; };\n"
@@ -1917,7 +1917,7 @@ class TestNullPointer : public TestFixture {
               "}\n"
               "void bar() {\n"
               "  f(0, 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Possible null pointer dereference: params [nullPointer]\n", errout_str());
     }
 
@@ -1933,7 +1933,7 @@ class TestNullPointer : public TestFixture {
               "int bar() {\n"
               "    int **array = NULL;\n"
               "    foo (array, 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1943,7 +1943,7 @@ class TestNullPointer : public TestFixture {
               "    while (tok3->astParent() && tok3->str() == \",\")\n"
               "        tok3 = tok3->astParent();\n"
               "    if (tok3 && tok3->str() == \"(\") {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:5:9] -> [test.cpp:3:12]: (warning) Either the condition 'tok3' is redundant or there is possible null pointer dereference: tok3. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -1956,7 +1956,7 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    if (!t1 || !t2)\n"
               "        return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(int* i);\n"
@@ -1964,7 +1964,7 @@ class TestNullPointer : public TestFixture {
               "    while(f(i) && *i == 0)\n"
               "        i++;\n"
               "    if (!i) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1976,7 +1976,7 @@ class TestNullPointer : public TestFixture {
               "    ListEntry *prev = NULL;\n"
               "    for (ListEntry *cursor = listHead; cursor != NULL; prev = cursor, cursor = cursor->next) {}\n"
               "    if (prev) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2499,7 +2499,7 @@ class TestNullPointer : public TestFixture {
               "    int *p = 0;\n"
               "    pp = &p;\n"
               "    **pp = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:6]: (error) Null pointer dereference: *pp [nullPointer]\n", errout_str());
     }
 
@@ -2735,7 +2735,7 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "  }\n"
               "  return \"unknown\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:7:12] -> [test.cpp:3:7]: (warning) Either the condition 'ctx' is redundant or there is possible null pointer dereference: ctx. [nullPointerRedundantCheck]\n",
             errout_str());
@@ -2777,7 +2777,7 @@ class TestNullPointer : public TestFixture {
               "        int* myNull = GetThing();\n"
               "        *myNull=42;\n"
               "        return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (error) Null pointer dereference: myNull [nullPointer]\n", errout_str());
 
         check("struct foo {\n"
@@ -2788,7 +2788,7 @@ class TestNullPointer : public TestFixture {
               "        int* myNull = myFoo.GetThing();\n"
               "        *myNull=42;\n"
               "        return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:10]: (error) Null pointer dereference: myNull [nullPointer]\n", errout_str());
 
         check("struct T { bool g() const; };\n"
@@ -2885,7 +2885,7 @@ class TestNullPointer : public TestFixture {
               "        int * buf = foo(true);\n"
               "        buf[2] = 0;" // <<
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:14:9]: (error) Null pointer dereference: buf [nullPointer]\n", errout_str());
     }
 
@@ -3113,7 +3113,7 @@ class TestNullPointer : public TestFixture {
               "    int *p{};\n"
               "    int *&r{p};\n"
               "    if (*r) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (error) Null pointer dereference: r [nullPointer]\n", errout_str());
     }
 
@@ -3142,7 +3142,7 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        thunk().g(0);\n"
               "    *p = 1;\n"
-              "}",
+              "}\n",
               dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
@@ -3151,13 +3151,13 @@ class TestNullPointer : public TestFixture {
         check("void f() {\n"
               "  struct X *x = 0;\n"
               "  if (addr == &x->y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  struct X *x = 0;\n"
               "  if (addr == &x->y.z[0]) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkP("typedef int Count;\n" // #10018
@@ -3183,7 +3183,7 @@ class TestNullPointer : public TestFixture {
               "        break;\n"
               "    }\n"
               "    return p;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:7:10]: (warning) Possible null pointer dereference: p [nullPointer]\n", errout_str());
     }
 
@@ -3193,7 +3193,7 @@ class TestNullPointer : public TestFixture {
               "        while (*p && nasm_isspace(*p))\n"
               "            p++;\n"
               "    return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char* origin) {\n" // #11449
@@ -3208,7 +3208,7 @@ class TestNullPointer : public TestFixture {
         check("void f () {\n"
               "    int *buf; buf = NULL;\n"
               "    buf;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3230,27 +3230,27 @@ class TestNullPointer : public TestFixture {
               "    if (!p) {\n"
               "    }\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:6]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(char *p) {\n"
               "    if (p && *p == 0) {\n"
               "    }\n"
               "    printf(\"%c\", *p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:19]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(char *p) {\n"
               "    if (p && *p == 0) {\n"
               "    } else { *p = 0; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:15]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(char *p) {\n"
               "    if (p) {\n"
               "    }\n"
               "    strcpy(p, \"abc\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:12]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(char *p) {\n"
@@ -3258,7 +3258,7 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    bar();\n"
               "    strcpy(p, \"abc\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:5:12]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(abc *p) {\n"
@@ -3266,7 +3266,7 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    else { if (!p->x) {\n"
               "    } }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         {
@@ -3276,7 +3276,7 @@ class TestNullPointer : public TestFixture {
                 "        abort();\n"
                 "    }\n"
                 "    *p = 0;\n"
-                "}";
+                "}\n";
             check(code);
             ASSERT_EQUALS("", errout_str());
 
@@ -3289,7 +3289,7 @@ class TestNullPointer : public TestFixture {
               "        (*bail)();\n"
               "    }\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char *p) {\n"
@@ -3297,7 +3297,7 @@ class TestNullPointer : public TestFixture {
               "        throw x;\n"
               "    }\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char *p) {\n"
@@ -3305,21 +3305,21 @@ class TestNullPointer : public TestFixture {
               "        ab.abort();\n"
               "    }\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char *p) {\n"
               "    if (!p) {\n"
               "        switch (x) { }\n"
               "    }\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char *p) {\n"
               "    if (!p) {\n"
               "    }\n"
               "    return *x;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("int foo(int *p) {\n"
@@ -3327,7 +3327,7 @@ class TestNullPointer : public TestFixture {
               "        x = *p;\n"
               "        return 5+*p;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:14]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n"
                       "[test.cpp:2:9] -> [test.cpp:4:19]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
@@ -3337,7 +3337,7 @@ class TestNullPointer : public TestFixture {
               "    if (!a) {\n"
               "        a.x();\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // This is why this check can't be used on the simplified token list
@@ -3345,7 +3345,7 @@ class TestNullPointer : public TestFixture {
               "    if (!dynamic_cast<bar *>(foo)) {\n"
               "        *foo = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket: #2300 - calling unknown function that may initialize the pointer
@@ -3355,7 +3355,7 @@ class TestNullPointer : public TestFixture {
               "        initfred();\n"
               "        fred->x = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #1219
@@ -3364,7 +3364,7 @@ class TestNullPointer : public TestFixture {
               "        return;\n"
               "    }\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:5:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // #2467 - unknown macro may terminate the application
@@ -3373,7 +3373,7 @@ class TestNullPointer : public TestFixture {
               "        MACRO;\n"
               "    }\n"
               "    fred->a();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #2493 - switch
@@ -3386,7 +3386,7 @@ class TestNullPointer : public TestFixture {
               "            fred->a();\n"
               "            break;\n"
               "    };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4118 - second if
@@ -3394,7 +3394,7 @@ class TestNullPointer : public TestFixture {
               "    int x = 1;\n"
               "    if (!p) x = 0;\n"
               "    if (x) *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #2674 - different functions
@@ -3411,7 +3411,7 @@ class TestNullPointer : public TestFixture {
               "\n"
               "void Fred::b() {\n"
               "    wilma->Reload();\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void test(int *i) {\n"
@@ -3419,7 +3419,7 @@ class TestNullPointer : public TestFixture {
               "  else {\n"
               "    int b = *i;\n"
               "  }\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         // #2696 - false positives nr 1
@@ -3432,7 +3432,7 @@ class TestNullPointer : public TestFixture {
               "\n"
               "   if (pFoo)\n"
               "      bar();\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         // #2696 - false positives nr 2
@@ -3445,7 +3445,7 @@ class TestNullPointer : public TestFixture {
               "      pFoo = pFoo->next;\n"
               "\n"
               "   len = sizeof(pFoo->data);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         // #2696 - false positives nr 3
@@ -3458,13 +3458,13 @@ class TestNullPointer : public TestFixture {
               "      pFoo = pFoo->next;\n"
               "\n"
               "   len = decltype(*pFoo);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("int foo(struct Fred *fred) {\n"
               "    if (fred) { }\n"
               "    return fred->a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:12]: (warning) Either the condition 'fred' is redundant or there is possible null pointer dereference: fred. [nullPointerRedundantCheck]\n", errout_str());
 
         // #2789 - assign and check pointer
@@ -3472,7 +3472,7 @@ class TestNullPointer : public TestFixture {
               "    char *p; p = x();\n"
               "    if (!p) { }\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:4:6]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // check, assign and use
@@ -3481,7 +3481,7 @@ class TestNullPointer : public TestFixture {
               "    if (p == 0 && (p = malloc(10)) != 0) {\n"
               "        *p = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // check, assign and use
@@ -3490,7 +3490,7 @@ class TestNullPointer : public TestFixture {
               "    if (p == 0 && (p = malloc(10)) != a && (*p = a)) {\n"
               "        *p = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // check, and use
@@ -3499,7 +3499,7 @@ class TestNullPointer : public TestFixture {
               "    if (p == 0 && (*p = 0)) {\n"
               "        return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:3:21]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // check, and use
@@ -3508,7 +3508,7 @@ class TestNullPointer : public TestFixture {
               "    if (p == 0 && p->x == 10) {\n"
               "        return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:3:19]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // check, and use
@@ -3517,7 +3517,7 @@ class TestNullPointer : public TestFixture {
               "    if (p == 0 || p->x == 10) {\n"
               "        return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // check, and use
@@ -3526,7 +3526,7 @@ class TestNullPointer : public TestFixture {
               "    if (p == NULL && (*p = a)) {\n"
               "        return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:3:24]: (warning) Either the condition 'p==NULL' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // check, and use
@@ -3534,14 +3534,14 @@ class TestNullPointer : public TestFixture {
               "    if (!p && x==1 || p && p->x==0) {\n"
               "        return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         {
             const char code[] = "void f(Fred *fred) {\n"
                                 "    if (fred == NULL) { }\n"
                                 "    fred->x();\n"
-                                "}";
+                                "}\n";
 
             check(code);     // inconclusive
             ASSERT_EQUALS("[test.cpp:2:14] -> [test.cpp:3:5]: (warning) Either the condition 'fred==NULL' is redundant or there is possible null pointer dereference: fred. [nullPointerRedundantCheck]\n", errout_str());
@@ -3550,52 +3550,52 @@ class TestNullPointer : public TestFixture {
         check("void f(char *s) {\n"   // #3358
               "    if (s==0);\n"
               "    strcpy(a, s?b:c);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // sizeof
         check("void f(struct fred_t *fred) {\n"
               "    if (!fred)\n"
               "        int sz = sizeof(fred->x);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         // check in macro
         check("void f(int *x) {\n"
               "    $if (!x) {}\n"
               "    *x = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // return ?:
         check("int f(ABC *p) {\n" // FP : return ?:
               "    if (!p) {}\n"
               "    return p ? p->x : 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("int f(ABC *p) {\n" // no fn
               "    if (!p) {}\n"
               "    return q ? p->x : 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:16]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("int f(ABC *p) {\n" // FP : return &&
               "    if (!p) {}\n"
               "    return p && p->x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int *p) {\n"
               "    if (x || !p) {}\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14] -> [test.cpp:3:6]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // sizeof
         check("void f() {\n"
               "  int *pointer = NULL;\n"
               "  pointer = func(sizeof pointer[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct T {\n" // #14164
@@ -3618,12 +3618,12 @@ class TestNullPointer : public TestFixture {
         check("int f() {\n"
               "    int* p = 0;\n"
               "    return p[4];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("void f() {\n"
               "    typeof(*NULL) y;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("int * f() {\n"
@@ -3631,7 +3631,7 @@ class TestNullPointer : public TestFixture {
               "}\n"
               "int main() {\n"
               "  return *f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (error) Null pointer dereference: f() [nullPointer]\n", errout_str());
     }
 
@@ -3639,7 +3639,7 @@ class TestNullPointer : public TestFixture {
         // Ticket #2621
         check("void f(struct ABC *abc) {\n"
               "    ({ if (abc) dbg(); })\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3647,7 +3647,7 @@ class TestNullPointer : public TestFixture {
         // Ticket #2840
         check("void f() {\n"
               "    int bytes = snprintf(0, 0, \"%u\", 1);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3655,25 +3655,25 @@ class TestNullPointer : public TestFixture {
         // Ticket #2840
         check("void f() {\n"
               "    int bytes = snprintf(0, 10, \"%u\", 1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:26]: (error) Null pointer dereference [nullPointer]\n", errout_str());
     }
 
     void printf_with_invalid_va_argument() {
         check("void f() {\n"
               "    printf(\"%s\", 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
         check("void f(char* s) {\n"
               "    printf(\"%s\", s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char* s = 0;\n"
               "    printf(\"%s\", s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:18]: (error) Null pointer dereference: s [nullPointer]\n",
             errout_str());
@@ -3681,23 +3681,23 @@ class TestNullPointer : public TestFixture {
         check("void f() {\n"
               "    char *s = 0;\n"
               "    printf(\"%s\", s == 0 ? a : s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    printf(\"%u%s\", 0, 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:23]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
         check("void f(char* s) {\n"
               "    printf(\"%u%s\", 0, s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char* s = 0;\n"
               "    printf(\"%u%s\", 123, s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:25]: (error) Null pointer dereference: s [nullPointer]\n",
             errout_str());
@@ -3705,51 +3705,51 @@ class TestNullPointer : public TestFixture {
 
         check("void f() {\n"
               "    printf(\"%%%s%%\", 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
         check("void f(char* s) {\n"
               "    printf(\"text: %s, %s\", s, 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:31]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
 
         check("void f() {\n"
               "    char* s = \"blabla\";\n"
               "    printf(\"%s\", s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
         check("void f(char* s) {\n"
               "    printf(\"text: %m%s, %s\", s, 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:33]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
         check("void f(char* s) {\n"
               "    printf(\"text: %*s, %s\", s, 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:32]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
         // Ticket #3364
         check("void f() {\n"
               "    printf(\"%-*.*s\", s, 0);\n"
               "    sprintf(\"%*\", s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void scanf_with_invalid_va_argument() {
         check("void f(char* s) {\n"
               "    sscanf(s, \"%s\", 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:21]: (error) Null pointer dereference [nullPointer]\n",
             errout_str());
 
         check("void f() {\n"
               "    scanf(\"%d\", 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:17]: (error) Null pointer dereference [nullPointer]\n",
             errout_str());
@@ -3758,19 +3758,19 @@ class TestNullPointer : public TestFixture {
               "    char location[200];\n"
               "    int width, height;\n"
               "    sscanf(imgInfo, \"%s %d %d\", location, &width, &height);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // ticket #3207
 
         check("void f(char *dummy) {\n"
               "    int iVal;\n"
               "    sscanf(dummy, \"%d%c\", &iVal);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // ticket #3211
 
         check("void f(char *dummy) {\n"
               "    int* iVal = 0;\n"
               "    sscanf(dummy, \"%d\", iVal);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:25]: (error) Null pointer dereference: iVal [nullPointer]\n",
             errout_str());
@@ -3778,18 +3778,18 @@ class TestNullPointer : public TestFixture {
         check("void f(char *dummy) {\n"
               "    int* iVal;\n"
               "    sscanf(dummy, \"%d\", foo(iVal));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char *dummy) {\n"
               "    int* iVal = 0;\n"
               "    sscanf(dummy, \"%d%d\", foo(iVal), iVal);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char* dummy) {\n"
               "    sscanf(dummy, \"%*d%u\", 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:28]: (error) Null pointer dereference [nullPointer]\n",
             errout_str());
@@ -3801,12 +3801,12 @@ class TestNullPointer : public TestFixture {
               "    int* iVal = 0;\n"
               "    if(maybe()) iVal = g();\n"
               "    return iVal[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (warning) Possible null pointer dereference: iVal [nullPointer]\n", errout_str());
 
         check("int foo(int* iVal) {\n"
               "    return iVal[0];\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3816,20 +3816,20 @@ class TestNullPointer : public TestFixture {
               "bool foo() {\n"
               "     PolymorphicA* a = 0;\n"
               "     return typeid(*a) == typeid(*a);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("struct NonPolymorphicA { ~A() {} };\n"
               "bool foo() {\n"
               "     NonPolymorphicA* a = 0;\n"
               "     return typeid(*a) == typeid(*a);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("bool foo() {\n"
               "     char* c = 0;\n"
               "     return typeid(*c) == typeid(*c);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3838,40 +3838,40 @@ class TestNullPointer : public TestFixture {
         check("size_t foo() {\n"
               "    char* c = 0;\n"
               "    return alignof(*c);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("size_t foo() {\n"
               "    return alignof(*0);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int *p) {\n"
               "    f(alignof(*p));\n"
               "    if (p) {}\n"
               "    return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("size_t foo() {\n"
               "    char* c = 0;\n"
               "    return _Alignof(*c);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("size_t foo() {\n"
               "    return _alignof(*0);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("size_t foo() {\n"
               "    return __alignof(*0);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("size_t foo() {\n"
               "    return __alignof__(*0);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3882,7 +3882,7 @@ class TestNullPointer : public TestFixture {
               "  cnt = 0;\n"
               " for (int i = 0; i < cnt; ++i)\n"
               "  *ptr++ = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #11635
@@ -3992,7 +3992,7 @@ class TestNullPointer : public TestFixture {
               "void f(int* x) {\n"
               "    if (x)\n"
               "        g(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct T {\n" // #14308
@@ -4034,7 +4034,7 @@ class TestNullPointer : public TestFixture {
               "    std::string s4 = p;\n"
               "    std::string s5(p);\n"
               "    foo(std::string(p));\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:9:10]: (error) Null pointer dereference: p [nullPointer]\n"
                       "[test.cpp:10:22]: (error) Null pointer dereference: p [nullPointer]\n"
                       "[test.cpp:11:20]: (error) Null pointer dereference: p [nullPointer]\n"
@@ -4050,7 +4050,7 @@ class TestNullPointer : public TestFixture {
               "    std::string s2 = nullptr;\n"
               "    std::string s3(nullptr);\n"
               "    foo(std::string(nullptr));\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2:10]: (error) Null pointer dereference [nullPointer]\n"
                       "[test.cpp:3:22]: (error) Null pointer dereference [nullPointer]\n"
                       "[test.cpp:4:17]: (error) Null pointer dereference [nullPointer]\n"
@@ -4062,7 +4062,7 @@ class TestNullPointer : public TestFixture {
               "    std::string s2 = NULL;\n"
               "    std::string s3(NULL);\n"
               "    foo(std::string(NULL));\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2:10]: (error) Null pointer dereference [nullPointer]\n"
                       "[test.cpp:3:22]: (error) Null pointer dereference [nullPointer]\n"
                       "[test.cpp:4:17]: (error) Null pointer dereference [nullPointer]\n"
@@ -4078,7 +4078,7 @@ class TestNullPointer : public TestFixture {
               "    foo(p == s1);\n"
               "    foo(p == s2);\n"
               "    foo(p == s3);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:4:15]: (error) Null pointer dereference: p [nullPointer]\n"
                       "[test.cpp:5:15]: (error) Null pointer dereference: p [nullPointer]\n"
                       "[test.cpp:7:9]: (error) Null pointer dereference: p [nullPointer]\n"
@@ -4093,7 +4093,7 @@ class TestNullPointer : public TestFixture {
               "    foo(s1.size() == 0);\n"
               "    foo(s2.size() == 0);\n"
               "    foo(s3->size() == 0);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::string s1, const std::string& s2) {\n"
@@ -4102,7 +4102,7 @@ class TestNullPointer : public TestFixture {
               "    foo(0 == s2[0]);\n"
               "    foo(s1[0] == 0);\n"
               "    foo(s2[0] == 0);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::string s1, const std::string& s2) {\n"
@@ -4111,7 +4111,7 @@ class TestNullPointer : public TestFixture {
               "    foo(s2 == '\\0');\n"
               "    foo('\\0' == s1);\n"
               "    foo('\\0' == s2);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("class Bar {\n"
@@ -4122,19 +4122,19 @@ class TestNullPointer : public TestFixture {
               "    std::string s;\n"
               "    Foo();\n"
               "};\n"
-              "Foo::Foo() : s(0) {}");
+              "Foo::Foo() : s(0) {}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Null pointer dereference [nullPointer]\n"
                       "[test.cpp:9:14]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
         check("void f() {\n"
               "    std::string s = 0 == x ? \"a\" : \"b\";\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  const std::string s = g();\n"
               "  ASSERT_MESSAGE(\"Error on s\", 0 == s.compare(\"Some text\"));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int i, std::string s);\n"
@@ -4145,7 +4145,7 @@ class TestNullPointer : public TestFixture {
               "  foo(var, NULL);\n"
               "  foo(var, nullptr);\n"
               "  foo(0, var);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (error) Null pointer dereference [nullPointer]\n"
                       "[test.cpp:5:12]: (error) Null pointer dereference [nullPointer]\n"
                       "[test.cpp:6:12]: (error) Null pointer dereference [nullPointer]\n"
@@ -4190,7 +4190,7 @@ class TestNullPointer : public TestFixture {
         check("void f(std::ifstream& is) {\n"
               "    char* p = 0;\n"
               "    is >> p;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Possible null pointer dereference: p\n", "", errout_str());
 
         check("void f(const std::ostringstream& oss, char* q) {\n"
@@ -4199,7 +4199,7 @@ class TestNullPointer : public TestFixture {
               "    oss << foo << p;\n"
               "    if(q == 0)\n"
               "        oss << foo << q;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Null pointer dereference: p [nullPointer]\n"
                       "[test.cpp:4:19]: (error) Null pointer dereference: p [nullPointer]\n"
                       "[test.cpp:5:10] -> [test.cpp:6:23]: (warning) Either the condition 'q==0' is redundant or there is possible null pointer dereference: q. [nullPointerRedundantCheck]\n", errout_str());
@@ -4211,7 +4211,7 @@ class TestNullPointer : public TestFixture {
               "        std::cin >> p;\n"
               "        std::cout << abc << p;\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:3:22]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n"
                            "[test.cpp:2:10] -> [test.cpp:4:22]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n"
                            "[test.cpp:2:10] -> [test.cpp:5]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n"
@@ -4226,7 +4226,7 @@ class TestNullPointer : public TestFixture {
               "    char* p2 = 0;\n"
               "    std::cin >> (int)p;\n" // result casted
               "    std::cout << (int)p;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::string& str) {\n"
@@ -4234,13 +4234,13 @@ class TestNullPointer : public TestFixture {
               "    std::istringstream istr(str);\n"
               "    istr >> std::hex >> ret;\n" // Read integer
               "    return ret;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int* i) {\n"
               "    if(i) return;\n"
               "    std::cout << i;\n" // Its no char* (#4240)
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         // #5811 false positive: (error) Null pointer dereference
@@ -4249,7 +4249,7 @@ class TestNullPointer : public TestFixture {
               "    stringstream out;\n"
               "    out << ((ip >> 0) & 0xFF);\n"
               "    return out.str();\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
         // avoid regression from first fix attempt for #5811...
         check("void deserialize(const std::string &data) {\n"
@@ -4269,42 +4269,42 @@ class TestNullPointer : public TestFixture {
               "void f(std::shared_ptr<Fred> p) {\n"
               "  if (p) {}\n"
               "  dostuff(p->x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7] -> [test.cpp:4:11]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f(std::shared_ptr<Fred> p) {\n"
               "  p = nullptr;\n"
               "  dostuff(p->x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f(std::unique_ptr<Fred> p) {\n"
               "  if (p) {}\n"
               "  dostuff(p->x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7] -> [test.cpp:4:11]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f(std::unique_ptr<Fred> p) {\n"
               "  p = nullptr;\n"
               "  dostuff(p->x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f() {\n"
               "  std::shared_ptr<Fred> p;\n"
               "  dostuff(p->x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f(std::shared_ptr<Fred> p) {\n"
               "  p.reset();\n"
               "  dostuff(p->x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct Fred { int x; };\n"
@@ -4312,7 +4312,7 @@ class TestNullPointer : public TestFixture {
               "  Fred * pp = nullptr;\n"
               "  p.reset(pp);\n"
               "  dostuff(p->x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct Fred { int x; };\n"
@@ -4320,28 +4320,28 @@ class TestNullPointer : public TestFixture {
               "  std::shared_ptr<Fred> p;\n"
               "  p.reset(&f);\n"
               "  dostuff(p->x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f(std::shared_ptr<Fred> p) {\n"
               "  p.reset();\n"
               "  dostuff(p->x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f() {\n"
               "  std::shared_ptr<Fred> p(nullptr);\n"
               "  dostuff(p->x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct A {};\n"
               "void f(int n) {\n"
               "    std::unique_ptr<const A*[]> p;\n"
               "    p.reset(new const A*[n]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9216
@@ -4352,7 +4352,7 @@ class TestNullPointer : public TestFixture {
               "void g(std::unique_ptr<A> var) {\n"
               "    var->reset();\n"
               "    var->f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9439
@@ -4380,21 +4380,21 @@ class TestNullPointer : public TestFixture {
               "    int *p = malloc(10);\n"
               "    *p = 0;\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (warning) If memory allocation fails, then there is a possible null pointer dereference: p [nullPointerOutOfMemory]\n", errout_str());
 
         check("void f() {\n"
               "    int *p = malloc(10);\n"
               "    *(p+2) = 0;\n"
               "    free(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8]: (error) If memory allocation fails: pointer addition with NULL pointer. [nullPointerArithmeticOutOfMemory]\n", errout_str());
 
         check("void f() {\n" // #13676
               "    int* q = static_cast<int*>(std::malloc(4));\n"
               "    *q = 0;\n"
               "    std::free(q);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (warning) If memory allocation fails, then there is a possible null pointer dereference: q [nullPointerOutOfMemory]\n", errout_str());
     }
 
@@ -4406,7 +4406,7 @@ class TestNullPointer : public TestFixture {
                   "    *p = 0;\n"
                   "    foo(p);\n"
                   "    if (p) { }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("", errout_str());
 
             // function seen (taking pointer parameter)
@@ -4416,7 +4416,7 @@ class TestNullPointer : public TestFixture {
                   "    *p = 0;\n"
                   "    foo(p);\n"
                   "    if (p) { }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS(
                 "[test.cpp:6:9] -> [test.cpp:4:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
                 errout_str());
@@ -4428,7 +4428,7 @@ class TestNullPointer : public TestFixture {
                   "    *p = 0;\n"
                   "    foo(p);\n"
                   "    if (p) { }\n"
-                  "}", dinit(CheckOptions, $.inconclusive = true));
+                  "}\n", dinit(CheckOptions, $.inconclusive = true));
             ASSERT_EQUALS("", errout_str());
 
             // function implementation not seen
@@ -4438,7 +4438,7 @@ class TestNullPointer : public TestFixture {
                   "    *p = 0;\n"
                   "    foo(p);\n"
                   "    if (p) { }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS(
                 "[test.cpp:6:9] -> [test.cpp:4:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
                 errout_str());
@@ -4448,7 +4448,7 @@ class TestNullPointer : public TestFixture {
                   "    *p = 0;\n"
                   "    foo(p);\n"
                   "    if (p) { }\n"
-                  "}", dinit(CheckOptions, $.inconclusive = true));
+                  "}\n", dinit(CheckOptions, $.inconclusive = true));
             ASSERT_EQUALS(
                 "[test.cpp:4:9] -> [test.cpp:2:6]: (warning, inconclusive) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
                 errout_str());
@@ -4461,7 +4461,7 @@ class TestNullPointer : public TestFixture {
                   "    abc->a = 0;\n"
                   "    foo(abc);\n"
                   "    if (abc) { }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("", errout_str());
 
             // function seen (taking pointer parameter)
@@ -4471,7 +4471,7 @@ class TestNullPointer : public TestFixture {
                   "    abc->a = 0;\n"
                   "    foo(abc);\n"
                   "    if (abc) { }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS(
                 "[test.cpp:6:9] -> [test.cpp:4:5]: (warning) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
                 errout_str());
@@ -4483,7 +4483,7 @@ class TestNullPointer : public TestFixture {
                   "    abc->a = 0;\n"
                   "    foo(abc);\n"
                   "    if (abc) { }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS(
                 "[test.cpp:6:9] -> [test.cpp:4:5]: (warning) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
                 errout_str());
@@ -4493,7 +4493,7 @@ class TestNullPointer : public TestFixture {
                   "    abc->a = 0;\n"
                   "    foo(abc);\n"
                   "    if (abc) { }\n"
-                  "}", dinit(CheckOptions, $.inconclusive = true));
+                  "}\n", dinit(CheckOptions, $.inconclusive = true));
             ASSERT_EQUALS(
                 "[test.cpp:4:9] -> [test.cpp:2:5]: (warning, inconclusive) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
                 errout_str());
@@ -4567,7 +4567,7 @@ class TestNullPointer : public TestFixture {
 
     void functioncalllibrary() {
         SimpleTokenizer tokenizer(settingsDefault,*this,false);
-        const char code[] = "void f() { int a,b,c; x(a,b,c); }";
+        const char code[] = "void f() { int a,b,c; x(a,b,c); }\n";
         ASSERT_EQUALS(true, tokenizer.tokenize(code));
         const Token *xtok = Token::findsimplematch(tokenizer.tokens(), "x");
 
@@ -4613,51 +4613,51 @@ class TestNullPointer : public TestFixture {
 
         check("void f(int *p = 0) {\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:6]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    if (!p)\n"
               "        return;\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char a, int *p = 0) {\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:6]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    printf(\"p = %d\", *p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:23]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    printf(\"p[1] = %d\", p[1]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:25]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    buf[p] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    if (p != 0 && bar())\n"
               "      *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p) {\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    if (p != 0)\n"
               "      *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
@@ -4665,13 +4665,13 @@ class TestNullPointer : public TestFixture {
               "    if (p == 0)\n"
               "      p = &y;\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int a, int *p = 0) {\n"
               "    if (a != 0)\n"
               "      *p = 0;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS(
             "[test.cpp:3:8]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n",
             errout_str());
@@ -4679,13 +4679,13 @@ class TestNullPointer : public TestFixture {
         check("void f(int *p = 0) {\n"
               "    p = a;\n"
               "    *p = 0;\n" // <- don't simplify and verify
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    p += a;\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int *p = 0) {\n"
@@ -4693,17 +4693,17 @@ class TestNullPointer : public TestFixture {
               "        return 0;\n"
               "    }\n"
               "    return *p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    std::cout << p ? *p : 0;\n" // Due to operator precedence, this is equivalent to: (std::cout << p) ? *p : 0;
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:23]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str()); // Check the first branch of ternary
 
         check("void f(char *p = 0) {\n"
               "    std::cout << p ? *p : 0;\n" // Due to operator precedence, this is equivalent to: (std::cout << p) ? *p : 0;
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:18]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n"
             "[test.cpp:2:23]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n",   // duplicate
@@ -4711,27 +4711,27 @@ class TestNullPointer : public TestFixture {
 
         check("void f(int *p = 0) {\n"
               "    std::cout << (p ? *p : 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    std::cout << p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    std::cout << (p && p[0] ? *p : 42);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void isEmpty(int *p = 0) {\n"
               "    return p && *p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g(int *p = 0) {\n"
               "    return !p || *p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -4740,13 +4740,13 @@ class TestNullPointer : public TestFixture {
         check("void f(int *p = 0) {\n"
               "    bar(p);\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    printf(\"%p\", p);\n"
               "    *p = 0;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:3:6]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str());
 
         // The init() function may or may not initialize p, but since the address
@@ -4755,14 +4755,14 @@ class TestNullPointer : public TestFixture {
         check("void f(int *p = 0) {\n"
               "    init(&p);\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void init(int* &g);\n"
               "void f(int *p = 0) {\n"
               "    init(p);\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
@@ -4770,7 +4770,7 @@ class TestNullPointer : public TestFixture {
               "        init(&p);\n"
               "    }\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
@@ -4778,12 +4778,12 @@ class TestNullPointer : public TestFixture {
               "        throw SomeException;\n"
               "    }\n"
               "    *p = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int x, int *p = 0) {\n"
               "    int var1 = x ? *p : 5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:21]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str());
 
         check("void f(int* i = nullptr) { *i = 0; }\n" // #11567
@@ -4798,7 +4798,7 @@ class TestNullPointer : public TestFixture {
               "    unsigned int j;\n"
               "    for (j = 0; j < b[0].a->size; ++j) {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4822,33 +4822,33 @@ class TestNullPointer : public TestFixture {
         check("void foo(char *s) {\n"
               "  char *p = s - 20;\n"
               "}\n"
-              "void bar() { foo(0); }");
+              "void bar() { foo(0); }\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (error) Overflow in pointer arithmetic, NULL pointer is subtracted. [nullPointerArithmetic]\n",
                       errout_str());
 
         check("void foo(char *s) {\n"
               "  if (!s) {}\n"
               "  char *p = s - 20;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7] -> [test.cpp:3:15]: (warning) Either the condition '!s' is redundant or there is overflow in pointer subtraction. [nullPointerArithmeticRedundantCheck]\n", errout_str());
 
         check("void foo(char *s) {\n"
               "  s -= 20;\n"
               "}\n"
-              "void bar() { foo(0); }");
+              "void bar() { foo(0); }\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (error) Overflow in pointer arithmetic, NULL pointer is subtracted. [nullPointerArithmetic]\n",
                       errout_str());
 
         check("void foo(char *s) {\n"
               "  if (!s) {}\n"
               "  s -= 20;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7] -> [test.cpp:3:5]: (warning) Either the condition '!s' is redundant or there is overflow in pointer subtraction. [nullPointerArithmeticRedundantCheck]\n", errout_str());
 
-        check("int* f8() { int *x = NULL; return --x; }");
+        check("int* f8() { int *x = NULL; return --x; }\n");
         ASSERT_EQUALS("[test.cpp:1:35]: (error) Overflow in pointer arithmetic, NULL pointer is subtracted. [nullPointerArithmetic]\n", errout_str());
 
-        check("int* f9() { int *x = NULL; return x--; }");
+        check("int* f9() { int *x = NULL; return x--; }\n");
         ASSERT_EQUALS("[test.cpp:1:36]: (error) Overflow in pointer arithmetic, NULL pointer is subtracted. [nullPointerArithmetic]\n", errout_str());
     }
 
@@ -4856,48 +4856,48 @@ class TestNullPointer : public TestFixture {
         check("void foo(char *s) {\n"
               "  char * p = s + 20;\n"
               "}\n"
-              "void bar() { foo(0); }");
+              "void bar() { foo(0); }\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (error) Pointer addition with NULL pointer. [nullPointerArithmetic]\n", errout_str());
 
         check("void foo(char *s) {\n"
               "  if (!s) {}\n"
               "  char * p = s + 20;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7] -> [test.cpp:3:16]: (warning) Either the condition '!s' is redundant or there is pointer arithmetic with NULL pointer. [nullPointerArithmeticRedundantCheck]\n", errout_str());
 
         check("void foo(char *s) {\n"
               "  char * p = 20 + s;\n"
               "}\n"
-              "void bar() { foo(0); }");
+              "void bar() { foo(0); }\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (error) Pointer addition with NULL pointer. [nullPointerArithmetic]\n", errout_str());
 
         check("void foo(char *s) {\n"
               "  if (!s) {}\n"
               "  char * p = 20 + s;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7] -> [test.cpp:3:17]: (warning) Either the condition '!s' is redundant or there is pointer arithmetic with NULL pointer. [nullPointerArithmeticRedundantCheck]\n", errout_str());
 
         check("void foo(char *s) {\n"
               "  s += 20;\n"
               "}\n"
-              "void bar() { foo(0); }");
+              "void bar() { foo(0); }\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (error) Pointer addition with NULL pointer. [nullPointerArithmetic]\n", errout_str());
 
         check("void foo(char *s) {\n"
               "  if (!s) {}\n"
               "  s += 20;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7] -> [test.cpp:3:5]: (warning) Either the condition '!s' is redundant or there is pointer arithmetic with NULL pointer. [nullPointerArithmeticRedundantCheck]\n", errout_str());
 
-        check("int* f7() { int *x = NULL; return ++x; }");
+        check("int* f7() { int *x = NULL; return ++x; }\n");
         ASSERT_EQUALS("[test.cpp:1:35]: (error) Pointer addition with NULL pointer. [nullPointerArithmetic]\n", errout_str());
 
-        check("int* f10() { int *x = NULL; return x++; }");
+        check("int* f10() { int *x = NULL; return x++; }\n");
         ASSERT_EQUALS("[test.cpp:1:37]: (error) Pointer addition with NULL pointer. [nullPointerArithmetic]\n", errout_str());
 
         check("class foo {};\n"
               "const char* get() const { return 0; }\n"
-              "void f(foo x) { if (get()) x += get(); }");
+              "void f(foo x) { if (get()) x += get(); }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("typedef struct { uint8_t* buf, *buf_end; } S;\n" // #11117
@@ -4913,7 +4913,7 @@ class TestNullPointer : public TestFixture {
     }
 
     void isPointerDeRefFunctionDecl() {
-        check("const char** get() { return 0; }");
+        check("const char** get() { return 0; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4947,7 +4947,7 @@ class TestNullPointer : public TestFixture {
             "int main() {\n"
             "  int *p = 0;\n"
             "  f(p);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: error: Null pointer dereference: fp [ctunullpointer]\n"
                       "[test.cpp:5:12]: note: Assignment 'p=0', assigned value is 0\n"
                       "[test.cpp:6:4]: note: Calling function f, 1st argument is null\n"
@@ -4957,7 +4957,7 @@ class TestNullPointer : public TestFixture {
             "void call(int x, int *p) { x++; use(p); }\n"
             "int main() {\n"
             "  call(4,0);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:1:25]: error: Null pointer dereference: p [ctunullpointer]\n"
                       "[test.cpp:4:7]: note: Calling function call, 2nd argument is null\n"
                       "[test.cpp:2:33]: note: Calling function use, 1st argument is null\n"
@@ -4971,7 +4971,7 @@ class TestNullPointer : public TestFixture {
             "\n"
             "void f() {\n"
             "  dostuff(a, 0);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         ctu("void dostuff(int *x, int *y) {\n"
@@ -4982,7 +4982,7 @@ class TestNullPointer : public TestFixture {
             "\n"
             "void f() {\n"
             "  dostuff(a, 0);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // else
@@ -4993,7 +4993,7 @@ class TestNullPointer : public TestFixture {
             "\n"
             "void f() {\n"
             "  dostuff(0, 0);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ?, &&, ||
@@ -5003,14 +5003,14 @@ class TestNullPointer : public TestFixture {
             "\n"
             "void f() {\n"
             "  dostuff(0, 0);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         ctu("void g(int* x) { *x; }\n"
             "void f(int* x) {\n"
             "    if (x)\n"
             "        g(x);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         ctu("size_t f(int* p) {\n"
diff --git a/test/testother.cpp b/test/testother.cpp
index b12e26e1ffa..3c301a3fc3c 100644
--- a/test/testother.cpp
+++ b/test/testother.cpp
@@ -398,7 +398,7 @@ class TestOther : public TestFixture {
 
     void emptyBrackets() {
         check("{\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -406,22 +406,22 @@ class TestOther : public TestFixture {
     void zeroDiv1() { // floating point division by zero => no error
         check("void foo() {\n"
               "    cout << 1. / 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    cout << 42 / (double)0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    cout << 42 / (float)0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    cout << 42 / (int)0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
 
@@ -434,34 +434,34 @@ class TestOther : public TestFixture {
               "        sum += i;\n"
               "    }\n"
               "    cout<<b/sum;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void zeroDiv3() {
         check("int foo(int i) {\n"
               "    return i / 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         check("int foo(int i) {\n"
               "    return i % 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         check("void foo(int& i) {\n"
               "    i /= 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         check("void foo(int& i) {\n"
               "    i %= 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         check("uint8_t foo(uint8_t i) {\n"
               "    return i / 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
 
@@ -469,40 +469,40 @@ class TestOther : public TestFixture {
         check("void f()\n"
               "{\n"
               "   long a = b / 0x6;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "   long a = b / 0x0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(long b)\n"
               "{\n"
               "   long a = b / 0x0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   long a = b / 0L;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(long b)\n"
               "{\n"
               "   long a = b / 0L;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   long a = b / 0ul;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(long b)\n"
               "{\n"
               "   long a = b / 0ul;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         // Don't warn about floating points (gcc doesn't warn either)
@@ -510,13 +510,13 @@ class TestOther : public TestFixture {
         check("void f()\n"
               "{\n"
               "   long a = b / 0.0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "   long a = b / 0.5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -524,12 +524,12 @@ class TestOther : public TestFixture {
         check("void f()\n"
               "{ { {\n"
               "   long a = b / 0;\n"
-              "} } }");
+              "} } }\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(long b)\n"
               "{ { {\n"
               "   long a = b / 0;\n"
-              "} } }");
+              "} } }\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
 
@@ -537,12 +537,12 @@ class TestOther : public TestFixture {
         check("void f()\n"
               "{ { {\n"
               "   int a = b % 0;\n"
-              "} } }");
+              "} } }\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(int b)\n"
               "{ { {\n"
               "   int a = b % 0;\n"
-              "} } }");
+              "} } }\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
 
@@ -551,12 +551,12 @@ class TestOther : public TestFixture {
         check("void f() {\n"
               "  int a = x/2*3/0;\n"
               "  int b = y/2*3%0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void f(int x, int y) {\n"
               "  int a = x/2*3/0;\n"
               "  int b = y/2*3%0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (error) Division by zero. [zerodiv]\n"
                       "[test.cpp:3:16]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
@@ -567,7 +567,7 @@ class TestOther : public TestFixture {
               "  int a = 0;\n"
               "  do_something(a);\n"
               "  return 4 / a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (error, inconclusive) Division by zero. [zerodiv]\n", errout_str());
     }
 
@@ -581,7 +581,7 @@ class TestOther : public TestFixture {
               "       sal_Int32 nIntervalCount = static_cast< sal_Int32 >(fStepMain / fStepHelp);\n"
               "    }\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -592,7 +592,7 @@ class TestOther : public TestFixture {
               "    << boost::format(\" %d :: %s <> %s\") % 0 % \"a\" % \"b\"\n"
               "    << std::endl;\n"
               "  return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -600,13 +600,13 @@ class TestOther : public TestFixture {
         check("void f(int a) {\n"
               "  int res = (a+2)/0;\n"
               "  int res = (a*2)/0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (error) Division by zero. [zerodiv]\n"
                       "[test.cpp:3:18]: (error) Division by zero. [zerodiv]\n", errout_str());
         check("void f() {\n"
               "  int res = (a+2)/0;\n"
               "  int res = (a*2)/0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -614,7 +614,7 @@ class TestOther : public TestFixture {
         // #8141
         check("intmax_t f() {\n"
               "  return 1 / imaxabs(0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
     void zeroDiv13() {
@@ -709,7 +709,7 @@ class TestOther : public TestFixture {
               "{\n"
               "    uint16_t x = 0xFFFFU;\n" // UINT16_MAX=0xFFFF
               "    return 42/(++x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:14]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
 
@@ -736,25 +736,25 @@ class TestOther : public TestFixture {
         check("void f(unsigned int x) {\n"
               "  int y = 17 / x;\n"
               "  if (x > 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:14]: (warning) Either the condition 'x>0' is redundant or there is division by zero at line 2. [zerodivcond]\n", errout_str());
 
         check("void f(unsigned int x) {\n"
               "  int y = 17 / x;\n"
               "  if (x >= 1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:14]: (warning) Either the condition 'x>=1' is redundant or there is division by zero at line 2. [zerodivcond]\n", errout_str());
 
         check("void f(int x) {\n"
               "  int y = 17 / x;\n"
               "  if (x == 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:14]: (warning) Either the condition 'x==0' is redundant or there is division by zero at line 2. [zerodivcond]\n", errout_str());
 
         check("void f(unsigned int x) {\n"
               "  int y = 17 / x;\n"
               "  if (x != 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:14]: (warning) Either the condition 'x!=0' is redundant or there is division by zero at line 2. [zerodivcond]\n", errout_str());
 
         // function call
@@ -762,7 +762,7 @@ class TestOther : public TestFixture {
               "void f2(unsigned int y) {\n"
               "    f1(123,y);\n"
               "    if (y>0){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:10] -> [test.cpp:1:28]: (warning) Either the condition 'y>0' is redundant or there is division by zero at line 1. [zerodivcond]\n",
             errout_str());
@@ -773,7 +773,7 @@ class TestOther : public TestFixture {
               "  int y = 17 / x;\n"
               "  x = some+calculation;\n"
               "  if (x != 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         {
@@ -784,7 +784,7 @@ class TestOther : public TestFixture {
                   "  int y = 17 / x;\n"
                   "  do_something();\n"
                   "  if (x != 0) {}\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("", errout_str());
 
             // function is called. but don't care, variable is local
@@ -794,7 +794,7 @@ class TestOther : public TestFixture {
                   "  int y = 17 / x;\n"
                   "  do_something();\n"
                   "  if (x != 0) {}\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("[test.cpp:6:9] -> [test.cpp:4:14]: (warning) Either the condition 'x!=0' is redundant or there is division by zero at line 4. [zerodivcond]\n", errout_str());
         }
 
@@ -802,14 +802,14 @@ class TestOther : public TestFixture {
               "void f(int x) {\n"
               "  int y = 17 / x;\n"
               "  do_something(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int x;\n"
               "void f() {\n"
               "  int y = 17 / x;\n"
               "  while (y || x == 0) { x--; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket 5033 segmentation fault (valid code) in CheckOther::checkZeroDivisionOrUselessCondition
@@ -818,33 +818,33 @@ class TestOther : public TestFixture {
               "double* p2= new double[1];\n"
               "double* p3= new double[1];\n"
               "double* pp[3] = {p1,p2,p3};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5105 - FP
         check("int f(int a, int b) {\n"
               "  int r = a / b;\n"
               "  if (func(b)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Unknown types for b and c --> do not warn
         check("int f(int d) {\n"
               "  int r = (a?b:c) / d;\n"
               "  if (d == 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int a) {\n"
               "  int r = a ? 1 / a : 0;\n"
               "  if (a == 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int a) {\n"
               "  int r = (a == 0) ? 0 : 1 / a;\n"
               "  if (a == 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int g();\n"
@@ -854,7 +854,7 @@ class TestOther : public TestFixture {
               "  else if (x > 0) {}\n"
               "  else\n"
               "    a = b / -x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -901,35 +901,35 @@ class TestOther : public TestFixture {
               "{\n"
               "   double x = 3.0 / 0.0 + 1.0;\n"
               "   printf(\"%f\", x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (style) Using NaN/Inf in a computation. [nanInArithmeticExpression]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   double x = 3.0 / 0.0 - 1.0;\n"
               "   printf(\"%f\", x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (style) Using NaN/Inf in a computation. [nanInArithmeticExpression]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   double x = 1.0 + 3.0 / 0.0;\n"
               "   printf(\"%f\", x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:25]: (style) Using NaN/Inf in a computation. [nanInArithmeticExpression]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   double x = 1.0 - 3.0 / 0.0;\n"
               "   printf(\"%f\", x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:25]: (style) Using NaN/Inf in a computation. [nanInArithmeticExpression]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   double x = 3.0 / 0.0;\n"
               "   printf(\"%f\", x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
     }
@@ -960,7 +960,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "\n"
               "    return 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -970,7 +970,7 @@ class TestOther : public TestFixture {
               "    Error e;\n"
               "    e.SetValue(12);\n"
               "    throw e;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -984,7 +984,7 @@ class TestOther : public TestFixture {
               "        p = &i;\n"
               "    }\n"
               "    *p = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -992,7 +992,7 @@ class TestOther : public TestFixture {
         check("void foo()\n"
               "{\n"
               "    int i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1003,7 +1003,7 @@ class TestOther : public TestFixture {
               "    if (x) {\n"
               "        for ( ; i < 10; ++i) ;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) The scope of the variable 'i' can be reduced. [variableScope]\n", errout_str());
 
         check("void f(int x) {\n"
@@ -1011,7 +1011,7 @@ class TestOther : public TestFixture {
               "    if (x) {\n"
               "        for ( ; i < 10; ++i) ;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x)\n"
@@ -1021,7 +1021,7 @@ class TestOther : public TestFixture {
               "    else {\n"
               "        for ( ; i < 10; ++i) ;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) The scope of the variable 'i' can be reduced. [variableScope]\n", errout_str());
     }
 
@@ -1035,7 +1035,7 @@ class TestOther : public TestFixture {
               "    if (b) {\n"
               "        c(i);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #5398
@@ -1044,14 +1044,14 @@ class TestOther : public TestFixture {
               "    if (success) {\n"
               "        foo(notReducable);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(Test &test) {\n"
               "  int& x = test.getData();\n"
               "  if (test.process())\n"
               "    x = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -1066,7 +1066,7 @@ class TestOther : public TestFixture {
               "  return 0;\n"
               " }\n"
               "}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int &x)\n"
@@ -1077,7 +1077,7 @@ class TestOther : public TestFixture {
               "    ++n;\n"
               "    ++x;\n"
               "  } while (x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1089,7 +1089,7 @@ class TestOther : public TestFixture {
               "    if (x) {\n"
               "        y++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1100,7 +1100,7 @@ class TestOther : public TestFixture {
               "    BOOST_FOREACH(int edge, edges) {\n"
               "        edgeResistance = (edge+1) / 2.0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) The scope of the variable 'edgeResistance' can be reduced. [variableScope]\n", errout_str());
     }
 
@@ -1116,7 +1116,7 @@ class TestOther : public TestFixture {
               "    if (a == 2) {\n"
               "        f.x();\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class fred {\n" // #2062
@@ -1128,7 +1128,7 @@ class TestOther : public TestFixture {
               "    if (a == 2) {\n"
               "        f.x();\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:10]: (style) The scope of the variable 'f' can be reduced. [variableScope]\n", errout_str());
 
         check("struct S { int a, b; };\n"
@@ -1149,7 +1149,7 @@ class TestOther : public TestFixture {
               "    FOR {\n"
               "        foo(x++);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1157,21 +1157,21 @@ class TestOther : public TestFixture {
         check("int f() {\n"
               "    int x = 0;\n"
               "    AB ab = { x, 0 };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    int x = 0;\n"
               "    if (a == 0) { ++x; }\n"
               "    AB ab = { x, 0 };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    int x = 0;\n"
               "    if (a == 0) { ++x; }\n"
               "    if (a == 1) { AB ab = { x, 0 }; }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1182,7 +1182,7 @@ class TestOther : public TestFixture {
               "    if (x)\n"
               "        foo(i);\n"
               "    foo(j);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'i' can be reduced. [variableScope]\n", errout_str());
 
         check("void f(int x) {\n"
@@ -1191,7 +1191,7 @@ class TestOther : public TestFixture {
               "    if (x)\n"
               "        j = i;\n"
               "    foo(j);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
@@ -1199,7 +1199,7 @@ class TestOther : public TestFixture {
               "    x++;\n"
               "    if (x == 5)\n"
               "        foo(b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
@@ -1207,7 +1207,7 @@ class TestOther : public TestFixture {
               "    x++;\n"
               "    if (x == 5)\n"
               "        foo(b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1218,7 +1218,7 @@ class TestOther : public TestFixture {
               "    forever {\n"
               "        if (i++ == 42) { break; }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1229,7 +1229,7 @@ class TestOther : public TestFixture {
               "    if(a) {\n"
               "        for ( ; i < 10; ++i) ;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1241,7 +1241,7 @@ class TestOther : public TestFixture {
               "    else if(b);\n"
               "    else if(c);\n"
               "    else;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1251,7 +1251,7 @@ class TestOther : public TestFixture {
               "    while((++a) < 56) {\n"
               "        foo();\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -1259,7 +1259,7 @@ class TestOther : public TestFixture {
               "    do {\n"
               "        foo();\n"
               "    } while((++a) < 56);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -1268,7 +1268,7 @@ class TestOther : public TestFixture {
               "        a = 64;\n"
               "        foo(a);\n"
               "    } while((++a) < 56);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -1277,7 +1277,7 @@ class TestOther : public TestFixture {
               "        a = 64;\n"
               "        foo(a);\n"
               "    } while(z());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'a' can be reduced. [variableScope]\n", errout_str());
     }
 
@@ -1288,7 +1288,7 @@ class TestOther : public TestFixture {
               "        x = stuff(x);\n"
               "        morestuff(x);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'x' can be reduced. [variableScope]\n", errout_str());
 
         check("void f() {\n"
@@ -1298,7 +1298,7 @@ class TestOther : public TestFixture {
               "        morestuff(x);\n"
               "    }\n"
               "    if (b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'x' can be reduced. [variableScope]\n", errout_str());
     }
 
@@ -1318,7 +1318,7 @@ class TestOther : public TestFixture {
               "        x = foo();\n"
               "        do_something(x);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) The scope of the variable 'x' can be reduced. [variableScope]\n", errout_str());
 
         check("void f() {\n"
@@ -1337,7 +1337,7 @@ class TestOther : public TestFixture {
               "        x = foo();\n"
               "        do_something(x);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -1352,7 +1352,7 @@ class TestOther : public TestFixture {
               "        default:\n"
               "            break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) The scope of the variable 'x' can be reduced. [variableScope]\n", errout_str());
 
         check("void f() {\n"
@@ -1369,7 +1369,7 @@ class TestOther : public TestFixture {
               "                do_something(x);\n"
               "            break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1379,7 +1379,7 @@ class TestOther : public TestFixture {
               "  int b = a;\n"
               "  if (b > 32) b = x;\n"
               "  return b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1388,7 +1388,7 @@ class TestOther : public TestFixture {
               "    int test_value = 3;\n"
               "    int test_array[1][1] = { { test_value } };\n"
               "    return sizeof(test_array);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1401,7 +1401,7 @@ class TestOther : public TestFixture {
               "      ++p;\n"
               "      ++i;\n"
               "   }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         // try to avoid an obvious false negative after applying the fix for the example above:
         check("void foo() {\n"
@@ -1414,7 +1414,7 @@ class TestOther : public TestFixture {
               "      ++p;\n"
               "      ++i;\n"
               "   }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'p' can be reduced. [variableScope]\n", errout_str());
     }
 
@@ -1424,7 +1424,7 @@ class TestOther : public TestFixture {
               "   Test myTest([&](size_t aX){\n"
               "       std::cout << myCounter += aX << std::endl;\n"
               "   });\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1434,7 +1434,7 @@ class TestOther : public TestFixture {
               "   if (cond) {\n"
               "       r.dostuff();\n"
               "   }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'r' can be reduced. [variableScope]\n", errout_str());
 
         check("void f(Foo x) {\n"
@@ -1442,7 +1442,7 @@ class TestOther : public TestFixture {
               "   if (cond) {\n"
               "       foo.dostuff();\n"
               "   }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1453,7 +1453,7 @@ class TestOther : public TestFixture {
               "        currtime = time(&dummy);\n"
               "        if (currtime > t) {}\n"
               "    }\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:2:12]: (style) The scope of the variable 'currtime' can be reduced. [variableScope]\n", errout_str());
     }
 
@@ -1465,7 +1465,7 @@ class TestOther : public TestFixture {
               "       if (cond2) { dostuff(key); }\n"
               "     }\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1475,7 +1475,7 @@ class TestOther : public TestFixture {
                "#ifdef X\n"
                "#endif\n"
                "  if (id == ABC) { return x; }\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkP("void f() {\n"
@@ -1483,7 +1483,7 @@ class TestOther : public TestFixture {
                "#endif\n"
                "  int x = 0;\n"
                "  if (id == ABC) { return x; }\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (style) The scope of the variable 'x' can be reduced. [variableScope]\n", errout_str());
     }
 
@@ -1517,7 +1517,7 @@ class TestOther : public TestFixture {
               "        s = \"abc\";\n"
               "        g(s);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (style) The scope of the variable 's' can be reduced. [variableScope]\n", errout_str());
 
         check("auto foo(std::vector<int>& vec, bool flag) {\n"
@@ -1530,7 +1530,7 @@ class TestOther : public TestFixture {
               "        iter = dummy.begin();\n"
               "    }\n"
               "    return *iter;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:28]: (style) Parameter 'vec' can be declared as reference to const [constParameterReference]\n", errout_str());
 
         check("auto& foo(std::vector<int>& vec, bool flag) {\n"
@@ -1543,7 +1543,7 @@ class TestOther : public TestFixture {
               "        iter = dummy.begin();\n"
               "    }\n"
               "    return *iter;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2067,7 +2067,7 @@ class TestOther : public TestFixture {
                                  "void foo(Base* base)\n"
                                  "{\n"
                                  "    Derived * d = (Derived *) base;\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:5:19]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
 
         checkOldStylePointerCast("class Base{};\n"
@@ -2075,13 +2075,13 @@ class TestOther : public TestFixture {
                                  "void foo(Derived* derived)\n"
                                  "{\n"
                                  "    Base * b = (Base *) derived;\n" // <- cast from derived to base is safe => cstyleCast
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:5:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
 
         checkOldStylePointerCast("void foo(Base* base)\n"
                                  "{\n"
                                  "    Derived * d = (Derived *) base;\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
 
         checkOldStylePointerCast("class Base{};\n"
@@ -2089,7 +2089,7 @@ class TestOther : public TestFixture {
                                  "void foo(Base* base)\n"
                                  "{\n"
                                  "    Derived * d = (const Derived *) base;\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:5:19]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
 
         checkOldStylePointerCast("class Base{};\n"
@@ -2097,7 +2097,7 @@ class TestOther : public TestFixture {
                                  "void foo()\n"
                                  "{\n"
                                  "    Derived * d = (const Derived *) ( new Base() );\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:5:19]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
 
         checkOldStylePointerCast("class Base{};\n"
@@ -2105,102 +2105,102 @@ class TestOther : public TestFixture {
                                  "void foo()\n"
                                  "{\n"
                                  "    Derived * d = (const Derived *) new Base();\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:5:19]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
 
         checkOldStylePointerCast("class Base{};\n"
                                  "void foo()\n"
                                  "{\n"
                                  "    Base * b = (Base *) new short[10];\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
 
         checkOldStylePointerCast("class Base;\n"
                                  "void foo()\n"
                                  "{\n"
                                  "    Base * b = (volatile Base *) derived;\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
 
         checkOldStylePointerCast("class Base;\n"
                                  "void foo()\n"
                                  "{\n"
                                  "    Base * b = (volatile Base * const) derived;\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
 
         checkOldStylePointerCast("class Base;\n"
                                  "void foo()\n"
                                  "{\n"
                                  "    Base * b = (const volatile Base *) derived;\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
 
         checkOldStylePointerCast("class Base;\n"
                                  "void foo()\n"
                                  "{\n"
                                  "    Base * b = (const volatile Base * const) derived;\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
 
         checkOldStylePointerCast("class Base;\n"
                                  "void foo()\n"
                                  "{\n"
                                  "    Base * b = (const Base *) ( new Derived() );\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
 
         checkOldStylePointerCast("class Base;\n"
                                  "void foo()\n"
                                  "{\n"
                                  "    Base * b = (const Base *) new Derived();\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
 
         checkOldStylePointerCast("class Base;\n"
                                  "void foo()\n"
                                  "{\n"
                                  "    Base * b = (const Base *) new short[10];\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
 
         checkOldStylePointerCast("class B;\n"
                                  "class A\n"
                                  "{\n"
                                  "  virtual void abc(B *) const = 0;\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOldStylePointerCast("class B;\n"
                                  "class A\n"
                                  "{\n"
                                  "  virtual void abc(const B *) const = 0;\n"
-                                 "}");
+                                 "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3630
         checkOldStylePointerCast("class SomeType{};\n"
                                  "class X : public Base {\n"
                                  "    X() : Base((SomeType*)7) {}\n" // <- intToPointerCast
-                                 "};");
+                                 "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOldStylePointerCast("class SomeType{};\n"
                                  "class X : public Base {\n"
                                  "    X() : Base((SomeType*)0x7000) {}\n" // <- it's common in embedded code to cast address
-                                 "};");
+                                 "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkOldStylePointerCast("class SomeType;\n"
                                  "class X : public Base {\n"
                                  "    X() : Base((SomeType*)var) {}\n"
-                                 "};");
+                                 "};\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
 
         checkOldStylePointerCast("class SomeType;\n"
                                  "class X : public Base {\n"
                                  "    X() : Base((SomeType*)0) {}\n"
-                                 "};");
+                                 "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5560
@@ -2210,7 +2210,7 @@ class TestOther : public TestFixture {
                                  "{ virtual G* createGui(S*, C*) const = 0; };\n"
                                  "\n"
                                  "class MS : public M\n"
-                                 "{ virtual void addController(C*) override {} };", Standards::CPP03);
+                                 "{ virtual void addController(C*) override {} };\n", Standards::CPP03);
         ASSERT_EQUALS("", errout_str());
 
         // #6164
@@ -2219,7 +2219,7 @@ class TestOther : public TestFixture {
                                  "void testCC() {\n"
                                  "  std::vector<Base*> v;\n"
                                  "  v.push_back((Base*)new Derived);\n"
-                                 "}");
+                                 "}\n");
         // FIXME write a dangerousTypeCast warning instead
         ASSERT_EQUALS("[test.cpp:5:15]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
 
@@ -2348,23 +2348,23 @@ class TestOther : public TestFixture {
 
     void intToPointerCast() {
         // #3630
-        checkIntToPointerCast("uint8_t* ptr = (uint8_t*)7;");
+        checkIntToPointerCast("uint8_t* ptr = (uint8_t*)7;\n");
         ASSERT_EQUALS("[test.cpp:1:16]: (portability) Casting non-zero decimal integer literal to pointer. [intToPointerCast]\n", errout_str());
 
-        checkIntToPointerCast("void* ptr = (void*)7;");
+        checkIntToPointerCast("void* ptr = (void*)7;\n");
         ASSERT_EQUALS("[test.cpp:1:13]: (portability) Casting non-zero decimal integer literal to pointer. [intToPointerCast]\n", errout_str());
 
-        checkIntToPointerCast("uint8_t* ptr = (uint8_t*)0;");
+        checkIntToPointerCast("uint8_t* ptr = (uint8_t*)0;\n");
         ASSERT_EQUALS("", errout_str());
 
-        checkIntToPointerCast("uint8_t* ptr = (uint8_t*)0x7000;"); // <- it's common in embedded code to cast address
+        checkIntToPointerCast("uint8_t* ptr = (uint8_t*)0x7000;\n"); // <- it's common in embedded code to cast address
         ASSERT_EQUALS("", errout_str());
 
         checkIntToPointerCast("struct S { int i; };\n" // #13886, don't crash
-                              "int f() { return sizeof(((struct S*)0)->i); }");
+                              "int f() { return sizeof(((struct S*)0)->i); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        checkIntToPointerCast("auto p = (int*)0b10;"); // #14180
+        checkIntToPointerCast("auto p = (int*)0b10;\n"); // #14180
         ASSERT_EQUALS("[test.cpp:1:10]: (portability) Casting non-zero binary integer literal to pointer. [intToPointerCast]\n", errout_str());
     }
 
@@ -2394,19 +2394,19 @@ class TestOther : public TestFixture {
                                 "    float *f = new float[10];\n"
                                 "    delete [] (double*)f;\n"
                                 "    delete [] (long double const*)(new float[10]);\n"
-                                "}");
+                                "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (portability) Casting between float * and double * which have an incompatible binary data representation. [invalidPointerCast]\n"
                       "[test.cpp:4:15]: (portability) Casting between float * and const long double * which have an incompatible binary data representation. [invalidPointerCast]\n", errout_str());
 
         checkInvalidPointerCast("void test(const float* f) {\n"
                                 "    double *d = (double*)f;\n"
-                                "}");
+                                "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (portability) Casting between const float * and double * which have an incompatible binary data representation. [invalidPointerCast]\n", errout_str());
 
         checkInvalidPointerCast("void test(double* d1) {\n"
                                 "    long double *ld = (long double*)d1;\n"
                                 "    double *d2 = (double*)ld;\n"
-                                "}");
+                                "}\n");
         ASSERT_EQUALS("[test.cpp:2:23]: (portability) Casting between double * and long double * which have an incompatible binary data representation. [invalidPointerCast]\n"
                       "[test.cpp:3:18]: (portability) Casting between long double * and double * which have an incompatible binary data representation. [invalidPointerCast]\n", errout_str());
 
@@ -2414,148 +2414,148 @@ class TestOther : public TestFixture {
                                 "    long double *d = (long double*)(i);\n"
                                 "    double *d = (double*)(i);\n"
                                 "    float *f = reinterpret_cast<float*>(i);\n"
-                                "}");
+                                "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (portability) Casting between signed int * and long double * which have an incompatible binary data representation. [invalidPointerCast]\n"
                       "[test.cpp:3:17]: (portability) Casting between signed int * and double * which have an incompatible binary data representation. [invalidPointerCast]\n"
                       "[test.cpp:4:16]: (portability) Casting between signed int * and float * which have an incompatible binary data representation. [invalidPointerCast]\n", errout_str());
 
         checkInvalidPointerCast("float* test(unsigned int* i) {\n"
                                 "    return (float*)i;\n"
-                                "}");
+                                "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (portability) Casting between unsigned int * and float * which have an incompatible binary data representation. [invalidPointerCast]\n", errout_str());
 
         checkInvalidPointerCast("float* test(unsigned int* i) {\n"
                                 "    return (float*)i[0];\n"
-                                "}");
+                                "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInvalidPointerCast("float* test(double& d) {\n"
                                 "    return (float*)&d;\n"
-                                "}");
+                                "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (portability) Casting between double * and float * which have an incompatible binary data representation. [invalidPointerCast]\n", errout_str());
 
         checkInvalidPointerCast("void test(float* data) {\n"
                                 "    f.write((char*)data,sizeof(float));\n"
-                                "}");
+                                "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInvalidPointerCast("void test(float* data) {\n"
                                 "    f.write((char*)data,sizeof(float));\n"
-                                "}", dinit(CheckInvalidPointerCastOptions, $.inconclusive = true)); // #3639
+                                "}\n", dinit(CheckInvalidPointerCastOptions, $.inconclusive = true)); // #3639
         ASSERT_EQUALS("[test.cpp:2:13]: (portability, inconclusive) Casting from float * to char * is not portable due to different binary data representations on different platforms. [invalidPointerCast]\n", errout_str());
 
 
         checkInvalidPointerCast("long long* test(float* f) {\n"
                                 "    return (long long*)f;\n"
-                                "}", dinit(CheckInvalidPointerCastOptions, $.portability = false));
+                                "}\n", dinit(CheckInvalidPointerCastOptions, $.portability = false));
         ASSERT_EQUALS("", errout_str());
 
         checkInvalidPointerCast("long long* test(float* f, char* c) {\n"
                                 "    foo((long long*)f);\n"
                                 "    return reinterpret_cast<long long*>(c);\n"
-                                "}");
+                                "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (portability) Casting from float * to signed long long * is not portable due to different binary data representations on different platforms. [invalidPointerCast]\n", errout_str());
 
-        checkInvalidPointerCast("Q_DECLARE_METATYPE(int*)"); // #4135 - don't crash
+        checkInvalidPointerCast("Q_DECLARE_METATYPE(int*)\n"); // #4135 - don't crash
     }
 
 
     void passedByValue() {
-        check("void f(const std::string str) {}");
+        check("void f(const std::string str) {}\n");
         ASSERT_EQUALS("[test.cpp:1:26]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("void f(std::unique_ptr<std::string> ptr) {}");
+        check("void f(std::unique_ptr<std::string> ptr) {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(const std::shared_ptr<std::string> ptr) {}");
+        check("void f(const std::shared_ptr<std::string> ptr) {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(const std::function<F> ptr) {}");
+        check("void f(const std::function<F> ptr) {}\n");
         ASSERT_EQUALS("", errout_str());
 
         {
-            check("void f(const std::pair<int,int> x) {}");
+            check("void f(const std::pair<int,int> x) {}\n");
             ASSERT_EQUALS("", errout_str());
 
-            check("void f(const std::pair<std::string,std::string> x) {}");
+            check("void f(const std::pair<std::string,std::string> x) {}\n");
             TODO_ASSERT_EQUALS("error", "", errout_str());
         }
 
-        check("void f(const std::string::size_type x) {}");
+        check("void f(const std::string::size_type x) {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("class Foo;\nvoid f(const Foo foo) {}"); // Unknown class
+        check("class Foo;\nvoid f(const Foo foo) {}\n"); // Unknown class
         ASSERT_EQUALS("[test.cpp:2:18]: (performance, inconclusive) Function parameter 'foo' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("class Foo { std::vector<int> v; };\nvoid f(const Foo foo) {}"); // Large class (STL member)
+        check("class Foo { std::vector<int> v; };\nvoid f(const Foo foo) {}\n"); // Large class (STL member)
         ASSERT_EQUALS("[test.cpp:2:18]: (performance) Function parameter 'foo' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("class Foo { int i; };\nvoid f(const Foo foo) {}"); // Small class
+        check("class Foo { int i; };\nvoid f(const Foo foo) {}\n"); // Small class
         ASSERT_EQUALS("", errout_str());
 
-        check("class Foo { int i[6]; };\nvoid f(const Foo foo) {}"); // Large class (array)
+        check("class Foo { int i[6]; };\nvoid f(const Foo foo) {}\n"); // Large class (array)
         ASSERT_EQUALS("[test.cpp:2:18]: (performance) Function parameter 'foo' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("class Foo { std::string* s; };\nvoid f(const Foo foo) {}"); // Small class (pointer)
+        check("class Foo { std::string* s; };\nvoid f(const Foo foo) {}\n"); // Small class (pointer)
         ASSERT_EQUALS("", errout_str());
 
-        check("class Foo { static std::string s; };\nvoid f(const Foo foo) {}"); // Small class (static member)
+        check("class Foo { static std::string s; };\nvoid f(const Foo foo) {}\n"); // Small class (static member)
         ASSERT_EQUALS("", errout_str());
 
-        check("class X { std::string s; }; class Foo : X { };\nvoid f(const Foo foo) {}"); // Large class (inherited)
+        check("class X { std::string s; }; class Foo : X { };\nvoid f(const Foo foo) {}\n"); // Large class (inherited)
         ASSERT_EQUALS("[test.cpp:2:18]: (performance) Function parameter 'foo' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("class X { std::string s; }; class Foo { X x; };\nvoid f(const Foo foo) {}"); // Large class (inherited)
+        check("class X { std::string s; }; class Foo { X x; };\nvoid f(const Foo foo) {}\n"); // Large class (inherited)
         ASSERT_EQUALS("[test.cpp:2:18]: (performance) Function parameter 'foo' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("void f(const std::string &str) {}");
+        check("void f(const std::string &str) {}\n");
         ASSERT_EQUALS("", errout_str());
 
         // The idiomatic way of passing a std::string_view is by value
-        check("void f(const std::string_view str) {}");
+        check("void f(const std::string_view str) {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(std::string_view str) {}");
+        check("void f(std::string_view str) {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(const std::string_view &str) {}");
+        check("void f(const std::string_view &str) {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(const std::vector<int> v) {}");
+        check("void f(const std::vector<int> v) {}\n");
         ASSERT_EQUALS("[test.cpp:1:31]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("void f(const std::vector<std::string> v) {}");
+        check("void f(const std::vector<std::string> v) {}\n");
         ASSERT_EQUALS("[test.cpp:1:39]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("void f(const std::vector<std::string>::size_type s) {}");
+        check("void f(const std::vector<std::string>::size_type s) {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(const std::vector<int> &v) {}");
+        check("void f(const std::vector<int> &v) {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(const std::map<int,int> &v) {}");
+        check("void f(const std::map<int,int> &v) {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(const std::map<int,int> v) {}");
+        check("void f(const std::map<int,int> v) {}\n");
         ASSERT_EQUALS("[test.cpp:1:32]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("void f(const std::map<std::string,std::string> v) {}");
+        check("void f(const std::map<std::string,std::string> v) {}\n");
         ASSERT_EQUALS("[test.cpp:1:48]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("void f(const std::map<int,std::string> v) {}");
+        check("void f(const std::map<int,std::string> v) {}\n");
         ASSERT_EQUALS("[test.cpp:1:40]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("void f(const std::map<std::string,int> v) {}");
+        check("void f(const std::map<std::string,int> v) {}\n");
         ASSERT_EQUALS("[test.cpp:1:40]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("void f(const std::streamoff pos) {}");
+        check("void f(const std::streamoff pos) {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(std::initializer_list<int> i) {}");
+        check("void f(std::initializer_list<int> i) {}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5824
-        check("void log(const std::string& file, int line, const std::string& function, const std::string str, ...) {}");
+        check("void log(const std::string& file, int line, const std::string& function, const std::string str, ...) {}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5534
@@ -2564,12 +2564,12 @@ class TestOther : public TestFixture {
               "class Plane {\n"
               "    vec Refract(vec &vec) const;\n"
               "    bool IntersectLinePlane(const vec &planeNormal);\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class X {\n"
               "    virtual void func(const std::string str) {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:2:41]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("enum X;\n"
@@ -2586,7 +2586,7 @@ class TestOther : public TestFixture {
         ASSERT_EQUALS("", errout_str());
 
         check("enum X;\n"
-              "enum X { a, b, c };"
+              "enum X { a, b, c };\n"
               "void foo(X x4){}\n");
         ASSERT_EQUALS("", errout_str());
 
@@ -2746,87 +2746,87 @@ class TestOther : public TestFixture {
     }
 
     void passedByValue_nonConst() {
-        check("void f(std::string str) {}");
+        check("void f(std::string str) {}\n");
         ASSERT_EQUALS("[test.cpp:1:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(std::string str) {\n"
               "    return str + x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(std::string str) {\n"
               "    std::cout << str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(std::string str) {\n"
               "    std::cin >> str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::string str) {\n"
               "    std::string s2 = str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (performance, inconclusive) Use const reference for 's2' to avoid unnecessary data copying. [redundantCopyLocalConst]\n"
                       "[test.cpp:1:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n",
                       errout_str());
 
         check("void f(std::string str) {\n"
               "    std::string& s2 = str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n"
                       "[test.cpp:2:18]: (style) Variable 's2' can be declared as reference to const [constVariableReference]\n",
                       errout_str());
 
         check("void f(std::string str) {\n"
               "    const std::string& s2 = str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(std::string str) {\n"
               "    str = \"\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::string str) {\n"
               "    foo(str);\n" // It could be that foo takes str as non-const-reference
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(const std::string& str);\n"
               "void f(std::string str) {\n"
               "    foo(str);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void foo(std::string str);\n"
               "void f(std::string str) {\n"
               "    foo(str);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void foo(std::string& str);\n"
               "void f(std::string str) {\n"
               "    foo(str);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(std::string* str);\n"
               "void f(std::string str) {\n"
               "    foo(&str);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int& i1, const std::string& str, int& i2);\n"
               "void f(std::string str) {\n"
               "    foo((a+b)*c, str, x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("std::string f(std::string str) {\n"
               "    str += x;\n"
               "    return str;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class X {\n"
@@ -2835,7 +2835,7 @@ class TestOther : public TestFixture {
               "};\n"
               "Y f(X x) {\n"
               "    x.func();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:7]: (performance) Function parameter 'x' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("class X {\n"
@@ -2843,17 +2843,17 @@ class TestOther : public TestFixture {
               "};\n"
               "Y f(X x) {\n"
               "    x.func();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class X {\n"
               "    void func(std::string str) {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:2:27]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("class X {\n"
               "    virtual void func(std::string str) {}\n" // Do not warn about virtual functions, if 'str' is not declared as const
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class X {\n"
@@ -2863,7 +2863,7 @@ class TestOther : public TestFixture {
               "    char b;\n"
               "};\n"
               "void f(Y y) {\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:10]: (performance) Function parameter 'y' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("class X {\n"
@@ -2876,7 +2876,7 @@ class TestOther : public TestFixture {
               "    char c;\n"
               "};\n"
               "void f(X x, Y y) {\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:15]: (performance) Function parameter 'y' should be passed by const reference. [passedByValue]\n", errout_str());
 
         {
@@ -2885,7 +2885,7 @@ class TestOther : public TestFixture {
                                 "    uint64_t a;\n"
                                 "    uint64_t b;\n"
                                 "};\n"
-                                "void f(X x) {}";
+                                "void f(X x) {}\n";
 
             /*const*/ Settings s32 = settingsBuilder(settings1).platform(Platform::Type::Unix32).build();
             check(code, dinit(CheckOptions, $.settings = &s32));
@@ -2900,30 +2900,30 @@ class TestOther : public TestFixture {
               "\n"
               "void foo(Buffer& buffer) {\n"
               "    getWriter()->operator<<(buffer);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void passedByValue_externC() {
-        check("struct X { int a[5]; }; void f(X v) { }");
+        check("struct X { int a[5]; }; void f(X v) { }\n");
         ASSERT_EQUALS("[test.cpp:1:34]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("extern \"C\" { struct X { int a[5]; }; void f(X v) { } }");
+        check("extern \"C\" { struct X { int a[5]; }; void f(X v) { } }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("struct X { int a[5]; }; extern \"C\" void f(X v) { }");
+        check("struct X { int a[5]; }; extern \"C\" void f(X v) { }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("struct X { int a[5]; }; void f(const X v);");
+        check("struct X { int a[5]; }; void f(const X v);\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("struct X { int a[5]; }; void f(const X v) { (void) v; }");
+        check("struct X { int a[5]; }; void f(const X v) { (void) v; }\n");
         ASSERT_EQUALS("[test.cpp:1:40]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
-        check("extern \"C\" { struct X { int a[5]; }; void f(const X v); }");
+        check("extern \"C\" { struct X { int a[5]; }; void f(const X v); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("struct X { int a[5]; }; extern \"C\" void f(const X v) { }");
+        check("struct X { int a[5]; }; extern \"C\" void f(const X v) { }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2931,140 +2931,140 @@ class TestOther : public TestFixture {
         check("int f(std::vector<int> x) {\n"
               "    int& i = x[0];\n"
               "    return i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:24]: (performance) Function parameter 'x' should be passed by const reference. [passedByValue]\n"
                       "[test.cpp:2:10]: (style) Variable 'i' can be declared as reference to const [constVariableReference]\n",
                       errout_str());
 
         check("int f(std::vector<int>& x) {\n"
               "    return x[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:25]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
 
         check("int f(std::vector<int> x) {\n"
               "    const int& i = x[0];\n"
               "    return i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:24]: (performance) Function parameter 'x' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("int f(std::vector<int> x) {\n"
               "    static int& i = x[0];\n"
               "    return i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:24]: (performance) Function parameter 'x' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("int f(std::vector<int> x) {\n"
               "    int& i = x[0];\n"
               "    i++;\n"
               "    return i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int& f(std::vector<int>& x) {\n"
               "    x.push_back(1);\n"
               "    int& i = x[0];\n"
               "    return i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(const std::vector<int>& x) {\n"
               "    return x[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int& f(std::vector<int>& x) {\n"
               "    return x[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("const int& f(std::vector<int>& x) {\n"
               "    return x[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:32]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
 
         check("int f(std::vector<int>& x) {\n"
               "    x[0]++;\n"
               "    return x[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { int a; };\n"
               "A f(std::vector<A>& x) {\n"
               "    x[0].a = 1;\n"
               "    return x[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { int a(); };\n"
               "A f(std::vector<A>& x) {\n"
               "    x[0].a();\n"
               "    return x[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int g(int& x);\n"
               "int f(std::vector<int>& x) {\n"
               "    g(x[0]);\n"
               "    return x[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template<class T>\n"
               "T f(T& x) {\n"
               "    return x[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template<class T>\n"
               "T f(T&& x) {\n"
               "    return x[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template<class T>\n"
               "T f(T& x) {\n"
               "    return x[0];\n"
               "}\n"
-              "void h() { std::vector<int> v; h(v); }");
+              "void h() { std::vector<int> v; h(v); }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int& x) {\n"
               "    return std::move(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::ostream& os) {\n"
               "    os << \"Hello\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g(int*);\n"
               "void f(int& x) {\n"
               "    g(&x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { A(int*); };\n"
               "A f(int& x) {\n"
               "    return A(&x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { A(int*); };\n"
               "A f(int& x) {\n"
               "    return A{&x};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int& x, int& y) {\n"
               "    y++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:13]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
 
         check("struct A {\n"
               "    explicit A(int& y) : x(&y) {}\n"
               "    int * x = nullptr;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -3072,7 +3072,7 @@ class TestOther : public TestFixture {
               "    void swap(A& a) {\n"
               "        v.swap(a.v);\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -3083,24 +3083,24 @@ class TestOther : public TestFixture {
               "};\n"
               "void g(A& a) {\n"
               "    a.f<int>();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::vector<int>& v) {\n"
               "    for(auto&& x:v)\n"
               "        x = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::vector<int>& v) {\n"
               "    for(auto x:v)\n"
               "        x = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:26]: (style) Parameter 'v' can be declared as reference to const [constParameterReference]\n", errout_str());
 
         check("void f(std::vector<int>& v) {\n"
               "    for(auto& x:v) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (style) Variable 'x' can be declared as reference to const [constVariableReference]\n",
                       errout_str());
 
@@ -3121,32 +3121,32 @@ class TestOther : public TestFixture {
 
         check("void f(std::vector<int>& v) {\n"
               "    for(const auto& x:v) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:26]: (style) Parameter 'v' can be declared as reference to const [constParameterReference]\n", errout_str());
 
         check("void f(int& i) {\n"
               "    int& j = i;\n"
               "    j++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::vector<int>& v) {\n"
               "    int& i = v[0];\n"
               "    i++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::map<unsigned int, std::map<std::string, unsigned int> >& m, unsigned int i) {\n"
               "    std::map<std::string, unsigned int>& members = m[i];\n"
               "    members.clear();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    int& x;\n"
               "    A(int& y) : x(y)\n"
               "    {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -3155,14 +3155,14 @@ class TestOther : public TestFixture {
               "struct B : A {\n"
               "    B(int& x) : A(x)\n"
               "    {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b, int& x, int& y) {\n"
               "  auto& z = x;\n"
               "  auto& w = b ? y : z;\n"
               "  w = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -3170,7 +3170,7 @@ class TestOther : public TestFixture {
               "};\n"
               "int& f(S& s) {\n"
               "  return s.i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int* f(std::list<int>& x, unsigned int y) {\n"
@@ -3179,7 +3179,7 @@ class TestOther : public TestFixture {
               "            return &m;\n"
               "    }\n"
               "    return nullptr;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int& f(std::list<int>& x, int& y) {\n"
@@ -3188,7 +3188,7 @@ class TestOther : public TestFixture {
               "            return m;\n"
               "    }\n"
               "    return y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool from_string(int& t, const std::string& s) {\n"
@@ -3232,7 +3232,7 @@ class TestOther : public TestFixture {
         check("struct T { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
         check("struct T : public U  { void dostuff() const {}};\n"
               "void a(T& x) {\n"
@@ -3240,86 +3240,86 @@ class TestOther : public TestFixture {
               "    const T& z = x;\n" // Make sure we find all assignments
               "    T& y = x;\n"
               "    y.mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("struct T : public U  { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    const U& y = x\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
         check("struct T : public U  { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    U& y = x;\n"
               "    y.mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("struct T : public U  { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    my<fancy>::type& y = x;\n" // we don't know if y is const or not
               "    y.mutate();\n"             // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("struct T : public U  { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    const U& y = static_cast<const U&>(x);\n"
               "    y.mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
         check("struct T : public U  { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    U& y = static_cast<U&>(x);\n"
               "    y.mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    const U& y = dynamic_cast<const U&>(x)\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    const U& y = dynamic_cast<U const &>(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    const U& y = dynamic_cast<U & const>(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    U& y = dynamic_cast<U&>(x);\n"
               "    y.mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    const U& y = dynamic_cast<typename const U&>(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    U& y = dynamic_cast<typename U&>(x);\n"
               "    y.mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    U* y = dynamic_cast<U*>(&x);\n"
               "    y->mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct T : public U { void dostuff() const {}};\n"
@@ -3327,49 +3327,49 @@ class TestOther : public TestFixture {
               "    x.dostuff();\n"
               "    const U * y = dynamic_cast<const U *>(&x);\n"
               "    y->mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("can be const", errout_str(), ""); //Currently taking the address is treated as a non-const operation when it should depend on what we do with it
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    U const * y = dynamic_cast<U const *>(&x);\n"
               "    y->mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("can be const", errout_str(), ""); //Currently taking the address is treated as a non-const operation when it should depend on what we do with it
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    const U const * const * const * const y = dynamic_cast<const U const * const * const * const>(&x);\n"
               "    y->mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    const U const * const * const * const y = dynamic_cast<const U const * const * const * const>(&x);\n"
               "    y->mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("can be const", errout_str(), ""); //Currently taking the address is treated as a non-const operation when it should depend on what we do with it
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    const U const * const *  * const y = dynamic_cast<const U const * const *  * const>(&x);\n"
               "    y->mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    my::fancy<typename type const *> const * const  * const y = dynamic_cast<my::fancy<typename type const *> const * const  * const>(&x);\n"
               "    y->mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    const U& y = (const U&)(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
                       "[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n",
                       errout_str());
@@ -3378,13 +3378,13 @@ class TestOther : public TestFixture {
               "    x.dostuff();\n"
               "    U& y = (U&)(x);\n"
               "    y.mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    const U& y = (typename const U&)(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
                       "[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n",
                       errout_str());
@@ -3393,14 +3393,14 @@ class TestOther : public TestFixture {
               "    x.dostuff();\n"
               "    U& y = (typename U&)(x);\n"
               "    y.mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
         check("struct T : public U { void dostuff() const {}};\n"
               "void a(T& x) {\n"
               "    x.dostuff();\n"
               "    U* y = (U*)(&x);\n"
               "    y->mutate();\n" // to avoid warnings that y can be const
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
 
         check("struct C { void f() const; };\n" // #9875 - crash
@@ -3408,7 +3408,7 @@ class TestOther : public TestFixture {
               "void foo(C& x) {\n"
               "   x.f();\n"
               "   foo( static_cast<U2>(0) );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
 
         check("class a {\n"
@@ -3616,7 +3616,7 @@ class TestOther : public TestFixture {
               "void bh(const std::list<int> &ak, const std::list<int> &al);\n"
               "void ah();\n"
               "void an();\n"
-              "void h();");
+              "void h();\n");
         ASSERT_EQUALS("[test.cpp:131:12]: (style) Variable 'tm' can be declared as pointer to const [constVariablePointer]\n"
                       "[test.cpp:136:19]: (style) Variable 'af' can be declared as pointer to const [constVariablePointer]\n"
                       "[test.cpp:137:12]: (style) Variable 'ag' can be declared as pointer to const [constVariablePointer]\n",
@@ -3640,7 +3640,7 @@ class TestOther : public TestFixture {
               "D::D(int& i)\n"
               "  : c(i)\n"
               "{\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class C\n"
@@ -3660,7 +3660,7 @@ class TestOther : public TestFixture {
               "\n"
               "D::D(int& i) noexcept\n"
               "  : c(i)\n"
-              "{}");
+              "{}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class C\n"
@@ -3681,7 +3681,7 @@ class TestOther : public TestFixture {
               "D::D(int& i)\n"
               "  : c(i)\n"
               "{\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:16]: (style) Parameter 'i' can be declared as reference to const\n", "", errout_str());
 
         check("class C\n"
@@ -3702,7 +3702,7 @@ class TestOther : public TestFixture {
               "D::D(int& i)\n"
               "  : c(i)\n"
               "{\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:16]: (style) Parameter 'i' can be declared as reference to const\n", "", errout_str());
 
         check("class C\n"
@@ -3723,13 +3723,13 @@ class TestOther : public TestFixture {
               "D::D(int& i)\n"
               "  : c(0, i)\n"
               "{\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:16]: (style) Parameter 'i' can be declared as reference to const\n", "", errout_str());
 
         check("void f(std::map<int, std::vector<int>> &map) {\n" // #10266
               "  for (auto &[slave, panels] : map)\n"
               "    panels.erase(it);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S { void f(); int i; };\n"
@@ -4080,7 +4080,7 @@ class TestOther : public TestFixture {
                       "[test.cpp:10:25]: (style) Parameter 'v' can be declared as reference to const [constParameterReference]\n",
                       errout_str());
 
-        check("void push(V& v) { v.push_back({ .x = 1 }); }"); // #14010
+        check("void push(V& v) { v.push_back({ .x = 1 }); }\n"); // #14010
         ASSERT_EQUALS("", errout_str());
 
         check("size_t* f(std::array<uint8_t, 128>& a) { return reinterpret_cast<size_t*>(a.data()); }\n"); // #14074
@@ -4170,7 +4170,7 @@ class TestOther : public TestFixture {
 
     void constParameterCallback() {
         check("int callback(std::vector<int>& x) { return x[0]; }\n"
-              "void f() { dostuff(callback); }");
+              "void f() { dostuff(callback); }\n");
         ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:1:32]: (style) Parameter 'x' can be declared as reference to const. However it seems that 'callback' is a callback function, if 'x' is declared with const you might also need to cast function pointer(s). [constParameterCallback]\n", errout_str());
 
         // #9906
@@ -4188,13 +4188,13 @@ class TestOther : public TestFixture {
               "\n"
               "void EventEngine::signalEvent(ev::sig& signal, int revents) {\n"
               "    switch (signal.signum) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:48] -> [test.cpp:13:40]: (style) Parameter 'signal' can be declared as reference to const. However it seems that 'signalEvent' is a callback function, if 'signal' is declared with const you might also need to cast function pointer(s). [constParameterCallback]\n", errout_str());
 
         check("void f(int* p) {}\n" // 12843
               "void g(std::map<void(*)(int*), int>&m) {\n"
               "    m[&f] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:1:13]: (style) Parameter 'p' can be declared as pointer to const. "
                       "However it seems that 'f' is a callback function, if 'p' is declared with const you might also need to cast function pointer(s). [constParameterCallback]\n",
                       errout_str());
@@ -4220,49 +4220,49 @@ class TestOther : public TestFixture {
     }
 
     void constPointer() {
-        check("void foo(int *p) { return *p; }");
+        check("void foo(int *p) { return *p; }\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
-        check("void foo(int *p) { x = *p; }");
+        check("void foo(int *p) { x = *p; }\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
-        check("void foo(int *p) { int &ref = *p; ref = 12; }");
+        check("void foo(int *p) { int &ref = *p; ref = 12; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void foo(int *p) { x = *p + 10; }");
+        check("void foo(int *p) { x = *p + 10; }\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
-        check("void foo(int *p) { return p[10]; }");
+        check("void foo(int *p) { return p[10]; }\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
-        check("void foo(int *p) { int &ref = p[0]; ref = 12; }");
+        check("void foo(int *p) { int &ref = p[0]; ref = 12; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void foo(int *p) { x[*p] = 12; }");
+        check("void foo(int *p) { x[*p] = 12; }\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
-        check("void foo(int *p) { if (p) {} }");
+        check("void foo(int *p) { if (p) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
-        check("void foo(int *p) { if (p || x) {} }");
+        check("void foo(int *p) { if (p || x) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
-        check("void foo(int *p) { if (p == 0) {} }");
+        check("void foo(int *p) { if (p == 0) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
-        check("void foo(int *p) { if (!p) {} }");
+        check("void foo(int *p) { if (!p) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
-        check("void foo(int *p) { if (*p > 123) {} }");
+        check("void foo(int *p) { if (*p > 123) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
-        check("void foo(int *p) { return *p + 1; }");
+        check("void foo(int *p) { return *p + 1; }\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
-        check("void foo(int *p) { return *p > 1; }");
+        check("void foo(int *p) { return *p > 1; }\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
-        check("void foo(const int* c) { if (c == 0) {}; }");
+        check("void foo(const int* c) { if (c == 0) {}; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct a { void b(); };\n"
@@ -4295,59 +4295,59 @@ class TestOther : public TestFixture {
               "    int& i = (*x)[0];\n"
               "    i++;\n"
               "    return i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { int a; };\n"
               "A f(std::vector<A>* x) {\n"
               "    x->front().a = 1;\n"
               "    return x->front();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::vector<int>* v) {\n"
               "    for(auto&& x:*v)\n"
               "        x = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    int* x;\n"
               "    A(int* y) : x(y)\n"
               "    {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b, int* x, int* y) {\n"
               "  int* z = x;\n"
               "  int* w = b ? y : z;\n"
               "  *w = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b, int* x, int* y) {\n"
               "  int& z = *x;\n"
               "  int& w = b ? *y : z;\n"
               "  w = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Base { virtual void dostuff(int *p) = 0; };\n" // #10397
-              "class Derived: public Base { int x; void dostuff(int *p) override { x = *p; } };");
+              "class Derived: public Base { int x; void dostuff(int *p) override { x = *p; } };\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Data { char buf[128]; };\n" // #10483
               "void encrypt(Data& data) {\n"
               "    const char a[] = \"asfasd\";\n"
               "    memcpy(data.buf, &a, sizeof(a));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #10547
         check("void foo(std::istream &istr) {\n"
               "  unsigned char x[2];\n"
               "  istr >> x[0];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #10744
@@ -4898,7 +4898,7 @@ class TestOther : public TestFixture {
         check("struct S {\n" // #14817
               "    explicit S(int *a) : m{ a[0], a[1] } {}\n"
               "    int m[2];\n"
-              "}"
+              "}\n"
               "struct T {\n"
               "    explicit T(int *a) : m{ &a[0], &a[1] } {}\n"
               "    int* m[2];\n"
@@ -5019,7 +5019,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:11] -> [test.cpp:9:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
 
         check("void foo()\n"
@@ -5035,7 +5035,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:11] -> [test.cpp:11:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
 
         check("void foo()\n"
@@ -5052,7 +5052,7 @@ class TestOther : public TestFixture {
               "        }\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -5070,7 +5070,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -5085,7 +5085,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -5100,7 +5100,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -5117,7 +5117,7 @@ class TestOther : public TestFixture {
               "        }\n"
               "        bar(y);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -5134,7 +5134,7 @@ class TestOther : public TestFixture {
               "        }\n"
               "        bar(y);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -5149,7 +5149,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -5164,7 +5164,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:11] -> [test.cpp:10:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
 
         check("void bar() {}\n" // bar isn't noreturn
@@ -5180,7 +5180,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:11] -> [test.cpp:11:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
 
         check("void foo(int a) {\n"
@@ -5192,7 +5192,7 @@ class TestOther : public TestFixture {
               "    case 3:\n"
               "      strcpy(str, \"b'\");\n"
               "    }\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         TODO_ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:8]: (style) Buffer 'str' is being written before its old content has been used. 'break;' missing?\n",
                            "",
                            errout_str());
@@ -5206,7 +5206,7 @@ class TestOther : public TestFixture {
               "    case 3:\n"
               "      strncpy(str, \"b'\");\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:8]: (style) Buffer 'str' is being written before its old content has been used. 'break;' missing?\n",
                            "",
                            errout_str());
@@ -5223,7 +5223,7 @@ class TestOther : public TestFixture {
               "      strcpy(str, \"b'\");\n"
               "      z++;\n"
               "    }\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         TODO_ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:10]: (style) Buffer 'str' is being written before its old content has been used. 'break;' missing?\n",
                            "",
                            errout_str());
@@ -5239,7 +5239,7 @@ class TestOther : public TestFixture {
               "      strcpy(str, \"b'\");\n"
               "      break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a) {\n"
@@ -5252,7 +5252,7 @@ class TestOther : public TestFixture {
               "    case 3:\n"
               "      strcpy(str, \"b'\");\n"
               "    }\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #5158 "segmentation fault (valid code)"
@@ -5285,7 +5285,7 @@ class TestOther : public TestFixture {
               "  case 1: x = 3; goto a;\n"
               "  case 1: x = 6; goto a;\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5301,7 +5301,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:9] -> [test.cpp:9:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5316,7 +5316,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:9] -> [test.cpp:11:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5329,7 +5329,7 @@ class TestOther : public TestFixture {
               "        ++y;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5342,7 +5342,7 @@ class TestOther : public TestFixture {
               "        ++y;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5355,7 +5355,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:9] -> [test.cpp:9:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5370,7 +5370,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:9] -> [test.cpp:11:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5383,7 +5383,7 @@ class TestOther : public TestFixture {
               "        --y;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5396,7 +5396,7 @@ class TestOther : public TestFixture {
               "        --y;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5409,7 +5409,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:10] -> [test.cpp:9:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5424,7 +5424,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:10] -> [test.cpp:11:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5437,7 +5437,7 @@ class TestOther : public TestFixture {
               "        y++;\n"
               "    }\n"
               "    bar(y);\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5450,7 +5450,7 @@ class TestOther : public TestFixture {
               "        y++;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5463,7 +5463,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:10] -> [test.cpp:9:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5478,7 +5478,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:10] -> [test.cpp:11:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5491,7 +5491,7 @@ class TestOther : public TestFixture {
               "        y--;\n"
               "    }\n"
               "    bar(y);\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5504,7 +5504,7 @@ class TestOther : public TestFixture {
               "        y--;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5520,7 +5520,7 @@ class TestOther : public TestFixture {
               "        }\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5537,7 +5537,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5551,7 +5551,7 @@ class TestOther : public TestFixture {
               "        y++;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5565,7 +5565,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5581,7 +5581,7 @@ class TestOther : public TestFixture {
               "        }\n"
               "        bar(y);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5597,7 +5597,7 @@ class TestOther : public TestFixture {
               "        }\n"
               "        bar(y);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5611,7 +5611,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
@@ -5625,7 +5625,7 @@ class TestOther : public TestFixture {
               "        y = 3;\n"
               "    }\n"
               "    bar(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:10] -> [test.cpp:10:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
 
         check("bool f() {\n"
@@ -5643,7 +5643,7 @@ class TestOther : public TestFixture {
               "    };\n"
               "    ret = true;\n"
               "    return ret;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:13] -> [test.cpp:14:9]: (style) Variable 'ret' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:8:13] -> [test.cpp:14:9]: (style) Variable 'ret' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:11:13] -> [test.cpp:14:9]: (style) Variable 'ret' is reassigned a value before the old one has been used. [redundantAssignment]\n",
@@ -5662,7 +5662,7 @@ class TestOther : public TestFixture {
               "        y |= 3;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:9]: (style) Redundant bitwise operation on 'y' in 'switch' statement. 'break;' missing? [redundantBitwiseOperationInSwitch]\n", errout_str());
 
         check("void foo(int a)\n"
@@ -5676,7 +5676,7 @@ class TestOther : public TestFixture {
               "        y = y | 3;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:9]: (style) Redundant bitwise operation on 'y' in 'switch' statement. 'break;' missing? [redundantBitwiseOperationInSwitch]\n", errout_str());
 
         check("void foo(int a)\n"
@@ -5690,7 +5690,7 @@ class TestOther : public TestFixture {
               "        y |= 3;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:9]: (style) Redundant bitwise operation on 'y' in 'switch' statement. 'break;' missing? [redundantBitwiseOperationInSwitch]\n", errout_str());
 
         check("void foo(int a)\n"
@@ -5705,7 +5705,7 @@ class TestOther : public TestFixture {
               "            y |= 3;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
@@ -5720,7 +5720,7 @@ class TestOther : public TestFixture {
               "        y |= z;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
@@ -5735,7 +5735,7 @@ class TestOther : public TestFixture {
               "        y |= 3;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
@@ -5750,7 +5750,7 @@ class TestOther : public TestFixture {
               "        y |= 3;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:11] -> [test.cpp:8:11]: (style) Variable 'y' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
 
         check("void foo(int a)\n"
@@ -5764,7 +5764,7 @@ class TestOther : public TestFixture {
               "        y &= 3;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:9]: (style) Redundant bitwise operation on 'y' in 'switch' statement. 'break;' missing? [redundantBitwiseOperationInSwitch]\n", errout_str());
 
         check("void foo(int a)\n"
@@ -5779,7 +5779,7 @@ class TestOther : public TestFixture {
               "        y |= 3;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
@@ -5793,7 +5793,7 @@ class TestOther : public TestFixture {
               "        y ^= 3;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
@@ -5807,7 +5807,7 @@ class TestOther : public TestFixture {
               "        y |= 3;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
@@ -5821,7 +5821,7 @@ class TestOther : public TestFixture {
               "        y &= 3;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
@@ -5835,7 +5835,7 @@ class TestOther : public TestFixture {
               "        y &= 2;\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5847,20 +5847,20 @@ class TestOther : public TestFixture {
               "            continue;\n"
               "        }\n"
               "    }\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:5:13]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("int foo(int a) {\n"
               "    return 0;\n"
               "    return(a-1);\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("int foo(int a) {\n"
               "  A:"
               "    return(0);\n"
               "    goto A;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
@@ -5875,7 +5875,7 @@ class TestOther : public TestFixture {
         check("void foo() {\n"
               "    exit(0);\n"
               "    break;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+              "}\n", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("class NeonSession {\n"
@@ -5884,16 +5884,16 @@ class TestOther : public TestFixture {
               "void NeonSession::exit()\n"
               "{\n"
               "    SAL_INFO(\"ucb.ucp.webdav\", \"neon commands cannot be aborted\");\n"
-              "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+              "}\n", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
         ASSERT_EQUALS("", errout_str());
 
         check("void NeonSession::exit()\n"
               "{\n"
               "    SAL_INFO(\"ucb.ucp.webdav\", \"neon commands cannot be aborted\");\n"
-              "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+              "}\n", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
         ASSERT_EQUALS("", errout_str());
 
-        check("void foo() { xResAccess->exit(); }", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+        check("void foo() { xResAccess->exit(); }\n", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
@@ -5907,7 +5907,7 @@ class TestOther : public TestFixture {
               "            c++;\n"
               "            break;\n"
               "         }\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:7:13]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("void foo(int a)\n"
@@ -5920,7 +5920,7 @@ class TestOther : public TestFixture {
               "            c++;\n"
               "            break;\n"
               "         }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
@@ -5931,7 +5931,7 @@ class TestOther : public TestFixture {
               "            break;\n"
               "          }\n"
               "       }\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:6:13]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("void foo(int a)\n"
@@ -5943,7 +5943,7 @@ class TestOther : public TestFixture {
               "          }\n"
               "          a+=2;\n"
               "       }\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:6:13]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("void foo(int a)\n"
@@ -5954,50 +5954,50 @@ class TestOther : public TestFixture {
               "          }\n"
               "          a+=2;\n"
               "       }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int foo() {\n"
               "    throw 0;\n"
               "    return 1;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("void foo() {\n"
               "    throw 0;\n"
               "    return;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("int foo() {\n"
               "    throw = 0;\n"
               "    return 1;\n"
-              "}", dinit(CheckOptions, $.cpp = false, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.cpp = false, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("int foo() {\n"
               "    return 0;\n"
               "    return 1;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("int foo() {\n"
               "    return 0;\n"
               "    foo();\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Statements following 'return' will never be executed. [unreachableCode]\n", errout_str());
 
         check("int foo(int unused) {\n"
               "    return 0;\n"
               "    (void)unused;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("int foo(int unused1, int unused2) {\n"
               "    return 0;\n"
               "    (void)unused1;\n"
               "    (void)unused2;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("int foo(int unused1, int unused2) {\n"
@@ -6005,14 +6005,14 @@ class TestOther : public TestFixture {
               "    (void)unused1;\n"
               "    (void)unused2;\n"
               "    foo();\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:5:5]: (style) Statements following 'return' will never be executed. [unreachableCode]\n", errout_str());
 
         check("int foo() {\n"
               "    if(bar)\n"
               "        return 0;\n"
               "    return 124;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int foo() {\n"
@@ -6023,7 +6023,7 @@ class TestOther : public TestFixture {
               "        return 0;\n"
               "    }\n"
               "    return 124;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:4:9]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("void foo() {\n"
@@ -6031,7 +6031,7 @@ class TestOther : public TestFixture {
               "        return;\n"
               "        break;\n"
               "    }\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:4:9]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         // #5707
@@ -6042,20 +6042,20 @@ class TestOther : public TestFixture {
               "    }\n"
               "    return 0;\n"
               "    j=2;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:7:5]: (style) Statements following 'return' will never be executed. [unreachableCode]\n", errout_str());
 
         check("int foo() {\n"
               "    return 0;\n"
               "  label:\n"
               "    throw 0;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:3:3]: (style) Label 'label' is not used. [unusedLabel]\n", errout_str());
 
         check("struct A {\n"
               "    virtual void foo  (P & Val) throw ();\n"
               "    virtual void foo1 (P & Val) throw ();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int foo() {\n"
@@ -6064,7 +6064,7 @@ class TestOther : public TestFixture {
               "     bar();\n"
               "     label:\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // #3457
 
         check("int foo() {\n"
@@ -6073,7 +6073,7 @@ class TestOther : public TestFixture {
               "     bar();\n"
               "     label:\n"
               "    } while (true);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // #3457
 
         check("int foo() {\n"
@@ -6082,7 +6082,7 @@ class TestOther : public TestFixture {
               "     bar();\n"
               "     label:\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // #3457
 
         // #3383. TODO: Use preprocessor
@@ -6091,20 +6091,20 @@ class TestOther : public TestFixture {
               "    return 0;\n"
               "\n" // #endif
               "    return 1;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
         check("int foo() {\n"
               "\n" // #ifdef A
               "    return 0;\n"
               "\n" // #endif
               "    return 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (style, inconclusive) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         // #4711 lambda functions
         check("int f() {\n"
               "    return g([](int x){(void)x+1; return x;});\n"
-              "}",
+              "}\n",
               dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
@@ -6119,7 +6119,7 @@ class TestOther : public TestFixture {
               "             __asm__ (\"rorw $8, %w0\" : \"=r\" (__v) : \"0\" (__x) : \"cc\");\n"
               "         (void)__v;\n"
               "     }));\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         // #6008
@@ -6128,7 +6128,7 @@ class TestOther : public TestFixture {
               "        int sum = a_ + b_;\n"
               "        return sum;\n"
               "    };\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         // #5789
@@ -6136,20 +6136,20 @@ class TestOther : public TestFixture {
               "    uint64_t enter, exit;\n"
               "    uint64_t events;\n"
               "    per_state_info() : enter(0), exit(0), events(0) {}\n"
-              "};", dinit(CheckOptions, $.inconclusive = false));
+              "};\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         // #6664
         check("void foo() {\n"
               "    (beat < 100) ? (void)0 : exit(0);\n"
               "    bar();\n"
-              "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+              "}\n", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    (beat < 100) ? exit(0) : (void)0;\n"
               "    bar();\n"
-              "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+              "}\n", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
         ASSERT_EQUALS("", errout_str());
 
         // #8261
@@ -6157,13 +6157,13 @@ class TestOther : public TestFixture {
         TODO_ASSERT_THROW(check("void foo() {\n"
                                 "    (beat < 100) ? (void)0 : throw(0);\n"
                                 "    bar();\n"
-                                "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings)), InternalError);
+                                "}\n", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings)), InternalError);
         //ASSERT_EQUALS("", errout_str());
 
         check("int foo() {\n"
               "    exit(0);\n"
               "    return 1;\n" // <- clarify for tools that function does not continue..
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -6406,7 +6406,7 @@ class TestOther : public TestFixture {
               "        case A||B:\n"
               "            foo();\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (warning, inconclusive) Found suspicious case label in switch(). Operator '&&' probably doesn't work as intended. [suspiciousCase]\n"
                       "[test.cpp:5:16]: (warning, inconclusive) Found suspicious case label in switch(). Operator '||' probably doesn't work as intended. [suspiciousCase]\n"
                       "[test.cpp:7:15]: (warning, inconclusive) Found suspicious case label in switch(). Operator '||' probably doesn't work as intended. [suspiciousCase]\n", errout_str());
@@ -6416,7 +6416,7 @@ class TestOther : public TestFixture {
               "        case 1:\n"
               "            a=A&&B;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // TODO Do not throw AST validation exception
@@ -6425,19 +6425,19 @@ class TestOther : public TestFixture {
                                 "        case A&&B?B:A:\n"
                                 "            foo();\n"
                                 "    }\n"
-                                "}"), InternalError);
+                                "}\n"), InternalError);
         //ASSERT_EQUALS("", errout_str());
     }
 
     void suspiciousEqualityComparison() {
         check("void foo(int c) {\n"
               "    if (x) c == 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(const int* c) {\n"
               "    if (x) *c == 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
 
@@ -6445,90 +6445,90 @@ class TestOther : public TestFixture {
               "    if (c == 1) {\n"
               "        c = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int c) {\n"
               "    c == 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(int c) {\n"
               "    for (int i = 0; i == 10; i ++) {\n"
               "        a ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int c) {\n"
               "    for (i == 0; i < 10; i ++) {\n"
               "        c ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(int c) {\n"
               "    for (i == 1; i < 10; i ++) {\n"
               "        c ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(int c) {\n"
               "    for (i == 2; i < 10; i ++) {\n"
               "        c ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(int c) {\n"
               "    for (int i = 0; i < 10; i == c) {\n"
               "        c ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:31]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(int c) {\n"
               "    for (; running == 1;) {\n"
               "        c ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int c) {\n"
               "    printf(\"%i\", ({x==0;}));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int arg) {\n"
               "    printf(\"%i\", ({int x = do_something(); x == 0;}));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int x) {\n"
               "    printf(\"%i\", ({x == 0; x > 0 ? 10 : 20}));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(int x) {\n"
               "    for (const Token* end = tok->link(); tok != end; tok = (tok == end) ? end : tok->next()) {\n"
               "        x++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int x) {\n"
               "    for (int i = (x == 0) ? 0 : 5; i < 10; i ++) {\n"
               "        x++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int x) {\n"
               "    for (int i = 0; i < 10; i += (x == 5) ? 1 : 2) {\n"
               "        x++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6584,26 +6584,26 @@ class TestOther : public TestFixture {
               "    int x = 1;\n"
               "    x = x;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    int x = x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n", errout_str());
 
         check("struct A { int b; };\n"
               "void foo(A* a1, A* a2) {\n"
               "    a1->b = a1->b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Redundant assignment of 'a1->b' to itself. [selfAssignment]\n", errout_str());
 
         check("int x;\n"
               "void f()\n"
               "{\n"
               "    x = x = 3;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n", errout_str());
 
         // #4073 (segmentation fault)
@@ -6611,59 +6611,59 @@ class TestOther : public TestFixture {
               "{\n"
               "    if (a == 42)\n"
               "    a = a;\n"
-              "}");
+              "}\n");
 
         check("void foo()\n"
               "{\n"
               "    int x = 1;\n"
               "    x = x + 1;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
               "        int *x = getx();\n"
               "        *x = x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    BAR *x = getx();\n"
               "    x = x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n", errout_str());
 
         // #2502 - non-primitive type -> there might be some side effects
         check("void foo()\n"
               "{\n"
               "    Fred fred; fred = fred;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    x = (x == 0);"
               "    func(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    x = (x != 0);"
               "    func(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #3001 - false positive
         check("void foo(int x) {\n"
               "    x = x ? x : 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3800 - false negative when variable is extern
         check("extern int i;\n"
               "void f() {\n"
               "    i = i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (style) Redundant assignment of 'i' to itself. [selfAssignment]\n", errout_str());
 
         // #4291 - id for variables accessed through 'this'
@@ -6673,7 +6673,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void Foo::func() {\n"
               "    this->var = var;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:15]: (style) Redundant assignment of 'this->var' to itself. [selfAssignment]\n", errout_str());
 
         check("class Foo {\n"
@@ -6682,7 +6682,7 @@ class TestOther : public TestFixture {
               "};\n"
               "Foo::Foo(int var) {\n"
               "    this->var = var;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6406 - designated initializer doing bogus self assignment
@@ -6692,7 +6692,7 @@ class TestOther : public TestFixture {
               "void something(void) {}\n"
               "void f() {\n"
               "    struct callbacks ops = { .s = ops.s };\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6]: (style) Redundant assignment of 'something' to itself.\n", "", errout_str());
 
         check("class V\n"
@@ -6707,12 +6707,12 @@ class TestOther : public TestFixture {
               "        x = x; y = y; z = z;\n"
               "    }\n"
               "    double x, y, z;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:10:11]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n"
                       "[test.cpp:10:18]: (style) Redundant assignment of 'y' to itself. [selfAssignment]\n"
                       "[test.cpp:10:25]: (style) Redundant assignment of 'z' to itself. [selfAssignment]\n", errout_str());
 
-        check("void f(int i) { i = !!i; }");
+        check("void f(int i) { i = !!i; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -6782,7 +6782,7 @@ class TestOther : public TestFixture {
               "    Lock(123);\n"
               "    std::cout << \"hello\" << std::endl;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:15:5]: (style) Instance of 'Lock' object is destroyed immediately. [unusedScopedObject]\n", errout_str());
     }
 
@@ -6801,7 +6801,7 @@ class TestOther : public TestFixture {
               "{\n"
               "    CouldBeFunction ( 123 ) ;\n"
               "    return 0 ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6818,7 +6818,7 @@ class TestOther : public TestFixture {
               "        error();\n"
               "        do_something();\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6828,7 +6828,7 @@ class TestOther : public TestFixture {
               "{\n"
               "    NotAFunction ( 123 );\n"
               "    return 0 ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (style) Instance of 'NotAFunction' object is destroyed immediately. [unusedScopedObject]\n", errout_str());
     }
 
@@ -6838,7 +6838,7 @@ class TestOther : public TestFixture {
               "{\n"
               "    NotAClass ( 123 ) ;\n"
               "    return true ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (style) Instance of 'NotAClass' object is destroyed immediately. [unusedScopedObject]\n", errout_str());
     }
 
@@ -6847,7 +6847,7 @@ class TestOther : public TestFixture {
               "{\n"
               "    if ( a > b ) return c == a ;\n"
               "    return b == a ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6857,7 +6857,7 @@ class TestOther : public TestFixture {
               "public:\n"
               "~Something ( ) ;\n"
               "Something ( ) ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6876,7 +6876,7 @@ class TestOther : public TestFixture {
               "    int a = 1;\n"
               "    IncrementFunctor()(a);\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6889,7 +6889,7 @@ class TestOther : public TestFixture {
               "    };\n"
               "    Foo();\n"
               "    do_something();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (style) Instance of 'Foo' object is destroyed immediately. [unusedScopedObject]\n", errout_str());
     }
 
@@ -6901,7 +6901,7 @@ class TestOther : public TestFixture {
               "\n"
               "void fn() {\n"
               "    Foo().bar();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6930,7 +6930,7 @@ class TestOther : public TestFixture {
               "void foo() {\n"
               "    stat(\"file.txt\", &st);\n"
               "    do_something();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("",errout_str());
 
         check("struct AMethodObject {\n" // #4336
@@ -7084,7 +7084,7 @@ class TestOther : public TestFixture {
               "\n"
               "    { sigaction(SIGHUP, &sa, 0); };\n"
               "    { sigaction(SIGINT, &sa, 0); };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7095,76 +7095,76 @@ class TestOther : public TestFixture {
               "    };\n"
               "\n"
               "    const AB ab[3] = { AB(0), AB(1), AB(2) };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void clarifyCalculation() {
         check("int f(char c) {\n"
               "    return 10 * (c == 0) ? 1 : 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:26]: (style) Clarify calculation precedence for '*' and '?'. [clarifyCalculation]\n", errout_str());
 
         check("void f(char c) {\n"
               "    printf(\"%i\", 10 * (c == 0) ? 1 : 2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:32]: (style) Clarify calculation precedence for '*' and '?'. [clarifyCalculation]\n", errout_str());
 
         check("void f() {\n"
               "    return (2*a)?b:c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char c) {\n"
               "    printf(\"%i\", a + b ? 1 : 2);\n"
-              "}",dinit(CheckOptions, $.inconclusive = false));
+              "}\n",dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:2:24]: (style) Clarify calculation precedence for '+' and '?'. [clarifyCalculation]\n", errout_str());
 
         check("void f() {\n"
               "    std::cout << x << y ? 2 : 3;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:25]: (style) Clarify calculation precedence for '<<' and '?'. [clarifyCalculation]\n", errout_str());
 
         check("void f() {\n"
               "    int ab = a - b ? 2 : 3;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20]: (style) Clarify calculation precedence for '-' and '?'. [clarifyCalculation]\n", errout_str());
 
         check("void f() {\n"
               "    int ab = a | b ? 2 : 3;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20]: (style) Clarify calculation precedence for '|' and '?'. [clarifyCalculation]\n", errout_str());
 
         // ticket #195
         check("int f(int x, int y) {\n"
               "    return x >> ! y ? 8 : 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:21]: (style) Clarify calculation precedence for '>>' and '?'. [clarifyCalculation]\n", errout_str());
 
         check("int f() {\n"
               "   return shift < sizeof(int64_t)*8 ? 1 : 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { a = *p ? 1 : 2; }");
+        check("void f() { a = *p ? 1 : 2; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int x) { const char *p = x & 1 ? \"1\" : \"0\"; }");
+        check("void f(int x) { const char *p = x & 1 ? \"1\" : \"0\"; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void foo() { x = a % b ? \"1\" : \"0\"; }");
+        check("void foo() { x = a % b ? \"1\" : \"0\"; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int x) { return x & 1 ? '1' : '0'; }");
+        check("void f(int x) { return x & 1 ? '1' : '0'; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int x) { return x & 16 ? 1 : 0; }");
+        check("void f(int x) { return x & 16 ? 1 : 0; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int x) { return x % 16 ? 1 : 0; }");
+        check("void f(int x) { return x % 16 ? 1 : 0; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("enum {X,Y}; void f(int x) { return x & Y ? 1 : 0; }");
+        check("enum {X,Y}; void f(int x) { return x & Y ? 1 : 0; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7172,7 +7172,7 @@ class TestOther : public TestFixture {
         check("char* f(char* c) {\n"
               "    *c++;\n"
               "    return c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
             "[test.cpp:2:7]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
@@ -7181,7 +7181,7 @@ class TestOther : public TestFixture {
         check("char* f(char** c) {\n"
               "    *c[5]--;\n"
               "    return *c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
             "[test.cpp:2:10]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
@@ -7189,7 +7189,7 @@ class TestOther : public TestFixture {
 
         check("void f(Foo f) {\n"
               "    *f.a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
             "[test.cpp:2:9]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
@@ -7197,7 +7197,7 @@ class TestOther : public TestFixture {
 
         check("void f(Foo f) {\n"
               "    *f.a[5].v[3]++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
             "[test.cpp:2:17]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
@@ -7205,7 +7205,7 @@ class TestOther : public TestFixture {
 
         check("void f(Foo f) {\n"
               "    *f.a(1, 5).v[x + y]++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
             "[test.cpp:2:24]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
@@ -7214,18 +7214,18 @@ class TestOther : public TestFixture {
         check("char* f(char* c) {\n"
               "    (*c)++;\n"
               "    return c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(char* c) {\n"
               "    bar(*c++);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("char*** f(char*** c) {\n"
               "    ***c++;\n"
               "    return c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
             "[test.cpp:2:9]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
@@ -7234,7 +7234,7 @@ class TestOther : public TestFixture {
         check("char** f(char*** c) {\n"
               "    **c[5]--;\n"
               "    return **c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
             "[test.cpp:2:11]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
@@ -7243,7 +7243,7 @@ class TestOther : public TestFixture {
         check("char*** f(char*** c) {\n"
               "    (***c)++;\n"
               "    return c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const int*** p) {\n" // #10923
@@ -7253,12 +7253,12 @@ class TestOther : public TestFixture {
 
         check("void *f(char** c) {\n"
               "    bar(**c++);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void *f(char* p) {\n"
               "    for (p = path; *p++;) ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -7278,7 +7278,7 @@ class TestOther : public TestFixture {
               "        b = 1;\n"
               "    else\n"
               "        b = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:2:5]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
 
         check("void f(int a, int &b) {\n"
@@ -7289,7 +7289,7 @@ class TestOther : public TestFixture {
               "            b = 2;\n"
               "    } else\n"
               "        b = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:3:9]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
 
         check("void f(int a, int &b) {\n"
@@ -7301,7 +7301,7 @@ class TestOther : public TestFixture {
               "        else\n"
               "            b = 2;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:9] -> [test.cpp:5:9]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
 
         check("int f(int signed, unsigned char value) {\n"
@@ -7311,7 +7311,7 @@ class TestOther : public TestFixture {
               "    else\n"
               "        ret = (unsigned char)value;\n"
               "    return ret;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -7319,7 +7319,7 @@ class TestOther : public TestFixture {
               "        __asm__(\"mov ax, bx\");\n"
               "    else\n"
               "        __asm__(\"mov bx, bx\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // #3407
 
         check("void f() {\n"
@@ -7327,7 +7327,7 @@ class TestOther : public TestFixture {
               "        __asm__(\"mov ax, bx\");\n"
               "    else\n"
               "        __asm__(\"mov ax, bx\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:2:5]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
     }
 
@@ -7341,7 +7341,7 @@ class TestOther : public TestFixture {
               "    frac = front/(front-back);\n"
               "  else\n"
               "    frac = front/(front-back);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:3] -> [test.cpp:3:3]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
 
         check("void f()\n"
@@ -7350,7 +7350,7 @@ class TestOther : public TestFixture {
               "  { frac = front/(front-back);}\n"
               "  else\n"
               "    frac = front/((front-back));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:3] -> [test.cpp:3:3]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
 
         // No message about empty branches (#5354)
@@ -7360,7 +7360,7 @@ class TestOther : public TestFixture {
               "  {}\n"
               "  else\n"
               "  {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7372,7 +7372,7 @@ class TestOther : public TestFixture {
                "    DOSTUFF1\n"
                "  else\n"
                "    DOSTUFF2\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7384,7 +7384,7 @@ class TestOther : public TestFixture {
               "    } else {\n"
               "        x = j;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:5:7] -> [test.cpp:3:5]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n"
                       "[test.cpp:2:9]: (style) The scope of the variable 'j' can be reduced. [variableScope]\n",
                       errout_str());
@@ -7397,7 +7397,7 @@ class TestOther : public TestFixture {
               "    } else {\n"
               "        x = j;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7408,7 +7408,7 @@ class TestOther : public TestFixture {
               "    } else {\n"
               "        return new A::Z(true);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7422,7 +7422,7 @@ class TestOther : public TestFixture {
               "        unsigned int i = 0;\n"
               "        j = i;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:7] -> [test.cpp:3:5]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
 
         check("void f(bool b) {\n"
@@ -7434,7 +7434,7 @@ class TestOther : public TestFixture {
               "        unsigned int i = 0;\n"
               "        j = 1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b) {\n"
@@ -7444,7 +7444,7 @@ class TestOther : public TestFixture {
               "    } else {\n"
               "        int i = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b) {\n"
@@ -7456,7 +7456,7 @@ class TestOther : public TestFixture {
               "        int i = 0;\n"
               "        j = i;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int i) {\n"
@@ -7475,7 +7475,7 @@ class TestOther : public TestFixture {
               "    } else {\n"
               "        int i = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b) {\n"
@@ -7483,14 +7483,14 @@ class TestOther : public TestFixture {
               "        int i = 0;\n"
               "    } else {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateExpression1() {
         check("void foo(int a) {\n"
               "    if (a == a) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
 
         check("void fun(int b) {\n"
@@ -7499,7 +7499,7 @@ class TestOther : public TestFixture {
               "            d > d &&\n"
               "            e < e &&\n"
               "            f ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n"
                       "[test.cpp:3:15]: (style) Same expression on both sides of '=='. [duplicateExpression]\n"
                       "[test.cpp:4:15]: (style) Same expression on both sides of '>'. [duplicateExpression]\n"
@@ -7507,82 +7507,82 @@ class TestOther : public TestFixture {
 
         check("void foo() {\n"
               "    return a && a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    a = b && b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n", errout_str());
 
         check("void foo(int b) {\n"
               "    f(a,b == b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
 
         check("void foo(int b) {\n"
               "    f(b == b, a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (x!=2 || x!=2) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void foo(int a, int b) {\n"
               "    if ((a < b) && (b > a)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (style) Same expression on both sides of '&&' because 'a<b' and 'b>a' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void foo(int a, int b) {\n"
               "    if ((a <= b) && (b >= a)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (style) Same expression on both sides of '&&' because 'a<=b' and 'b>=a' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void foo() {\n"
               "    if (x!=2 || y!=3 || x!=2) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (style) Same expression 'x!=2' found multiple times in chain of '||' operators. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (x!=2 && (x=y) && x!=2) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if (a && b || a && b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (a && b || b && c) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if (a && b | b && c) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (style) Same expression on both sides of '|'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if ((a + b) | (a + b)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (style) Same expression on both sides of '|'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if ((a | b) & (a | b)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (style) Same expression on both sides of '&'. [duplicateExpression]\n", errout_str());
 
         check("void foo(int a, int b) {\n"
               "    if ((a | b) == (a | b)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (a1[a2[c & 0xff] & 0xff]) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void d(const char f, int o, int v)\n"
@@ -7590,127 +7590,127 @@ class TestOther : public TestFixture {
               "     if (((f=='R') && (o == 1) && ((v < 2) || (v > 99))) ||\n"
               "         ((f=='R') && (o == 2) && ((v < 2) || (v > 99))) ||\n"
               "         ((f=='T') && (o == 2) && ((v < 200) || (v > 9999)))) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int f(int x) { return x+x; }");
+        check("int f(int x) { return x+x; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int x) { while (x+=x) ; }");
+        check("void f(int x) { while (x+=x) ; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if (a && b && b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (a || b || b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (a / 1000 / 1000) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int foo(int i) {\n"
               "    return i/i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Same expression on both sides of '/'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (a << 1 << 1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int f() { return !!y; }"); // No FP
+        check("int f() { return !!y; }\n"); // No FP
         ASSERT_EQUALS("", errout_str());
 
         // make sure there are not "same expression" fp when there are different casts
-        check("void f(long x) { if ((int32_t)x == (int64_t)x) {} }",
+        check("void f(long x) { if ((int32_t)x == (int64_t)x) {} }\n",
               dinit(CheckOptions, $.inconclusive = false)
               );
         ASSERT_EQUALS("", errout_str());
 
         // make sure there are not "same expression" fp when there are different ({}) expressions
-        check("void f(long x) { if (({ 1+2; }) == ({3+4;})) {} }");
+        check("void f(long x) { if (({ 1+2; }) == ({3+4;})) {} }\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5535: Reference named like its type
-        check("void foo() { UMSConfig& UMSConfig = GetUMSConfiguration(); }");
+        check("void foo() { UMSConfig& UMSConfig = GetUMSConfiguration(); }\n");
         ASSERT_EQUALS("[test.cpp:1:25]: (style) Variable 'UMSConfig' can be declared as reference to const [constVariableReference]\n", errout_str());
 
         // #3868 - false positive (same expression on both sides of |)
         check("void f(int x) {\n"
               "    a = x ? A | B | C\n"
               "          : A | B;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const Bar &bar) {\n"
               "    bool a = bar.isSet() && bar->isSet();\n"
               "    bool b = bar.isSet() && bar.isSet();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:26]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n", errout_str());
 
 
         check("void foo(int a, int b) {\n"
               "    if ((b + a) | (a + b)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (style) Same expression on both sides of '|' because 'b+a' and 'a+b' represent the same value. [duplicateExpression]\n", errout_str());
 
         check("void foo(const std::string& a, const std::string& b) {\n"
               "  return a.find(b+\"&\") || a.find(\"&\"+b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a, int b) {\n"
               "    if ((b > a) | (a > b)) {}\n" // > is not commutative
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(double a, double b) {\n"
               "    if ((b + a) > (a + b)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (style) The comparison 'b+a > a+b' is always false because 'b+a' and 'a+b' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x == 1) && (x == 0x00000001))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (style) Same expression on both sides of '&&' because 'x==1' and 'x==0x00000001' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    enum { Four = 4 };\n"
-              "    if (Four == 4) {}"
-              "}");
+              "    if (Four == 4) {}\n"
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (style) The comparison 'Four == 4' is always true. [knownConditionTrueFalse]\n",
                       errout_str());
 
         check("void f() {\n"
               "    enum { Four = 4 };\n"
               "    static_assert(Four == 4, \"\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    enum { Four = 4 };\n"
               "    _Static_assert(Four == 4, \"\");\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    enum { Four = 4 };\n"
               "    static_assert(4 == Four, \"\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    enum { FourInEnumOne = 4 };\n"
               "    enum { FourInEnumTwo = 4 };\n"
               "    if (FourInEnumOne == FourInEnumTwo) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:23]: (style) The comparison 'FourInEnumOne == FourInEnumTwo' is always true because 'FourInEnumOne' and 'FourInEnumTwo' represent the same value. [knownConditionTrueFalse]\n",
                       errout_str());
 
@@ -7718,13 +7718,13 @@ class TestOther : public TestFixture {
               "    enum { FourInEnumOne = 4 };\n"
               "    enum { FourInEnumTwo = 4 };\n"
               "    static_assert(FourInEnumOne == FourInEnumTwo, \"\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a, int b) {\n"
               "    if (sizeof(a) == sizeof(a)) { }\n"
               "    if (sizeof(a) == sizeof(b)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:19]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
 
         check("float bar(int) __attribute__((pure));\n"
@@ -7733,7 +7733,7 @@ class TestOther : public TestFixture {
               "    if (bar(a) == bar(a)) { }\n"
               "    if (unknown(a) == unknown(a)) { }\n"
               "    if (foo(a) == foo(a)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:16]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
     }
 
@@ -7743,25 +7743,25 @@ class TestOther : public TestFixture {
               "    if (!(dbl == dbl)) have_nan = 1;\n"
               "    if (flt != flt) have_nan = 1;\n"
               "    return have_nan;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("float f(float x) { return x-x; }"); // ticket #4485 (Inf)
+        check("float f(float x) { return x-x; }\n"); // ticket #4485 (Inf)
         ASSERT_EQUALS("", errout_str());
 
-        check("float f(float x) { return (X double)x == (X double)x; }", dinit(CheckOptions, $.inconclusive = false));
+        check("float f(float x) { return (X double)x == (X double)x; }\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("struct X { float f; };\n"
-              "float f(struct X x) { return x.f == x.f; }");
+              "float f(struct X x) { return x.f == x.f; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct X { int i; };\n"
-              "int f(struct X x) { return x.i == x.i; }");
+              "int f(struct X x) { return x.i == x.i; }\n");
         ASSERT_EQUALS("[test.cpp:2:32]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
 
         // #5284 - when type is unknown, assume it's float
-        check("int f() { return x==x; }");
+        check("int f() { return x==x; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7778,7 +7778,7 @@ class TestOther : public TestFixture {
 
         check("void foo() {\n"
               "    if (x() || x()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
@@ -7787,7 +7787,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void A::foo() const {\n"
               "    if (bar() && bar()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:15]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n", errout_str());
 
         check("struct A {\n"
@@ -7797,7 +7797,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void A::foo() {\n"
               "    if (bar() && bar()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class B {\n"
@@ -7811,55 +7811,55 @@ class TestOther : public TestFixture {
               "    A a;\n"
               "    if (b.bar(1) && b.bar(1)) {}\n"
               "    if (a.bar(1) && a.bar(1)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:11:18]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n", errout_str());
 
         check("class D { void strcmp(); };\n"
               "void foo() {\n"
               "    D d;\n"
               "    if (d.strcmp() && d.strcmp()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if ((mystrcmp(a, b) == 0) || (mystrcmp(a, b) == 0)) {}\n"
-              "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+              "}\n", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:2:31]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void GetValue() { return rand(); }\n"
               "void foo() {\n"
               "    if ((GetValue() == 0) || (GetValue() == 0)) { dostuff(); }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void __attribute__((const)) GetValue() { return X; }\n"
               "void foo() {\n"
               "    if ((GetValue() == 0) || (GetValue() == 0)) { dostuff(); }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:27]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void GetValue() __attribute__((const));\n"
               "void GetValue() { return X; }\n"
               "void foo() {\n"
               "    if ((GetValue() == 0) || (GetValue() == 0)) { dostuff(); }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:27]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (str == \"(\" || str == \"(\") {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (bar(a) && !strcmp(a, b) && bar(a) && !strcmp(a, b)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5334
         check("void f(C *src) {\n"
               "    if (x<A*>(src) || x<B*>(src))\n"
               "        a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(A *src) {\n"
@@ -7870,12 +7870,12 @@ class TestOther : public TestFixture {
         // #5819
         check("Vector func(Vector vec1) {\n"
               "    return fabs(vec1 & vec1 & vec1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("Vector func(int vec1) {\n"
               "    return fabs(vec1 & vec1 & vec1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:22]: (style) Same expression on both sides of '&'. [duplicateExpression]\n"
             "[test.cpp:2:29]: (style) Same expression on both sides of '&'. [duplicateExpression]\n",
@@ -7886,25 +7886,25 @@ class TestOther : public TestFixture {
     void duplicateExpression4() {
         check("void foo() {\n"
               "    if (*a++ != b || *a++ != b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if (*a-- != b || *a-- != b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // assignment
         check("void f() {\n"
               "  while (*(a+=2)==*(b+=2) && *(a+=2)==*(b+=2)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateExpression5() {  // #3749 - macros with same values
         check("void f() {\n"
               "    if ($a == $a) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkP("#define X 1\n"
@@ -7926,7 +7926,7 @@ class TestOther : public TestFixture {
     void duplicateExpression6() {  // #4639
         check("float IsNan(float value) { return !(value == value); }\n"
               "double IsNan(double value) { return !(value == value); }\n"
-              "long double IsNan(long double value) { return !(value == value); }");
+              "long double IsNan(long double value) { return !(value == value); }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7934,36 +7934,36 @@ class TestOther : public TestFixture {
         check("void f() {\n"
               "    const int i = sizeof(int);\n"
               "    if ( i != sizeof (int)){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:25] -> [test.cpp:3:12]: (style) The comparison 'i != sizeof(int)' is always false because 'i' and 'sizeof(int)' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    const int i = sizeof(int);\n"
               "    if ( sizeof (int) != i){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:25] -> [test.cpp:3:23]: (style) The comparison 'sizeof(int) != i' is always false because 'sizeof(int)' and 'i' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
-        check("void f(int a = 1) { if ( a != 1){}}");
+        check("void f(int a = 1) { if ( a != 1){}}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a = 1;\n"
               "    if ( a != 1){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:12]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    int a = 1;\n"
               "    int b = 1;\n"
               "    if ( a != b){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:13] -> [test.cpp:4:12]: (style) The comparison 'a != b' is always false because 'a' and 'b' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    int a = 1;\n"
               "    int b = a;\n"
               "    if ( a != b){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13] -> [test.cpp:4:12]: (style) The comparison 'a != b' is always false because 'a' and 'b' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void use(int);\n"
@@ -7972,7 +7972,7 @@ class TestOther : public TestFixture {
               "    int b = 1;\n"
               "    use(b);\n"
               "    if ( a != 1){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13] -> [test.cpp:6:12]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("void use(int);\n"
@@ -7981,7 +7981,7 @@ class TestOther : public TestFixture {
               "    use(a);\n"
               "    a = 2;\n"
               "    if ( a != 1){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void use(int);\n"
@@ -7990,38 +7990,38 @@ class TestOther : public TestFixture {
               "    use(a);\n"
               "    a = 1;\n"
               "    if ( a != 1){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("const int a = 1;\n"
               "void f() {\n"
               "    if ( a != 1){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:15] -> [test.cpp:3:12]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("int a = 1;\n"
               "    void f() {\n"
               "    if ( a != 1){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    static const int a = 1;\n"
               "    if ( a != 1){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:26] -> [test.cpp:3:12]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    static int a = 1;\n"
               "    if ( a != 1){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a = 1;\n"
               "    if ( a != 1){\n"
               "        a++;\n"
-              "    }}");
+              "    }}\n");
         ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:12]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int b) {\n"
@@ -8030,13 +8030,13 @@ class TestOther : public TestFixture {
               "        if ( a != 1){}\n"
               "        a++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(bool a, bool b) {\n"
               "    const bool c = a;\n"
               "    return a && b && c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:3:19]: (style) Same expression 'a' found multiple times in chain of '&&' operators because 'a' and 'c' represent the same value. [knownConditionTrueFalse]\n",
                       errout_str());
 
@@ -8044,13 +8044,13 @@ class TestOther : public TestFixture {
         check("void f(const bool b) {\n"
               "   const bool b1 = !b;\n"
               "   if(!b && b1){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:3:10]: (style) Same expression on both sides of '&&' because '!b' and 'b1' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         // 7284
         check("void f(void) {\n"
               "   if (a || !!a) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) Same expression on both sides of '||' because 'a' and '!!a' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         // 8205
@@ -8061,7 +8061,7 @@ class TestOther : public TestFixture {
               "       if (Diag==0) {}\n"
               "       break;\n"
               "   }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15] -> [test.cpp:5:16]: (style) The comparison 'Diag == 0' is always true. [knownConditionTrueFalse]\n", errout_str());
 
         // #9744
@@ -8089,13 +8089,13 @@ class TestOther : public TestFixture {
               "    int b = a;\n"
               "    a = 2;\n"
               "    if ( b != a){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int * a, int i) { int b = a[i]; a[i] = 2; if ( b != a[i]){}}");
+        check("void f(int * a, int i) { int b = a[i]; a[i] = 2; if ( b != a[i]){}}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int * a, int i) { int b = *a; *a = 2; if ( b != *a){}}");
+        check("void f(int * a, int i) { int b = *a; *a = 2; if ( b != *a){}}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A { int f() const; };\n"
@@ -8106,7 +8106,7 @@ class TestOther : public TestFixture {
               "        x = g();\n"
               "        if (x.f() == a) break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int i);\n"
@@ -8119,14 +8119,14 @@ class TestOther : public TestFixture {
               "    const bool x = a.f(A::B);\n"
               "    const bool y = a.f(A::C);\n"
               "    if(!x && !y) return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    const bool x = a.f(A::B);\n"
               "    const bool y = a.f(A::C);\n"
               "    if (!x && !y) return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool * const b);\n"
@@ -8135,17 +8135,17 @@ class TestOther : public TestFixture {
               "    bool y = true;\n"
               "    f(&x);\n"
               "    if (!x && !y) return;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const int a = {};\n"
               "    if(a == 1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("volatile const int var = 42;\n"
-              "void f() { if(var == 42) {} }");
+              "void f() { if(var == 42) {} }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -8154,7 +8154,7 @@ class TestOther : public TestFixture {
               "    c.a = &a;\n"
               "    g(&c);\n"
               "    if (a == 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -8164,7 +8164,7 @@ class TestOther : public TestFixture {
               "  uint16_t x = 1000;\n"
               "  uint8_t y = x;\n"
               "  if (x != y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -8175,7 +8175,7 @@ class TestOther : public TestFixture {
               "   const int b = a-1;\n"
               "   const int c = a+1;\n"
               "   return c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -8196,7 +8196,7 @@ class TestOther : public TestFixture {
               "        setZoom(m_zoom + 1);\n"
               "        double scale_ratio = getScale() / old_scale;\n" // <- FP
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -8205,14 +8205,14 @@ class TestOther : public TestFixture {
               "{\n"
               "        int var = buffer[index - 1];\n"
               "        return buffer[index - 1] - var;\n"  // <<
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:25] -> [test.cpp:4:34]: (style) Same expression on both sides of '-' because 'buffer[index-1]' and 'var' represent the same value. [duplicateExpression]\n", errout_str());
     }
 
     void duplicateExpression13() { //#7899
         check("void f() {\n"
               "    if (sizeof(long) == sizeof(long long)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -8345,7 +8345,7 @@ class TestOther : public TestFixture {
 
     void duplicateExpression20() {
         check("enum { N = 1 };\n" // #14202
-              "int f() { return N - 1; }");
+              "int f() { return N - 1; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -8411,23 +8411,23 @@ class TestOther : public TestFixture {
         check("void f() {\n"
               "    int a = 1;\n"
               "    while ( a != 1){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:15]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
-        check("void f() { int a = 1; while ( a != 1){ a++; }}");
+        check("void f() { int a = 1; while ( a != 1){ a++; }}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f() { int a = 1; for ( int i=0; i < 3 && a != 1; i++){ a++; }}");
+        check("void f() { int a = 1; for ( int i=0; i < 3 && a != 1; i++){ a++; }}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int b) { int a = 1; while (b) { if ( a != 1){} b++; } a++; }");
+        check("void f(int b) { int a = 1; while (b) { if ( a != 1){} b++; } a++; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    for(int i = 0; i < 10;) {\n"
               "        if( i != 0 ) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17] -> [test.cpp:3:15]: (style) The comparison 'i != 0' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
@@ -8435,7 +8435,7 @@ class TestOther : public TestFixture {
               "        if( i != 0 ) {}\n"
               "        i++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -8443,14 +8443,14 @@ class TestOther : public TestFixture {
               "        if( i != 0 ) { i++; }\n"
               "        i++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    for(int i = 0; i < 10;) {\n"
               "        if( i != 0 ) { i++; }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -8459,7 +8459,7 @@ class TestOther : public TestFixture {
               "        if( i != 0 ) {}\n"
               "        i++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int b) {\n"
@@ -8468,7 +8468,7 @@ class TestOther : public TestFixture {
               "        if ( a != 1){}\n"
               "        b++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17] -> [test.cpp:4:16]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("struct T {\n" // #11083
@@ -8511,35 +8511,35 @@ class TestOther : public TestFixture {
     void duplicateExpressionTernary() { // #6391
         check("void f() {\n"
               "    return A ? x : x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
 
         check("int f(bool b, int a) {\n"
               "    const int c = a;\n"
               "    return b ? a : c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:19] -> [test.cpp:3:18]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
 
         check("void f() {\n"
               "    return A ? x : z;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(unsigned char c) {\n"
               "  x = y ? (signed char)c : (unsigned char)c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::string stringMerge(std::string const& x, std::string const& y) {\n" // #7938
               "    return ((x > y) ? (y + x) : (x + y));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6426
         {
             const char code[] = "void foo(bool flag) {\n"
                                 "  bar( (flag) ? ~0u : ~0ul);\n"
-                                "}";
+                                "}\n";
             /*const*/ Settings settings = settings1;
             settings.platform.sizeof_int = 4;
             settings.platform.int_bit = 32;
@@ -8559,31 +8559,31 @@ class TestOther : public TestFixture {
     void duplicateValueTernary() {
         check("void f() {\n"
               "    if( a ? (b ? false:false): false ) ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:23]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
 
-        check("int f1(int a) {return (a == 1) ? (int)1 : 1; }");
+        check("int f1(int a) {return (a == 1) ? (int)1 : 1; }\n");
         ASSERT_EQUALS("[test.cpp:1:41]: (style) Same value in both branches of ternary operator. [duplicateValueTernary]\n", errout_str());
 
-        check("int f2(int a) {return (a == 1) ? (int)1 : (int)1; }");
+        check("int f2(int a) {return (a == 1) ? (int)1 : (int)1; }\n");
         ASSERT_EQUALS("[test.cpp:1:41]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
 
-        check("int f3(int a) {return (a == 1) ? 1 : (int)1; }");
+        check("int f3(int a) {return (a == 1) ? 1 : (int)1; }\n");
         ASSERT_EQUALS("[test.cpp:1:36]: (style) Same value in both branches of ternary operator. [duplicateValueTernary]\n", errout_str());
 
-        check("int f4(int a) {return (a == 1) ? 1 : 1; }");
+        check("int f4(int a) {return (a == 1) ? 1 : 1; }\n");
         ASSERT_EQUALS("[test.cpp:1:36]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
 
-        check("int f5(int a) {return (a == (int)1) ? (int)1 : 1; }");
+        check("int f5(int a) {return (a == (int)1) ? (int)1 : 1; }\n");
         ASSERT_EQUALS("[test.cpp:1:46]: (style) Same value in both branches of ternary operator. [duplicateValueTernary]\n", errout_str());
 
-        check("int f6(int a) {return (a == (int)1) ? (int)1 : (int)1; }");
+        check("int f6(int a) {return (a == (int)1) ? (int)1 : (int)1; }\n");
         ASSERT_EQUALS("[test.cpp:1:46]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
 
-        check("int f7(int a) {return (a == (int)1) ? 1 : (int)1; }");
+        check("int f7(int a) {return (a == (int)1) ? 1 : (int)1; }\n");
         ASSERT_EQUALS("[test.cpp:1:41]: (style) Same value in both branches of ternary operator. [duplicateValueTernary]\n", errout_str());
 
-        check("int f8(int a) {return (a == (int)1) ? 1 : 1; }");
+        check("int f8(int a) {return (a == (int)1) ? 1 : 1; }\n");
         ASSERT_EQUALS("[test.cpp:1:41]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
 
         check("struct Foo {\n"
@@ -8637,10 +8637,10 @@ class TestOther : public TestFixture {
     }
 
     void duplicateValueTernarySizeof() { // #13773
-        check("int f() { return x ? sizeof(uint32_t) : sizeof(unsigned int); }");
+        check("int f() { return x ? sizeof(uint32_t) : sizeof(unsigned int); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int f() { return x ? sizeof(uint32_t) : sizeof(uint32_t); }");
+        check("int f() { return x ? sizeof(uint32_t) : sizeof(uint32_t); }\n");
         ASSERT_EQUALS("[test.cpp:1:39]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
     }
 
@@ -8649,7 +8649,7 @@ class TestOther : public TestFixture {
               "    if (I >= 0 && I < 3) {}\n"
               "}\n"
               "\n"
-              "static auto a = f<0>();");
+              "static auto a = f<0>();\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template<typename T>\n" // #7754
@@ -8735,35 +8735,35 @@ class TestOther : public TestFixture {
     }
 
     void oppositeExpression() {
-        check("void f(bool a) { if(a && !a) {} }");
+        check("void f(bool a) { if(a && !a) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (style) Opposite expression on both sides of '&&'. [oppositeExpression]\n", errout_str());
 
-        check("void f(bool a) { if(a != !a) {} }");
+        check("void f(bool a) { if(a != !a) {} }\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (style) Opposite expression on both sides of '!='. [oppositeExpression]\n", errout_str());
 
-        check("void f(bool a) { if( a == !(a) ) {}}");
+        check("void f(bool a) { if( a == !(a) ) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:24]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
 
-        check("void f(bool a) { if( a != !(a) ) {}}");
+        check("void f(bool a) { if( a != !(a) ) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:24]: (style) Opposite expression on both sides of '!='. [oppositeExpression]\n", errout_str());
 
-        check("void f(bool a) { if( !(a) == a ) {}}");
+        check("void f(bool a) { if( !(a) == a ) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:27]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
 
-        check("void f(bool a) { if( !(a) != a ) {}}");
+        check("void f(bool a) { if( !(a) != a ) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:27]: (style) Opposite expression on both sides of '!='. [oppositeExpression]\n", errout_str());
 
-        check("void f(bool a) { if( !(!a) == !(a) ) {}}");
+        check("void f(bool a) { if( !(!a) == !(a) ) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:28]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
 
-        check("void f(bool a) { if( !(!a) != !(a) ) {}}");
+        check("void f(bool a) { if( !(!a) != !(a) ) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:28]: (style) Opposite expression on both sides of '!='. [oppositeExpression]\n", errout_str());
 
         check("void f1(bool a) {\n"
               "    const bool b = a;\n"
               "    if( a == !(b) ) {}\n"
               "    if( b == !(a) ) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:3:11]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n"
                       "[test.cpp:2:20] -> [test.cpp:4:11]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
 
@@ -8771,26 +8771,26 @@ class TestOther : public TestFixture {
               "    const bool b = *a;\n"
               "    if( *a == !(b) ) {}\n"
               "    if( b == !(*a) ) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:3:12]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n"
                       "[test.cpp:2:20] -> [test.cpp:4:11]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
 
-        check("void f(bool a) { a = !a; }");
+        check("void f(bool a) { a = !a; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int a) { if( a < -a ) {}}");
+        check("void f(int a) { if( a < -a ) {}}\n");
         ASSERT_EQUALS("[test.cpp:1:23]: (style) Opposite expression on both sides of '<'. [oppositeExpression]\n", errout_str());
 
-        check("void f(int a) { a -= -a; }");
+        check("void f(int a) { a -= -a; }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int a) { a = a / (-a); }");
+        check("void f(int a) { a = a / (-a); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("bool f(int i){ return !((i - 1) & i); }");
+        check("bool f(int i){ return !((i - 1) & i); }\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("bool f(unsigned i){ return (x > 0) && (x & (x-1)) == 0; }");
+        check("bool f(unsigned i){ return (x > 0) && (x & (x-1)) == 0; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void A::f(bool a, bool c)\n"
@@ -8798,27 +8798,27 @@ class TestOther : public TestFixture {
               "    const bool b = a;\n"
               "    if(c) { a = false; }\n"
               "    if(b && !a) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(bool c) {\n"
               "    const bool b = a;\n"
               "    if(c) { a = false; }\n"
               "    if(b && !a) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    bool x = a;\n"
               "    dostuff();\n"
               "    if (x && a) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  const bool b = g();\n"
               "  if (!b && g()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const bool *a) {\n"
@@ -8861,7 +8861,7 @@ class TestOther : public TestFixture {
               "void test() {\n"
               "    int i = f();\n"
               "    int j = f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct Foo { int f() const; int g() const; };\n"
@@ -8869,7 +8869,7 @@ class TestOther : public TestFixture {
               "    Foo f = Foo{};\n"
               "    int i = f.f();\n"
               "    int j = f.f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct Foo { int f() const; int g() const; };\n"
@@ -8878,7 +8878,7 @@ class TestOther : public TestFixture {
               "    Foo f2 = Foo{};\n"
               "    int i = f.f();\n"
               "    int j = f.f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:9] -> [test.cpp:5:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("int f() __attribute__((pure));\n"
@@ -8886,7 +8886,7 @@ class TestOther : public TestFixture {
               "void test() {\n"
               "    int i = 1 + f();\n"
               "    int j = 1 + f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("int f() __attribute__((pure));\n"
@@ -8894,7 +8894,7 @@ class TestOther : public TestFixture {
               "void test() {\n"
               "    int i = f() + 1;\n"
               "    int j = 1 + f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() __attribute__((pure));\n"
@@ -8903,7 +8903,7 @@ class TestOther : public TestFixture {
               "    int x = f();\n"
               "    int i = x + 1;\n"
               "    int j = f() + 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() __attribute__((pure));\n"
@@ -8911,7 +8911,7 @@ class TestOther : public TestFixture {
               "void test() {\n"
               "    int i = f() + f();\n"
               "    int j = f() + f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("int f(int) __attribute__((pure));\n"
@@ -8919,7 +8919,7 @@ class TestOther : public TestFixture {
               "void test() {\n"
               "    int i = f(0);\n"
               "    int j = f(0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("int f(int) __attribute__((pure));\n"
@@ -8928,39 +8928,39 @@ class TestOther : public TestFixture {
               "    const int x = 0;\n"
               "    int i = f(0);\n"
               "    int j = f(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void test(const int * p, const int * q) {\n"
               "    int i = *p;\n"
               "    int j = *p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct A { int x; int y; };"
               "void test(A a) {\n"
               "    int i = a.x;\n"
               "    int j = a.x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("void test() {\n"
               "    int i = 0;\n"
               "    int j = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void test() {\n"
               "    int i = -1;\n"
               "    int j = -1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int);\n"
               "void test() {\n"
               "    int i = f(0);\n"
               "    int j = f(1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f();\n"
@@ -8968,21 +8968,21 @@ class TestOther : public TestFixture {
               "void test() {\n"
               "    int i = f() || f();\n"
               "    int j = f() && f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Foo {};\n"
               "void test() {\n"
               "    Foo i = Foo();\n"
               "    Foo j = Foo();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Foo {};\n"
               "void test() {\n"
               "    Foo i = Foo{};\n"
               "    Foo j = Foo{};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Foo { int f() const; float g() const; };\n"
@@ -8990,7 +8990,7 @@ class TestOther : public TestFixture {
               "    Foo f = Foo{};\n"
               "    int i = f.f();\n"
               "    int j = f.f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct Foo { int f(); int g(); };\n"
@@ -8998,43 +8998,43 @@ class TestOther : public TestFixture {
               "    Foo f = Foo{};\n"
               "    int i = f.f();\n"
               "    int j = f.f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void test() {\n"
               "    int i = f();\n"
               "    int j = f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void test(int x) {\n"
               "    int i = ++x;\n"
               "    int j = ++x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void test(int x) {\n"
               "    int i = x++;\n"
               "    int j = x++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void test(int x) {\n"
               "    int i = --x;\n"
               "    int j = --x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void test(int x) {\n"
               "    int i = x--;\n"
               "    int j = x--;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void test(int x) {\n"
               "    int i = x + 1;\n"
               "    int j = 1 + x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -9043,7 +9043,7 @@ class TestOther : public TestFixture {
               "void foo(SW* x) {\n"
               "    int start = x->first;\n"
               "    int end   = x->first;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'start' and 'end'. [duplicateAssignExpression]\n"
                       "[test.cpp:2:14]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
@@ -9052,7 +9052,7 @@ class TestOther : public TestFixture {
               "void foo(SW* x, int i, int j) {\n"
               "    int start = x->first;\n"
               "    int end   = x->first;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'start' and 'end'. [duplicateAssignExpression]\n"
                       "[test.cpp:2:14]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
@@ -9062,13 +9062,13 @@ class TestOther : public TestFixture {
               "    Foo f = Foo{};\n"
               "    int i = f.f();\n"
               "    int j = f.f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("void test(const int * p) {\n"
               "    int i = *p;\n"
               "    int j = *p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct Foo { int f() const; int g(int) const; };\n"
@@ -9076,7 +9076,7 @@ class TestOther : public TestFixture {
               "    Foo f = Foo{};\n"
               "    int i = f.f();\n"
               "    int j = f.f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct Foo { int f() const; };\n"
@@ -9084,7 +9084,7 @@ class TestOther : public TestFixture {
               "    Foo f = Foo{};\n"
               "    int i = f.f();\n"
               "    int j = f.f();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
     }
 
@@ -9096,7 +9096,7 @@ class TestOther : public TestFixture {
               "    int j = a.x;\n"
               "    use(i);\n"
               "    i = j;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct A { int x; int y; };"
@@ -9106,7 +9106,7 @@ class TestOther : public TestFixture {
               "    int j = a.x;\n"
               "    use(j);\n"
               "    j = i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct A { int x; int y; };"
@@ -9116,7 +9116,7 @@ class TestOther : public TestFixture {
               "    int j = a.x;\n"
               "    use(j);\n"
               "    if (i == j) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n",
             errout_str());
@@ -9128,7 +9128,7 @@ class TestOther : public TestFixture {
               "    int j = a.x;\n"
               "    use(j);\n"
               "    if (i == a.x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n",
             errout_str());
@@ -9140,7 +9140,7 @@ class TestOther : public TestFixture {
               "    int j = a.x;\n"
               "    use(i);\n"
               "    if (j == a.x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n",
             errout_str());
@@ -9171,7 +9171,7 @@ class TestOther : public TestFixture {
               "        }\n"
               "        previous = current;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:16:7] -> [test.cpp:15:7]: (style, inconclusive) Same expression used in consecutive assignments of 'current' and 'previous'. [duplicateAssignExpression]\n", errout_str());
     }
 
@@ -9187,21 +9187,21 @@ class TestOther : public TestFixture {
               "        int b = x.f();\n"
               "        (void)a;\n"
               "        (void)b;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:13] -> [test.cpp:7:13]: (style, inconclusive) Same expression used in consecutive assignments of 'a' and 'b'. [duplicateAssignExpression]\n", errout_str());
 
         // Issue #8712
         check("void f() {\n"
               "  unsigned char d;\n"
               "  d = d % 5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template <typename T>\n"
               "T f() {\n"
               "  T x = T();\n"
               "}\n"
-              "int &a = f<int&>();");
+              "int &a = f<int&>();\n");
         ASSERT_EQUALS("", errout_str());
 
         // Issue #8713
@@ -9213,7 +9213,7 @@ class TestOther : public TestFixture {
               "  uint32_t a = 42;\n"
               "  uint32_t b = uint32_t(A ::B / 1024);\n"
               "  int32_t c = int32_t(a / b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Issue #8709
@@ -9222,7 +9222,7 @@ class TestOther : public TestFixture {
               "  switch (d) { case b:; }\n"
               "  double e(b);\n"
               "  if(e <= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #10718
@@ -9243,7 +9243,7 @@ class TestOther : public TestFixture {
               "  int val = 0;\n"
               "  if (val < 0) continue;\n"
               "  if ((val > 0)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:11]: (style) The comparison 'val < 0' is always false. [knownConditionTrueFalse]\n"
                       "[test.cpp:2:13] -> [test.cpp:4:12]: (style) The comparison 'val > 0' is always false. [knownConditionTrueFalse]\n", errout_str());
 
@@ -9274,7 +9274,7 @@ class TestOther : public TestFixture {
               "  if (val < 0) {\n"
               "    if ((val > 0)) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:11]: (style) The comparison 'val < 0' is always false. [knownConditionTrueFalse]\n"
                       "[test.cpp:2:13] -> [test.cpp:4:14]: (style) The comparison 'val > 0' is always false. [knownConditionTrueFalse]\n", errout_str());
 
@@ -9283,7 +9283,7 @@ class TestOther : public TestFixture {
               "  if (val < 0) {\n"
               "    if ((val < 0)) {}\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:11]: (style) The comparison 'val < 0' is always false. [knownConditionTrueFalse]\n"
                       "[test.cpp:2:13] -> [test.cpp:4:14]: (style) The comparison 'val < 0' is always false. [knownConditionTrueFalse]\n", errout_str());
 
@@ -9292,25 +9292,25 @@ class TestOther : public TestFixture {
               "  int foo = 0;\n"
               "  if (activate) {}\n"
               "  else if (foo) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void checkSignOfUnsignedVariable() {
         check("void foo() {\n"
               "  for(unsigned char i = 10; i >= 0; i--) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:31]: (style) Unsigned expression 'i' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(bool b) {\n"
               "  for(unsigned int i = 10; b || i >= 0; i--) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:35]: (style) Unsigned expression 'i' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         {
             const char code[] = "void foo(unsigned int x) {\n"
                                 "  if (x < 0) {}\n"
-                                "}";
+                                "}\n";
             check(code, dinit(CheckOptions, $.inconclusive = false));
             ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
             check(code, dinit(CheckOptions, $.inconclusive = false, $.verbose = true));
@@ -9319,19 +9319,19 @@ class TestOther : public TestFixture {
 
         check("void foo(unsigned int x) {\n"
               "  if (x < 0u) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x) {\n"
               "  if (x < 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         {
             const char code[] = "void foo(unsigned x) {\n"
                                 "  int y = 0;\n"
                                 "  if (x < y) {}\n"
-                                "}";
+                                "}\n";
             check(code, dinit(CheckOptions, $.inconclusive = false));
             ASSERT_EQUALS("[test.cpp:3:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
             check(code, dinit(CheckOptions, $.inconclusive = false, $.verbose = true));
@@ -9342,149 +9342,149 @@ class TestOther : public TestFixture {
               "  if (b)\n"
               "    y = 1;\n"
               "  if (x < y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x) {\n"
               "  if (0 > x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(unsigned int x) {\n"
               "  if (0UL > x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x) {\n"
               "  if (0 > x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x) {\n"
               "  if (x >= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(unsigned int x, unsigned y) {\n"
               "  if (x - y >= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Unsigned expression 'x-y' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(unsigned int x) {\n"
               "  if (x >= 0ull) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(int x) {\n"
               "  if (x >= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x) {\n"
               "  if (0 <= x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(unsigned int x) {\n"
               "  if (0ll <= x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(int x) {\n"
               "  if (0 <= x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (x < 0 && y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (x < 0 && y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (0 > x && y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (0 > x && y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (x >= 0 && y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (x >= 0 && y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (y && x < 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (y && x < 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (y && 0 > x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (y && 0 > x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (y && x >= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (y && x >= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (x < 0 || y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (x < 0 || y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (0 > x || y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (0 > x || y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (x >= 0 || y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (x >= 0 || y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3233 - FP when template is used (template parameter is numeric constant)
@@ -9492,7 +9492,7 @@ class TestOther : public TestFixture {
             const char code[] = "template<int n> void foo(unsigned int x) {\n"
                                 "  if (x <= n);\n"
                                 "}\n"
-                                "foo<0>();";
+                                "foo<0>();\n";
             check(code, dinit(CheckOptions, $.inconclusive = false));
             ASSERT_EQUALS("", errout_str());
             check(code);
@@ -9502,7 +9502,7 @@ class TestOther : public TestFixture {
         {
             check("template<int n> void foo(unsigned int x) {\n"
                   "if (x <= 0);\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("[test.cpp:2:7]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
         }
 
@@ -9513,7 +9513,7 @@ class TestOther : public TestFixture {
               "  {\n"
               "    value = 0u;\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (style) Checking if unsigned expression 'value' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         // #9040
@@ -9530,7 +9530,7 @@ class TestOther : public TestFixture {
               "   const uint32_t x = 0;\n"
               "   constexpr const auto y = 0xFFFFU;\n"
               "   if (y < x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (style) Checking if unsigned expression 'y' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         // #12387
@@ -9542,14 +9542,14 @@ class TestOther : public TestFixture {
               "}\n"
               "void g() {\n"
               "    f<uint32_t>(0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #13734
         check("void f() {\n"
               "    uint8_t a[N + 1];\n"
               "    for (unsigned p = 0; p < (sizeof(a) / sizeof((a)[0])); ++p) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const unsigned char u) {\n"
@@ -9561,7 +9561,7 @@ class TestOther : public TestFixture {
               "    if (0 >  u) {}\n"
               "    if (0 <= u) {}\n"
               "    if (0 >= u) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Checking if unsigned expression 'u' is less than zero. [unsignedLessThanZero]\n"
                       "[test.cpp:4:11]: (style) Unsigned expression 'u' can't be negative so it is unnecessary to test it. [unsignedPositive]\n"
                       "[test.cpp:5:11]: (style) Checking if unsigned expression 'u' is less than zero. [unsignedLessThanZero]\n"
@@ -9574,14 +9574,14 @@ class TestOther : public TestFixture {
     void checkSignOfPointer() {
         check("void foo(const int* x) {\n"
               "  if (x >= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not. [pointerPositive]\n", errout_str());
 
         {
             const char code[] = "void foo(const int* x) {\n"
                                 "  int y = 0;\n"
                                 "  if (x >= y) {}\n"
-                                "}";
+                                "}\n";
             check(code, dinit(CheckOptions, $.inconclusive = false));
             ASSERT_EQUALS("[test.cpp:3:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not. [pointerPositive]\n", errout_str());
             check(code, dinit(CheckOptions, $.inconclusive = false, $.verbose = true));
@@ -9589,19 +9589,19 @@ class TestOther : public TestFixture {
         }
         check("void foo(const int* x) {\n"
               "  if (*x >= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(const int* x) {\n"
               "  if (x < 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is. [pointerLessThanZero]\n", errout_str());
 
         {
             const char code[] = "void foo(const int* x) {\n"
                                 "  unsigned y = 0u;\n"
                                 "  if (x < y) {}\n"
-                                "}";
+                                "}\n";
 
             check(code, dinit(CheckOptions, $.inconclusive = false));
             ASSERT_EQUALS("[test.cpp:3:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is. [pointerLessThanZero]\n", errout_str());
@@ -9611,32 +9611,32 @@ class TestOther : public TestFixture {
 
         check("void foo(const int* x) {\n"
               "  if (*x < 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(const int* x, const int* y) {\n"
               "  if (x - y < 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(const int* x, const int* y) {\n"
               "  if (x - y <= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(const int* x, const int* y) {\n"
               "  if (x - y > 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(const int* x, const int* y) {\n"
               "  if (x - y >= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(const Bar* x) {\n"
               "  if (0 <= x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not. [pointerPositive]\n", errout_str());
 
         check("struct S {\n"
@@ -9644,7 +9644,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void foo(S* first) {\n"
               "  if (first.ptr >= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:17]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not. [pointerPositive]\n"
                       "[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
@@ -9654,7 +9654,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void foo(S* first, S* second) {\n"
               "  if((first.ptr - second.ptr) >= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
                       "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
@@ -9664,7 +9664,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void foo(S* first) {\n"
               "  if((first.ptr) >= 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:18]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not. [pointerPositive]\n"
                       "[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
@@ -9674,7 +9674,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void foo(S* first, S* second) {\n"
               "  if(0 <= first.ptr - second.ptr) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
                       "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
@@ -9684,7 +9684,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void foo(S* first, S* second) {\n"
               "  if(0 <= (first.ptr - second.ptr)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
                       "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
@@ -9694,7 +9694,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void foo(S* first, S* second) {\n"
               "  if(first.ptr - second.ptr < 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
                       "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
@@ -9704,7 +9704,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void foo(S* first, S* second) {\n"
               "  if((first.ptr - second.ptr) < 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
                       "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
@@ -9714,7 +9714,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void foo(S* first, S* second) {\n"
               "  if(0 > first.ptr - second.ptr) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
                       "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
@@ -9724,69 +9724,69 @@ class TestOther : public TestFixture {
               "};\n"
               "void foo(S* first, S* second) {\n"
               "  if(0 > (first.ptr - second.ptr)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
                       "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
 
         check("void foo(const int* x) {\n"
               "  if (0 <= x[0]) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(Bar* x) {\n"
               "  if (0 <= x.y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
         check("void foo(Bar* x) {\n"
               "  if (0 <= x->y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
         check("void foo(Bar* x, Bar* y) {\n"
               "  if (0 <= x->y - y->y ) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n"
                       "[test.cpp:1:23]: (style) Parameter 'y' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
 
         check("void foo(const Bar* x) {\n"
               "  if (0 > x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is. [pointerLessThanZero]\n", errout_str());
 
         check("void foo(const int* x) {\n"
               "  if (0 > x[0]) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(Bar* x) {\n"
               "  if (0 > x.y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
         check("void foo(Bar* x) {\n"
               "  if (0 > x->y) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
         check("void foo() {\n"
               "  int (*t)(void *a, void *b);\n"
               "  if (t(a, b) < 0) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "  int (*t)(void *a, void *b);\n"
               "  if (0 > t(a, b)) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct object_info { int *typep; };\n"
               "void packed_object_info(struct object_info *oi) {\n"
               "  if (oi->typep < 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style) A pointer can not be negative so it is either pointless or an error to check if it is. [pointerLessThanZero]\n"
                       "[test.cpp:2:45]: (style) Parameter 'oi' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
@@ -9794,7 +9794,7 @@ class TestOther : public TestFixture {
         check("struct object_info { int typep[10]; };\n"
               "void packed_object_info(struct object_info *oi) {\n"
               "  if (oi->typep < 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style) A pointer can not be negative so it is either pointless or an error to check if it is. [pointerLessThanZero]\n"
                       "[test.cpp:2:45]: (style) Parameter 'oi' can be declared as pointer to const [constParameterPointer]\n",
                       errout_str());
@@ -9802,28 +9802,28 @@ class TestOther : public TestFixture {
         check("struct object_info { int *typep; };\n"
               "void packed_object_info(struct object_info *oi) {\n"
               "  if (*oi->typep < 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:45]: (style) Parameter 'oi' can be declared as pointer to const [constParameterPointer]\n", errout_str());
     }
 
     void checkSuspiciousSemicolon1() {
         check("void foo() {\n"
               "  for(int i = 0; i < 10; ++i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Empty block
         check("void foo() {\n"
               "  for(int i = 0; i < 10; ++i); {\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: (warning) Suspicious use of ; at the end of 'for' statement. [suspiciousSemicolon]\n", errout_str());
 
         check("void foo() {\n"
               "  while (!quit); {\n"
               "    do_something();\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: (warning) Suspicious use of ; at the end of 'while' statement. [suspiciousSemicolon]\n", errout_str());
     }
 
@@ -9832,21 +9832,21 @@ class TestOther : public TestFixture {
               "  if (i == 1); {\n"
               "    do_something();\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: (warning) Suspicious use of ; at the end of 'if' statement. [suspiciousSemicolon]\n", errout_str());
 
         // Seen this in the wild
         check("void foo() {\n"
               "  if (Match());\n"
               "  do_something();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "  if (Match());\n"
               "  else\n"
               "    do_something();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -9855,7 +9855,7 @@ class TestOther : public TestFixture {
               "  {\n"
               "    do_something();\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -9864,7 +9864,7 @@ class TestOther : public TestFixture {
               "  {\n"
               "    do_something();\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -9873,20 +9873,20 @@ class TestOther : public TestFixture {
                "void foo() {\n"
                "  if (x == 123);\n"
                "  REQUIRE(y=z);\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void checkSuspiciousComparison() {
         checkP("void f(int a, int b) {\n"
                "  a > b;\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '>', result is not used. [constStatement]\n", errout_str());
 
         checkP("void f() {\n" // #10607
                "  for (auto p : m)\n"
                "    std::vector<std::pair<std::string, std::string>> k;\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -9894,25 +9894,25 @@ class TestOther : public TestFixture {
         check("void foo(char *p) {\n"
               "  char *a; a = malloc(1024);\n"
               "  free(a + 10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3]: (error) Mismatching address is freed. The address you get from malloc() must be freed without offset. [invalidFree]\n", errout_str());
 
         check("void foo(char *p) {\n"
               "  char *a; a = malloc(1024);\n"
               "  free(a - 10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3]: (error) Mismatching address is freed. The address you get from malloc() must be freed without offset. [invalidFree]\n", errout_str());
 
         check("void foo(char *p) {\n"
               "  char *a; a = malloc(1024);\n"
               "  free(10 + a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3]: (error) Mismatching address is freed. The address you get from malloc() must be freed without offset. [invalidFree]\n", errout_str());
 
         check("void foo(char *p) {\n"
               "  char *a; a = new char[1024];\n"
               "  delete[] (a + 10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:16]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n"
                       "[test.cpp:3:3]: (error) Mismatching address is deleted. The address you get from new must be deleted without offset. [invalidFree]\n",
                       errout_str());
@@ -9920,7 +9920,7 @@ class TestOther : public TestFixture {
         check("void foo(char *p) {\n"
               "  char *a; a = new char;\n"
               "  delete a + 10;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:16]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n"
                       "[test.cpp:3:3]: (error) Mismatching address is deleted. The address you get from new must be deleted without offset. [invalidFree]\n",
                       errout_str());
@@ -9929,7 +9929,7 @@ class TestOther : public TestFixture {
               "  char *a; a = new char;\n"
               "  bar(a);\n"
               "  delete a + 10;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char *p) {\n"
@@ -9938,7 +9938,7 @@ class TestOther : public TestFixture {
               "  bar(a);\n"
               "  delete a + 10;\n"
               "  delete b + 10;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:3]: (error) Mismatching address is deleted. The address you get from new must be deleted without offset. [invalidFree]\n", errout_str());
 
         check("void foo(char *p) {\n"
@@ -9947,14 +9947,14 @@ class TestOther : public TestFixture {
               "  bar(a, b);\n"
               "  delete a + 10;\n"
               "  delete b + 10;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char *p) {\n"
               "  char *a; a = new char;\n"
               "  bar()\n"
               "  delete a + 10;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:16]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n"
                       "[test.cpp:4:3]: (error) Mismatching address is deleted. The address you get from new must be deleted without offset. [invalidFree]\n",
                       errout_str());
@@ -9963,7 +9963,7 @@ class TestOther : public TestFixture {
               "  char *ptr; ptr = malloc(42);\n"
               "  ptr += xx;\n"
               "  free(ptr + 1 - xx);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:3]: (error) Mismatching address is freed. The address you get from malloc() must be freed without offset. [invalidFree]\n", errout_str());
 
         check("void foo(size_t xx) {\n"
@@ -9971,7 +9971,7 @@ class TestOther : public TestFixture {
               "  std::cout << ptr;\n"
               "  ptr = otherPtr;\n"
               "  free(otherPtr - xx - 1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:9]: (style) Variable 'ptr' can be declared as pointer to const [constVariablePointer]\n",
             errout_str());
@@ -9981,7 +9981,7 @@ class TestOther : public TestFixture {
         check("const std::string& getA(){static std::string a;return a;}\n"
               "void foo() {\n"
               "    const std::string a = getA();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:23]: (performance, inconclusive) Use const reference for 'a' to avoid unnecessary data copying. [redundantCopyLocalConst]\n", errout_str());
 
         check("class A { public: A() {} char x[100]; };\n"
@@ -9990,7 +9990,7 @@ class TestOther : public TestFixture {
               "{\n"
               "    const A a = getA();\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:13]: (performance, inconclusive) Use const reference for 'a' to avoid unnecessary data copying. [redundantCopyLocalConst]\n", errout_str());
 
         check("const int& getA(){static int a;return a;}\n"
@@ -9998,7 +9998,7 @@ class TestOther : public TestFixture {
               "{\n"
               "    const int a = getA();\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("const int& getA(){static int a;return a;}\n"
@@ -10007,7 +10007,7 @@ class TestOther : public TestFixture {
               "    int getA = 0;\n"
               "    const int a = getA + 3;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:12] -> [test.cpp:4:9]: (style) Local variable 'getA' shadows outer function [shadowFunction]\n", errout_str());
 
         check("class A { public: A() {} char x[100]; };\n"
@@ -10016,7 +10016,7 @@ class TestOther : public TestFixture {
               "{\n"
               "    const A a(getA());\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:13]: (performance, inconclusive) Use const reference for 'a' to avoid unnecessary data copying. [redundantCopyLocalConst]\n", errout_str());
 
         check("const int& getA(){static int a;return a;}\n"
@@ -10024,7 +10024,7 @@ class TestOther : public TestFixture {
               "{\n"
               "    const int a(getA());\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A{\n"
@@ -10036,7 +10036,7 @@ class TestOther : public TestFixture {
               "{\n"
               "    const A a = getA() + 1;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A{\n"
@@ -10048,7 +10048,7 @@ class TestOther : public TestFixture {
               "{\n"
               "    const A a(getA()+1);\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5190 - FP when creating object with constructor that takes a reference
@@ -10057,7 +10057,7 @@ class TestOther : public TestFixture {
               "const A &getA();\n"
               "void f() {\n"
               "    const B b(getA());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A {};\n"
@@ -10065,7 +10065,7 @@ class TestOther : public TestFixture {
               "const A& getA();\n"
               "void f() {\n"
               "    const B b{ getA() };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5618
@@ -10078,7 +10078,7 @@ class TestOther : public TestFixture {
                                 "        const std::string temp = tok->str();\n"
                                 "        tok->str(tok->strAt(2));\n"
                                 "    }\n"
-                                "}";
+                                "}\n";
         check(code5618);
         ASSERT_EQUALS("", errout_str());
         check(code5618, dinit(CheckOptions, $.inconclusive = false));
@@ -10089,7 +10089,7 @@ class TestOther : public TestFixture {
               "X f<X>(const X &in) {\n"
               "    const X s = f<X>(in);\n"
               "    return f<X>(s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7981 - False positive redundantCopyLocalConst - const ref argument to ctor
@@ -10101,7 +10101,7 @@ class TestOther : public TestFixture {
               " \n"
               "void foo() {\n"
               "  const CD cd(CD::getOne());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n" // #10545
@@ -10114,7 +10114,7 @@ class TestOther : public TestFixture {
               "    if (i != 0)\n"
               "        return old;\n"
               "    return {};\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct X { int x; };\n" // #10191
@@ -10296,62 +10296,62 @@ class TestOther : public TestFixture {
               "{\n"
               "   int a; a = 123;\n"
               "   (void)(a << -1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Shifting by a negative value is undefined behaviour [shiftNegative]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "   int a; a = 123;\n"
               "   (void)(a >> -1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Shifting by a negative value is undefined behaviour [shiftNegative]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "   int a; a = 123;\n"
               "   a <<= -1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Shifting by a negative value is undefined behaviour [shiftNegative]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "   int a; a = 123;\n"
               "   a >>= -1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Shifting by a negative value is undefined behaviour [shiftNegative]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "   std::cout << -1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "   std::cout << a << -1 ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "   std::cout << 3 << -1 ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo() {\n"
               "   x = (-10+2) << 3;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (portability) Shifting a negative value is technically undefined behaviour [shiftNegativeLHS]\n", errout_str());
 
-        check("x = y ? z << $-1 : 0;");
+        check("x = y ? z << $-1 : 0;\n");
         ASSERT_EQUALS("", errout_str());
 
         // Negative LHS
-        check("const int x = -1 >> 2;");
+        check("const int x = -1 >> 2;\n");
         ASSERT_EQUALS("[test.cpp:1:18]: (portability) Shifting a negative value is technically undefined behaviour [shiftNegativeLHS]\n", errout_str());
 
         // #6383 - unsigned type
-        check("const int x = (unsigned int)(-1) >> 2;");
+        check("const int x = (unsigned int)(-1) >> 2;\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7814 - UB happening in valueflowcode when it tried to compute shifts.
         check("int shift1() { return 1 >> -1 ;}\n"
               "int shift2() { return 1 << -1 ;}\n"
               "int shift3() { return -1 >> 1 ;}\n"
-              "int shift4() { return -1 << 1 ;}");
+              "int shift4() { return -1 << 1 ;}\n");
         ASSERT_EQUALS("[test.cpp:1:25]: (error) Shifting by a negative value is undefined behaviour [shiftNegative]\n"
                       "[test.cpp:2:25]: (error) Shifting by a negative value is undefined behaviour [shiftNegative]\n"
                       "[test.cpp:3:26]: (portability) Shifting a negative value is technically undefined behaviour [shiftNegativeLHS]\n"
@@ -10400,7 +10400,7 @@ class TestOther : public TestFixture {
               "    memset(a, 123, 5);\n"
               "    memcpy(a, b, 5);\n"
               "    memmove(a, b, 5);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(// TODO "[test.cpp:4] -> [test.cpp:5]: (performance) Buffer 'a' is being written before its old content has been used.\n"
             "[test.cpp:3:5]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'? [incompleteArrayFill]\n"
             "[test.cpp:4:5]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memcpy()' with 'sizeof(*a)'? [incompleteArrayFill]\n"
@@ -10411,7 +10411,7 @@ class TestOther : public TestFixture {
               "void f() {\n"
               "    memset(::a, 123, 5);\n"
               "    memset(Z::b.a, 123, 5);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4:5]: (warning, inconclusive) Array '::a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*::a)'? [incompleteArrayFill]\n"
                            "[test.cpp:5]: (warning, inconclusive) Array 'Z::b.a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*Z::b.a)'?\n",
                            "[test.cpp:4:5]: (warning, inconclusive) Array '::a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*::a)'? [incompleteArrayFill]\n", errout_str());
@@ -10419,45 +10419,45 @@ class TestOther : public TestFixture {
         check("void f() {\n"
               "    Foo* a[5];\n"
               "    memset(a, 'a', 5);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'? [incompleteArrayFill]\n", errout_str());
 
         check("class Foo {int a; int b;};\n"
               "void f() {\n"
               "    Foo a[5];\n"
               "    memset(a, 'a', 5);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'? [incompleteArrayFill]\n", errout_str());
 
         check("void f() {\n"
               "    Foo a[5];\n" // Size of foo is unknown
               "    memset(a, 'a', 5);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char a[5];\n"
               "    memset(a, 'a', 5);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a[5];\n"
               "    memset(a+15, 'a', 5);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    bool a[5];\n"
               "    memset(a, false, 5);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (portability, inconclusive) Array 'a' might be filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'? [incompleteArrayFill]\n", errout_str());
 
         check("void f() {\n"
               "    const int n = 5;"
               "    int a[n];\n"
               "    memset(a, 0, n);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'? [incompleteArrayFill]\n", errout_str());
     }
 
@@ -10468,7 +10468,7 @@ class TestOther : public TestFixture {
         check("void f(int i) {\n"
               "    i = 1;\n"
               "    i = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: style: Variable 'i' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:2:7]: note: i is assigned\n"
                       "[test.cpp:3:7]: note: i is overwritten\n", errout_str());
@@ -10478,7 +10478,7 @@ class TestOther : public TestFixture {
               "void f() {\n"
               "    i = 1;\n"
               "    i = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: style: Variable 'i' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:3:7]: note: i is assigned\n"
                       "[test.cpp:4:7]: note: i is overwritten\n", errout_str());
@@ -10487,7 +10487,7 @@ class TestOther : public TestFixture {
               "    int i;\n"
               "    i = 1;\n"
               "    i = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: style: Variable 'i' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:3:7]: note: i is assigned\n"
                       "[test.cpp:4:7]: note: i is overwritten\n", errout_str());
@@ -10496,14 +10496,14 @@ class TestOther : public TestFixture {
               "    static int i;\n"
               "    i = 1;\n"
               "    i = 1;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         check("void f() {\n"
               "    int i[10];\n"
               "    i[2] = 1;\n"
               "    i[2] = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: style: Variable 'i[2]' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:3:10]: note: i[2] is assigned\n"
                       "[test.cpp:4:10]: note: i[2] is overwritten\n", errout_str());
@@ -10513,14 +10513,14 @@ class TestOther : public TestFixture {
               "    i[x] = 1;\n"
               "    x=1;\n"
               "    i[x] = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const int x) {\n"
               "    int i[10];\n"
               "    i[x] = 1;\n"
               "    i[x] = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: style: Variable 'i[x]' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:3:10]: note: i[x] is assigned\n"
                       "[test.cpp:4:10]: note: i[x] is overwritten\n", errout_str());
@@ -10529,14 +10529,14 @@ class TestOther : public TestFixture {
         check("void f() {\n"
               "    Foo& bar = foo();\n"
               "    bar = x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    Foo& bar = foo();\n"
               "    bar = x;\n"
               "    bar = y;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         check("void f() {\n"
@@ -10544,7 +10544,7 @@ class TestOther : public TestFixture {
               "    bar = y();\n"
               "    foo();\n"
               "    bar = y();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Tests with function call between assignment
@@ -10552,7 +10552,7 @@ class TestOther : public TestFixture {
               "    i = 1;\n"
               "    bar();\n"
               "    i = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: style: Variable 'i' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:2:7]: note: i is assigned\n"
                       "[test.cpp:4:7]: note: i is overwritten\n", errout_str());
@@ -10562,7 +10562,7 @@ class TestOther : public TestFixture {
               "    i = 1;\n"
               "    bar();\n" // Global variable might be accessed in bar()
               "    i = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -10570,7 +10570,7 @@ class TestOther : public TestFixture {
               "    i = 1;\n"
               "    bar();\n" // bar() might call f() recursively. This could be a false positive in more complex examples (when value of i is used somewhere. See #4229)
               "    i = 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -10578,7 +10578,7 @@ class TestOther : public TestFixture {
               "    i = 1;\n"
               "    bar();\n"
               "    i = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:7]: style: Variable 'i' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:3:7]: note: i is assigned\n"
                       "[test.cpp:5:7]: note: i is overwritten\n", errout_str());
@@ -10588,14 +10588,14 @@ class TestOther : public TestFixture {
               "    i = 1;\n"
               "    bar(i);\n" // Passed as argument
               "    i = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    Foo bar = foo();\n"
               "    bar();\n" // #5568. operator() called
               "    bar = y();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Branch tests
@@ -10603,7 +10603,7 @@ class TestOther : public TestFixture {
               "    i = 1;\n"
               "    if(x)\n"
               "        i = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int i) {\n"
@@ -10611,7 +10611,7 @@ class TestOther : public TestFixture {
               "        i = 0;\n"
               "    i = 1;\n"
               "    i = 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:7]: style: Variable 'i' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:4:7]: note: i is assigned\n"
                       "[test.cpp:5:7]: note: i is overwritten\n", errout_str());
@@ -10624,7 +10624,7 @@ class TestOther : public TestFixture {
               "void f() {\n"
               "    x = 2;\n"
               "    x = g();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int g() {\n"
@@ -10633,7 +10633,7 @@ class TestOther : public TestFixture {
               "void f(int x) {\n"
               "    x = 2;\n"
               "    x = g();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:7]: style: Variable 'x' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:5:7]: note: x is assigned\n"
                       "[test.cpp:6:7]: note: x is overwritten\n", errout_str());
@@ -10642,7 +10642,7 @@ class TestOther : public TestFixture {
               "    Foo& bar = foo();\n"
               "    bar = x;\n"
               "    bar = y();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class C {\n"
@@ -10654,7 +10654,7 @@ class TestOther : public TestFixture {
               "void C::f() {\n"
               "    x = 2;\n"
               "    x = g();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class C {\n"
@@ -10666,7 +10666,7 @@ class TestOther : public TestFixture {
               "void C::f(Foo z) {\n"
               "    x = 2;\n"
               "    x = z.g();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ({ })
@@ -10674,7 +10674,7 @@ class TestOther : public TestFixture {
               "  int x;\n"
               "  x = 321;\n"
               "  x = ({ asm(123); })\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // from #3103 (avoid a false negative)
@@ -10683,7 +10683,7 @@ class TestOther : public TestFixture {
               "    x = 1;\n"
               "    x = 1;\n"
               "    return x + 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: style: Variable 'x' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:3:7]: note: x is assigned\n"
                       "[test.cpp:4:7]: note: x is overwritten\n", errout_str());
@@ -10695,20 +10695,20 @@ class TestOther : public TestFixture {
               "    if (y)\n" // <-- cppcheck does not know anything about 'y'
               "        x = 2;\n"
               "    return x + 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // initialization, assignment with 0
         check("void f() {\n"  // Ticket #4356
               "    int x = 0;\n"  // <- ignore initialization with 0
               "    x = 3;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  state_t *x = NULL;\n"
               "  x = dostuff();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:12]: style: Variable 'x' can be declared as pointer to const [constVariablePointer]\n",
             errout_str());
@@ -10717,7 +10717,7 @@ class TestOther : public TestFixture {
               "  state_t *x;\n"
               "  x = NULL;\n"
               "  x = dostuff();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:12]: style: Variable 'x' can be declared as pointer to const [constVariablePointer]\n",
             errout_str());
@@ -10727,7 +10727,7 @@ class TestOther : public TestFixture {
               "    bar(++x);\n"
               "    x = 5;\n"
               "    return bar(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // struct member..
@@ -10738,7 +10738,7 @@ class TestOther : public TestFixture {
               "    ab.a = 1;\n"
               "    ab.a = 2;\n"
               "    return ab.a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:10]: style: Variable 'ab.a' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:5:10]: note: ab.a is assigned\n"
                       "[test.cpp:6:10]: note: ab.a is overwritten\n", errout_str());
@@ -10750,7 +10750,7 @@ class TestOther : public TestFixture {
               "    ab.a = 1;\n"
               "    ab = do_something();\n"
               "    return ab.a;\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         check("struct AB { int a; int b; };\n"
@@ -10761,7 +10761,7 @@ class TestOther : public TestFixture {
               "    do_something(&ab);\n"
               "    ab.a = 2;\n"
               "    return ab.a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct AB { int a; int b; };\n"
@@ -10772,7 +10772,7 @@ class TestOther : public TestFixture {
               "    do_something(&ab);\n"
               "    ab.a = 2;\n"
               "    return ab.a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct AB { int a; int b; };\n"
@@ -10783,7 +10783,7 @@ class TestOther : public TestFixture {
               "    ab++;\n"
               "    ab->a = 1;\n"
               "    ab->b = 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct AB { int a; int b; };\n"
@@ -10794,20 +10794,20 @@ class TestOther : public TestFixture {
               "    ab = x;\n"
               "    ab->a = 1;\n"
               "    ab->b = 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(struct AB *ab) {\n" // #
               "    ab->data->x = 1;\n"
               "    ab = &ab1;\n"
               "    ab->data->x = 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5964
         check("void func(char *buffer, const char *format, int precision, unsigned value) {\n"
               "    (precision < 0) ? sprintf(buffer, format, value) : sprintf(buffer, format, precision, value);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // don't crash
@@ -10820,14 +10820,14 @@ class TestOther : public TestFixture {
               "void func(struct state *s) {\n"
               "  s->foo[s->x++] = 2;\n"
               "  s->d[1].fc.i++;\n"
-              "}");
+              "}\n");
 
         // #6525 - inline assembly
         check("void f(int i) {\n"
               "    i = 1;\n"
               "    asm(\"foo\");\n"
               "    i = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6555
@@ -10840,7 +10840,7 @@ class TestOther : public TestFixture {
               "    catch (...) {\n"
               "        barney(p);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
@@ -10852,7 +10852,7 @@ class TestOther : public TestFixture {
               "    catch (...) {\n"
               "        barney(x);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: style: The scope of the variable 'p' can be reduced. [variableScope]\n"
                       "[test.cpp:2:11]: style: Variable 'p' can be declared as pointer to const [constVariablePointer]\n",
                       errout_str());
@@ -10868,7 +10868,7 @@ class TestOther : public TestFixture {
               "    catch (...) {\n"
               "        barney(p);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Member variable pointers
@@ -10878,7 +10878,7 @@ class TestOther : public TestFixture {
               "    memptr = &POD::b;\n"
               "    if (memptr)\n"
               "        memptr = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: style: Variable 'memptr' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:3:12]: note: memptr is assigned\n"
                       "[test.cpp:4:12]: note: memptr is overwritten\n", errout_str());
@@ -10888,7 +10888,7 @@ class TestOther : public TestFixture {
               "{\n"
               "  var[0] = 0.2f;\n"
               "  var[0] = 0.2f;\n" // <-- is initialized twice
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: style: Variable 'var[0]' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:3:10]: note: var[0] is assigned\n"
                       "[test.cpp:4:10]: note: var[0] is overwritten\n", errout_str());
@@ -10897,7 +10897,7 @@ class TestOther : public TestFixture {
               "{\n"
               "  *var = 0.2f;\n"
               "  *var = 0.2f;\n" // <-- is initialized twice
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:8]: style: Variable '*var' is reassigned a value before the old one has been used. [redundantAssignment]\n"
                       "[test.cpp:3:8]: note: *var is assigned\n"
                       "[test.cpp:4:8]: note: *var is overwritten\n", errout_str());
@@ -10907,7 +10907,7 @@ class TestOther : public TestFixture {
               "  volatile char *reg = (volatile char *)0x12345;\n"
               "  *reg = 12;\n"
               "  *reg = 34;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::map<int, int>& m, int key, int value) {\n" // #6379
@@ -10924,28 +10924,28 @@ class TestOther : public TestFixture {
         check("void f() {\n"
               "   int a = 0;\n"
               "   a = 4;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "   int a;\n"
               "   a = 0;\n"
               "   a = 4;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "   unsigned a;\n"
               "   a = 0u;\n"
               "   a = 2u;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "   void* a;\n"
               "   a = (void*)0;\n"
               "   a = p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:10]: (style) Variable 'a' can be declared as pointer to const [constVariablePointer]\n",
             errout_str());
@@ -10954,7 +10954,7 @@ class TestOther : public TestFixture {
               "   void* a;\n"
               "   a = (void*)0U;\n"
               "   a = p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:10]: (style) Variable 'a' can be declared as pointer to const [constVariablePointer]\n",
             errout_str());
@@ -10968,7 +10968,7 @@ class TestOther : public TestFixture {
               "    const char* p = \"abc\";\n"
               "    p = \"def\";\n"
               "    return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:19] -> [test.cpp:3:7]: (style) Redundant initialization for 's'. The initialized value is overwritten before it is read. [redundantInitialization]\n"
             "[test.cpp:7:19] -> [test.cpp:8:7]: (style) Redundant initialization for 'p'. The initialized value is overwritten before it is read. [redundantInitialization]\n",
@@ -10984,7 +10984,7 @@ class TestOther : public TestFixture {
               "  struct foo x;\n"
               "  x.a = _mm_set1_ps(1.0);\n"
               "  x.a = _mm_set1_ps(2.0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:7] -> [test.cpp:8:7]: (style) Variable 'x.a' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
 
         check("void f() {\n"
@@ -10992,13 +10992,13 @@ class TestOther : public TestFixture {
               "  ab.x = 23;\n"
               "  ab.y = 41;\n"
               "  ab.x = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:5:8]: (style) Variable 'ab.x' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
 
         check("void f() {\n"
               "  struct AB ab = {0};\n"
               "  ab = foo();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -11019,7 +11019,7 @@ class TestOther : public TestFixture {
               "    u.l1 = 1;\n"
               "    lTotal += u.b.b1;\n"
               "    u.l1 = 2;\n" //Should not show RedundantAssignment
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #5115 "redundantAssignment when using a union"
@@ -11037,7 +11037,7 @@ class TestOther : public TestFixture {
               "    } u;\n"
               "    u.l1 = 1;\n"
               "    u.l1 = 2;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:13:10] -> [test.cpp:14:10]: (style) Variable 'u.l1' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
 
         // Ticket #10093 "redundantAssignment when using a union"
@@ -11061,7 +11061,7 @@ class TestOther : public TestFixture {
               "    m.u16.ab = 47;\n"
               "    m.u16.cd = 0;\n"
               "    m.u16.ab = m.u32.abcd / 53;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #10093 "redundantAssignment when using a union"
@@ -11079,7 +11079,7 @@ class TestOther : public TestFixture {
               "    u.as_int = 42;\n"
               "    fn(&u.as_char[0], 4);\n"
               "    u.as_int = 0;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #5115 "redundantAssignment when using a union"
@@ -11090,7 +11090,7 @@ class TestOther : public TestFixture {
               "    } addr;\n"
               "    addr.s8 = ptr;\n"
               "    addr.u64 += 8;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n" // #12895
@@ -11167,7 +11167,7 @@ class TestOther : public TestFixture {
               "   }\n"
               "   catch (const uno::Exception&)  {\n"
               "   }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void ConvertBitmapData(sal_uInt16 nDestBits) {\n"
@@ -11176,7 +11176,7 @@ class TestOther : public TestFixture {
               "    BitmapBuffer aDstBuf;\n"
               "    aSrcBuf.mnBitCount = nDestBits;\n"
               "    bConverted = ::ImplFastBitmapConversion( aDstBuf, aSrcBuf, aTwoRects );\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:3:24] -> [test.c:5:24]: (style) Variable 'aSrcBuf.mnBitCount' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
         check("void ConvertBitmapData(sal_uInt16 nDestBits) {\n"
               "    BitmapBuffer aSrcBuf;\n"
@@ -11184,7 +11184,7 @@ class TestOther : public TestFixture {
               "    BitmapBuffer aDstBuf;\n"
               "    aSrcBuf.mnBitCount = nDestBits;\n"
               "    bConverted = ::ImplFastBitmapConversion( aDstBuf, aSrcBuf, aTwoRects );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:24] -> [test.cpp:5:24]: (style) Variable 'aSrcBuf.mnBitCount' is reassigned a value before the old one has been used. [redundantAssignment]\n",
                       errout_str());
 
@@ -11193,7 +11193,7 @@ class TestOther : public TestFixture {
               "    C c;\n"
               "    c = x;\n"
               "    c = x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7] -> [test.cpp:5:7]: (style, inconclusive) Variable 'c' is reassigned a value before the old one has been used if variable is no semaphore variable. [redundantAssignment]\n", errout_str());
     }
 
@@ -11207,7 +11207,7 @@ class TestOther : public TestFixture {
               "    m->prev->next = m->next;\n"
               "    m->next->prev = m->prev;\n"
               "    return m->next;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -11221,7 +11221,7 @@ class TestOther : public TestFixture {
               "    x = 6;\n"
               "    f();\n"
               "    return y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #10228
@@ -11241,7 +11241,7 @@ class TestOther : public TestFixture {
               "    for (i = 0; i < 4; i++)\n"
               "        buf[i] = 131;\n"
               "    buf[i] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void bar() {\n" // #9262 do-while with break
@@ -11251,20 +11251,20 @@ class TestOther : public TestFixture {
               "        if (foo()) break;\n"
               "        x = 1;\n"
               "     } while (false);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int num) {\n" // #9420 FP
               "  int a = num;\n"
               "  for (int b = 0; b < num; a = b++)\n"
               "    dostuff(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(int num) {\n" // #9420 FN
               "  int a = num;\n"
               "  for (int b = 0; b < num; a = b++);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
@@ -11277,7 +11277,7 @@ class TestOther : public TestFixture {
               "        break;\n"
               "    }\n"
               "    ret = 3;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:13] -> [test.cpp:8:9]: (style) Variable 'ret' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
     }
 
@@ -11287,7 +11287,7 @@ class TestOther : public TestFixture {
               "    *x = 23;\n"
               "    foo(ptr);\n"
               "    *x = 32;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8997
@@ -11297,7 +11297,7 @@ class TestOther : public TestFixture {
               "  *p = 1;\n"
               "  p += 1;\n"
               "  *p = 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -11306,7 +11306,7 @@ class TestOther : public TestFixture {
               "    *p = 1;\n"
               "    if (condition) return;\n"
               "    *p = 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -11318,7 +11318,7 @@ class TestOther : public TestFixture {
               "    i += 2;\n"
               "    arr[i] = 3;\n"
               "    dostuff(arr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -11332,9 +11332,9 @@ class TestOther : public TestFixture {
               "        if (b) break;\n"
               "        ret = 1;\n"
               "        break;\n"
-              "    }"
+              "    }\n"
               "    return ret;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int a, int b) {\n"
@@ -11345,8 +11345,8 @@ class TestOther : public TestFixture {
               "        if (b) break;\n"
               "        ret = 1;\n"
               "        break;\n"
-              "    }"
-              "}");
+              "    }\n"
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:13] -> [test.cpp:7:13]: (style) Variable 'ret' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
     }
 
@@ -11356,7 +11356,7 @@ class TestOther : public TestFixture {
         check("void f() {\n"
               "    int err = -ENOMEM;\n"
               "    err = dostuff();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: style: Redundant initialization for 'err'. The initialized value is overwritten before it is read. [redundantInitialization]\n"
                       "[test.cpp:2:13]: note: err is initialized\n"
                       "[test.cpp:3:9]: note: err is overwritten\n",
@@ -11365,7 +11365,7 @@ class TestOther : public TestFixture {
         check("void f() {\n"
               "    struct S s = {1,2,3};\n"
               "    s = dostuff();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: style: Redundant initialization for 's'. The initialized value is overwritten before it is read. [redundantInitialization]\n"
                       "[test.cpp:2:16]: note: s is initialized\n"
                       "[test.cpp:3:7]: note: s is overwritten\n",
@@ -11374,7 +11374,7 @@ class TestOther : public TestFixture {
         check("void f() {\n"
               "    int *p = NULL;\n"
               "    p = dostuff();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:10]: style: Variable 'p' can be declared as pointer to const [constVariablePointer]\n",
             errout_str());
@@ -11383,14 +11383,14 @@ class TestOther : public TestFixture {
         check("void f() {\n"
               "    struct S s = {0};\n"
               "    s = dostuff();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("namespace N { enum E {e0,e1}; }\n"
               "void f() {\n"
               "    N::E e = N::e0;\n" // #9261
               "    e = dostuff();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #10143
@@ -11415,21 +11415,21 @@ class TestOther : public TestFixture {
               "    char a[10];\n"
               "    memcpy(a, foo, bar);\n"
               "    memset(a, 0, bar);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout_str());
 
         check("void f() {\n"
               "    char a[10];\n"
               "    strcpy(a, foo);\n"
               "    strncpy(a, 0, bar);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout_str());
 
         check("void f() {\n"
               "    char a[10];\n"
               "    sprintf(a, \"foo\");\n"
               "    memmove(a, 0, bar);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout_str());
 
         check("void f(char *filename) {\n"
@@ -11437,14 +11437,14 @@ class TestOther : public TestFixture {
               "    strcpy(p, \"foo\");\n"
               "    dostuff(filename);\n"
               "    strcpy(p, \"foo\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Writing to different parts of a buffer
         check("void f(void* a) {\n"
               "    memcpy(a, foo, bar);\n"
               "    memset(a+5, 0, bar);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Use variable as second argument
@@ -11452,7 +11452,7 @@ class TestOther : public TestFixture {
               "    memset(a, 0, 5);\n"
               "    memcpy(b, a, 5);\n"
               "    memset(a, 1, 5);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // strcat is special
@@ -11461,7 +11461,7 @@ class TestOther : public TestFixture {
               "    strcpy(a, foo);\n"
               "    strcat(a, bar);\n" // Not redundant
               "    strcpy(a, x);\n" // Redundant
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout_str());
 
         // Tests with function call between copy
@@ -11470,7 +11470,7 @@ class TestOther : public TestFixture {
               "    snprintf(a, foo, bar);\n"
               "    bar();\n"
               "    memset(a, 0, size);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout_str());
 
         check("void* a;\n"
@@ -11478,7 +11478,7 @@ class TestOther : public TestFixture {
               "    memset(a, 0, size);\n"
               "    bar();\n" // Global variable might be accessed in bar()
               "    memset(a, 0, size);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -11486,7 +11486,7 @@ class TestOther : public TestFixture {
               "    memset(a, 0, size);\n"
               "    bar();\n"
               "    memset(a, 0, size);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (performance) Buffer 'a' is being written before its old content has been used.\n", "", errout_str());
 
         check("void bar(void* a) {}\n"
@@ -11494,7 +11494,7 @@ class TestOther : public TestFixture {
               "    memset(a, 0, size);\n"
               "    bar(a);\n" // Passed as argument
               "    memset(a, 0, size);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Branch tests
@@ -11502,7 +11502,7 @@ class TestOther : public TestFixture {
               "    memset(a, 0, size);\n"
               "    if(x)\n"
               "        memset(a, 0, size);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4455 - initialization of local buffer
@@ -11510,14 +11510,14 @@ class TestOther : public TestFixture {
               "    char buf[10];\n"
               "    memset(buf, 0, 10);\n"
               "    strcpy(buf, string);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(void) {\n"
               "    char buf[10] = {0};\n"
               "    memset(buf, 0, 10);\n"
               "    strcpy(buf, string);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (performance) Buffer 'buf' is being written before its old content has been used.\n", errout_str());
 
         // #5689 - use return value of strcpy
@@ -11525,7 +11525,7 @@ class TestOther : public TestFixture {
               "    int i = atoi(strcpy(a, foo));\n"
               "    strncpy(a, 0, bar);\n"
               "    return i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7175 - read+write
@@ -11534,7 +11534,7 @@ class TestOther : public TestFixture {
               "    strcpy(buf, x);\n"
               "    strcpy(buf, dostuff(buf));\n" // <- read + write
               "    strcpy(buf, x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -11542,7 +11542,7 @@ class TestOther : public TestFixture {
               "    strcpy(buf, x);\n"
               "    strcpy(buf, dostuff(buf));\n"
               "    strcpy(buf, x);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
@@ -11612,17 +11612,17 @@ class TestOther : public TestFixture {
 
     void varFuncNullUB() { // #4482
         check("void a(...);\n"
-              "void b() { a(NULL); }");
+              "void b() { a(NULL); }\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (portability) Passing NULL after the last typed argument to a variadic function leads to undefined behaviour. [varFuncNullUB]\n", errout_str());
 
         check("void a(char *p, ...);\n"
-              "void b() { a(NULL, 2); }");
+              "void b() { a(NULL, 2); }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkP("extern const int sentinel;\n"
                "void a(int, ...);\n"
                "#define b(x, ...) a((x), __VA_ARGS__, &sentinel)\n"
-               "void c() { b(1, NULL); }");
+               "void c() { b(1, NULL); }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -11636,7 +11636,7 @@ class TestOther : public TestFixture {
               "    bar(c);\n"
               "    c = getchar();\n"
               "  } ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (warning) Storing getchar() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f() {\n"
@@ -11645,7 +11645,7 @@ class TestOther : public TestFixture {
               "  {\n"
               "    bar(c);\n"
               "  } ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (warning) Storing getchar() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f() {\n"
@@ -11655,7 +11655,7 @@ class TestOther : public TestFixture {
               "    bar(c);\n"
               "    c = getchar();\n"
               "  } ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (warning) Storing getchar() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f() {\n"
@@ -11663,7 +11663,7 @@ class TestOther : public TestFixture {
               "  while( EOF != ( c = getchar() ) )\n"
               "  {\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (warning) Storing getchar() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f() {\n"
@@ -11673,7 +11673,7 @@ class TestOther : public TestFixture {
               "    bar(i);\n"
               "    i = getchar();\n"
               "  } ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -11683,7 +11683,7 @@ class TestOther : public TestFixture {
               "    bar(i);\n"
               "    i = getchar();\n"
               "  } ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -11693,7 +11693,7 @@ class TestOther : public TestFixture {
               "do {\n"
               "  c = getc (pFile);\n"
               "} while (c != EOF);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (warning) Storing getc() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f (FILE * pFile){\n"
@@ -11701,7 +11701,7 @@ class TestOther : public TestFixture {
               "do {\n"
               "  c = getc (pFile);\n"
               "} while (EOF != c);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:17]: (warning) Storing getc() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f (FILE * pFile){\n"
@@ -11709,7 +11709,7 @@ class TestOther : public TestFixture {
               "do {\n"
               "  i = getc (pFile);\n"
               "} while (i != EOF);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f (FILE * pFile){\n"
@@ -11717,7 +11717,7 @@ class TestOther : public TestFixture {
               "do {\n"
               "  i = getc (pFile);\n"
               "} while (EOF != i);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -11727,7 +11727,7 @@ class TestOther : public TestFixture {
               "do {\n"
               "  c = fgetc (pFile);\n"
               "} while (c != EOF);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (warning) Storing fgetc() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f (FILE * pFile){\n"
@@ -11735,7 +11735,7 @@ class TestOther : public TestFixture {
               "do {\n"
               "  c = fgetc (pFile);\n"
               "} while (EOF != c);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:17]: (warning) Storing fgetc() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f (FILE * pFile){\n"
@@ -11743,7 +11743,7 @@ class TestOther : public TestFixture {
               "do {\n"
               "  c = fgetc (pFile);\n"
               "} while (EOF != c);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f (FILE * pFile){\n"
@@ -11751,7 +11751,7 @@ class TestOther : public TestFixture {
               "do {\n"
               "  i = fgetc (pFile);\n"
               "} while (i != EOF);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f (FILE * pFile){\n"
@@ -11759,7 +11759,7 @@ class TestOther : public TestFixture {
               "do {\n"
               "  i = fgetc (pFile);\n"
               "} while (EOF != i);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // cin.get()
@@ -11769,7 +11769,7 @@ class TestOther : public TestFixture {
               "        std::cout << ch;\n"
               "        ch = std::cin.get();\n"
               "   }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:18]: (warning) Storing cin.get() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f(){\n"
@@ -11778,7 +11778,7 @@ class TestOther : public TestFixture {
               "        std::cout << ch;\n"
               "        ch = std::cin.get();\n"
               "   }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (warning) Storing cin.get() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f(){\n"
@@ -11787,7 +11787,7 @@ class TestOther : public TestFixture {
               "        std::cout << i;\n"
               "        i = std::cin.get();\n"
               "   }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(){\n"
@@ -11796,7 +11796,7 @@ class TestOther : public TestFixture {
               "        std::cout << i;\n"
               "        i = std::cin.get();\n"
               "   }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -11805,32 +11805,32 @@ class TestOther : public TestFixture {
               "  if (a < 0)\n"
               "    return a++,\n"
               "  do_something();\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Comma is used in return statement. The comma can easily be misread as a ';'.\n", "", errout_str());
 
         check("int fun(int a) {\n"
               "  if (a < 0)\n"
               "    return a++, do_something();\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("int fun(int a) {\n"
               "  if (a < 0)\n"
               "    return a+5,\n"
               "  do_something();\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Comma is used in return statement. The comma can easily be misread as a ';'.\n", "", errout_str());
 
         check("int fun(int a) {\n"
               "  if (a < 0)\n"
               "    return a+5, do_something();\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("int fun(int a) {\n"
               "  if (a < 0)\n"
               "    return c<int,\nint>::b;\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         // #4943 take care of C++11 initializer lists
@@ -11841,7 +11841,7 @@ class TestOther : public TestFixture {
               "        { \"2\" },\n"
               "        { \"3\" }\n"
               "    };\n"
-              "}", dinit(CheckOptions, $.inconclusive = false));
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -11857,7 +11857,7 @@ class TestOther : public TestFixture {
               "    explicit B(A a) : a(std::move(a)) {}\n"
               "    void Init(A _a) { a = std::move(_a); }\n"
               "    A a;"
-              "};", dinit(CheckOptions, $.inconclusive = false));
+              "};\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("struct A\n"
@@ -11870,7 +11870,7 @@ class TestOther : public TestFixture {
               "    explicit B(A a) : a{std::move(a)} {}\n"
               "    void Init(A _a) { a = std::move(_a); }\n"
               "    A a;"
-              "};", dinit(CheckOptions, $.inconclusive = false));
+              "};\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("struct A\n"
@@ -11884,7 +11884,7 @@ class TestOther : public TestFixture {
               "    void Init(A _a) { a = std::move(_a); }\n"
               "    A a;"
               "    A a2;"
-              "};", dinit(CheckOptions, $.inconclusive = false));
+              "};\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
 
         check("struct A\n"
@@ -11898,7 +11898,7 @@ class TestOther : public TestFixture {
               "    void Init(A _a) { a = std::move(_a); }\n"
               "    A a;"
               "    A a2;"
-              "};", dinit(CheckOptions, $.inconclusive = false));
+              "};\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:8:14]: (performance) Function parameter 'a2' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("struct A\n"
@@ -11912,11 +11912,11 @@ class TestOther : public TestFixture {
               "    void Init(A _a) { a = std::move(_a); }\n"
               "    A a;"
               "    A a2;"
-              "};", dinit(CheckOptions, $.inconclusive = false));
+              "};\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("[test.cpp:8:14]: (performance) Function parameter 'a2' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("std::map<int, int> m;\n" // #10817
-              "void f(const decltype(m)::const_iterator i) {}");
+              "void f(const decltype(m)::const_iterator i) {}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int (*pf) (std::vector<int>) = nullptr;\n" // #12118
@@ -11959,7 +11959,7 @@ class TestOther : public TestFixture {
               "};\n"
               "T f(T t) {\n"
               "    return t;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // don't crash
 
         Settings settingsUnix32 = settingsBuilder().platform(Platform::Type::Unix32).build();
@@ -11976,33 +11976,33 @@ class TestOther : public TestFixture {
         // positive test
         check("bool f(int x){\n"
               "   return isless(x,x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of two identical variables with isless(x,x) always evaluates to false. [comparisonFunctionIsAlwaysTrueOrFalse]\n", errout_str());
 
         check("bool f(int x){\n"
               "   return isgreater(x,x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of two identical variables with isgreater(x,x) always evaluates to false. [comparisonFunctionIsAlwaysTrueOrFalse]\n", errout_str());
 
         check("bool f(int x){\n"
               "   return islessgreater(x,x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of two identical variables with islessgreater(x,x) always evaluates to false. [comparisonFunctionIsAlwaysTrueOrFalse]\n", errout_str());
 
         check("bool f(int x){\n"
               "   return islessequal(x,x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of two identical variables with islessequal(x,x) always evaluates to true. [comparisonFunctionIsAlwaysTrueOrFalse]\n", errout_str());
 
         check("bool f(int x){\n"
               "   return isgreaterequal(x,x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of two identical variables with isgreaterequal(x,x) always evaluates to true. [comparisonFunctionIsAlwaysTrueOrFalse]\n", errout_str());
 
         // no warning should be reported for
         check("bool f(int x, int y){\n"
               "   return isgreaterequal(x,y) && islessequal(x,y) && islessgreater(x,y) && isgreater(x,y) && isless(x,y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -12010,7 +12010,7 @@ class TestOther : public TestFixture {
         // no signed integer overflow should happen
         check("void f(unsigned long long ull) {\n"
               "    if (ull == 0x89504e470d0a1a0a || ull == 0x8a4d4e470d0a1a0a) ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -12105,7 +12105,7 @@ class TestOther : public TestFixture {
     void test_isSameExpression() { // see #5738
         check("bool isInUnoIncludeFile(StringRef name) {"
               "   return  name.startswith(SRCDIR \"/com/\") || name.startswith(SRCDIR \"/uno/\");\n"
-              "};", dinit(CheckOptions, $.inconclusive = false));
+              "};\n", dinit(CheckOptions, $.inconclusive = false));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -12114,7 +12114,7 @@ class TestOther : public TestFixture {
                                   "    int counter = 0;\n"
                                   "    InterlockedDecrement(&counter);\n"
                                   "    whatever();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12123,7 +12123,7 @@ class TestOther : public TestFixture {
                                   "    if (counter)\n"
                                   "        return;\n"
                                   "    destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12131,7 +12131,7 @@ class TestOther : public TestFixture {
                                   "    InterlockedDecrement(&counter);\n"
                                   "    if (!counter)\n"
                                   "        destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12140,7 +12140,7 @@ class TestOther : public TestFixture {
                                   "    if (counter > 0)\n"
                                   "        return;\n"
                                   "    destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12149,7 +12149,7 @@ class TestOther : public TestFixture {
                                   "    if (0 < counter)\n"
                                   "        return;\n"
                                   "    destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12157,7 +12157,7 @@ class TestOther : public TestFixture {
                                   "    InterlockedDecrement(&counter);\n"
                                   "    if (counter == 0)\n"
                                   "        destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12165,7 +12165,7 @@ class TestOther : public TestFixture {
                                   "    InterlockedDecrement(&counter);\n"
                                   "    if (0 == counter)\n"
                                   "        destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12174,7 +12174,7 @@ class TestOther : public TestFixture {
                                   "    if (0 != counter)\n"
                                   "        return;\n"
                                   "    destroy()\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12183,7 +12183,7 @@ class TestOther : public TestFixture {
                                   "    if (counter != 0)\n"
                                   "        return;\n"
                                   "    destroy()\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12191,7 +12191,7 @@ class TestOther : public TestFixture {
                                   "    InterlockedDecrement(&counter);\n"
                                   "    if (counter <= 0)\n"
                                   "        destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12199,7 +12199,7 @@ class TestOther : public TestFixture {
                                   "    InterlockedDecrement(&counter);\n"
                                   "    if (0 >= counter)\n"
                                   "        destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12208,7 +12208,7 @@ class TestOther : public TestFixture {
                                   "    if (newCount)\n"
                                   "        return;\n"
                                   "    destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12216,7 +12216,7 @@ class TestOther : public TestFixture {
                                   "    int newCount = InterlockedDecrement(&counter);\n"
                                   "    if (!newCount)\n"
                                   "        destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12225,7 +12225,7 @@ class TestOther : public TestFixture {
                                   "    if (newCount > 0)\n"
                                   "        return;\n"
                                   "    destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12234,7 +12234,7 @@ class TestOther : public TestFixture {
                                   "    if (0 < newCount)\n"
                                   "        return;\n"
                                   "    destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12242,7 +12242,7 @@ class TestOther : public TestFixture {
                                   "    int newCount = InterlockedDecrement(&counter);\n"
                                   "    if (newCount == 0)\n"
                                   "        destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12250,7 +12250,7 @@ class TestOther : public TestFixture {
                                   "    int newCount = InterlockedDecrement(&counter);\n"
                                   "    if (0 == newCount)\n"
                                   "        destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12259,7 +12259,7 @@ class TestOther : public TestFixture {
                                   "    if (0 != newCount)\n"
                                   "        return;\n"
                                   "    destroy()\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12268,7 +12268,7 @@ class TestOther : public TestFixture {
                                   "    if (newCount != 0)\n"
                                   "        return;\n"
                                   "    destroy()\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12276,7 +12276,7 @@ class TestOther : public TestFixture {
                                   "    int newCount = InterlockedDecrement(&counter);\n"
                                   "    if (newCount <= 0)\n"
                                   "        destroy();\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
@@ -12284,7 +12284,7 @@ class TestOther : public TestFixture {
                                   "    int newCount = InterlockedDecrement(&counter);\n"
                                   "    if (0 >= newCount)\n"
                                   "        destroy;\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("int f() {\n"
@@ -12295,7 +12295,7 @@ class TestOther : public TestFixture {
                                   "    } else {\n"
                                   "        return counter;\n"
                                   "    }\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:7:16]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("int f() {\n"
@@ -12306,7 +12306,7 @@ class TestOther : public TestFixture {
                                   "    } else {\n"
                                   "        return counter;\n"
                                   "    }\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:7:16]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
 
@@ -12317,7 +12317,7 @@ class TestOther : public TestFixture {
                                   "        return 0;\n"
                                   "    }\n"
                                   "    return counter;\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:7:12]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("int f() {\n"
@@ -12327,7 +12327,7 @@ class TestOther : public TestFixture {
                                   "        return 0;\n"
                                   "    }\n"
                                   "    return counter;\n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:7:12]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("int f() {\n"
@@ -12338,7 +12338,7 @@ class TestOther : public TestFixture {
                                   "    } else\n"
                                   "        return counter;\n"
                                   "   \n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:7:16]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("int f() {\n"
@@ -12349,21 +12349,21 @@ class TestOther : public TestFixture {
                                   "    } else\n"
                                   "        return counter;\n"
                                   "   \n"
-                                  "}");
+                                  "}\n");
         ASSERT_EQUALS("[test.cpp:7:16]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
     }
 
     void testUnusedLabel() {
         check("void f() {\n"
               "    label:\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (style) Label 'label' is not used. [unusedLabel]\n", errout_str());
 
         check("void f() {\n"
               "    label:\n"
               "    foo();\n"
               "    goto label;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -12373,28 +12373,28 @@ class TestOther : public TestFixture {
               "}\n"
               "void g() {\n"
               "    label:\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (style) Label 'label' is not used. [unusedLabel]\n", errout_str());
 
         check("void f() {\n"
               "    switch(a) {\n"
               "        default:\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    class X {\n"
               "        protected:\n"
               "    };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    class X {\n"
               "        my_protected:\n"
               "    };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int test(char art) {\n"
@@ -12406,7 +12406,7 @@ class TestOther : public TestFixture {
               "    case 2:\n"
               "        return 2;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) Label 'caseZERO' is not used. Should this be a 'case' of the enclosing switch()? [unusedLabelSwitch]\n"
                       "[test.cpp:5:5]: (warning) Label 'case1' is not used. Should this be a 'case' of the enclosing switch()? [unusedLabelSwitch]\n", errout_str());
 
@@ -12416,7 +12416,7 @@ class TestOther : public TestFixture {
               "        return 2;\n"
               "    }\n"
               "    label:\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (style) Label 'label' is not used. [unusedLabel]\n", errout_str());
     }
 
@@ -12427,7 +12427,7 @@ class TestOther : public TestFixture {
                "    goto END;\n"
                "#endif\n"
                "END:\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("[test.cpp:5:1]: (style) Label 'END' is not used. There is #if in function body so the label might be used in code that is removed by the preprocessor. [unusedLabelConfiguration]\n",
                       errout_str());
     }
@@ -12445,7 +12445,7 @@ class TestOther : public TestFixture {
                "    END:\n"
                "        return;\n"
                "    }\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("[test.cpp:10:5]: (warning) Label 'END' is not used. There is #if in function body so the label might be used in code that is removed by the preprocessor. Should this be a 'case' of the enclosing switch()? [unusedLabelSwitchConfiguration]\n",
                       errout_str());
     }
@@ -12454,12 +12454,12 @@ class TestOther : public TestFixture {
         Settings s;
         check("void f() {\n"
               "    label:\n"
-              "}", dinit(CheckOptions, $.settings = &s));
+              "}\n", dinit(CheckOptions, $.settings = &s));
         ASSERT_EQUALS("", errout_str());
         s.premiumArgs = "--premium=misra-c-2012"; // <- activates unusedLabel checking
         check("void f() {\n"
               "    label:\n"
-              "}", dinit(CheckOptions, $.settings = &s));
+              "}\n", dinit(CheckOptions, $.settings = &s));
         ASSERT_EQUALS("[test.cpp:2:5]: (style) Label 'label' is not used. [unusedLabel]\n", errout_str());
     }
 
@@ -12479,24 +12479,24 @@ class TestOther : public TestFixture {
         check("void f() {\n"
               "  int x = dostuff();\n"
               "  return x + x++;\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:3:12]: (error) Expression 'x+x++' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
 
         // #7226
         check("long int f1(const char *exp) {\n"
               "  return strtol(++exp, (char **)&exp, 10);\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         check("long int f1(const char *exp) {\n"
               "  return dostuff(++exp, exp, 10);\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:2:23]: (error) Expression '++exp,exp' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
 
         check("void f() {\n"
               "  int a;\n"
               "  while (a=x(), a==123) {}\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         // # 8717
@@ -12521,25 +12521,25 @@ class TestOther : public TestFixture {
 
         check("void f(int i) {\n"
               "  int n = ++i + i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (error) Expression '++i+i' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
 
         check("long int f1(const char *exp) {\n"
               "  return dostuff(++exp, ++exp, 10);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:23]: (portability) Expression '++exp,++exp' depends on order of evaluation of side effects. Behavior is Unspecified according to c++17 [unknownEvaluationOrder]\n"
                       "[test.cpp:2:23]: (portability) Expression '++exp,++exp' depends on order of evaluation of side effects. Behavior is Unspecified according to c++17 [unknownEvaluationOrder]\n", errout_str());
 
         check("void f(int i) {\n"
               "  int n = (~(-(++i)) + i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (error) Expression '~(-(++i))+i' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
 
         const Settings settings11 = settingsBuilder(settings0).cpp(Standards::CPP11).certainty(Certainty::inconclusive).build();
 
         checkCustomSettings("void f(int i) {\n"
                             "  i = i++ + 2;\n"
-                            "}", settings11);
+                            "}\n", settings11);
         ASSERT_EQUALS("[test.cpp:2:11]: (error) Expression 'i+++2' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
 
         // #14431
@@ -12553,7 +12553,7 @@ class TestOther : public TestFixture {
         // self assignment
         check("void f() {\n"
               "  int x = x = y + 1;\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS(
             "[test.c:2:9]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n"
             "[test.c:2:9]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n",   // duplicate
@@ -12565,7 +12565,7 @@ class TestOther : public TestFixture {
         checkP("#define X x\n"
                "void f(int x) {\n"
                "  return x + X++;\n"
-               "}", dinit(CheckPOptions, $.cpp = false));
+               "}\n", dinit(CheckPOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:3:12]: (error) Expression 'x+x++' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
     }
 
@@ -12573,13 +12573,13 @@ class TestOther : public TestFixture {
         // FP
         check("void f(int id) {\n"
               "  id = dostuff(id += 42);\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         // FN
         check("void f(int id) {\n"
               "  id = id + dostuff(id += 42);\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
@@ -12587,19 +12587,19 @@ class TestOther : public TestFixture {
         check("int f(void) {\n"
               "  int t;\n"
               "  return (unsigned char)(t=1,t^c);\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         check("void f(void) {\n"
               "  int t;\n"
               "  dostuff(t=1,t^c);\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:3:14]: (error) Expression 't=1,t^c' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
 
         check("void f(void) {\n"
               "  int t;\n"
               "  dostuff((t=1,t),2);\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         // #8230
@@ -12628,7 +12628,7 @@ class TestOther : public TestFixture {
     void testEvaluationOrderSizeof() {
         check("void f(char *buf) {\n"
               "  dostuff(buf++, sizeof(*buf));"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -12647,7 +12647,7 @@ class TestOther : public TestFixture {
               "  if (0 > d.n) {\n"
               "    return;\n"
               "  }\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:8:11]: (style) Checking if unsigned expression 'd.n' is less than zero. [unsignedLessThanZero]\n"
                       "[test.c:12:9]: (style) Checking if unsigned expression 'd.n' is less than zero. [unsignedLessThanZero]\n",
                       errout_str());
@@ -12659,7 +12659,7 @@ class TestOther : public TestFixture {
               "    A a;\n"
               "    g(std::move(a));\n"
               "    g(std::move(a));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:17]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
@@ -12673,7 +12673,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    B b1;\n"
               "    B b2;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:6:24]: (warning) Access of moved variable 'b'. [accessMoved]\n", errout_str());
     }
 
@@ -12686,7 +12686,7 @@ class TestOther : public TestFixture {
               "    {}\n"
               "    B b1;\n"
               "    B b2;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:19]: (warning) Access of moved variable 'b'. [accessMoved]\n", errout_str());
     }
 
@@ -12717,7 +12717,7 @@ class TestOther : public TestFixture {
               "    A a;\n"
               "    a = g(std::move(a));\n"
               "    a = g(std::move(a));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -12727,7 +12727,7 @@ class TestOther : public TestFixture {
               "    A a;\n"
               "    B b = g(std::move(a));\n"
               "    C c = g(std::move(a));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:23]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
@@ -12743,7 +12743,7 @@ class TestOther : public TestFixture {
               "    h(a);\n"
               "    a = b;\n"
               "    h(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (warning) Access of moved variable 'a'. [accessMoved]\n"
                       "[test.cpp:8:7]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
@@ -12754,7 +12754,7 @@ class TestOther : public TestFixture {
               "    A a;\n"
               "    a.reset(g(std::move(a)));\n"
               "    a.reset(g(std::move(a)));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -12766,7 +12766,7 @@ class TestOther : public TestFixture {
               "    A c;\n"
               "    b.reset(g(std::move(a)));\n"
               "    c.reset(g(std::move(a)));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:25]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
@@ -12782,7 +12782,7 @@ class TestOther : public TestFixture {
               "    h(a);\n"
               "    a.reset(b);\n"
               "    h(a);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (warning) Access of moved variable 'a'. [accessMoved]\n"
                       "[test.cpp:8:7]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
@@ -12794,7 +12794,7 @@ class TestOther : public TestFixture {
               "    A b = std::move(a);\n"
               "    g(a);\n"
               "    A c = a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:7]: (warning) Access of moved variable 'a'. [accessMoved]\n"
                       "[test.cpp:6:11]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
@@ -12806,7 +12806,7 @@ class TestOther : public TestFixture {
               "    A b = std::move(a);\n"
               "    g(a);\n"
               "    A c = a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -12817,7 +12817,7 @@ class TestOther : public TestFixture {
               "    A b = std::move(a);\n"
               "    g(a);\n"
               "    A c = a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:7]: (warning) Access of moved variable 'a'. [accessMoved]\n"
                       "[test.cpp:6:11]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
@@ -12828,7 +12828,7 @@ class TestOther : public TestFixture {
               "    A b = std::move(a);\n"
               "    g(a);\n"
               "    A c = a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (warning, inconclusive) Access of moved variable 'a'. [accessMoved]\n"
                       "[test.cpp:5:11]: (warning, inconclusive) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
@@ -12841,7 +12841,7 @@ class TestOther : public TestFixture {
               "    if (i)\n"
               "        return g(std::move(b));\n"
               "    return h(std::move(a),std::move(b));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:24]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
@@ -12851,7 +12851,7 @@ class TestOther : public TestFixture {
               "    g(std::move(v));\n"
               "    v.clear();\n"
               "    if (v.empty()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -12861,7 +12861,7 @@ class TestOther : public TestFixture {
               "    g(std::move(p));\n"
               "    x = p->x;\n"
               "    y = p->y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (warning) Access of moved variable 'p'. [accessMoved]\n"
                       "[test.cpp:5:9]: (warning) Access of moved variable 'p'. [accessMoved]\n", errout_str());
     }
@@ -12871,7 +12871,7 @@ class TestOther : public TestFixture {
               "    std::string s1 = x;\n"
               "    std::string s2 = std::move(s1);\n"
               "    p = &s1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -12880,16 +12880,16 @@ class TestOther : public TestFixture {
               "    A a;\n"
               "    gx(std::move(a).x());\n"
               "    gy(std::move(a).y());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void moveAndLambda() {
         check("void f() {\n"
               "    A a;\n"
-              "    auto h = [a=std::move(a)](){return g(std::move(a));};"
+              "    auto h = [a=std::move(a)](){return g(std::move(a));};\n"
               "    b = a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -12960,7 +12960,7 @@ class TestOther : public TestFixture {
               "void f(T && t) {\n"
               "    g(std::forward<T>(t));\n"
               "    T s = t;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (warning) Access of forwarded variable 't'. [accessForwarded]\n", errout_str());
     }
 
@@ -13093,7 +13093,7 @@ class TestOther : public TestFixture {
               "void Fred::func1(int a, int b, int c) { }\n"
               "void Fred::func2(int A, int B, int C) { }\n"
               "void Fred::func3(int a, int b, int c) { }\n"
-              "void Fred::func4(int A, int B, int C) { }");
+              "void Fred::func4(int A, int B, int C) { }\n");
         ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:4:16]: (style, inconclusive) Function 'func2' argument 1 names different: declaration 'a' definition 'A'. [funcArgNamesDifferent]\n"
                       "[test.cpp:3:23] -> [test.cpp:4:23]: (style, inconclusive) Function 'func2' argument 2 names different: declaration 'b' definition 'B'. [funcArgNamesDifferent]\n"
                       "[test.cpp:3:30] -> [test.cpp:4:30]: (style, inconclusive) Function 'func2' argument 3 names different: declaration 'c' definition 'C'. [funcArgNamesDifferent]\n"
@@ -13170,49 +13170,49 @@ class TestOther : public TestFixture {
     // #7846 - Syntax error when using C++11 braced-initializer in default argument
     void cpp11FunctionArgInit() {
         // syntax error is not expected
-        ASSERT_NO_THROW(check("\n void foo(int declaration = {}) {"
+        ASSERT_NO_THROW(check("\n void foo(int declaration = {}) {\n"
                               "\n   for (int i = 0; i < 10; i++) {}\n"
-                              "\n }"
-                              "\n  "));
+                              "\n }\n"
+                              "\n"));
         ASSERT_EQUALS("", errout_str());
     }
 
     void shadowVariables() {
         check("int x;\n"
-              "void f() { int x; }");
+              "void f() { int x; }\n");
         ASSERT_EQUALS("[test.cpp:1:5] -> [test.cpp:2:16]: (style) Local variable 'x' shadows outer variable [shadowVariable]\n", errout_str());
 
         check("int x();\n"
-              "void f() { int x; }");
+              "void f() { int x; }\n");
         ASSERT_EQUALS("[test.cpp:1:5] -> [test.cpp:2:16]: (style) Local variable 'x' shadows outer function [shadowFunction]\n", errout_str());
 
         check("struct C {\n"
               "    C(int x) : x(x) {}\n" // <- we do not want a FP here
               "    int x;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  if (cond) {int x;}\n" // <- not a shadow variable
               "  int x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int size() {\n"
               "  int size;\n" // <- not a shadow variable
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #8954 - lambda
               "  int x;\n"
-              "  auto f = [](){ int x; }"
-              "}");
+              "  auto f = [](){ int x; }\n"
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void f(int x) { int x; }");
+        check("void f(int x) { int x; }\n");
         ASSERT_EQUALS("[test.cpp:1:12] -> [test.cpp:1:21]: (style) Local variable 'x' shadows outer argument [shadowArgument]\n", errout_str());
 
-        check("class C { C(); void foo() { static int C = 0; } }"); // #9195 - shadow constructor
+        check("class C { C(); void foo() { static int C = 0; } }\n"); // #9195 - shadow constructor
         ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n" // #10091 - shadow destructor
@@ -13221,7 +13221,7 @@ class TestOther : public TestFixture {
               "        bool C{};\n"
               "    }\n"
               "};\n"
-              "C::~C() = default;");
+              "C::~C() = default;\n");
         ASSERT_EQUALS("", errout_str());
 
         // 10752 - no
@@ -13232,7 +13232,7 @@ class TestOther : public TestFixture {
               "        int i = 0;\n"
               "        return i;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
@@ -13317,19 +13317,19 @@ class TestOther : public TestFixture {
         check("void g(int);\n"
               "void f(int x) {\n"
               "   g((x & 0x01) >> 7);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style) Argument '(x&0x01)>>7' to function g is always 0. It does not matter what value 'x' has. [knownArgument]\n", errout_str());
 
         check("void g(int);\n"
               "void f(int x) {\n"
               "   g((int)((x & 0x01) >> 7));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (style) Argument '(int)((x&0x01)>>7)' to function g is always 0. It does not matter what value 'x' has. [knownArgument]\n", errout_str());
 
         check("void g(int, int);\n"
               "void f(int x) {\n"
               "   g(x, (x & 0x01) >> 7);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:20]: (style) Argument '(x&0x01)>>7' to function g is always 0. It does not matter what value 'x' has. [knownArgument]\n",
             errout_str());
@@ -13337,65 +13337,65 @@ class TestOther : public TestFixture {
         check("void g(int);\n"
               "void f(int x) {\n"
               "    g(0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g(int);\n"
               "void h() { return 1; }\n"
               "void f(int x) {\n"
               "    g(h());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g(int);\n"
               "void f(int x) {\n"
               "    g(std::strlen(\"a\"));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g(int);\n"
               "void f(int x) {\n"
               "    g((int)0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g(Foo *);\n"
               "void f() {\n"
               "    g(reinterpret_cast<Foo*>(0));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g(int);\n"
               "void f(int x) {\n"
               "    x = 0;\n"
               "    g(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g(int);\n"
               "void f() {\n"
               "    const int x = 0;\n"
               "    g(x + 1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void g(int);\n"
               "void f() {\n"
               "    char i = 1;\n"
               "    g(static_cast<int>(i));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("char *yytext;\n"
               "void re_init_scanner() {\n"
               "  int size = 256;\n"
               "  yytext = xmalloc(size * sizeof *yytext);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(const char *c) {\n"
               "    if (*c == '+' && (operand || !isalnum(*c))) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8986
@@ -13403,14 +13403,14 @@ class TestOther : public TestFixture {
               "void g() {\n"
               "    const int x[] = { 10, 10 };\n"
               "    f(x[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int);\n"
               "void g() {\n"
               "    int x[] = { 10, 10 };\n"
               "    f(x[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Variable 'x' can be declared as const array [constVariable]\n", errout_str());
 
         check("struct A { int x; };"
@@ -13419,21 +13419,21 @@ class TestOther : public TestFixture {
               "    A y;\n"
               "    y.x = 1;\n"
               "    g(y.x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // allow known argument value in assert call
         check("void g(int);\n"
               "void f(int x) {\n"
               "   ASSERT((int)((x & 0x01) >> 7));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9905 - expression that does not use integer calculation at all
         check("void foo() {\n"
               "    const std::string heading = \"Interval\";\n"
               "    std::cout << std::setw(heading.length());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9909 - struct member with known value
@@ -13444,7 +13444,7 @@ class TestOther : public TestFixture {
               "void growLongStack(LongStack* self) {\n"
               "    self->maxsize = 32;\n"
               "    dostuff(self->maxsize * sizeof(intptr_t));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #11894
@@ -13539,7 +13539,7 @@ class TestOther : public TestFixture {
               "    bar(P, N); \n"
               "    if (c ? a : b)\n"
               "      baz(P, N); \n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -13552,7 +13552,7 @@ class TestOther : public TestFixture {
               "       diff = 1;\n"
               "    }\n"
               "    return diff;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:15] -> [test.cpp:5:8] -> [test.cpp:3:15] -> [test.cpp:5:14] -> [test.cpp:5:12]: (error) Comparing pointers that point to different objects [comparePointers]\n",
             errout_str());
@@ -13563,7 +13563,7 @@ class TestOther : public TestFixture {
               "    int* xp = &x;\n"
               "    int* yp = &y;\n"
               "    return xp > yp;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:9] -> [test.cpp:4:15] -> [test.cpp:3:9] -> [test.cpp:5:15] -> [test.cpp:6:15]: (error) Comparing pointers that point to different objects [comparePointers]\n"
             "[test.cpp:4:10]: (style) Variable 'xp' can be declared as pointer to const [constVariablePointer]\n"
@@ -13574,7 +13574,7 @@ class TestOther : public TestFixture {
               "    int x = 0;\n"
               "    int y = 1;\n"
               "    return &x > &y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:9] -> [test.cpp:4:12] -> [test.cpp:3:9] -> [test.cpp:4:17] -> [test.cpp:4:15]: (error) Comparing pointers that point to different objects [comparePointers]\n",
             errout_str());
@@ -13586,7 +13586,7 @@ class TestOther : public TestFixture {
               "    int* xp = &x.data;\n"
               "    int* yp = &y.data;\n"
               "    return xp > yp;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:7] -> [test.cpp:5:15] -> [test.cpp:4:7] -> [test.cpp:6:15] -> [test.cpp:7:15]: (error) Comparing pointers that point to different objects [comparePointers]\n"
             "[test.cpp:5:10]: (style) Variable 'xp' can be declared as pointer to const [constVariablePointer]\n"
@@ -13600,7 +13600,7 @@ class TestOther : public TestFixture {
               "    int* xp = &x->data;\n"
               "    int* yp = &y->data;\n"
               "    return xp > yp;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:10] -> [test.cpp:3:12] -> [test.cpp:5:15] -> [test.cpp:2:16] -> [test.cpp:4:12] -> [test.cpp:6:15] -> [test.cpp:7:15]: (error) Comparing pointers that point to different objects [comparePointers]\n"
             "[test.cpp:5:10]: (style) Variable 'xp' can be declared as pointer to const [constVariablePointer]\n"
@@ -13609,7 +13609,7 @@ class TestOther : public TestFixture {
 
         check("bool f(int * xp, int* yp) {\n"
               "    return &xp > &yp;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:1:14] -> [test.cpp:2:12] -> [test.cpp:1:23] -> [test.cpp:2:18] -> [test.cpp:2:16]: (error) Comparing pointers that point to different objects [comparePointers]\n",
             errout_str());
@@ -13618,7 +13618,7 @@ class TestOther : public TestFixture {
               "    int x = 0;\n"
               "    int y = 1;\n"
               "    return &x - &y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:9] -> [test.cpp:4:12] -> [test.cpp:3:9] -> [test.cpp:4:17] -> [test.cpp:4:15]: (error) Subtracting pointers that point to different objects [subtractPointers]\n",
             errout_str());
@@ -13628,19 +13628,19 @@ class TestOther : public TestFixture {
               "    int* xp = &x[0];\n"
               "    int* yp = &x[1];\n"
               "    return xp > yp;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) Variable 'xp' can be declared as pointer to const [constVariablePointer]\n"
                       "[test.cpp:4:10]: (style) Variable 'yp' can be declared as pointer to const [constVariablePointer]\n",
                       errout_str());
 
         check("bool f(const int * xp, const int* yp) {\n"
               "    return xp > yp;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f(const int & x, const int& y) {\n"
               "    return &x > &y;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int& g();\n"
@@ -13650,7 +13650,7 @@ class TestOther : public TestFixture {
               "    const int* xp = &x;\n"
               "    const int* yp = &y;\n"
               "    return xp > yp;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct A {int data;};\n"
@@ -13660,7 +13660,7 @@ class TestOther : public TestFixture {
               "    int* xp = &x->data;\n"
               "    int* yp = &y->data;\n"
               "    return xp > yp;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (style) Variable 'xp' can be declared as pointer to const [constVariablePointer]\n"
                       "[test.cpp:6:10]: (style) Variable 'yp' can be declared as pointer to const [constVariablePointer]\n",
                       errout_str());
@@ -13711,21 +13711,21 @@ class TestOther : public TestFixture {
               "            return A::Hash{}(a);\n"
               "        }\n"
               "    };\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void moduloOfOne() {
         check("void f(unsigned int x) {\n"
               "  int y = x % 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (style) Modulo of one is always equal to zero [moduloofone]\n", errout_str());
 
         check("void f() {\n"
               "  for (int x = 1; x < 10; x++) {\n"
               "    int y = 100 % x;\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int i, int j) {\n" // #11191
@@ -13758,44 +13758,44 @@ class TestOther : public TestFixture {
               "    union { int i; float f; } u;\n"
               "    u.i = 0;\n"
               "    u.i = u.f;\n" // <- error
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Overlapping read/write of union is undefined behavior [overlappingWriteUnion]\n", errout_str());
 
         check("void foo() {\n" // #11013
               "    union { struct { uint8_t a; uint8_t b; }; uint16_t c; } u;\n"
               "    u.a = u.b = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // memcpy
         check("void foo() {\n"
               "    char a[10];\n"
               "    memcpy(&a[5], &a[4], 2u);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
 
         check("void foo() {\n"
               "    char a[10];\n"
               "    memcpy(a+5, a+4, 2u);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
 
         check("void foo() {\n"
               "    char a[10];\n"
               "    memcpy(a, a+1, 2u);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
 
         check("void foo() {\n"
               "    char a[8];\n"
               "    memcpy(&a[0], &a[4], 4u);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("_Bool a[10];\n" // #10350
               "void foo() {\n"
               "    memcpy(&a[5], &a[4], 2u * sizeof(a[0]));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
 
         check("int K[2];\n" // #12638
@@ -13804,7 +13804,7 @@ class TestOther : public TestFixture {
               "    memcpy(&K[1], &K[0], sizeof(K[0]));\n"
               "    memcpy(p, p + 1, sizeof(*p));\n"
               "    memcpy(p + 1, p, sizeof(*p));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int K[2];\n"
@@ -13813,7 +13813,7 @@ class TestOther : public TestFixture {
               "    memcpy(&K[1], &K[0], 2 *sizeof(K[0]));\n"
               "    memcpy(p, p + 1, 2 * sizeof(*p));\n"
               "    memcpy(p + 1, p, 2 * sizeof(*p));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n"
                       "[test.cpp:4:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n"
                       "[test.cpp:5:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n"
@@ -13824,25 +13824,25 @@ class TestOther : public TestFixture {
         check("void foo() {\n"
               "    wchar_t a[10];\n"
               "    wmemcpy(&a[5], &a[4], 2u);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in wmemcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
 
         check("void foo() {\n"
               "    wchar_t a[10];\n"
               "    wmemcpy(a+5, a+4, 2u);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in wmemcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
 
         check("void foo() {\n"
               "    wchar_t a[10];\n"
               "    wmemcpy(a, a+1, 2u);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in wmemcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
 
         // strcpy
         check("void foo(char *ptr) {\n"
               "    strcpy(ptr, ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (error) Overlapping read/write in strcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
     }
 
@@ -13899,7 +13899,7 @@ class TestOther : public TestFixture {
               "}\n");
         ASSERT_EQUALS("[test.cpp:4:17]: (style) Pointer expression 'a.x' converted to bool is always true. [knownPointerToBool]\n", errout_str());
 
-        check("void f(bool* b) { if (b) *b = true; }");
+        check("void f(bool* b) { if (b) *b = true; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f() {\n"
@@ -13947,7 +13947,7 @@ class TestOther : public TestFixture {
               "void f() {\n"
               "    bool b[2] = {};\n"
               "    g(b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -14146,7 +14146,7 @@ class TestOther : public TestFixture {
             "  union bad_union_0 bad1 = {0};\n"
             "  e(&bad1);\n"
             "  bad_union_1 bad2 = {0};\n"
-            "}");
+            "}\n");
         const std::string exp = unionZeroInitMessage(20, 28, "bad0", "i") +
                                 unionZeroInitMessage(21, 21, "bad1", "i64") +
                                 unionZeroInitMessage(23, 15, "bad2", "i");
@@ -14157,7 +14157,7 @@ class TestOther : public TestFixture {
         check(
             "void foo(void) {\n"
             " union { int c; char s8[2]; } u = {0};\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -14173,7 +14173,7 @@ class TestOther : public TestFixture {
             "       } s1;\n"
             "    } s0;\n"
             "  } u = {0};\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -14181,7 +14181,7 @@ class TestOther : public TestFixture {
         check(
             "union u {\n"
             "  Unknown x;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -14201,7 +14201,7 @@ class TestOther : public TestFixture {
             "\n"
             "void foo(void) {\n"
             "  Evex evex = {0};\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 };
diff --git a/test/testpostfixoperator.cpp b/test/testpostfixoperator.cpp
index 2277039820f..85568c974ac 100644
--- a/test/testpostfixoperator.cpp
+++ b/test/testpostfixoperator.cpp
@@ -71,7 +71,7 @@ class TestPostfixOperator : public TestFixture {
               "    k--;\n"
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class K {};"
@@ -82,7 +82,7 @@ class TestPostfixOperator : public TestFixture {
               "    k++;\n"
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("struct K {};"
@@ -90,14 +90,14 @@ class TestPostfixOperator : public TestFixture {
               "{\n"
               "    K k(0);\n"
               "    k++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("struct K {};\n"
               "void foo(K& k)\n"
               "{\n"
               "    k++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("union K {};"
@@ -105,7 +105,7 @@ class TestPostfixOperator : public TestFixture {
               "{\n"
               "    K k(0);\n"
               "    k++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("class K {};"
@@ -118,7 +118,7 @@ class TestPostfixOperator : public TestFixture {
               "    }\n"
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:9]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("class K {};"
@@ -132,7 +132,7 @@ class TestPostfixOperator : public TestFixture {
               "    k++;\n"
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
 
@@ -144,7 +144,7 @@ class TestPostfixOperator : public TestFixture {
               "    k--;\n"
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("class K {};"
@@ -155,7 +155,7 @@ class TestPostfixOperator : public TestFixture {
               "    ++k;\n"
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class K {};"
@@ -166,7 +166,7 @@ class TestPostfixOperator : public TestFixture {
               "    --k;\n"
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #9042
@@ -177,7 +177,7 @@ class TestPostfixOperator : public TestFixture {
               "};\n"
               "template <class T>\n"
               "class s {};\n"
-              "using BOOL = char;");
+              "using BOOL = char;\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -188,7 +188,7 @@ class TestPostfixOperator : public TestFixture {
               "         std::cout << i << std::endl;\n"
               "    }\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class K {};\n"
@@ -198,7 +198,7 @@ class TestPostfixOperator : public TestFixture {
               "         std::cout << i << std::endl;\n"
               "    }\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:28]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("class K {};\n"
@@ -208,7 +208,7 @@ class TestPostfixOperator : public TestFixture {
               "         std::cout << i << std::endl;\n"
               "    }\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class K {};\n"
@@ -218,7 +218,7 @@ class TestPostfixOperator : public TestFixture {
               "         std::cout << i << std::endl;\n"
               "    }\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:27]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("class K {};\n"
@@ -228,7 +228,7 @@ class TestPostfixOperator : public TestFixture {
               "         std::cout << i << std::endl;\n"
               "    }\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::string &s) {\n" // #7731
@@ -246,7 +246,7 @@ class TestPostfixOperator : public TestFixture {
               "    k++;\n"
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
     }
 
@@ -261,7 +261,7 @@ class TestPostfixOperator : public TestFixture {
               "    }\n"
               "    v.clear();\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:64]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("int main() {\n"
@@ -275,7 +275,7 @@ class TestPostfixOperator : public TestFixture {
               "       it++;\n"
               "    }\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:8]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("int main() {\n"
@@ -288,7 +288,7 @@ class TestPostfixOperator : public TestFixture {
               "       it++;\n"
               "    }\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:8]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("int main() {\n"
@@ -302,14 +302,14 @@ class TestPostfixOperator : public TestFixture {
               "       rit--;\n"
               "    }\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:8]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
     }
 
     void test2168() {
         ASSERT_THROW_INTERNAL(check("--> declare allocator lock here\n"
-                                    "int main(){}"),
+                                    "int main(){}\n"),
                               AST);
     }
 
@@ -317,7 +317,7 @@ class TestPostfixOperator : public TestFixture {
         check("void f(int* p){\n"
               "    p++;\n"
               "    std::cout << *p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -327,7 +327,7 @@ class TestPostfixOperator : public TestFixture {
               "\n"
               "void f() {\n"
               "    p++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -335,7 +335,7 @@ class TestPostfixOperator : public TestFixture {
         check("bool foo() {\n"
               "    std::vector<FilterConfigCacheEntry>::iterator aIter(aImport.begin());\n"
               "    aIter++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
     }
 
@@ -344,14 +344,14 @@ class TestPostfixOperator : public TestFixture {
               "    class A {}; class B {A a;};\n"
               "    B b;\n"
               "    b.a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("bool foo() {\n"
               "    class A {}; class B {A a;};\n"
               "    B b;\n"
               "    foo(b.a++);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -360,7 +360,7 @@ class TestPostfixOperator : public TestFixture {
               "    class A {};\n"
               "    A a;\n"
               "    i++, a++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("bool foo(int i) {\n"
@@ -368,7 +368,7 @@ class TestPostfixOperator : public TestFixture {
               "    A a;\n"
               "    foo(i, a++);\n"
               "    foo(a++, i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -380,7 +380,7 @@ class TestPostfixOperator : public TestFixture {
               "        a += i;\n"
               "    }\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 };
diff --git a/test/testpreprocessor.cpp b/test/testpreprocessor.cpp
index 55fcafd4f4f..f1cffe50486 100644
--- a/test/testpreprocessor.cpp
+++ b/test/testpreprocessor.cpp
@@ -57,7 +57,7 @@ class TestPreprocessor : public TestFixture {
     std::string expandMacros_(const char* file, int line, const char (&code)[size], ErrorLogger &errorLogger) const {
         simplecpp::OutputList outputList;
         std::vector<std::string> files;
-        simplecpp::TokenList tokens1 = simplecpp::TokenList(code, files, "file.cpp", &outputList);
+        simplecpp::TokenList tokens1 = simplecpp::TokenList(code, files, "file.cpp", {}, &outputList);
         Preprocessor p(tokens1, settingsDefault, errorLogger, Path::identify(tokens1.getFiles()[0], false));
         ASSERT_LOC(p.loadFiles(files), file, line);
         simplecpp::TokenList tokens2 = p.preprocess("", files, outputList);
@@ -75,7 +75,7 @@ class TestPreprocessor : public TestFixture {
             throw std::runtime_error("token list not empty");
 
         simplecpp::OutputList outputList;
-        const simplecpp::TokenList tokens1(code, files, file0, &outputList);
+        const simplecpp::TokenList tokens1(code, files, file0, dui, &outputList);
 
         // Preprocess..
         simplecpp::TokenList tokens2(files);
@@ -124,7 +124,7 @@ class TestPreprocessor : public TestFixture {
         simplecpp::OutputList outputList;
         std::vector<std::string> files;
 
-        simplecpp::TokenList tokens({code, size}, files, Path::simplifyPath(filename), &outputList);
+        simplecpp::TokenList tokens({code, size}, files, Path::simplifyPath(filename), {}, &outputList);
 
         // TODO: we should be using the actual Preprocessor implementation
         Preprocessor preprocessor(tokens, settings, errorlogger, Path::identify(tokens.getFiles()[0], false));
@@ -399,7 +399,7 @@ class TestPreprocessor : public TestFixture {
             ASSERT(settings.library.load("", library, false).errorcode == Library::ErrorCode::OK);
         std::vector<std::string> files;
         simplecpp::OutputList outputList;
-        simplecpp::TokenList tokens(code,files,"test.c",&outputList);
+        simplecpp::TokenList tokens(code, files, "test.c", {}, &outputList);
         Preprocessor preprocessor(tokens, settings, *this, Standards::Language::C);
         std::set<std::string> configs = { "" };
         std::set<std::string> configDefines = { "__cplusplus" };
@@ -410,9 +410,11 @@ class TestPreprocessor : public TestFixture {
                        settings.library.defines().end(),
                        std::inserter(configDefines, configDefines.end()),
                        getDefineName);
-        preprocessor.setLoadCallback([&](simplecpp::FileData &data) {
-            Preprocessor::removeComments(data.tokens);
-            preprocessor.getConfigs(data.filename, data.tokens, configDefines, configs);
+        preprocessor.setLoadCallback([&](simplecpp::FileData &data, bool loaded) {
+            if (loaded) {
+                Preprocessor::removeComments(data.tokens);
+                preprocessor.getConfigs(data.filename, data.tokens, configDefines, configs);
+            }
         });
         preprocessor.removeComments();
         preprocessor.getConfigs(configDefines, configs);
@@ -429,8 +431,10 @@ class TestPreprocessor : public TestFixture {
         std::vector<std::string> files;
         simplecpp::TokenList tokens(code,files,"test.c");
         Preprocessor preprocessor(tokens, settingsDefault, *this, Standards::Language::C);
-        preprocessor.setLoadCallback([](simplecpp::FileData &data) {
-            Preprocessor::removeComments(data.tokens);
+        preprocessor.setLoadCallback([](simplecpp::FileData &data, bool loaded) {
+            if (loaded) {
+                Preprocessor::removeComments(data.tokens);
+            }
         });
         preprocessor.removeComments();
         ASSERT(preprocessor.loadFiles(files));
@@ -442,7 +446,7 @@ class TestPreprocessor : public TestFixture {
                                 "cpp\n"
                                 "#else\n"
                                 "c\n"
-                                "#endif";
+                                "#endif\n";
 
         {
             // Preprocess => actual result..
@@ -498,7 +502,7 @@ class TestPreprocessor : public TestFixture {
         {
             ScopedFile header("ab.h", "#error hello world!\n");
             const auto settings = dinit(Settings, $.userDefines = "TEST");
-            const char code[] = "#include \"ab.h\"";
+            const char code[] = "#include \"ab.h\"\n";
             (void)getcodeforcfg(settings, *this, code, "TEST", "test.c");
             ASSERT_EQUALS("[ab.h:1:2]: (error) #error hello world! [preprocessorErrorDirective]\n", errout_str());
         }
@@ -508,7 +512,7 @@ class TestPreprocessor : public TestFixture {
             ScopedFile header("ab.h", "");
             const auto settings = dinit(Settings, $.userDefines = "TEST");
             const char code[] = "#include \"ab.h\"\n"
-                                "#error aaa";
+                                "#error aaa\n";
             (void)getcodeforcfg(settings, *this, code, "TEST", "test.c");
             ASSERT_EQUALS("[test.c:2:2]: (error) #error aaa [preprocessorErrorDirective]\n", errout_str());
         }
@@ -577,7 +581,7 @@ class TestPreprocessor : public TestFixture {
                                 "\n"
                                 "#ifndef C\n"
                                 "#error aa\n"
-                                "#endif";
+                                "#endif\n";
         ASSERT_EQUALS("A=A;B=B;C\nA=A;C\nC\n", getConfigsStr(filedata));
     }
 
@@ -618,7 +622,7 @@ class TestPreprocessor : public TestFixture {
         // Handling include guards..
         const char filedata[] = "#include \"abc.h\"\n"
                                 "#ifdef ABC\n"
-                                "#endif";
+                                "#endif\n";
         ASSERT_EQUALS("\nABC=ABC\n", getConfigsStr(filedata));
     }
 
@@ -954,7 +958,7 @@ class TestPreprocessor : public TestFixture {
     void ticket_4922() { // #4922
         const char code[] = "__asm__ \n"
                             "{ int extern __value) 0; (double return (\"\" } extern\n"
-                            "__typeof __finite (__finite) __finite __inline \"__GI___finite\");";
+                            "__typeof __finite (__finite) __finite __inline \"__GI___finite\");\n";
         (void)getcode(settings0, *this, code);
     }
 
@@ -1065,7 +1069,7 @@ class TestPreprocessor : public TestFixture {
 
     void macro_simple16() {  // # 4703
         const char filedata[] = "#define MACRO( A, B, C ) class A##B##C##Creator {};\n"
-                                "MACRO( B\t, U , G )";
+                                "MACRO( B\t, U , G )\n";
         ASSERT_EQUALS("\nclass BUGCreator { } ;", expandMacros(filedata, *this));
     }
 
@@ -1073,41 +1077,41 @@ class TestPreprocessor : public TestFixture {
         // It would probably be OK if the generated code was
         // "\n123+$123" since the first 123 comes from the source code
         const char filedata[] = "#define MACRO(A) A+123\n"
-                                "MACRO(123)";
+                                "MACRO(123)\n";
         ASSERT_EQUALS("\n123 + 123", expandMacros(filedata, *this));
     }
 
     void macro_simple18() {  // (1e-7)
         const char filedata1[] = "#define A (1e-7)\n"
-                                 "a=A;";
+                                 "a=A;\n";
         ASSERT_EQUALS("\na = ( 1e-7 ) ;", expandMacros(filedata1, *this));
 
         const char filedata2[] = "#define A (1E-7)\n"
-                                 "a=A;";
+                                 "a=A;\n";
         ASSERT_EQUALS("\na = ( 1E-7 ) ;", expandMacros(filedata2, *this));
 
         const char filedata3[] = "#define A (1e+7)\n"
-                                 "a=A;";
+                                 "a=A;\n";
         ASSERT_EQUALS("\na = ( 1e+7 ) ;", expandMacros(filedata3, *this));
 
         const char filedata4[] = "#define A (1.e+7)\n"
-                                 "a=A;";
+                                 "a=A;\n";
         ASSERT_EQUALS("\na = ( 1.e+7 ) ;", expandMacros(filedata4, *this));
 
         const char filedata5[] = "#define A (1.7f)\n"
-                                 "a=A;";
+                                 "a=A;\n";
         ASSERT_EQUALS("\na = ( 1.7f ) ;", expandMacros(filedata5, *this));
 
         const char filedata6[] = "#define A (.1)\n"
-                                 "a=A;";
+                                 "a=A;\n";
         ASSERT_EQUALS("\na = ( .1 ) ;", expandMacros(filedata6, *this));
 
         const char filedata7[] = "#define A (1.)\n"
-                                 "a=A;";
+                                 "a=A;\n";
         ASSERT_EQUALS("\na = ( 1. ) ;", expandMacros(filedata7, *this));
 
         const char filedata8[] = "#define A (8.0E+007)\n"
-                                 "a=A;";
+                                 "a=A;\n";
         ASSERT_EQUALS("\na = ( 8.0E+007 ) ;", expandMacros(filedata8, *this));
     }
 
@@ -1279,8 +1283,8 @@ class TestPreprocessor : public TestFixture {
 
     void macro_NULL() {
         // See ticket #4482 - UB when passing NULL to variadic function
-        ASSERT_EQUALS("\n0", expandMacros("#define null 0\nnull", *this));
-        TODO_ASSERT_EQUALS("\nNULL", "\n0", expandMacros("#define NULL 0\nNULL", *this)); // TODO: Let the tokenizer handle NULL?
+        ASSERT_EQUALS("\n0", expandMacros("#define null 0\nnull\n", *this));
+        TODO_ASSERT_EQUALS("\nNULL\n", "\n0", expandMacros("#define NULL 0\nNULL\n", *this)); // TODO: Let the tokenizer handle NULL?
     }
 
     void string1() {
@@ -1530,7 +1534,7 @@ class TestPreprocessor : public TestFixture {
                                 "#pragma asm foo\n"
                                 "    mov r1, 11\n"
                                 "#pragma endasm bar\n"
-                                "bbb";
+                                "bbb\n";
 
         // Preprocess => actual result..
         const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
@@ -1544,7 +1548,7 @@ class TestPreprocessor : public TestFixture {
         const char filedata[] = "#pragma asm\n"
                                 "    mov @w1, 11\n"
                                 "#pragma endasm ( temp=@w1 )\n"
-                                "bbb";
+                                "bbb\n";
 
         // Preprocess => actual result..
         const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
@@ -1666,7 +1670,7 @@ class TestPreprocessor : public TestFixture {
                                 "#else\n"
                                 "#define N 20\n"
                                 "#endif\n"
-                                "N";
+                                "N\n";
 
         // Preprocess => actual result..
         const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
@@ -1734,14 +1738,14 @@ class TestPreprocessor : public TestFixture {
             const char filedata[] = "#define A 0\n"
                                     "#if A\n"
                                     "FOO\n"
-                                    "#endif";
+                                    "#endif\n";
             ASSERT_EQUALS("", getcodeforcfg(settings0, *this, filedata,"","test.c"));
         }
         {
             const char filedata[] = "#define A 1\n"
                                     "#if A==1\n"
                                     "FOO\n"
-                                    "#endif";
+                                    "#endif\n";
             ASSERT_EQUALS("\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
         }
     }
@@ -1751,7 +1755,7 @@ class TestPreprocessor : public TestFixture {
                                 "#define B A\n"
                                 "#if (B==A) || (B==C)\n"
                                 "FOO\n"
-                                "#endif";
+                                "#endif\n";
         ASSERT_EQUALS("\n\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
     }
 
@@ -1759,7 +1763,7 @@ class TestPreprocessor : public TestFixture {
         const char filedata[] = "#define A 0\n"
                                 "#if (A==0)\n"
                                 "FOO\n"
-                                "#endif";
+                                "#endif\n";
         ASSERT_EQUALS("\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
     }
 
@@ -1767,7 +1771,7 @@ class TestPreprocessor : public TestFixture {
         const char filedata[] = "#define X +123\n"
                                 "#if X==123\n"
                                 "FOO\n"
-                                "#endif";
+                                "#endif\n";
         ASSERT_EQUALS("\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
     }
 
@@ -1777,7 +1781,7 @@ class TestPreprocessor : public TestFixture {
                                     "#define B (A & 0x00f0)\n"
                                     "#if B==0x0010\n"
                                     "FOO\n"
-                                    "#endif";
+                                    "#endif\n";
             ASSERT_EQUALS("\n\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
         }
         {
@@ -1786,14 +1790,14 @@ class TestPreprocessor : public TestFixture {
                                     "#define C (B & A)\n"
                                     "#if C==0x0010\n"
                                     "FOO\n"
-                                    "#endif";
+                                    "#endif\n";
             ASSERT_EQUALS("\n\n\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
         }
         {
             const char filedata[] = "#define A (1+A)\n" // don't hang for recursive macros
                                     "#if A==1\n"
                                     "FOO\n"
-                                    "#endif";
+                                    "#endif\n";
             ASSERT_EQUALS("\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
         }
     }
@@ -1925,7 +1929,7 @@ class TestPreprocessor : public TestFixture {
         const char filedata[] = "#ifndef A\n"
                                 "#define A(x) x\n"
                                 "#endif\n"
-                                "A(123);";
+                                "A(123);\n";
 
         // Preprocess => actual result..
         const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
@@ -2111,7 +2115,7 @@ class TestPreprocessor : public TestFixture {
     }
 
     void remarkComment4() {
-        const char code[] = "//REMARK /";
+        const char code[] = "//REMARK /\n";
         const auto remarkComments = getRemarkComments(code, *this);
         ASSERT_EQUALS(0, remarkComments.size());
     }
@@ -2160,19 +2164,19 @@ class TestPreprocessor : public TestFixture {
 
     void predefine5() {  // #3737, #5119 - automatically define __cplusplus
         // #3737...
-        const char code[] = "#ifdef __cplusplus\n123\n#endif";
+        const char code[] = "#ifdef __cplusplus\n123\n#endif\n";
         ASSERT_EQUALS("",      getcodeforcfg(settings0, *this, code, "", "test.c"));
         ASSERT_EQUALS("\n123", getcodeforcfg(settings0, *this, code, "", "test.cpp"));
     }
 
     void predefine6() { // automatically define __STDC_VERSION__
-        const char code[] = "#ifdef __STDC_VERSION__\n123\n#endif";
+        const char code[] = "#ifdef __STDC_VERSION__\n123\n#endif\n";
         ASSERT_EQUALS("\n123", getcodeforcfg(settings0, *this, code, "", "test.c"));
         ASSERT_EQUALS("",      getcodeforcfg(settings0, *this, code, "", "test.cpp"));
     }
 
     void strictAnsi() {
-        const char code[] = "#ifdef __STRICT_ANSI__\n123\n#endif";
+        const char code[] = "#ifdef __STRICT_ANSI__\n123\n#endif\n";
         Settings settings;
 
         settings.standards.setStd("gnu99");
@@ -2324,7 +2328,7 @@ class TestPreprocessor : public TestFixture {
                                 "#define bar foo\n"
                                 "#define baz bar+0\n"
                                 "#if 0\n"
-                                "#endif";
+                                "#endif\n";
         ASSERT_EQUALS("\n", getConfigsStr(filedata));
     }
 
@@ -2733,27 +2737,27 @@ class TestPreprocessor : public TestFixture {
 
     void getConfigsInvalid() { // #14732
         {
-            const char filedata[] = "#if<";
+            const char filedata[] = "#if<\n";
             ASSERT_EQUALS("\n", getConfigsStr(filedata));
         }
         {
-            const char filedata[] = "#if>";
+            const char filedata[] = "#if>\n";
             ASSERT_EQUALS("\n", getConfigsStr(filedata));
         }
         {
-            const char filedata[] = "#if==";
+            const char filedata[] = "#if==\n";
             ASSERT_EQUALS("\n", getConfigsStr(filedata));
         }
         {
-            const char filedata[] = "#if<=";
+            const char filedata[] = "#if<=\n";
             ASSERT_EQUALS("\n", getConfigsStr(filedata));
         }
         {
-            const char filedata[] = "#if>=";
+            const char filedata[] = "#if>=\n";
             ASSERT_EQUALS("\n", getConfigsStr(filedata));
         }
         {
-            const char filedata[] = "#if!";
+            const char filedata[] = "#if!\n";
             ASSERT_EQUALS("\n", getConfigsStr(filedata));
         }
     }
@@ -2764,7 +2768,7 @@ class TestPreprocessor : public TestFixture {
                             "#elif sizeof(unsigned short) == 4\n"
                             "Fred & Wilma\n"
                             "#else\n"
-                            "#endif";
+                            "#endif\n";
 
         const std::map<std::string, std::string> actual = getcode(settings0, *this, code);
         ASSERT_EQUALS("\nFred & Wilma", actual.at(""));
@@ -2792,7 +2796,7 @@ class TestPreprocessor : public TestFixture {
     void garbage() {
         const char filedata[] = "V\n"
                                 "#define X b   #endif #line 0 \"x\"  ;\n"
-                                "#if ! defined ( Y )    #endif";
+                                "#if ! defined ( Y )    #endif\n";
 
         // Preprocess => don't crash..
         (void)getcode(settings0, *this, filedata);
@@ -2816,7 +2820,7 @@ class TestPreprocessor : public TestFixture {
 
         ScopedFile header("header.h", "");
 
-        const char code[] = "#include \"header.h\"";
+        const char code[] = "#include \"header.h\"\n";
         (void)getcodeforcfg(settings, *this, code, "", "test.c");
 
         ASSERT_EQUALS("", errout_str());
@@ -2831,7 +2835,7 @@ class TestPreprocessor : public TestFixture {
                                     );
         setTemplateFormat("simple");
 
-        const char code[] = "#include \"header.h\"";
+        const char code[] = "#include \"header.h\"\n";
         (void)getcodeforcfg(settings, *this, code, "", "test.c");
 
         ASSERT_EQUALS("test.c:1:2: information: Include file: \"header.h\" not found. [missingInclude]\n", errout_str());
@@ -2848,7 +2852,7 @@ class TestPreprocessor : public TestFixture {
 
         ScopedFile header("header.h", "", "inc");
 
-        const char code[] = "#include \"header.h\"";
+        const char code[] = "#include \"header.h\"\n";
         (void)getcodeforcfg(settings, *this, code, "", "test.c");
 
         ASSERT_EQUALS("test.c:1:2: information: Include file: \"header.h\" not found. [missingInclude]\n", errout_str());
@@ -2866,7 +2870,7 @@ class TestPreprocessor : public TestFixture {
 
         ScopedFile header("header.h", "", "inc");
 
-        const char code[] = "#include \"inc/header.h\"";
+        const char code[] = "#include \"inc/header.h\"\n";
         (void)getcodeforcfg(settings, *this, code, "", "test.c");
 
         ASSERT_EQUALS("", errout_str());
@@ -2884,7 +2888,7 @@ class TestPreprocessor : public TestFixture {
 
         ScopedFile header("header.h", "", Path::getCurrentPath());
 
-        std::string code("#include \"" + header.path() + "\"");
+        std::string code("#include \"" + header.path() + "\"\n");
         (void)getcodeforcfg(settings, *this, code.data(), code.size(), "", "test.c");
 
         ASSERT_EQUALS("", errout_str());
@@ -2901,7 +2905,7 @@ class TestPreprocessor : public TestFixture {
 
         const std::string header = Path::join(Path::getCurrentPath(), "header.h");
 
-        std::string code("#include \"" + header + "\"");
+        std::string code("#include \"" + header + "\"\n");
         (void)getcodeforcfg(settings, *this, code.data(), code.size(), "", "test.c");
 
         ASSERT_EQUALS("test.c:1:2: information: Include file: \"" + header + "\" not found. [missingInclude]\n", errout_str());
@@ -2918,7 +2922,7 @@ class TestPreprocessor : public TestFixture {
 
         ScopedFile header("header.h", "");
 
-        const char code[] = "#include <header.h>";
+        const char code[] = "#include <header.h>\n";
         (void)getcodeforcfg(settings, *this, code, "", "test.c");
 
         ASSERT_EQUALS("test.c:1:2: information: Include file: <header.h> not found. Please note: Standard library headers do not need to be provided to get proper results. [missingIncludeSystem]\n", errout_str());
@@ -2933,7 +2937,7 @@ class TestPreprocessor : public TestFixture {
                                     );
         setTemplateFormat("simple");
 
-        const char code[] = "#include <header.h>";
+        const char code[] = "#include <header.h>\n";
         (void)getcodeforcfg(settings, *this, code, "", "test.c");
 
         ASSERT_EQUALS("test.c:1:2: information: Include file: <header.h> not found. Please note: Standard library headers do not need to be provided to get proper results. [missingIncludeSystem]\n", errout_str());
@@ -2951,7 +2955,7 @@ class TestPreprocessor : public TestFixture {
 
         ScopedFile header("header.h", "", "system");
 
-        const char code[] = "#include <header.h>";
+        const char code[] = "#include <header.h>\n";
         (void)getcodeforcfg(settings, *this, code, "", "test.c");
 
         ASSERT_EQUALS("", errout_str());
@@ -2969,7 +2973,7 @@ class TestPreprocessor : public TestFixture {
 
         ScopedFile header("header.h", "", Path::getCurrentPath());
 
-        std::string code("#include <" + header.path() + ">");
+        std::string code("#include <" + header.path() + ">\n");
         (void)getcodeforcfg(settings, *this, code.data(), code.size(), "", "test.c");
 
         ASSERT_EQUALS("", errout_str());
@@ -2986,7 +2990,7 @@ class TestPreprocessor : public TestFixture {
 
         const std::string header = Path::join(Path::getCurrentPath(), "header.h");
 
-        std::string code("#include <" + header + ">");
+        std::string code("#include <" + header + ">\n");
         (void)getcodeforcfg(settings, *this, code.data(), code.size(), "", "test.c");
 
         ASSERT_EQUALS("test.c:1:2: information: Include file: <" + header + "> not found. Please note: Standard library headers do not need to be provided to get proper results. [missingIncludeSystem]\n", errout_str());
@@ -3008,7 +3012,7 @@ class TestPreprocessor : public TestFixture {
         const char code[] = "#include \"missing.h\"\n"
                             "#include <header.h>\n"
                             "#include <missing2.h>\n"
-                            "#include \"header2.h\"";
+                            "#include \"header2.h\"\n";
         (void)getcodeforcfg(settings, *this, code, "", "test.c");
 
         ASSERT_EQUALS("test.c:1:2: information: Include file: \"missing.h\" not found. [missingInclude]\n"
@@ -3068,8 +3072,8 @@ class TestPreprocessor : public TestFixture {
         std::vector<std::string> files;
         simplecpp::TokenList tokens(code, files, "test.c");
 
-        ScopedFile header1("header1.h", "1");
-        ScopedFile header2("header2.h", "2");
+        ScopedFile header1("header1.h", "1\n");
+        ScopedFile header2("header2.h", "2\n");
 
         Settings settings;
         Preprocessor preprocessor(tokens, settings, *this, Standards::Language::CPP);
@@ -3087,7 +3091,7 @@ class TestPreprocessor : public TestFixture {
     }
 
     void hasInclude() {
-        const char code[] = "#if __has_include(<directory/non-existent-header.h>)\n123\n#endif";
+        const char code[] = "#if __has_include(<directory/non-existent-header.h>)\n123\n#endif\n";
         Settings settings;
 
         settings.standards.setStd("c++11");
@@ -3107,7 +3111,7 @@ class TestPreprocessor : public TestFixture {
         // #11928 / #10045
         const char code[] = "void f(long l) {\n"
                             "  if (l > INT_MAX) {}\n"
-                            "}";
+                            "}\n";
         const std::string actual = getcodeforcfg(settings0, *this, code, "", "test.c");
         ASSERT_EQUALS("void f ( long l ) {\n"
                       "if ( l > $2147483647 ) { }\n"
@@ -3116,9 +3120,9 @@ class TestPreprocessor : public TestFixture {
 
     void hashCalculation() {
         // #12383
-        const char code[] = "int a;";
-        const char code2[] = "int  a;"; // extra space
-        const char code3[] = "\n\nint a;"; // extra new line
+        const char code[] = "int a;\n";
+        const char code2[] = "int  a;\n"; // extra space
+        const char code3[] = "\n\nint a;\n"; // extra new line
 
         ASSERT_EQUALS(getHash(code), getHash(code));
         ASSERT_EQUALS(getHash(code2), getHash(code2));
@@ -3130,7 +3134,7 @@ class TestPreprocessor : public TestFixture {
 
     void standard() {
 
-        const char code[] = "int a;";
+        const char code[] = "int a;\n";
         // TODO: this bypasses the standard determined from the settings - the parameter should not be exposed
         simplecpp::DUI dui;
 
@@ -3171,7 +3175,7 @@ class TestPreprocessor : public TestFixture {
             std::vector<std::string> files;
             TokenList tokenlist{settingsDefault, Standards::Language::CPP};
             // TODO: can this happen from application code? if yes we need to turn it into a proper error
-            ASSERT_THROW_EQUALS(preprocess(code, files, "test.cpp", tokenlist, dui), std::runtime_error, "unexpected simplecpp::Output type 9");
+            ASSERT_THROW_EQUALS(preprocess(code, files, "test.cpp", tokenlist, dui), std::runtime_error, "unexpected simplecpp::Output type 12");
             ASSERT(!tokenlist.front()); // nothing is tokenized when an unknown standard is provided
         }
     }
@@ -3181,8 +3185,8 @@ class TestPreprocessor : public TestFixture {
         const char inc[] = "class A {\n"
                            "public:\n"
                            "    void f() {}\n"
-                           "};";
-        const char code[] = R"(#include "test.h")";
+                           "};\n";
+        const char code[] = "#include \"test.h\"\n";
         ScopedFile header("test.h", inc);
         const std::string processed = getcodeforcfg(settingsDefault, *this, code, "", "test.cpp");
         ASSERT_EQUALS(
@@ -3197,7 +3201,7 @@ class TestPreprocessor : public TestFixture {
 
     void pragmaAsm()
     {
-        const char code[] = "#pragma asm";
+        const char code[] = "#pragma asm\n";
         ASSERT_THROW_INTERNAL(getcodeforcfg(settingsDefault, *this, code, "", "test.cpp"), InternalError::SYNTAX);
     }
 };
diff --git a/test/testprogrammemory.cpp b/test/testprogrammemory.cpp
index 688efa0075b..c37431de608 100644
--- a/test/testprogrammemory.cpp
+++ b/test/testprogrammemory.cpp
@@ -39,7 +39,7 @@ class TestProgramMemory : public TestFixture {
     }
 
     void copyOnWrite() const {
-        SimpleTokenList tokenlist("1+1;");
+        SimpleTokenList tokenlist("1+1;\n");
         Token* tok = tokenlist.front();
         const nonneg int id = 123;
         tok->exprId(id);
diff --git a/test/testsimplifytemplate.cpp b/test/testsimplifytemplate.cpp
index b37ed03db34..475d03c696d 100644
--- a/test/testsimplifytemplate.cpp
+++ b/test/testsimplifytemplate.cpp
@@ -372,7 +372,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template1() {
         const char code[] = "template <class T> T f(T val) { T a; }\n"
-                            "f<int>(10);";
+                            "f<int>(10);\n";
 
         const char expected[] = "int f<int> ( int val ) ; "
                                 "f<int> ( 10 ) ; "
@@ -383,7 +383,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template2() {
         const char code[] = "template <class T> class Fred { T a; };\n"
-                            "Fred<int> fred;";
+                            "Fred<int> fred;\n";
 
         const char expected[] = "class Fred<int> ; "
                                 "Fred<int> fred ; "
@@ -394,7 +394,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template3() {
         const char code[] = "template <class T, int sz> class Fred { T data[sz]; };\n"
-                            "Fred<float,4> fred;";
+                            "Fred<float,4> fred;\n";
 
         const char expected[] = "class Fred<float,4> ; "
                                 "Fred<float,4> fred ; "
@@ -405,7 +405,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template4() {
         const char code[] = "template <class T> class Fred { Fred(); };\n"
-                            "Fred<float> fred;";
+                            "Fred<float> fred;\n";
 
         const char expected[] = "class Fred<float> ; "
                                 "Fred<float> fred ; "
@@ -417,7 +417,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template5() {
         const char code[] = "template <class T> class Fred { };\n"
                             "template <class T> Fred<T>::Fred() { }\n"
-                            "Fred<float> fred;";
+                            "Fred<float> fred;\n";
 
         const char expected[] = "class Fred<float> ; "
                                 "Fred<float> fred ; "
@@ -430,7 +430,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template6() {
         const char code[] = "template <class T> class Fred { };\n"
                             "Fred<float> fred1;\n"
-                            "Fred<float> fred2;";
+                            "Fred<float> fred2;\n";
 
         const char expected[] = "class Fred<float> ; "
                                 "Fred<float> fred1 ; "
@@ -531,7 +531,7 @@ class TestSimplifyTemplate : public TestFixture {
                       "template < typename T > class A { void f ( ) { B < T > a ; a = B < T > :: g ( ) ; T b ; b = 0 ; if ( b ) { b = 0 ; } } } ; "
                       "template < typename T > B < T > h ( ) { return B < T > ( ) ; }", tok(code));
 
-        ASSERT_EQUALS("class A { template < typename T > int foo ( T d ) ; } ;", tok("class A{ template<typename T> int foo(T d);};"));
+        ASSERT_EQUALS("class A { template < typename T > int foo ( T d ) ; } ;", tok("class A{ template<typename T> int foo(T d);};\n"));
     }
 
     void template9() {
@@ -636,7 +636,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    y(AA<CC>::create(new CC(AA<BB>(), 0)))\n"
                             "    {}\n"
                             "\n"
-                            "int yy[AA<CC>::size()];";
+                            "int yy[AA<CC>::size()];\n";
         const char expected[] = "class BB { } ; "
                                 "class AA<BB> ; "
                                 "class AA<CC> ; "
@@ -712,7 +712,7 @@ class TestSimplifyTemplate : public TestFixture {
                              "  vec(const vec<n-1>& v) {}\n" // <- never used don't instantiate
                              "};\n"
                              "\n"
-                             "vec<4> v;";
+                             "vec<4> v;\n";
         const char expected2[] = "struct vec<4> ; "
                                  "vec<4> v ; "
                                  "struct vec<4> { "
@@ -770,7 +770,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template18() {
         const char code[] = "template <class T> class foo { T a; };\n"
-                            "foo<int> *f;";
+                            "foo<int> *f;\n";
 
         const char expected[] = "class foo<int> ; "
                                 "foo<int> * f ; "
@@ -815,7 +815,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template21() {
         {
             const char code[] = "template <class T> struct Fred { T a; };\n"
-                                "Fred<int> fred;";
+                                "Fred<int> fred;\n";
 
             const char expected[] = "struct Fred<int> ; "
                                     "Fred<int> fred ; "
@@ -826,7 +826,7 @@ class TestSimplifyTemplate : public TestFixture {
 
         {
             const char code[] = "template <class T, int sz> struct Fred { T data[sz]; };\n"
-                                "Fred<float,4> fred;";
+                                "Fred<float,4> fred;\n";
 
             const char expected[] = "struct Fred<float,4> ; "
                                     "Fred<float,4> fred ; "
@@ -837,7 +837,7 @@ class TestSimplifyTemplate : public TestFixture {
 
         {
             const char code[] = "template <class T> struct Fred { Fred(); };\n"
-                                "Fred<float> fred;";
+                                "Fred<float> fred;\n";
 
             const char expected[] = "struct Fred<float> ; "
                                     "Fred<float> fred ; "
@@ -849,7 +849,7 @@ class TestSimplifyTemplate : public TestFixture {
         {
             const char code[] = "template <class T> struct Fred { };\n"
                                 "Fred<float> fred1;\n"
-                                "Fred<float> fred2;";
+                                "Fred<float> fred2;\n";
 
             const char expected[] = "struct Fred<float> ; "
                                     "Fred<float> fred1 ; "
@@ -862,7 +862,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template22() {
         const char code[] = "template <class T> struct Fred { T a; };\n"
-                            "Fred<std::string> fred;";
+                            "Fred<std::string> fred;\n";
 
         const char expected[] = "struct Fred<std::string> ; "
                                 "Fred<std::string> fred ; "
@@ -875,7 +875,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template <class T> void foo() { }\n"
                             "void bar() {\n"
                             "    std::cout << (foo<double>());\n"
-                            "}";
+                            "}\n";
 
         const char expected[] = "void foo<double> ( ) ; "
                                 "void bar ( ) {"
@@ -896,7 +896,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template<int x> class bitset: B<sizeof(int)>\n"
                             "{};\n"
                             "\n"
-                            "bitset<1> z;";
+                            "bitset<1> z;\n";
         const char expected[] = "struct B<4> ; "
                                 "class bitset<1> ; "
                                 "bitset<1> z ; "
@@ -914,7 +914,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template<int x> class bitset: B<((sizeof(int)) ? : 1)>\n"
                             "{};\n"
                             "\n"
-                            "bitset<1> z;";
+                            "bitset<1> z;\n";
         const char expected[] = "struct B<4> ; "
                                 "class bitset<1> ; "
                                 "bitset<1> z ; "
@@ -937,7 +937,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template27() {
         // #3350 - template inside macro call
-        const char code[] = "X(template<class T> class Fred);";
+        const char code[] = "X(template<class T> class Fred);\n";
         ASSERT_THROW_INTERNAL(tok(code), SYNTAX);
     }
 
@@ -954,19 +954,19 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template30() {
         // #3529 - template < template < ..
-        const char code[] = "template<template<class> class A, class B> void f(){}";
+        const char code[] = "template<template<class> class A, class B> void f(){}\n";
         ASSERT_EQUALS("template < template < class > class A , class B > void f ( ) { }", tok(code));
     }
 
     void template31() {
         // #4010 - template reference type
-        const char code[] = "template<class T> struct A{}; A<int&> a;";
+        const char code[] = "template<class T> struct A{}; A<int&> a;\n";
         ASSERT_EQUALS("struct A<int&> ; "
                       "A<int&> a ; "
                       "struct A<int&> { } ;", tok(code));
 
         // #7409 - rvalue
-        const char code2[] = "template<class T> struct A{}; A<int&&> a;";
+        const char code2[] = "template<class T> struct A{}; A<int&&> a;\n";
         ASSERT_EQUALS("struct A<int&&> ; "
                       "A<int&&> a ; "
                       "struct A<int&&> { } ;", tok(code2));
@@ -996,7 +996,7 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "template<class T> struct A { };\n"
                                 "template<class T> struct B { };\n"
                                 "template<class T> struct C { A<B<X<T> > > ab; };\n"
-                                "C<int> c;";
+                                "C<int> c;\n";
             ASSERT_EQUALS("struct A<B<X<int>>> ; "
                           "struct B<X<int>> ; "
                           "struct C<int> ; "
@@ -1011,7 +1011,7 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "struct A { };\n"
                                 "template<class T> struct B { };\n"
                                 "template<class T> struct C { };\n"
-                                "C< B<A> > c;";
+                                "C< B<A> > c;\n";
             ASSERT_EQUALS("struct A { } ; "
                           "template < class T > struct B { } ; "  // <- redundant.. but nevermind
                           "struct C<B<A>> ; "
@@ -1026,13 +1026,13 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "namespace abc {\n"
                             "template <typename T> struct X { void f(X<T> &x) {} };\n"
                             "}\n"
-                            "template <> int X<int>::Y(0);";
+                            "template <> int X<int>::Y(0);\n";
         (void)tok(code);
     }
 
     void template35() { // #4074 - "A<'x'> a;" is not recognized as template instantiation
         const char code[] = "template <char c> class A {};\n"
-                            "A <'x'> a;";
+                            "A <'x'> a;\n";
         ASSERT_EQUALS("class A<'x'> ; "
                       "A<'x'> a ; "
                       "class A<'x'> { } ;", tok(code));
@@ -1041,7 +1041,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template36() { // #4310 - Passing unknown template instantiation as template argument
         const char code[] = "template <class T> struct X { T t; };\n"
                             "template <class C> struct Y { Foo < X< Bar<C> > > _foo; };\n" // <- Bar is unknown
-                            "Y<int> bar;";
+                            "Y<int> bar;\n";
         ASSERT_EQUALS("struct X<Bar<int>> ; "
                       "struct Y<int> ; "
                       "Y<int> bar ; "
@@ -1055,7 +1055,7 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "class A { };\n"
                                 "template<class T> class B {};\n"
                                 "B<class A> b1;\n"
-                                "B<A> b2;";
+                                "B<A> b2;\n";
             ASSERT_EQUALS("class A { } ; class B<A> ; B<A> b1 ; B<A> b2 ; class B<A> { } ;",
                           tok(code));
         }
@@ -1063,7 +1063,7 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "struct A { };\n"
                                 "template<class T> class B {};\n"
                                 "B<struct A> b1;\n"
-                                "B<A> b2;";
+                                "B<A> b2;\n";
             ASSERT_EQUALS("struct A { } ; class B<A> ; B<A> b1 ; B<A> b2 ; class B<A> { } ;",
                           tok(code));
         }
@@ -1071,7 +1071,7 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "enum A { };\n"
                                 "template<class T> class B {};\n"
                                 "B<enum A> b1;\n"
-                                "B<A> b2;";
+                                "B<A> b2;\n";
             ASSERT_EQUALS("enum A { } ; class B<A> ; B<A> b1 ; B<A> b2 ; class B<A> { } ;",
                           tok(code));
         }
@@ -1079,7 +1079,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template_unhandled() {
         // An unhandled template usage should not be simplified..
-        ASSERT_EQUALS("x < int > ( ) ;", tok("x<int>();"));
+        ASSERT_EQUALS("x < int > ( ) ;", tok("x<int>();\n"));
     }
 
     void template38() { // #4832 - Crash on C++11 right angle brackets
@@ -1113,21 +1113,21 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template39() { // #4742 - Used to freeze in 1.60
-        const char code[] = "template<typename T> struct vector {"
-                            "  operator T() const;"
-                            "};"
-                            "void f() {"
-                            "  vector<vector<int>> v;"
-                            "  const vector<int> vi = static_cast<vector<int>>(v);"
-                            "}";
+        const char code[] = "template<typename T> struct vector {\n"
+                            "  operator T() const;\n"
+                            "};\n"
+                            "void f() {\n"
+                            "  vector<vector<int>> v;\n"
+                            "  const vector<int> vi = static_cast<vector<int>>(v);\n"
+                            "}\n";
         (void)tok(code);
     }
 
     void template40() { // #5055 - false negatives when there is template specialization outside struct
-        const char code[] = "struct A {"
-                            "  template<typename T> struct X { T t; };"
-                            "};"
-                            "template<> struct A::X<int> { int *t; };";
+        const char code[] = "struct A {\n"
+                            "  template<typename T> struct X { T t; };\n"
+                            "};\n"
+                            "template<> struct A::X<int> { int *t; };\n";
         const char expected[] = "struct A { "
                                 "struct X<int> ; "
                                 "template < typename T > struct X { T t ; } ; "
@@ -1138,13 +1138,13 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template41() { // #4710 - const in template instantiation not handled perfectly
         const char code1[] = "template<class T> struct X { };\n"
-                             "void f(const X<int> x) { }";
+                             "void f(const X<int> x) { }\n";
         ASSERT_EQUALS("struct X<int> ; "
                       "void f ( const X<int> x ) { } "
                       "struct X<int> { } ;", tok(code1));
 
         const char code2[] = "template<class T> T f(T t) { return t; }\n"
-                             "int x() { return f<int>(123); }";
+                             "int x() { return f<int>(123); }\n";
         ASSERT_EQUALS("int f<int> ( int t ) ; "
                       "int x ( ) { return f<int> ( 123 ) ; } "
                       "int f<int> ( int t ) { return t ; }", tok(code2));
@@ -1158,7 +1158,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "  }() + ^ {\n"
                             "    return sizeof...(args);\n"
                             "  }();\n"
-                            "}";
+                            "}\n";
         ASSERT_THROW_INTERNAL(tok(code), SYNTAX);
     }
 
@@ -1176,7 +1176,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "int main(void) {\n"
                             "    C<A> ca;\n"
                             "    return 0;\n"
-                            "}";
+                            "}\n";
         const char expected[] = "struct E<void*> ; "
                                 "struct C<B<A>> ; "
                                 "struct C<A> ; "
@@ -1215,14 +1215,14 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template44() { // #5297
-        const char code[] = "template<class T> struct StackContainer {"
-                            "  void foo(int i) {"
-                            "    if (0 >= 1 && i<0) {}"
-                            "  }"
-                            "};"
-                            "template<class T> class ZContainer : public StackContainer<T> {};"
-                            "struct FGSTensor {};"
-                            "class FoldedZContainer : public ZContainer<FGSTensor> {};";
+        const char code[] = "template<class T> struct StackContainer {\n"
+                            "  void foo(int i) {\n"
+                            "    if (0 >= 1 && i<0) {}\n"
+                            "  }\n"
+                            "};\n"
+                            "template<class T> class ZContainer : public StackContainer<T> {};\n"
+                            "struct FGSTensor {};\n"
+                            "class FoldedZContainer : public ZContainer<FGSTensor> {};\n";
         const char expected[] = "struct StackContainer<FGSTensor> ; "
                                 "class ZContainer<FGSTensor> ; "
                                 "struct FGSTensor { } ; "
@@ -1237,14 +1237,14 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template45() { // #5814
-        const char code[] = "namespace Constants { const int fourtytwo = 42; } "
-                            "template <class T, int U> struct TypeMath { "
-                            "  static const int mult = sizeof(T) * U; "
-                            "}; "
-                            "template <class T> struct FOO { "
-                            "  enum { value = TypeMath<T, Constants::fourtytwo>::mult }; "
-                            "}; "
-                            "FOO<int> foo;";
+        const char code[] = "namespace Constants { const int fourtytwo = 42; }\n"
+                            "template <class T, int U> struct TypeMath {\n"
+                            "  static const int mult = sizeof(T) * U;\n"
+                            "};\n"
+                            "template <class T> struct FOO {\n"
+                            "  enum { value = TypeMath<T, Constants::fourtytwo>::mult };\n"
+                            "};\n"
+                            "FOO<int> foo;\n";
         const char expected[] = "namespace Constants { const int fourtytwo = 42 ; } "
                                 "struct TypeMath<int,Constants::fourtytwo> ; "
                                 "struct FOO<int> ; "
@@ -1260,32 +1260,32 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template46() { // #5816
-        ASSERT_NO_THROW(tok("template<class T, class U> struct A { static const int value = 0; }; "
-                            "template <class T> struct B { "
-                            "  enum { value = A<typename T::type, int>::value }; "
-                            "};"));
+        ASSERT_NO_THROW(tok("template<class T, class U> struct A { static const int value = 0; };\n"
+                            "template <class T> struct B {\n"
+                            "  enum { value = A<typename T::type, int>::value };\n"
+                            "};\n"));
         ASSERT_EQUALS("", errout_str());
-        ASSERT_NO_THROW(tok("template <class T, class U> struct A {}; "
-                            "enum { e = sizeof(A<int, int>) }; "
-                            "template <class T, class U> struct B {};"));
+        ASSERT_NO_THROW(tok("template <class T, class U> struct A {};\n"
+                            "enum { e = sizeof(A<int, int>) };\n"
+                            "template <class T, class U> struct B {};\n"));
         ASSERT_EQUALS("", errout_str());
-        ASSERT_NO_THROW(tok("template<class T, class U> struct A { static const int value = 0; }; "
-                            "template<class T> struct B { typedef int type; }; "
-                            "template <class T> struct C { "
-                            "  enum { value = A<typename B<T>::type, int>::value }; "
-                            "};"));
+        ASSERT_NO_THROW(tok("template<class T, class U> struct A { static const int value = 0; };\n"
+                            "template<class T> struct B { typedef int type; };\n"
+                            "template <class T> struct C {\n"
+                            "  enum { value = A<typename B<T>::type, int>::value };\n"
+                            "};\n"));
         ASSERT_EQUALS("", errout_str());
     }
 
     void template47() { // #6023
-        ASSERT_NO_THROW(tok("template <typename T1, typename T2 = T3<T1> > class C1 {}; "
-                            "class C2 : public C1<C2> {};"));
+        ASSERT_NO_THROW(tok("template <typename T1, typename T2 = T3<T1> > class C1 {};\n"
+                            "class C2 : public C1<C2> {};\n"));
         ASSERT_EQUALS("", errout_str());
     }
 
     void template48() { // #6134 (hang)
-        (void)tok("template <int> int f( {  } ); "
-                  "int foo = f<1>(0);");
+        (void)tok("template <int> int f( {  } );\n"
+                  "int foo = f<1>(0);\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1327,17 +1327,17 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template52() { // #6437
-        const char code[] = "template <int value> int sum() { "
-                            "  return value + sum<value/2>(); "
-                            "} "
-                            "template<int x, int y> int calculate_value() { "
-                            "  if (x != y) { "
-                            "    return sum<x - y>(); "
-                            "  } else { "
-                            "    return 0; "
-                            "  } "
-                            "} "
-                            "int value = calculate_value<1,1>();";
+        const char code[] = "template <int value> int sum() {\n"
+                            "  return value + sum<value/2>();\n"
+                            "}\n"
+                            "template<int x, int y> int calculate_value() {\n"
+                            "  if (x != y) {\n"
+                            "    return sum<x - y>();\n"
+                            "  } else {\n"
+                            "    return 0;\n"
+                            "  }\n"
+                            "}\n"
+                            "int value = calculate_value<1,1>();\n";
         const char expected[] = "int sum<0> ( ) ; "
                                 "int calculate_value<1,1> ( ) ; "
                                 "int value ; value = calculate_value<1,1> ( ) ; "
@@ -1355,13 +1355,13 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template53() { // #4335
-        const char code[] = "template<int N> struct Factorial { "
-                            "  enum { value = N * Factorial<N - 1>::value }; "
-                            "};"
-                            "template <> struct Factorial<0> { "
-                            "  enum { value = 1 }; "
-                            "};"
-                            "const int x = Factorial<4>::value;";
+        const char code[] = "template<int N> struct Factorial {\n"
+                            "  enum { value = N * Factorial<N - 1>::value };\n"
+                            "};\n"
+                            "template <> struct Factorial<0> {\n"
+                            "  enum { value = 1 };\n"
+                            "};\n"
+                            "const int x = Factorial<4>::value;\n";
         const char expected[] = "struct Factorial<0> ; "
                                 "struct Factorial<4> ; "
                                 "struct Factorial<3> ; "
@@ -1388,12 +1388,12 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template54() { // #6587 (use-after-free)
-        (void)tok("template<typename _Tp> _Tp* fn(); "
-                  "template <class T> struct A { "
-                  "  template <class U, class S = decltype(fn<T>())> "
-                  "  struct B { }; "
-                  "}; "
-                  "A<int> a;");
+        (void)tok("template<typename _Tp> _Tp* fn();\n"
+                  "template <class T> struct A {\n"
+                  "  template <class U, class S = decltype(fn<T>())>\n"
+                  "  struct B { };\n"
+                  "};\n"
+                  "A<int> a;\n");
     }
 
     void template55() { // #6604
@@ -1407,7 +1407,7 @@ class TestSimplifyTemplate : public TestFixture {
                 "{\n"
                 "    friend struct ConstCastHelper<AtSmartPtr<const T>, T>;\n"
                 "    AtSmartPtr(const AtSmartPtr<T>& r);\n"
-                "};"));
+                "};\n"));
 
         // Similar problem can also happen with ...
         ASSERT_EQUALS(
@@ -1427,16 +1427,16 @@ class TestSimplifyTemplate : public TestFixture {
                 "        (A<T...>*)(p);\n"
                 "    }\n"
                 "};\n"
-                "A<int> a(0);"));
+                "A<int> a(0);\n"));
     }
 
     void template56() { // #7117
-        const char code[] = "template<bool B> struct Foo { "
-                            "  std::array<int, B ? 1 : 2> mfoo; "
-                            "}; "
-                            "void foo() { "
-                            "  Foo<true> myFoo; "
-                            "}";
+        const char code[] = "template<bool B> struct Foo {\n"
+                            "  std::array<int, B ? 1 : 2> mfoo;\n"
+                            "};\n"
+                            "void foo() {\n"
+                            "  Foo<true> myFoo;\n"
+                            "}\n";
         const char expected[] = "struct Foo<true> ; "
                                 "void foo ( ) { "
                                 "Foo<true> myFoo ; "
@@ -1449,7 +1449,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template57() { // #7891
         const char code[] = "template<class T> struct Test { Test(T); };\n"
-                            "Test<unsigned long> test( 0 );";
+                            "Test<unsigned long> test( 0 );\n";
         const char exp[] = "struct Test<unsignedlong> ; "
                            "Test<unsignedlong> test ( 0 ) ; "
                            "struct Test<unsignedlong> { Test<unsignedlong> ( unsigned long ) ; } ;";
@@ -1463,7 +1463,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "}\n"
                             "void foo() {\n"
                             "  TestArithmetic<int>();\n"
-                            "}";
+                            "}\n";
         const char exp[] = "void TestArithmetic<int> ( ) ; "
                            "void foo ( ) {"
                            " TestArithmetic<int> ( ) ; "
@@ -1489,7 +1489,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "}\n"
                             "int main () {\n"
                             "    return diagonalGroupTest<4>();\n"
-                            "}";
+                            "}\n";
         const char exp[] = "struct Factorial<0> ; "
                            "struct Factorial<4> ; "
                            "struct Factorial<3> ; "
@@ -1511,7 +1511,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <typename T> void f() {}\n"
                             "template <typename T> void h() { f<typename S<T>::type(0)>(); }\n"
                             "\n"
-                            "void j() { h<int>(); }";
+                            "void j() { h<int>(); }\n";
         const char exp[] = "struct S<int> ; "
                            "void f<S<int>::type(0)> ( ) ; "
                            "void h<int> ( ) ; "
@@ -1534,7 +1534,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "  void f1(Bar<T> x) {}\n"
                             "  Foo<Bar<T>> f2() { }\n"
                             "};\n"
-                            "Bar<int> c;";
+                            "Bar<int> c;\n";
         const char exp[] = "struct Foo<Bar<int>> ; "
                            "struct Bar<int> ; "
                            "Bar<int> c ; "
@@ -1551,7 +1551,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <class T> void f() { x = y ? C1<int>::allocate(1) : 0; }\n"
                             "template <class T, unsigned S> class C3 {};\n"
                             "template <class T, unsigned S> C3<T, S>::C3(const C3<T, S> &v) { C1<T *> c1; }\n"
-                            "C3<int,6> c3;";
+                            "C3<int,6> c3;\n";
         const char exp[] = "struct C1<int*> ; "
                            "template < class T > void f ( ) { x = y ? ( C1 < int > :: allocate ( 1 ) ) : 0 ; } "
                            "class C3<int,6> ; "
@@ -1563,8 +1563,8 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template63() { // #8576
-        const char code[] = "template<class T> struct TestClass { T m_hi; };"
-                            "TestClass<std::auto_ptr<v>> objTest3;";
+        const char code[] = "template<class T> struct TestClass { T m_hi; };\n"
+                            "TestClass<std::auto_ptr<v>> objTest3;\n";
         const char exp[] = "struct TestClass<std::auto_ptr<v>> ; "
                            "TestClass<std::auto_ptr<v>> objTest3 ; "
                            "struct TestClass<std::auto_ptr<v>> { std :: auto_ptr < v > m_hi ; } ;";
@@ -1585,7 +1585,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    t_func<0>();\n"
                             "    t_func<1>();\n"
                             "}\n"
-                            "};";
+                            "};\n";
         const char exp[] = "bool foo<int> ( ) ; "
                            "struct A { "
                            "void t_func<0> ( ) ; "
@@ -1623,7 +1623,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "int main() {\n"
                             "  AssociationDAGlobalGraphObserver<string,unsigned int> grObs;\n"
                             " return 1;\n"
-                            "}";
+                            "}\n";
         const char exp[] = "namespace bpp "
                            "{ "
                            "class AssociationDAGraphImplObserver<string,unsignedint,DAGlobalGraph> ; "
@@ -1643,7 +1643,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    const int ** foo();\n"
                             "};\n"
                             "template <class T> const int ** Fred<T>::foo() { return nullptr; }\n"
-                            "Fred<int> fred;";
+                            "Fred<int> fred;\n";
         const char exp[] = "struct Fred<int> ; "
                            "Fred<int> fred ; "
                            "struct Fred<int> { "
@@ -1666,7 +1666,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <class T> Container<T>::Container(const Container & x) { nElements = x.nElements; c = x.c; }\n"
                             "template <class T> Container<T> & Container<T>::operator = (const Container & x) { mElements = x.mElements; c = x.c; return *this; }\n"
                             "template <class T> Container<T>::~Container() {}\n"
-                            "Container<int> intContainer;";
+                            "Container<int> intContainer;\n";
 
         const char expected[] = "struct Container<int> ; "
                                 "Container<int> intContainer ; "
@@ -1691,7 +1691,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    char dummy[sizeof(T)];\n"
                             "    T value;\n"
                             "};\n"
-                            "Fred<int> fred;";
+                            "Fred<int> fred;\n";
         const char exp[] = "union Fred<int> ; "
                            "Fred<int> fred ; "
                            "union Fred<int> { "
@@ -1706,7 +1706,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    int test;\n"
                             "    template <class T> T lookup() { return test; }\n"
                             "    int Fun() { return lookup<int>(); }\n"
-                            "};";
+                            "};\n";
         const char exp[] = "class Test { "
                            "int test ; "
                            "int lookup<int> ( ) ; "
@@ -1724,7 +1724,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template<typename K, typename V, int KeySize>\n"
                             "class Bar : private Bar<void, void> {\n"
                             "   void foo() { }\n"
-                            "};";
+                            "};\n";
         const char exp[] = "template < typename T , typename V , int KeySize = 0 > class Bar ; "
                            "class Bar<void,void> ; "
                            "class Bar<void,void> { "
@@ -1756,7 +1756,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    return f1(pInterface, interface_type::static_type());\n"
                             "}\n"
                             "\n"
-                            "Reference< class XPropertyList > dostuff();";
+                            "Reference< class XPropertyList > dostuff();\n";
         const char exp[] = "int f1 ( int * pInterface , int x ) { return 0 ; } "
                            "class Reference<XPropertyList> ; "
                            "Reference<XPropertyList> dostuff ( ) ; "
@@ -1769,7 +1769,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template <typename N, typename P> class Tokenizer;\n"
                             "const Tokenizer<Node, Path> *tokenizer() const;\n"
                             "template <typename N, typename P>\n"
-                            "Tokenizer<N, P>::Tokenizer() { }";
+                            "Tokenizer<N, P>::Tokenizer() { }\n";
         const char exp[] = "template < typename N , typename P > class Tokenizer ; "
                            "const Tokenizer < Node , Path > * tokenizer ( ) const ; "
                            "template < typename N , typename P > "
@@ -1781,7 +1781,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template<typename T>\n"
                             "void keep_range(T& value, const T mini, const T maxi){}\n"
                             "template void keep_range<float>(float& v, const float l, const float u);\n"
-                            "template void keep_range<int>(int& v, const int l, const int u);";
+                            "template void keep_range<int>(int& v, const int l, const int u);\n";
         const char exp[] = "void keep_range<float> ( float & value , const float mini , const float maxi ) ; "
                            "void keep_range<int> ( int & value , const int mini , const int maxi ) ; "
                            "void keep_range<float> ( float & value , const float mini , const float maxi ) { } "
@@ -1794,7 +1794,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "class PushBackStreamBuf {\n"
                             "public:\n"
                             "    void pushBack(const BTlist<int> &vec);\n"
-                            "};";
+                            "};\n";
         const char exp[] = "class BTlist<int> ; "
                            "class PushBackStreamBuf { "
                            "public: "
@@ -1807,7 +1807,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template75() {
         const char code[] = "template<typename T>\n"
                             "T foo(T& value){ return value; }\n"
-                            "template std::vector<std::vector<int>> foo<std::vector<std::vector<int>>>(std::vector<std::vector<int>>& v);";
+                            "template std::vector<std::vector<int>> foo<std::vector<std::vector<int>>>(std::vector<std::vector<int>>& v);\n";
         const char exp[] = "std :: vector < std :: vector < int > > foo<std::vector<std::vector<int>>> ( std :: vector < std :: vector < int > > & value ) ; "
                            "std :: vector < std :: vector < int > > foo<std::vector<std::vector<int>>> ( std :: vector < std :: vector < int > > & value ) { return value ; }";
         ASSERT_EQUALS(exp, tok(code));
@@ -1837,7 +1837,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "int main() {\n"
                             "    std::cout << is_void<char>::value << std::endl;\n"
                             "    std::cout << is_void<void>::value << std::endl;\n"
-                            "}";
+                            "}\n";
         const char exp[] = "struct is_void<void> ; "
                            "struct is_void<char> ; "
                            "struct is_void<void> : std :: true_type { } ; "
@@ -1852,7 +1852,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template78() {
         const char code[] = "template <typename>\n"
                             "struct Base { };\n"
-                            "struct S : Base <void>::Type { };";
+                            "struct S : Base <void>::Type { };\n";
         const char exp[] = "struct Base<void> ; "
                            "struct S : Base<void> :: Type { } ; "
                            "struct Base<void> { } ;";
@@ -1870,7 +1870,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "void some_func() {\n"
                             "    Foo x;\n"
                             "    x.foo<int>();\n"
-                            "}";
+                            "}\n";
         const char exp[] = "class Foo { "
                            "public: "
                            "void foo<int> ( ) ; "
@@ -1891,7 +1891,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "class Fred {\n"
                             "    template <typename T> T foo(T t) const { return t; }\n"
                             "};\n"
-                            "const void * p = Fred::foo<const void *>(nullptr);";
+                            "const void * p = Fred::foo<const void *>(nullptr);\n";
         const char exp[] = "class Fred { "
                            "const void * foo<constvoid*> ( const void * t ) const ; "
                            "} ; "
@@ -1909,7 +1909,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "SortWith<Type>::SortWith(Type) {}\n"
                             "int main() {\n"
                             "    SortWith<int>(0);\n"
-                            "}";
+                            "}\n";
         const char exp[] = "template < typename Type > "
                            "struct SortWith { "
                            "SortWith ( Type ) ; "
@@ -1939,7 +1939,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "  swizzle<1>(tt2);\n"
                             "  tvec3<f16> tt3;\n"
                             "  swizzle<2,3>(tt3);\n"
-                            "}";
+                            "}\n";
         const char exp[] = "const int f16 = 16 ; "
                            "class tvec2<f16> ; "
                            "class tvec3<f16> ; "
@@ -1970,7 +1970,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "MultiConsumer<Task>::MultiConsumer() : sizeBuffer(0) {}\n"
                             "MultiReads::MultiReads() {\n"
                             "    mc = new MultiConsumer<reads_packet>();\n"
-                            "}";
+                            "}\n";
         const char exp[] = "template < typename Task > " // TODO: this should be expanded
                            "class MultiConsumer { "
                            "MultiConsumer ( ) ; "
@@ -1988,7 +1988,7 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "template <class b, int c, class>\n"
                                 "auto d() -> typename a<decltype(b{})>::e {\n"
                                 "  d<int, c, int>();\n"
-                                "}";
+                                "}\n";
             const char exp[] = "template < class b , int c , class > "
                                "auto d ( ) . a < decltype ( b { } ) > :: e { "
                                "d < int , c , int > ( ) ; "
@@ -1999,8 +1999,8 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "template <class b, int c, class>\n"
                                 "auto d() -> typename a<decltype(b{})>::e {\n"
                                 "  d<int, c, int>();\n"
-                                "}"
-                                "void foo() { d<char, 1, int>(); }";
+                                "}\n"
+                                "void foo() { d<char, 1, int>(); }\n";
             const char exp[] = "auto d<char,1,int> ( ) . a < char > :: e ; "
                                "auto d<int,1,int> ( ) . a < int > :: e ; "
                                "void foo ( ) { d<char,1,int> ( ) ; } "
@@ -2024,7 +2024,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "extern template void C<int>::foo<int, nullptr>();\n"
                             "template<typename T>\n"
                             "template<typename U, typename std::enable_if<(!std::is_fundamental<U>::value)>::type>\n"
-                            "void C<T>::foo() {}";
+                            "void C<T>::foo() {}\n";
         // @todo the output is very wrong but we are only worried about the crash for now
         (void)tok(code);
     }
@@ -2040,7 +2040,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <typename T>\n"
                             "S<T> U<T>::u;\n"
                             "template S<int> U<int>::u;\n"
-                            "S<int> &i = U<int>::u;";
+                            "S<int> &i = U<int>::u;\n";
         (void)tok(code);
     }
 
@@ -2048,7 +2048,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template<typename T>\n"
                             "T f1(T t) { return t; }\n"
                             "template const char * f1<const char *>(const char *);\n"
-                            "template const char & f1<const char &>(const char &);";
+                            "template const char & f1<const char &>(const char &);\n";
         const char exp[] = "const char * f1<constchar*> ( const char * t ) ; "
                            "const char & f1<constchar&> ( const char & t ) ; "
                            "const char * f1<constchar*> ( const char * t ) { return t ; } "
@@ -2075,7 +2075,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "int main() {\n"
                             "    CTest::Greeting<bool>(true);\n"
                             "    return 0;\n"
-                            "}";
+                            "}\n";
         const char exp[] = "class CTest { "
                            "public: "
                            "static void Greeting<bool> ( bool ) ; "
@@ -2105,7 +2105,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template void Fred::foo<char>();\n"
                             "template void Fred::foo<float>();\n"
                             "template <> void Fred::foo<bool>() { }\n"
-                            "template <> void Fred::foo<int>() { }";
+                            "template <> void Fred::foo<int>() { }\n";
         const char exp[] = "struct Fred { "
                            "static void foo<int> ( ) ; "
                            "static void foo<bool> ( ) ; "
@@ -2123,7 +2123,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template <typename T> struct S1 {};\n"
                             "void f(S1<double>) {}\n"
                             "template <typename T>\n"
-                            "decltype(S1<T>().~S1<T>()) fun1() {};";
+                            "decltype(S1<T>().~S1<T>()) fun1() {};\n";
         const char exp[] = "struct S1<double> ; "
                            "void f ( S1<double> ) { } "
                            "template < typename T > "
@@ -2138,7 +2138,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "template<> char foo<char>(char a) { return a; }\n"
                                 "template<> int foo<int>(int a) { return a; }\n"
                                 "template float foo<float>(float);\n"
-                                "template double foo<double>(double);";
+                                "template double foo<double>(double);\n";
             const char exp[] = "int foo<int> ( int a ) ; "
                                "char foo<char> ( char a ) ; "
                                "float foo<float> ( float t ) ; "
@@ -2156,7 +2156,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "    template<> int foo<int>(int a) { return a; }\n"
                                 "};\n"
                                 "template float Fred::foo<float>(float);\n"
-                                "template double Fred::foo<double>(double);";
+                                "template double Fred::foo<double>(double);\n";
             const char exp[] = "struct Fred { "
                                "int foo<int> ( int a ) ; "
                                "char foo<char> ( char a ) ; "
@@ -2181,7 +2181,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "    template float NS2::foo<float>(float);\n"
                                 "    template bool NS1::NS2::foo<bool>(bool);\n"
                                 "}\n"
-                                "template double NS1::NS2::foo<double>(double);";
+                                "template double NS1::NS2::foo<double>(double);\n";
             const char exp[] = "namespace NS1 { "
                                "namespace NS2 { "
                                "int foo<int> ( int a ) ; "
@@ -2214,7 +2214,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "    template float NS::foo<float>(float);\n"
                                 "    template bool NS1::NS::foo<bool>(bool);\n"
                                 "}\n"
-                                "template double NS1::NS::foo<double>(double);";
+                                "template double NS1::NS::foo<double>(double);\n";
             const char exp[] = "namespace NS1 { "
                                "namespace NS { "
                                "int foo<int> ( int a ) ; "
@@ -2245,7 +2245,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    foo<int>(2);\n"
                             "    foo<double>(3.14);\n"
                             "    foo<float>(3.14f);\n"
-                            "}";
+                            "}\n";
         const char exp[] = "void foo<double> ( const double & d ) ; "
                            "void foo<float> ( const float & t ) ; "
                            "void foo<int> ( const int & t ) ; "
@@ -2274,7 +2274,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "void Vector2<Type>::process() {\n"
                             "    ForEach<iterator>();\n"
                             "}\n"
-                            "Vector2<string> c;";
+                            "Vector2<string> c;\n";
         const char exp[] = "void ForEach<iterator> ( ) ; "
                            "class Vector2<string> ; "
                            "Vector2<string> c ; "
@@ -2304,7 +2304,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "Array<T> matmul() {\n"
                             "    return foo<T>( );\n"
                             "}\n"
-                            "template Array<std::complex<float>> matmul<std::complex<float>>();";
+                            "template Array<std::complex<float>> matmul<std::complex<float>>();\n";
         const char exp[] = "class Array<double> ; "
                            "class Array<std::complex<float>> ; "
                            "class Array<float> ; "
@@ -2332,7 +2332,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template<>\n"
                             "int Value<int> = 456;\n"
                             "float f = Value<float>;\n"
-                            "int i = Value<int>;";
+                            "int i = Value<int>;\n";
         const char exp[] = "float Value<float> ; Value<float> = 123 ; "
                            "int Value<int> ; Value<int> = 456 ; "
                            "float f ; f = Value<float> ; "
@@ -2351,7 +2351,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "long f0 = fib<0>;\n"
                                 "long f1 = fib<1>;\n"
                                 "long f2 = fib<2>;\n"
-                                "long f3 = fib<3>;";
+                                "long f3 = fib<3>;\n";
             const char exp[] = "constexpr long fib<2> = fib<1> + fib<0> ; "
                                "constexpr long fib<3> = fib<2> + fib<1> ; "
                                "constexpr long fib<0> = 0 ; "
@@ -2411,7 +2411,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "}\n"
                             "using namespace NS1::NS2::NS3::NS4;\n"
                             "Fred<bool> fred_bool1;\n"
-                            "NS1::NS2::NS3::NS4::Fred<int> fred_int1;";
+                            "NS1::NS2::NS3::NS4::Fred<int> fred_int1;\n";
         const char exp[] = "namespace NS1 { "
                            "namespace NS2 { "
                            "namespace NS3 { "
@@ -2489,7 +2489,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    unique_ptr_with_deleter<A> tmp(new A(), [](A* a) {\n"
                             "        delete a;\n"
                             "    });\n"
-                            "}";
+                            "}\n";
         const char exp[] = "class A { } ; "
                            "static void func ( ) { "
                            "std :: unique_ptr < A , std :: function < void ( A * ) > > tmp ( new A ( ) , [ ] ( A * a ) { "
@@ -2537,7 +2537,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    using ArrayType = std::vector<int>;\n"
                             "    void func(typename ArrayType::size_type i) {\n"
                             "    }\n"
-                            "};";
+                            "};\n";
 
         const char exp[] = "class A { "
                            "public: "
@@ -2558,7 +2558,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "}\n"
                             "void f() {\n"
                             "    if(std::is_floating_point<float>::value) {}\n"
-                            "}";
+                            "}\n";
         const char exp[] = "namespace ns { "
                            "template < class T > "
                            "struct is_floating_point "
@@ -2583,7 +2583,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    return t;\n"
                             "  }\n"
                             "}\n"
-                            "sample::Sample<int> s1;";
+                            "sample::Sample<int> s1;\n";
         const char exp[] = "namespace sample { "
                            "class Sample<int> ; "
                            "} "
@@ -2609,7 +2609,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    BOOST_HANA_CONSTANT_CHECK ( hana :: equal (\n"
                             "        hana :: at_key ( hana :: make_map ( p < 0 , 0 > ( ) ) , key < 0 > ( ) ) ,\n"
                             "        val < 0 > ( ) ) ) ;\n"
-                            "}";
+                            "}\n";
         const char exp[] = "auto key<0> ( ) ; "
                            "auto val<0> ( ) ; "
                            "auto p<0,0> ( ) ; "
@@ -2629,7 +2629,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <template <typename> class TOUT>\n"
                             "class ObjectCache { };\n"
                             "template <typename T> class Fred {};\n"
-                            "ObjectCache<Fred> _cache;";
+                            "ObjectCache<Fred> _cache;\n";
         const char exp[] = "class ObjectCache<Fred> ; "
                            "template < typename T > class Fred { } ; "
                            "ObjectCache<Fred> _cache ; class ObjectCache<Fred> { } ;";
@@ -2644,7 +2644,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template<template<class T, class U> class V> class B {\n"
                             "   V<char, char> i;\n"
                             "};\n"
-                            "B<A> c;";
+                            "B<A> c;\n";
         const char exp[] = "class A<char,char> ; "
                            "class B<A> ; "
                            "B<A> c ; "
@@ -2670,7 +2670,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "};\n"
                             "void foo() {\n"
                             "  f<C3, long>();\n"
-                            "}";
+                            "}\n";
         const char exp[] = "void f<C3,long> ( ) ; "
                            "struct C3 { "
                            "class T3<long> ; "
@@ -2721,7 +2721,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "  bool h = f::h;\n"
                                 "};\n"
                                 "template <typename i> using j = typename e<i>::g;\n"
-                                "}";
+                                "}\n";
             const char exp[] = "namespace { "
                                "template < typename > struct a ; "
                                "template < typename > struct b { } ; "
@@ -2749,7 +2749,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "};\n"
                                 "template <typename i> using j = typename e<i>::g;\n"
                                 "}\n"
-                                "j<int> foo;";
+                                "j<int> foo;\n";
             const char exp[] = "namespace { "
                                "template < typename > struct a ; "
                                "struct b<c<int>::g> ; "
@@ -2835,7 +2835,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template<typename T> using A<T*> = char;\n"
                             "template<> using A<char> = char;\n"
                             "template using A<char> = char;\n"
-                            "using A<char> = char;";
+                            "using A<char> = char;\n";
         const char exp[] = "template < typename T > using A = int ; "
                            "template < typename T > using A < T * > = char ; "
                            "template < > using A < char > = char ; "
@@ -2846,7 +2846,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template111() { // crash
         const char code[] = "template<typename T, typename U> struct pair;\n"
-                            "template<typename T> using cell = pair<T*, cell<T>*>;";
+                            "template<typename T> using cell = pair<T*, cell<T>*>;\n";
         const char exp[] = "template < typename T , typename U > struct pair ; "
                            "template < typename T > using cell = pair < T * , cell < T > * > ;";
         ASSERT_EQUALS(exp, tok(code));
@@ -2856,7 +2856,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template <int> struct a;\n"
                             "template <class, class b> using c = typename a<int{b::d}>::e;\n"
                             "template <class> struct f;\n"
-                            "template <class b> using g = typename f<c<int, b>>::e;";
+                            "template <class b> using g = typename f<c<int, b>>::e;\n";
         const char exp[] = "template < int > struct a ; "
                            "template < class , class b > using c = typename a < int { b :: d } > :: e ; "
                            "template < class > struct f ; "
@@ -2867,7 +2867,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template113() {
         {
             const char code[] = "template <class> class A { void f(); };\n"
-                                "A<int> a;";
+                                "A<int> a;\n";
             const char exp[] = "class A<int> ; "
                                "A<int> a ; "
                                "class A<int> { void f ( ) ; } ;";
@@ -2875,7 +2875,7 @@ class TestSimplifyTemplate : public TestFixture {
         }
         {
             const char code[] = "template <struct> struct A { void f(); };\n"
-                                "A<int> a;";
+                                "A<int> a;\n";
             const char exp[] = "struct A<int> ; "
                                "A<int> a ; "
                                "struct A<int> { void f ( ) ; } ;";
@@ -2889,7 +2889,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "template <typename> struct c;\n"
                                 "template <typename> struct d : b<bool, std::is_polymorphic<int>{}> {};\n"
                                 "template <bool> struct e;\n"
-                                "template <typename a> using f = typename e<c<d<a>>::g>::h;";
+                                "template <typename a> using f = typename e<c<d<a>>::g>::h;\n";
             const char exp[] =  "template < typename a , a > struct b { } ; "
                                "template < typename > struct c ; "
                                "template < typename > struct d : b < bool , std :: is_polymorphic < int > { } > { } ; "
@@ -2921,7 +2921,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    }\n"
                             "    template <class c> using g = b::f<e<int, c>>;\n"
                             "}\n"
-                            "g<int> g1;";
+                            "g<int> g1;\n";
         const char exp[] = "namespace { "
                            "namespace b { "
                            "struct B<0> ; "
@@ -2938,7 +2938,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template116() { // #9178
         {
             const char code[] = "template <class, class a> auto b() -> decltype(a{}.template b<void(int, int)>);\n"
-                                "template <class, class a> auto b() -> decltype(a{}.template b<void(int, int)>){}";
+                                "template <class, class a> auto b() -> decltype(a{}.template b<void(int, int)>){}\n";
             const char exp[] = "template < class , class a > auto b ( ) . decltype ( a { } . template b < void ( int , int ) > ) ; "
                                "template < class , class a > auto b ( ) . decltype ( a { } . template b < void ( int , int ) > ) { }";
             ASSERT_EQUALS(exp, tok(code));
@@ -2949,7 +2949,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "struct c {\n"
                                 "  template <class> void b();\n"
                                 "};\n"
-                                "void d() { b<c, c>(); }";
+                                "void d() { b<c, c>(); }\n";
             const char exp[] = "auto b<c,c> ( ) . decltype ( c { } . template b < void ( int , int ) > ( ) ) ; "
                                "struct c { "
                                "template < class > void b ( ) ; "
@@ -2962,7 +2962,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template117() {
         const char code[] = "template<typename T = void> struct X {};\n"
-                            "X<X<>> x;";
+                            "X<X<>> x;\n";
         const char exp[] = "struct X<void> ; "
                            "struct X<X<void>> ; "
                            "X<X<void>> x ; "
@@ -2973,7 +2973,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template118() {
         const char code[] = "template<int> struct S { void f(int i); };\n"
-                            "S<1> s;";
+                            "S<1> s;\n";
         const char exp[] = "struct S<1> ; "
                            "S<1> s ; struct S<1> { "
                            "void f ( int i ) ; "
@@ -2988,7 +2988,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "template <typename T>\n"
                                 "constexpr auto funcBraced = [](auto x){ return T{x};};\n"
                                 "double f(int x) { return func<double>(x); }\n"
-                                "double fBraced(int x) { return funcBraced<int>(x); }";
+                                "double fBraced(int x) { return funcBraced<int>(x); }\n";
             const char exp[] = "constexpr auto func<double> = [ ] ( auto x ) { return double ( x ) ; } ; "
                                "constexpr auto funcBraced<int> = [ ] ( auto x ) { return int { x } ; } ; "
                                "double f ( int x ) { return func<double> ( x ) ; } "
@@ -3001,7 +3001,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "void foo() {\n"
                                 "    func<int>(x);\n"
                                 "    func<double>(x);\n"
-                                "}";
+                                "}\n";
             const char exp[] = "constexpr auto func<int> = [ ] ( auto x ) { return int ( x ) ; } ; "
                                "constexpr auto func<double> = [ ] ( auto x ) { return double ( x ) ; } ; "
                                "void foo ( ) { "
@@ -3025,7 +3025,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    template<typename This>\n"
                             "    struct result<This()> : lambda_context<tuple<> > {};\n"
                             "};\n"
-                            "lambda<int> l;";
+                            "lambda<int> l;\n";
         const char exp[] = "template < typename Tuple > "
                            "struct lambda_context { "
                            "template < typename Sig > struct result ; "
@@ -3044,7 +3044,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template121() { // #9193
         const char code[] = "template <class VALUE_T, class LIST_T = std::list<VALUE_T>>\n"
                             "class TestList { };\n"
-                            "TestList<std::shared_ptr<int>> m_test;";
+                            "TestList<std::shared_ptr<int>> m_test;\n";
         const char exp[] = "class TestList<std::shared_ptr<int>,std::list<std::shared_ptr<int>>> ; "
                            "TestList<std::shared_ptr<int>,std::list<std::shared_ptr<int>>> m_test ; "
                            "class TestList<std::shared_ptr<int>,std::list<std::shared_ptr<int>>> { } ;";
@@ -3058,7 +3058,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <template <class> class c, class... f, template <class...> class d>\n"
                             "struct b<c<f...>, d<>>;\n"
                             "}\n"
-                            "void e() { using c = a<>; }";
+                            "void e() { using c = a<>; }\n";
         const char exp[] = "template < class ... > struct a ; "
                            "namespace { "
                            "template < class , class > struct b ; "
@@ -3080,7 +3080,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "void fn1() {\n"
                             "  using c = a<>;\n"
                             "  using e = a<>;\n"
-                            "}";
+                            "}\n";
         const char exp[] = "template < class ... > struct a ; "
                            "namespace { "
                            "template < class , class , class , class > "
@@ -3099,7 +3099,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <typename> struct e;\n"
                             "template <typename> struct h {\n"
                             "  template <typename... f, c<h<e<typename f::d...>>::g>> void i();\n"
-                            "};";
+                            "};\n";
         const char exp[] = "template < bool > struct a ; "
                            "template < bool b > using c = typename a < b > :: d ; "
                            "template < typename > struct e ; "
@@ -3117,12 +3117,12 @@ class TestSimplifyTemplate : public TestFixture {
                                   "};\n"
                                   "int main() {\n"
                                   "  GCD< 1, 0 >::val;\n"
-                                  "}"), INSTANTIATION);
+                                  "}\n"), INSTANTIATION);
     }
 
     void template126() { // #9217
         const char code[] = "template <typename b> using d = a<b>;\n"
-                            "static_assert(i<d<l<b>>>{}, \"\");";
+                            "static_assert(i<d<l<b>>>{}, \"\");\n";
         const char exp[] = "static_assert ( i < a < l < b > > > { } , \"\" ) ;";
         ASSERT_EQUALS(exp, tok(code));
     }
@@ -3135,7 +3135,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "a<int> c;\n"
                                 "template <typename d>\n"
                                 "template <typename b>\n"
-                                "constexpr decltype(auto) a<d>::operator()(b &&) const {}";
+                                "constexpr decltype(auto) a<d>::operator()(b &&) const {}\n";
             const char exp[] = "struct a<int> ; "
                                "a<int> c ; "
                                "template < typename d > "
@@ -3163,7 +3163,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "template <typename d>\n"
                                 "template <typename b>\n"
                                 "void a<d>::foo() {}\n"
-                                "void bar() { a<int>::foo<char>(); }";
+                                "void bar() { a<int>::foo<char>(); }\n";
             const char exp[] = "struct a<int> ; "
                                "a<int> c ; "
                                "template < typename d > "
@@ -3194,7 +3194,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "template <typename d>\n"
                                 "template <typename b>\n"
                                 "void a<d>::foo() {}\n"
-                                "void bar() { a<int>::foo<char>(); }";
+                                "void bar() { a<int>::foo<char>(); }\n";
             const char exp[] = "struct a<int> ; "
                                "template < typename d > "
                                "template < typename b > "
@@ -3220,7 +3220,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template128() { // #9224
         const char code[] = "template <typename> struct a { };\n"
                             "template <typename j> void h() { k.h<a<j>>; }\n"
-                            "void foo() { h<int>(); }";
+                            "void foo() { h<int>(); }\n";
         const char exp[] = "struct a<int> ; "
                            "void h<int> ( ) ; "
                            "void foo ( ) { h<int> ( ) ; } "
@@ -3237,7 +3237,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "};\n"
                             "void setupLuaBindingsDNSQuestion() {\n"
                             "  g_lua.registerFunction<void (DNSQuestion ::*)(std ::string, std ::string)>();\n"
-                            "}";
+                            "}\n";
         const char exp[] = "class LuaContext { "
                            "public: "
                            "template < typename TFunctionType , typename TType > "
@@ -3254,7 +3254,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <typename, typename> using b = a<>;\n"
                             "template <typename, typename> void c();\n"
                             "template <typename d, typename> void e() { c<b<d, int>, int>; }\n"
-                            "void f() { e<int(int, ...), int>(); }";
+                            "void f() { e<int(int, ...), int>(); }\n";
         const char exp[] = "template < typename , typename > void c ( ) ; "
                            "void e<int(int,...),int> ( ) ; "
                            "void f ( ) { e<int(int,...),int> ( ) ; } "
@@ -3265,7 +3265,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template131() { // #9249
         {
             const char code[] = "template <long a, bool = 0 == a> struct b {};\n"
-                                "b<1> b1;";
+                                "b<1> b1;\n";
             const char exp[] = "struct b<1,false> ; "
                                "b<1,false> b1 ; "
                                "struct b<1,false> { } ;";
@@ -3273,7 +3273,7 @@ class TestSimplifyTemplate : public TestFixture {
         }
         {
             const char code[] = "template <long a, bool = 0 != a> struct b {};\n"
-                                "b<1> b1;";
+                                "b<1> b1;\n";
             const char exp[] = "struct b<1,true> ; "
                                "b<1,true> b1 ; "
                                "struct b<1,true> { } ;";
@@ -3281,7 +3281,7 @@ class TestSimplifyTemplate : public TestFixture {
         }
         {
             const char code[] = "template <long a, bool = a < 0> struct b {};\n"
-                                "b<1> b1;";
+                                "b<1> b1;\n";
             const char exp[] = "struct b<1,false> ; "
                                "b<1,false> b1 ; "
                                "struct b<1,false> { } ;";
@@ -3289,7 +3289,7 @@ class TestSimplifyTemplate : public TestFixture {
         }
         {
             const char code[] = "template <long a, bool = 0 < a> struct b {};\n"
-                                "b<1> b1;";
+                                "b<1> b1;\n";
             const char exp[] = "struct b<1,true> ; "
                                "b<1,true> b1 ; "
                                "struct b<1,true> { } ;";
@@ -3297,7 +3297,7 @@ class TestSimplifyTemplate : public TestFixture {
         }
         {
             const char code[] = "template <long a, bool = 0 <= a> struct b {};\n"
-                                "b<1> b1;";
+                                "b<1> b1;\n";
             const char exp[] = "struct b<1,true> ; "
                                "b<1,true> b1 ; "
                                "struct b<1,true> { } ;";
@@ -3305,7 +3305,7 @@ class TestSimplifyTemplate : public TestFixture {
         }
         {
             const char code[] = "template <long a, bool = a >= 0> struct b {};\n"
-                                "b<1> b1;";
+                                "b<1> b1;\n";
             const char exp[] = "struct b<1,true> ; "
                                "b<1,true> b1 ; "
                                "struct b<1,true> { } ;";
@@ -3324,7 +3324,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "}\n"
                             "int f1() {\n"
                             "  return foo<TrueFalse>();\n"
-                            "}";
+                            "}\n";
         const char exp[] = "struct TrueFalse { "
                            "static constexpr bool v ( ) { return true ; } "
                            "} ; "
@@ -3349,7 +3349,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "bar<short> bs;\n"
                             "bar<std::array<int,4>> ba;\n"
                             "bar<short> b1 = bar<short>::foo<std::array<int,4>>(ba);\n"
-                            "bar<std::array<int,4>> b2 = bar<std::array<int,4>>::foo<short>(bs);";
+                            "bar<std::array<int,4>> b2 = bar<std::array<int,4>>::foo<short>(bs);\n";
         const char act[] = "struct bar<short> ; struct bar<std::array<int,4>> ; "
                            "bar<short> bs ; "
                            "bar<std::array<int,4>> ba ; "
@@ -3391,7 +3391,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template <int a> class e { };\n"
                             "template <int a> class b { e<(c > a ? 1 : 0)> d; };\n"
                             "b<0> b0;\n"
-                            "b<1> b1;";
+                            "b<1> b1;\n";
         const char exp[] = "class e<(c>0)> ; class e<(c>1)> ; "
                            "class b<0> ; class b<1> ; "
                            "b<0> b0 ; "
@@ -3403,7 +3403,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template135() {
         const char code[] = "template <int> struct a { template <int b> void c(a<b>); };\n"
-                            "a<2> d;";
+                            "a<2> d;\n";
         const char exp[] = "struct a<2> ; "
                            "a<2> d ; "
                            "struct a<2> { template < int b > void c ( a < b > ) ; } ;";
@@ -3422,7 +3422,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "}\n"
                             "namespace hana = a;\n"
                             "using e = int;\n"
-                            "void l(hana::d<hana::i<e>>);";
+                            "void l(hana::d<hana::i<e>>);\n";
         const char exp[] = "namespace a { "
                            "template < typename > struct b ; "
                            "template < int > struct c ; "
@@ -3442,7 +3442,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <class, template <class> class, class> struct e;\n"
                             "template <class f, class g, class... h>\n"
                             "using i = typename e<f, g::template fn, h...>::d;\n"
-                            "template <class... j> struct k : c<sizeof...(j), int>::template fn<j...> {};";
+                            "template <class... j> struct k : c<sizeof...(j), int>::template fn<j...> {};\n";
         const char exp[] = "template < bool > struct a ; "
                            "template < bool b , class > using c = typename a < b > :: d ; "
                            "template < class , template < class > class , class > struct e ; "
@@ -3463,7 +3463,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "};\n"
                                 "int main() {\n"
                                 "  return 0;\n"
-                                "}";
+                                "}\n";
             const char exp[] = "struct inferior { "
                                "template < typename T > "
                                "bool operator() ( const T & a , const T & b ) const { "
@@ -3484,7 +3484,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "};\n"
                                 "int main() {\n"
                                 "  return 0;\n"
-                                "}";
+                                "}\n";
             const char exp[] = "struct inferior { "
                                "template < typename T > "
                                "bool operator() ( const T & a , const T & b ) const { "
@@ -3506,7 +3506,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "};\n"
                                 "int main() {\n"
                                 "  return 0;\n"
-                                "}";
+                                "}\n";
             const char exp[] = "struct inferior { "
                                "template < typename T > "
                                "bool operator() ( const T & a , const T & b ) const { "
@@ -3527,7 +3527,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "};\n"
                                 "int main() {\n"
                                 "  return 0;\n"
-                                "}";
+                                "}\n";
             const char exp[] = "struct inferior { "
                                "template < typename T > "
                                "bool operator() ( const T & a , const T & b ) const { "
@@ -3546,7 +3546,7 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "template<typename T>\n"
                                 "struct Foo {\n"
                                 "  template<typename> friend struct Foo;\n"
-                                "};";
+                                "};\n";
             const char exp[] = "template < typename T > "
                                "struct Foo { "
                                "template < typename > friend struct Foo ; "
@@ -3558,7 +3558,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "struct Foo {\n"
                                 "  template<typename> friend struct Foo;\n"
                                 "} ;\n"
-                                "Foo<int> foo;";
+                                "Foo<int> foo;\n";
             const char exp[] = "struct Foo<int> ; "
                                "Foo<int> foo ; "
                                "struct Foo<int> { "
@@ -3575,7 +3575,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "    d();\n"
                                 "    d(d<a<b>> e);\n"
                                 "};\n"
-                                "void foo() { d<char> c; }";
+                                "void foo() { d<char> c; }\n";
             const char exp[] = "struct a<char> ; "
                                "struct d<char> ; "
                                "void foo ( ) { d<char> c ; } "
@@ -3592,7 +3592,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "template <typename> constexpr bool e() { return false; }\n"
                                 "template <typename b> class f { f(f<c<b>>); };\n"
                                 "static_assert(!e<f<char>>());\n"
-                                "}";
+                                "}\n";
             const char exp[] = "namespace a { "
                                "constexpr bool e<f<char>> ( ) ; "
                                "class f<char> ; "
@@ -3607,7 +3607,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "struct a {\n"
                             "  int c;\n"
                             "  template <typename b> void d(b e) const { c < *e; }\n"
-                            "};";
+                            "};\n";
         const char exp[] = "struct a { "
                            "int c ; "
                            "template < typename b > void d ( b e ) const { c < * e ; } "
@@ -3620,7 +3620,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <typename b, typename c, typename... d> struct a<b c::*, d...> {\n"
                             "  using typename b ::e;\n"
                             "  static_assert(e::f ? sizeof...(d) : sizeof...(d), \"\");\n"
-                            "};";
+                            "};\n";
         const char exp[] = "template < typename ... > struct a ; "
                            "template < typename b , typename c , typename ... d > struct a < b c :: * , d ... > { "
                            "using e = b :: e ; "
@@ -3638,7 +3638,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "A2<bool> a2;\n"
                             "template<class T>\n"
                             "using A3 = enum B3 {b = 0};\n"
-                            "A3<int> a3;";
+                            "A3<int> a3;\n";
         const char exp[] = "template < int N > "
                            "using A1 = struct B1 { static auto constexpr value = N ; } ; "
                            "A1 < 0 > a1 ; "
@@ -3660,7 +3660,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <typename T>\n"
                             "struct promote <T, typename std::enable_if< std::is_integral<T>::value && sizeof(T) < sizeof(int) >::type>{\n"
                             "};\n"
-                            "}";
+                            "}\n";
         const char exp[] = "namespace a { "
                            "template < typename T , typename enable = void > "
                            "struct promote { "
@@ -3674,7 +3674,7 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template145() { // syntax error
-        const char code[] = "template<template<typename, Ts = 0> class ...Cs, Cs<Ts> ...Vs> struct B { };";
+        const char code[] = "template<template<typename, Ts = 0> class ...Cs, Cs<Ts> ...Vs> struct B { };\n";
         const char exp[] = "template < template < typename , Ts = 0 > class ... Cs , Cs < Ts > ... Vs > struct B { } ;";
         ASSERT_EQUALS(exp, tok(code));
     }
@@ -3684,7 +3684,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template<class T, template<class TT_T0, template<class TT_T1> class TT_TT> class TT, class U = TT<int, C> >\n"
                             "struct S {\n"
                             "  void foo(TT<T, C>);\n"
-                            "};";
+                            "};\n";
         const char exp[] = "template < class T > struct C { } ; "
                            "template < class T , template < class TT_T0 , template < class TT_T1 > class TT_TT > class TT , class U = TT < int , C > > "
                            "struct S { "
@@ -3694,7 +3694,7 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template147() { // syntax error
-        const char code[] = "template <template <typename> class C, typename X, C<X>*> struct b { };";
+        const char code[] = "template <template <typename> class C, typename X, C<X>*> struct b { };\n";
         const char exp[] = "template < template < typename > class C , typename X , C < X > * > struct b { } ;";
         ASSERT_EQUALS(exp, tok(code));
     }
@@ -3702,7 +3702,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template148() { // syntax error
         const char code[] = "static_assert(var<S1<11, 100>> == var<S1<199, 23>> / 2\n"
                             "  && var<S1<50, 120>> == var<S1<150, var<S1<10, 10>>>>\n"
-                            "  && var<S1<53, 23>> != 222, \"\");";
+                            "  && var<S1<53, 23>> != 222, \"\");\n";
         const char exp[] = "static_assert ( var < S1 < 11 , 100 > > == var < S1 < 199 , 23 > > / 2 "
                            "&& var < S1 < 50 , 120 > > == var < S1 < 150 , var < S1 < 10 , 10 > > > > "
                            "&& var < S1 < 53 , 23 > > != 222 , \"\" ) ;";
@@ -3712,7 +3712,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template149() { // unknown macro
         const char code[] = "BEGIN_VERSIONED_NAMESPACE_DECL\n"
                             "template<typename T> class Fred { };\n"
-                            "END_VERSIONED_NAMESPACE_DECL";
+                            "END_VERSIONED_NAMESPACE_DECL\n";
         ASSERT_THROW_INTERNAL_EQUALS(tok(code), UNKNOWN_MACRO, "There is an unknown macro here somewhere. Configuration is required. If BEGIN_VERSIONED_NAMESPACE_DECL is a macro then please configure it.");
     }
 
@@ -3724,7 +3724,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "void foo() {\n"
                             "  Test test;\n"
                             "  const string type = test.operator[]<string>(\"type\");\n"
-                            "}";
+                            "}\n";
         const char exp[] = "struct Test { "
                            "string & operator[]<string> ( string ) ; "
                            "} ; "
@@ -3747,7 +3747,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "class GenericConfigurationHandler {\n"
                                 "  data_container<int, std::allocator<int>> m_target_configurations;\n"
                                 "};\n"
-                                "class TargetConfigurationHandler : public GenericConfigurationHandler<int> { };";
+                                "class TargetConfigurationHandler : public GenericConfigurationHandler<int> { };\n";
             const char exp[] = "class SimulationComponentGroupGenerator { "
                                "std :: list < int , std :: allocator < int > > build ( ) const ; "
                                "} ; "
@@ -3761,7 +3761,7 @@ class TestSimplifyTemplate : public TestFixture {
         {
             const char code[] = "std::list<std::allocator<int>> a;\n"
                                 "template <class, template <class> class allocator = std::allocator> class b {};\n"
-                                "class c : b<int> {};";
+                                "class c : b<int> {};\n";
             const char exp[] = "std :: list < std :: allocator < int > > a ; "
                                "class b<int,std::allocator> ; "
                                "class c : b<int,std::allocator> { } ; "
@@ -3772,7 +3772,7 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "template <typename> class a {};\n"
                                 "template class a<char>;\n"
                                 "template <class, template <class> class a = a> class b {};\n"
-                                "class c : b<int> {};";
+                                "class c : b<int> {};\n";
             const char exp[] = "class a<char> ; "
                                "class b<int,a> ; "
                                "class c : b<int,a> { } ; "
@@ -3796,7 +3796,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "int global() {\n"
                             "  int bar = 1;\n"
                             "  return bar;\n"
-                            "}";
+                            "}\n";
         const char exp[] = "class Foo { "
                            "bool bar<9> ( ) ; "
                            "template < unsigned int i > "
@@ -3815,13 +3815,13 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template153() { // #9483
-        const char code[] = "template <class = b<decltype(a<h>())...>> void i();";
+        const char code[] = "template <class = b<decltype(a<h>())...>> void i();\n";
         const char exp[] = "template < class = b < decltype ( a < h > ( ) ) ... > > void i ( ) ;";
         ASSERT_EQUALS(exp, tok(code));
     }
 
     void template154() { // #9495
-        const char code[] = "template <typename S, enable_if_t<(is_compile_string<S>::value), int>> void i(S s);";
+        const char code[] = "template <typename S, enable_if_t<(is_compile_string<S>::value), int>> void i(S s);\n";
         const char exp[] = "template < typename S , enable_if_t < ( is_compile_string < S > :: value ) , int > > void i ( S s ) ;";
         ASSERT_EQUALS(exp, tok(code));
     }
@@ -3834,7 +3834,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "void c() {\n"
                             "  b d;\n"
                             "  d[a<0>];\n"
-                            "}";
+                            "}\n";
         const char exp[] = "int a<0> ; "
                            "a<0> = 0 ; "
                            "struct b { "
@@ -3857,7 +3857,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <typename j> using k = e<i<j>::d>;\n"
                             "template <typename j> using l = h<k<j>::d, e<1 < (j)0>, f>;\n"
                             "template <typename> void m(int, int, int) { l<int> d; }\n"
-                            "void n() { m<int>(0, 4, 5); }";
+                            "void n() { m<int>(0, 4, 5); }\n";
         (void)tok(code); // don't crash
     }
 
@@ -3873,7 +3873,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "b3<0> var3;\n"
                             "b4<0> var4;\n"
                             "b5<0> var5;\n"
-                            "b6<0> var6;";
+                            "b6<0> var6;\n";
         const char exp[] = "struct b1<0,true> ; "
                            "struct b2<0,false> ; "
                            "struct b3<0,false> ; "
@@ -4098,7 +4098,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "b<a97<int>> d97;\n"
                             "b<a98<int>> d98;\n"
                             "b<a99<int>> d99;\n"
-                            "b<a100<int>> d100;";
+                            "b<a100<int>> d100;\n";
         // don't bother checking the output because this is not instantiated properly
         (void)tok(code); // don't crash
 
@@ -4130,7 +4130,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "tester<impl*, int> ti;\n"
                             "template<class T, class U, class = decltype(impl::create<T>()->impl::create<U>())>\n"
                             "int test() { return 0; }\n"
-                            "int i = test<impl*, int>();";
+                            "int i = test<impl*, int>();\n";
         const char exp[]  = "struct impl { template < class T > static T create ( ) ; } ; "
                             "struct tester<impl*,int,decltype(impl::create<impl*>().impl::create<int>())> ; "
                             "tester<impl*,int,decltype(impl::create<impl*>().impl::create<int>())> ti ; "
@@ -4149,7 +4149,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template void Fred::foo<char>();\n"
                             "template <> void Fred::foo<bool>() { }\n"
                             "template void Fred::foo<float>(float);\n"
-                            "template <> void Fred::foo<int>(int) { }";
+                            "template <> void Fred::foo<int>(int) { }\n";
         const char exp[]  = "struct Fred { "
                             "static void foo<bool> ( ) ; "
                             "static void foo<char> ( ) ; "
@@ -4172,7 +4172,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "};\n"
                             "void foo() {\n"
                             "   auto notifyJob = std::make_shared<adapter<JobEntry>> ();\n"
-                            "}";
+                            "}\n";
         const char exp[]  = "???";
         const char act[]  = "struct JobEntry { } ; "
                             "struct adapter<JobEntry> ; "
@@ -4190,12 +4190,12 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template <std::size_t N>\n"
                             "struct CountryCode {\n"
                             "    CountryCode(std::string cc);\n"
-                            "};"
+                            "};\n"
                             "template <std::size_t N>\n"
                             "CountryCode<N>::CountryCode(std::string cc) : m_String{std::move(cc)} {\n"
                             "}\n"
                             "template class CountryCode<2>;\n"
-                            "template class CountryCode<3>;";
+                            "template class CountryCode<3>;\n";
         const char exp[]  = "struct CountryCode<2> ; "
                             "struct CountryCode<3> ; "
                             "struct CountryCode<2> { "
@@ -4212,7 +4212,7 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template163() { // #9685 syntax error
-        const char code[] = "extern \"C++\" template < typename T > T * test ( ) { return nullptr ; }";
+        const char code[] = "extern \"C++\" template < typename T > T * test ( ) { return nullptr ; }\n";
         const char expected[] = "template < typename T > T * test ( ) { return nullptr ; }";
         ASSERT_EQUALS(expected, tok(code));
     }
@@ -4231,7 +4231,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <class TYPE>\n"
                             "void A<TYPE>::f() { }\n"
                             "template class A<int>;\n"
-                            "template class A<float>;";
+                            "template class A<float>;\n";
         const char exp[]  = "struct A<int> ; "
                             "struct A<float> ; "
                             "struct A<int> { "
@@ -4259,7 +4259,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    bool operator()(const T& l, const T& r) const {\n"
                             "        return l.first < r.first;\n"
                             "    }\n"
-                            "};";
+                            "};\n";
         const char exp[]  = "struct MyStruct { "
                             "template < class T > "
                             "bool operator() ( const T & l , const T & r ) const { "
@@ -4272,7 +4272,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template166() { // #10081 hang
         const char code[] = "template <typename T, size_t k = (T::s < 3) ? 0 : 3>\n"
                             "void foo() {}\n"
-                            "foo<T>();";
+                            "foo<T>();\n";
         const char exp[]  = "void foo<T,(T::s<3)?0:3> ( ) ; "
                             "foo<T,(T::s<3)?0:3> ( ) ; "
                             "void foo<T,(T::s<3)?0:3> ( ) { }";
@@ -4291,7 +4291,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "}\n"
                             "void foo() {\n"
                             "    std::string str = MathLib::toString(1.0);\n"
-                            "}";
+                            "}\n";
         const char exp[]  = "struct MathLib { "
                             "static std :: string toString<double> ( double value ) ; "
                             "template < class T > static std :: string toString ( T value ) { "
@@ -4321,7 +4321,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template < > struct type < long long, long long > {};\n"
                             "template < > struct type < double, double > {};\n"
                             "template < > struct type < float, float > {};\n"
-                            "template < > struct type < long double, long double > {};";
+                            "template < > struct type < long double, long double > {};\n";
         const char exp[]  = "struct type<longdouble,longdouble> ; "
                             "struct type<float,float> ; "
                             "struct type<double,double> ; "
@@ -4369,7 +4369,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "CImgList < last < long long > > c12;\n"
                             "CImgList < last < float > > c13;\n"
                             "CImgList < last < double > > c14;\n"
-                            "CImgList < last < long double > > c15;";
+                            "CImgList < last < long double > > c15;\n";
         const char exp[]  = "struct last<bool> ; "
                             "struct last<signedchar> ; "
                             "struct last<unsignedchar> ; "
@@ -4453,7 +4453,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "void c() {\n"
                             "  a<1>;\n"
                             "  [](auto b) {};\n"
-                            "}";
+                            "}\n";
         const char exp[]  = "int a<1> ; a<1> = 0 ; "
                             "void c ( ) { "
                             "a<1> ; "
@@ -4466,7 +4466,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template <int> struct c { enum { b }; };\n"
                             "template <int> struct h { enum { d }; enum { e }; };\n"
                             "template <int f, long = h<f>::d, int g = h<f>::e> class i { enum { e = c<g>::b }; };\n"
-                            "void j() { i<2> a; }";
+                            "void j() { i<2> a; }\n";
         const char exp[]  = "struct c<h<2>::e> ; "
                             "struct h<2> ; "
                             "class i<2,h<2>::d,h<2>::e> ; "
@@ -4486,7 +4486,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template172() { // #10258 crash
         const char code[] = "template<typename T, typename... Args>\n"
                             "void bar(T t, Args&&... args) { }\n"
-                            "void foo() { bar<int>(0, 1); }";
+                            "void foo() { bar<int>(0, 1); }\n";
         const char exp[]  = "void bar<int> ( int t , Args && ... args ) ; "
                             "void foo ( ) { bar<int> ( 0 , 1 ) ; } "
                             "void bar<int> ( int t , Args && ... args ) { }";
@@ -4502,7 +4502,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "}\n"
                             "namespace std {\n"
                             "template <> void swap<a::d>(a::d &, a::d &) {}\n"
-                            "}";
+                            "}\n";
         const char exp[]  = "namespace a { "
                             "template < typename , typename > struct b ; "
                             "template < template < typename , typename > class > class c ; "
@@ -4563,7 +4563,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template177() {
         const char code[] = "template <typename Encoding, typename Allocator>\n"
                             "class C { xyz<Encoding, Allocator> x; };\n"
-                            "C<UTF8<>, MemoryPoolAllocator<>> c;";
+                            "C<UTF8<>, MemoryPoolAllocator<>> c;\n";
         const char exp[] = "class C<UTF8<>,MemoryPoolAllocator<>> ; "
                            "C<UTF8<>,MemoryPoolAllocator<>> c ; "
                            "class C<UTF8<>,MemoryPoolAllocator<>> { xyz < UTF8 < > , MemoryPoolAllocator < > > x ; } ;";
@@ -4577,7 +4577,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "}\n"
                             "void f() {\n"
                             "    g<int>();\n"
-                            "}";
+                            "}\n";
         const char exp[] = "void g<int> ( ) ; void f ( ) { g<int> ( ) ; } void g<int> ( ) { for ( int i = 0 ; i < int { 3 } ; ++ i ) { } }";
         ASSERT_EQUALS(exp, tok(code));
 
@@ -4592,7 +4592,7 @@ class TestSimplifyTemplate : public TestFixture {
                              "void f() {\n"
                              "    S<char> s{};\n"
                              "    s.g<int>();\n"
-                             "}";
+                             "}\n";
         const char exp2[] = "struct S<char> ; void f ( ) { S<char> s { } ; s . g<int> ( ) ; } struct S<char> { char c ; void g<int> ( ) ; } ; "
                             "void S<char> :: g<int> ( ) { for ( int i = 0 ; i < int { 3 } ; ++ i ) { } }";
         ASSERT_EQUALS(exp2, tok(code2));
@@ -4732,7 +4732,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template <typename T> struct C {};\n"
                             "template <typename T> struct S {a};\n"
                             "template <typename T> struct S<C<T>> {b};\n"
-                            "S<int> s;";
+                            "S<int> s;\n";
         const char exp[]  = "template < typename T > struct C { } ; struct S<int> ; template < typename T > struct S < C < T > > { b } ; S<int> s ; struct S<int> { a } ;";
         ASSERT_EQUALS(exp, tok(code));
     }
@@ -4741,7 +4741,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template <typename T> struct C {};\n"
                             "template <typename T> struct S {a};\n"
                             "template <typename T> struct S<C<T>> {b};\n"
-                            "S<C<int>> s;";
+                            "S<C<int>> s;\n";
         const char exp[]  = "template < typename T > struct C { } ; template < typename T > struct S { a } ; struct S<C<int>> ; S<C<int>> s ; struct S<C<int>> { b } ;";
         ASSERT_EQUALS(exp, tok(code));
     }
@@ -4793,7 +4793,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "struct template_is_const\n"
                             "{\n"
                             "    enum {value = !type_equal<T, typename Unconst<T>::type>::value  };\n"
-                            "};";
+                            "};\n";
         const char exp[] = "template < class T > struct Unconst { } ; "
                            "template < class T > struct Unconst < const T > { } ; "
                            "template < class T > struct Unconst < const T & > { } ; "
@@ -4876,7 +4876,7 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "class A { }; "
                                 "template<class T> class B { }; "
                                 "template<class T1, class T2 = B<T1>> class C { }; "
-                                "template<class T1 = A, typename T2 = B<A>> class D { };";
+                                "template<class T1 = A, typename T2 = B<A>> class D { };\n";
             ASSERT_EQUALS("class A { } ; "
                           "template < class T > class B { } ; "
                           "template < class T1 , class T2 = B < T1 > > class C { } ; "
@@ -4884,9 +4884,9 @@ class TestSimplifyTemplate : public TestFixture {
         }
         {
             // #7548
-            const char code[] = "template<class T, class U> class DefaultMemory {}; "
-                                "template<class Key, class Val, class Mem=DefaultMemory<Key,Val> > class thv_table_c  {}; "
-                                "thv_table_c<void *,void *> id_table_m;";
+            const char code[] = "template<class T, class U> class DefaultMemory {};\n"
+                                "template<class Key, class Val, class Mem=DefaultMemory<Key,Val> > class thv_table_c  {};\n"
+                                "thv_table_c<void *,void *> id_table_m;\n";
             const char exp[] = "template < class T , class U > class DefaultMemory { } ; "
                                "class thv_table_c<void*,void*,DefaultMemory<void*,void*>> ; "
                                "thv_table_c<void*,void*,DefaultMemory<void*,void*>> id_table_m ; "
@@ -4901,7 +4901,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "void f() {\n"
                                 "  a<> b;\n"
                                 "  b.a<>::c();\n"
-                                "}";
+                                "}\n";
             ASSERT_EQUALS("struct a<void> ; "
                           "void f ( ) { "
                           "a<void> b ; "
@@ -4930,7 +4930,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "    B b;\n"
                                 "    b.A<>::Print();\n"
                                 "    return 0;\n"
-                                "}";
+                                "}\n";
             ASSERT_EQUALS("class A<void> ; "
                           "template < typename T0 > class A ; "
                           "class A<void> { "
@@ -5010,7 +5010,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "struct ei_solve_triangular_selector<Lhs,UpLo> {\n"
                                 "};\n"
                                 "template<typename Lhs, int TriangularPart>\n"
-                                "struct ei_solve_triangular_selector { };";
+                                "struct ei_solve_triangular_selector { };\n";
 
             const char exp[] = "template < typename Lhs , int TriangularPart = ( int ( Lhs :: Flags ) & LowerTriangularBit ) > "
                                "struct ei_solve_triangular_selector ; "
@@ -5036,7 +5036,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "{\n"
                                 "  return T{};\n"
                                 "}\n"
-                                "Foo<> f;";
+                                "Foo<> f;\n";
             const char exp[] = "class Foo<128,wchar_t> ; Foo<128,wchar_t> f ; "
                                "class Foo<128,wchar_t> { public: wchar_t operator[] ( int Index ) const ; } ; "
                                "wchar_t Foo<128,wchar_t> :: operator[] ( int Index ) const { return wchar_t { } ; }";
@@ -5077,7 +5077,7 @@ class TestSimplifyTemplate : public TestFixture {
         {
             const char code[] = "template <class T>\n"
                                 "void foo(typename T::t *)\n"
-                                "{ }";
+                                "{ }\n";
 
             // The expected result..
             const char expected[] = "template < class T > void foo ( T :: t * ) { }";
@@ -5088,7 +5088,7 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "void f() {\n"
                                 "    x(sizeof typename);\n"
                                 "    type = 0;\n"
-                                "}";
+                                "}\n";
 
             ASSERT_EQUALS("void f ( ) { x ( sizeof ( typename ) ) ; type = 0 ; }", tok(code));
         }
@@ -5099,37 +5099,37 @@ class TestSimplifyTemplate : public TestFixture {
         //         "no constructor" false positives
         const char code[] = "class Fred {\n"
                             "    template<class T> explicit Fred(T t) { }\n"
-                            "};";
+                            "};\n";
         ASSERT_EQUALS("class Fred { template < class T > explicit Fred ( T t ) { } } ;", tok(code));
 
         // #3532
         const char code2[] = "class Fred {\n"
                              "    template<class T> Fred(T t) { }\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("class Fred { template < class T > Fred ( T t ) { } } ;", tok(code2));
     }
 
     void syntax_error_templates_1() {
         // ok code.. using ">" for a comparison
-        ASSERT_NO_THROW(tok("x<y>z> xyz;"));
+        ASSERT_NO_THROW(tok("x<y>z> xyz;\n"));
         ASSERT_EQUALS("", errout_str());
 
         // ok code
-        ASSERT_NO_THROW(tok("template<class T> operator<(T a, T b) { }"));
+        ASSERT_NO_THROW(tok("template<class T> operator<(T a, T b) { }\n"));
         ASSERT_EQUALS("", errout_str());
 
         // ok code (ticket #1984)
         ASSERT_NO_THROW(tok("void f(a) int a;\n"
-                            "{ ;x<y; }"));
+                            "{ ;x<y; }\n"));
         ASSERT_EQUALS("", errout_str());
 
         // ok code (ticket #1985)
         ASSERT_NO_THROW(tok("void f()\n"
-                            "{ try { ;x<y; } }"));
+                            "{ try { ;x<y; } }\n"));
         ASSERT_EQUALS("", errout_str());
 
         // ok code (ticket #3183)
-        ASSERT_NO_THROW(tok("MACRO(({ i < x }))"));
+        ASSERT_NO_THROW(tok("MACRO(({ i < x }))\n"));
         ASSERT_EQUALS("", errout_str());
 
         // bad code.. missing ">"
@@ -5152,7 +5152,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    }\n"
                             "private:\n"
                             "    A a;\n"
-                            "};"));
+                            "};\n"));
         ASSERT_EQUALS("", errout_str());
 
         //both of these should work but in cppcheck 2.1 only the first option will work (ticket #9843)
@@ -5170,30 +5170,30 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template_member_ptr() { // Ticket #5786 (segmentation fault)
-        (void)tok("struct A {}; "
-                  "struct B { "
-                  "template <void (A::*)() const> struct BB {}; "
-                  "template <bool BT> static bool foo(int) { return true; } "
-                  "void bar() { bool b = foo<true>(0); }"
-                  "};");
-        (void)tok("struct A {}; "
-                  "struct B { "
-                  "template <void (A::*)() volatile> struct BB {}; "
-                  "template <bool BT> static bool foo(int) { return true; } "
-                  "void bar() { bool b = foo<true>(0); }"
-                  "};");
-        (void)tok("struct A {}; "
-                  "struct B { "
-                  "template <void (A::*)() const volatile> struct BB {}; "
-                  "template <bool BT> static bool foo(int) { return true; } "
-                  "void bar() { bool b = foo<true>(0); }"
-                  "};");
-        (void)tok("struct A {}; "
-                  "struct B { "
-                  "template <void (A::*)() volatile const> struct BB {}; "
-                  "template <bool BT> static bool foo(int) { return true; } "
-                  "void bar() { bool b = foo<true>(0); }"
-                  "};");
+        (void)tok("struct A {};\n"
+                  "struct B {\n"
+                  "template <void (A::*)() const> struct BB {};\n"
+                  "template <bool BT> static bool foo(int) { return true; }\n"
+                  "void bar() { bool b = foo<true>(0); }\n"
+                  "};\n");
+        (void)tok("struct A {};\n"
+                  "struct B {\n"
+                  "template <void (A::*)() volatile> struct BB {};\n"
+                  "template <bool BT> static bool foo(int) { return true; }\n"
+                  "void bar() { bool b = foo<true>(0); }\n"
+                  "};\n");
+        (void)tok("struct A {};\n"
+                  "struct B {\n"
+                  "template <void (A::*)() const volatile> struct BB {};\n"
+                  "template <bool BT> static bool foo(int) { return true; }\n"
+                  "void bar() { bool b = foo<true>(0); }\n"
+                  "};\n");
+        (void)tok("struct A {};\n"
+                  "struct B {\n"
+                  "template <void (A::*)() volatile const> struct BB {};\n"
+                  "template <bool BT> static bool foo(int) { return true; }\n"
+                  "void bar() { bool b = foo<true>(0); }\n"
+                  "};\n");
     }
 
     void template_namespace_1() {
@@ -5201,7 +5201,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "namespace {\n"
                             "  template<class T> void Fred(T value) { }\n"
                             "}\n"
-                            "Fred<int>(123);";
+                            "Fred<int>(123);\n";
         ASSERT_EQUALS("namespace { "
                       "void Fred<int> ( int value ) ; "
                       "} "
@@ -5214,7 +5214,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "namespace X {\n"
                             "  template<class T> struct S { };\n"
                             "}\n"
-                            "X::S<int> s;";
+                            "X::S<int> s;\n";
         ASSERT_EQUALS("namespace X { "
                       "struct S<int> ; "
                       "} "
@@ -5228,7 +5228,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    static void *bar();\n"
                             "  };\n"
                             "  void *test() { return foo<int>::bar(); }\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("namespace test16 {"
                       " struct foo<int> ;"
                       " void * test ( ) {"
@@ -5248,7 +5248,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "      A<int>::dostuff();\n"
                             "    }\n"
                             "  };\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("namespace foo {"
                       " class A<int> ;"
                       " struct S : public A<int> {"
@@ -5262,7 +5262,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template_namespace_5() {
         const char code[] = "template<class C> struct S {};\n"
-                            "namespace X { S<int> s; }";
+                            "namespace X { S<int> s; }\n";
         ASSERT_EQUALS("struct S<int> ; "
                       "namespace X { S<int> s ; } "
                       "struct S<int> { } ;", tok(code));
@@ -5283,7 +5283,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <typename T> NS::C<T>::C() {}\n"
                             "template <typename T> NS::C<T>::~C() {}\n"
                             "template <typename T> NS::C<T>::C(const NS::C<T> &) {}\n"
-                            "template <typename T> NS::C<T> & NS::C<T>::operator=(const NS::C<T> &) {}";
+                            "template <typename T> NS::C<T> & NS::C<T>::operator=(const NS::C<T> &) {}\n";
         ASSERT_EQUALS("namespace NS { "
                       "union C<int> ; "
                       "} "
@@ -5313,7 +5313,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "N2::CT<int> ct2;\n"
                             "}\n"
                             "N1::N2::C c3;\n"
-                            "N1::N2::CT<int> ct3;";
+                            "N1::N2::CT<int> ct3;\n";
         ASSERT_EQUALS("namespace N1 { "
                       "namespace N2 { "
                       "struct C { } ; "
@@ -5348,7 +5348,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    Fred<T>::~Fred() { }\n"
                             "}\n"
                             "}\n"
-                            "NS1::NS2::Fred<int> fred;";
+                            "NS1::NS2::Fred<int> fred;\n";
         ASSERT_EQUALS("namespace NS1 { "
                       "namespace NS2 { "
                       "struct Fred<int> ; "
@@ -5404,7 +5404,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "};\n"
                             "}\n"
                             "}\n"
-                            "NS1::NS2::Fred<int> fred;";
+                            "NS1::NS2::Fred<int> fred;\n";
         ASSERT_EQUALS("namespace NS1 { "
                       "namespace NS2 { "
                       "class Fred<int> ; "
@@ -5431,7 +5431,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    template< typename T > T TemplatedMethod(T);\n"
                             "};\n"
                             "template< typename T > T TestClass::TemplatedMethod(T t) { return t; }\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("namespace MyNamespace { "
                       "class TestClass { "
                       "public: "
@@ -5485,7 +5485,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template_pointer_type() {
         const char code[] = "template<class T> void foo(const T x) {}\n"
-                            "void bar() { foo<int*>(0); }";
+                            "void bar() { foo<int*>(0); }\n";
         ASSERT_EQUALS("void foo<int*> ( int * const x ) ; "
                       "void bar ( ) { foo<int*> ( 0 ) ; } "
                       "void foo<int*> ( int * const x ) { }", tok(code));
@@ -5499,12 +5499,12 @@ class TestSimplifyTemplate : public TestFixture {
                           "void bar() {\n"
                           "  int y[3];\n"
                           "  foo<int[]>(y);\n"
-                          "}"));
+                          "}\n"));
         ASSERT_EQUALS("struct A<int[2]> ; "
                       "A<int[2]> y ; "
                       "struct A<int[2]> { int [ 2 ] x ; } ;",
                       tok("template <class T> struct A { T x; };\n"
-                          "A<int[2]> y;"));
+                          "A<int[2]> y;\n"));
 
         // Previously resulted in:
         //   test.cpp:2:33: error: Syntax Error: AST broken, binary operator '>' doesn't have two operands. [internalAstError]
@@ -5518,7 +5518,7 @@ class TestSimplifyTemplate : public TestFixture {
                       tok("template <class  > struct A {};\n"
                           "template <class T> struct B { A<T[]> x; };\n"
                           "template <class T> struct C : B<T> {};\n"
-                          "C<B<int>> y;"));
+                          "C<B<int>> y;\n"));
     }
 
     template<size_t size>
@@ -5541,52 +5541,52 @@ class TestSimplifyTemplate : public TestFixture {
 
     void templateParameters() {
         // Test that the function TemplateSimplifier::templateParameters works
-        ASSERT_EQUALS(1U, templateParameters("X<struct C> x;"));
-        ASSERT_EQUALS(1U, templateParameters("X<union C> x;"));
-        ASSERT_EQUALS(1U, templateParameters("X<const int> x;"));
-        ASSERT_EQUALS(1U, templateParameters("X<int const *> x;"));
-        ASSERT_EQUALS(1U, templateParameters("X<const struct C> x;"));
-        ASSERT_EQUALS(0U, templateParameters("X<len>>x;"));
-        ASSERT_EQUALS(1U, templateParameters("X<typename> x;"));
-        ASSERT_EQUALS(0U, templateParameters("X<...> x;"));
-        ASSERT_EQUALS(0U, templateParameters("X<class T...> x;")); // Invalid syntax
-        ASSERT_EQUALS(1U, templateParameters("X<class... T> x;"));
-        ASSERT_EQUALS(0U, templateParameters("X<class, typename T...> x;")); // Invalid syntax
-        ASSERT_EQUALS(2U, templateParameters("X<class, typename... T> x;"));
-        ASSERT_EQUALS(2U, templateParameters("X<int(&)(), class> x;"));
-        ASSERT_EQUALS(3U, templateParameters("X<char, int(*)(), bool> x;"));
-        ASSERT_EQUALS(1U, templateParameters("X<int...> x;"));
-        ASSERT_EQUALS(2U, templateParameters("X<class, typename...> x;"));
-        ASSERT_EQUALS(2U, templateParameters("X<1, T> x;"));
-        ASSERT_EQUALS(1U, templateParameters("X<T[]> x;"));
-        ASSERT_EQUALS(1U, templateParameters("X<T[2]> x;"));
-        ASSERT_EQUALS(1U, templateParameters("X<i == 0> x;"));
-        ASSERT_EQUALS(2U, templateParameters("X<int, i>=0> x;"));
-        ASSERT_EQUALS(3U, templateParameters("X<int, i>=0, i - 2> x;"));
-        ASSERT_EQUALS(0U, templateParameters("var1<1> x;"));
-        ASSERT_EQUALS(0U, templateParameters("X<1>2;"));
-        ASSERT_EQUALS(2U, templateParameters("template<typename...B,typename=SameSize<B...>> x;"));
-        ASSERT_EQUALS(2U, templateParameters("template<typename...B,typename=SameSize<B...> > x;"));
-        ASSERT_EQUALS(1U, templateParameters("template<template<typename>...Foo> x;"));
-        ASSERT_EQUALS(1U, templateParameters("template<template<typename>> x;"));
-        ASSERT_EQUALS(1U, templateParameters("template<template<template<typename>>> x;"));
-        ASSERT_EQUALS(1U, templateParameters("template<template<template<template<typename>>>> x;"));
-        ASSERT_EQUALS(1U, templateParameters("template<template<template<template<template<typename>>>>> x;"));
-        ASSERT_EQUALS(2U, templateParameters("template<template<typename>,int> x;"));
-        ASSERT_EQUALS(2U, templateParameters("template<template<template<typename>>,int> x;"));
-        ASSERT_EQUALS(2U, templateParameters("template<template<template<template<typename>>>,int> x;"));
-        ASSERT_EQUALS(2U, templateParameters("template<template<template<template<template<typename>>>>,int> x;"));
-        ASSERT_EQUALS(2U, templateParameters("template<template<typename>...Foo,template<template<template<typename>>>> x;"));
-        ASSERT_EQUALS(3U, templateParameters("template<template<typename>...Foo,int,template<template<template<typename>>>> x;"));
-        ASSERT_EQUALS(4U, templateParameters("template<template<typename>...Foo,int,template<template<template<typename>>>,int> x;"));
-        ASSERT_EQUALS(2U, templateParameters("template<typename S, enable_if_t<(is_compile_string<S>::value), int>> void i(S s);"));
-        ASSERT_EQUALS(2U, templateParameters("template<typename c, b<(c::d), int>> void e();"));
-        ASSERT_EQUALS(3U, templateParameters("template <class T, class... Args, class Tup = std::tuple<Args&...>> constexpr void f() {}")); // #11351
-        ASSERT_EQUALS(3U, templateParameters("template <class T, class... Args, class Tup = std::tuple<Args&&...>> void f() {}"));
-        ASSERT_EQUALS(3U, templateParameters("template <class T, class... Args, class Tup = std::tuple<Args*...>> void f() {}"));
-        ASSERT_EQUALS(1U, templateParameters("S<4 < sizeof(uintptr_t)> x;"));
-        ASSERT_EQUALS(2U, templateParameters("template <typename... Ts, typename = std::enable_if_t<std::is_same<Ts..., int>::value>> void g() {}")); // #11915
-        ASSERT_EQUALS(1U, templateParameters("S<N::M<O<\"A\"_I>>> s;")); // #10837
+        ASSERT_EQUALS(1U, templateParameters("X<struct C> x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("X<union C> x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("X<const int> x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("X<int const *> x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("X<const struct C> x;\n"));
+        ASSERT_EQUALS(0U, templateParameters("X<len>>x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("X<typename> x;\n"));
+        ASSERT_EQUALS(0U, templateParameters("X<...> x;\n"));
+        ASSERT_EQUALS(0U, templateParameters("X<class T...> x;\n")); // Invalid syntax
+        ASSERT_EQUALS(1U, templateParameters("X<class... T> x;\n"));
+        ASSERT_EQUALS(0U, templateParameters("X<class, typename T...> x;\n")); // Invalid syntax
+        ASSERT_EQUALS(2U, templateParameters("X<class, typename... T> x;\n"));
+        ASSERT_EQUALS(2U, templateParameters("X<int(&)(), class> x;\n"));
+        ASSERT_EQUALS(3U, templateParameters("X<char, int(*)(), bool> x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("X<int...> x;\n"));
+        ASSERT_EQUALS(2U, templateParameters("X<class, typename...> x;\n"));
+        ASSERT_EQUALS(2U, templateParameters("X<1, T> x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("X<T[]> x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("X<T[2]> x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("X<i == 0> x;\n"));
+        ASSERT_EQUALS(2U, templateParameters("X<int, i>=0> x;\n"));
+        ASSERT_EQUALS(3U, templateParameters("X<int, i>=0, i - 2> x;\n"));
+        ASSERT_EQUALS(0U, templateParameters("var1<1> x;\n"));
+        ASSERT_EQUALS(0U, templateParameters("X<1>2;\n"));
+        ASSERT_EQUALS(2U, templateParameters("template<typename...B,typename=SameSize<B...>> x;\n"));
+        ASSERT_EQUALS(2U, templateParameters("template<typename...B,typename=SameSize<B...> > x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("template<template<typename>...Foo> x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("template<template<typename>> x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("template<template<template<typename>>> x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("template<template<template<template<typename>>>> x;\n"));
+        ASSERT_EQUALS(1U, templateParameters("template<template<template<template<template<typename>>>>> x;\n"));
+        ASSERT_EQUALS(2U, templateParameters("template<template<typename>,int> x;\n"));
+        ASSERT_EQUALS(2U, templateParameters("template<template<template<typename>>,int> x;\n"));
+        ASSERT_EQUALS(2U, templateParameters("template<template<template<template<typename>>>,int> x;\n"));
+        ASSERT_EQUALS(2U, templateParameters("template<template<template<template<template<typename>>>>,int> x;\n"));
+        ASSERT_EQUALS(2U, templateParameters("template<template<typename>...Foo,template<template<template<typename>>>> x;\n"));
+        ASSERT_EQUALS(3U, templateParameters("template<template<typename>...Foo,int,template<template<template<typename>>>> x;\n"));
+        ASSERT_EQUALS(4U, templateParameters("template<template<typename>...Foo,int,template<template<template<typename>>>,int> x;\n"));
+        ASSERT_EQUALS(2U, templateParameters("template<typename S, enable_if_t<(is_compile_string<S>::value), int>> void i(S s);\n"));
+        ASSERT_EQUALS(2U, templateParameters("template<typename c, b<(c::d), int>> void e();\n"));
+        ASSERT_EQUALS(3U, templateParameters("template <class T, class... Args, class Tup = std::tuple<Args&...>> constexpr void f() {}\n")); // #11351
+        ASSERT_EQUALS(3U, templateParameters("template <class T, class... Args, class Tup = std::tuple<Args&&...>> void f() {}\n"));
+        ASSERT_EQUALS(3U, templateParameters("template <class T, class... Args, class Tup = std::tuple<Args*...>> void f() {}\n"));
+        ASSERT_EQUALS(1U, templateParameters("S<4 < sizeof(uintptr_t)> x;\n"));
+        ASSERT_EQUALS(2U, templateParameters("template <typename... Ts, typename = std::enable_if_t<std::is_same<Ts..., int>::value>> void g() {}\n")); // #11915
+        ASSERT_EQUALS(1U, templateParameters("S<N::M<O<\"A\"_I>>> s;\n")); // #10837
     }
 
     // Helper function to unit test TemplateSimplifier::getTemplateNamePosition
@@ -5609,57 +5609,57 @@ class TestSimplifyTemplate : public TestFixture {
 
     void templateNamePosition() {
         // Template class
-        ASSERT_EQUALS(2, templateNamePositionHelper("template<class T> class A {};", 4));
-        ASSERT_EQUALS(2, templateNamePositionHelper("template<class T> struct A {};", 4));
-        ASSERT_EQUALS(2, templateNamePositionHelper("template<class T> class A : B {};", 4));
-        ASSERT_EQUALS(2, templateNamePositionHelper("template<class T> struct A : B {};", 4));
+        ASSERT_EQUALS(2, templateNamePositionHelper("template<class T> class A {};\n", 4));
+        ASSERT_EQUALS(2, templateNamePositionHelper("template<class T> struct A {};\n", 4));
+        ASSERT_EQUALS(2, templateNamePositionHelper("template<class T> class A : B {};\n", 4));
+        ASSERT_EQUALS(2, templateNamePositionHelper("template<class T> struct A : B {};\n", 4));
         // Template function definitions
-        ASSERT_EQUALS(2, templateNamePositionHelper("template<class T> unsigned foo() { return 0; }", 4));
-        ASSERT_EQUALS(3, templateNamePositionHelper("template<class T> unsigned* foo() { return 0; }", 4));
-        ASSERT_EQUALS(4, templateNamePositionHelper("template<class T> unsigned** foo() { return 0; }", 4));
+        ASSERT_EQUALS(2, templateNamePositionHelper("template<class T> unsigned foo() { return 0; }\n", 4));
+        ASSERT_EQUALS(3, templateNamePositionHelper("template<class T> unsigned* foo() { return 0; }\n", 4));
+        ASSERT_EQUALS(4, templateNamePositionHelper("template<class T> unsigned** foo() { return 0; }\n", 4));
 
-        ASSERT_EQUALS(3, templateNamePositionHelper("template<class T> const unsigned foo() { return 0; }", 4));
-        ASSERT_EQUALS(4, templateNamePositionHelper("template<class T> const unsigned& foo() { return 0; }", 4));
-        ASSERT_EQUALS(5, templateNamePositionHelper("template<class T> const unsigned** foo() { return 0; }", 4));
+        ASSERT_EQUALS(3, templateNamePositionHelper("template<class T> const unsigned foo() { return 0; }\n", 4));
+        ASSERT_EQUALS(4, templateNamePositionHelper("template<class T> const unsigned& foo() { return 0; }\n", 4));
+        ASSERT_EQUALS(5, templateNamePositionHelper("template<class T> const unsigned** foo() { return 0; }\n", 4));
 
-        ASSERT_EQUALS(4, templateNamePositionHelper("template<class T> std::string foo() { static str::string str; return str; }", 4));
-        ASSERT_EQUALS(5, templateNamePositionHelper("template<class T> std::string & foo() { static str::string str; return str; }", 4));
-        ASSERT_EQUALS(6, templateNamePositionHelper("template<class T> const std::string & foo() { static str::string str; return str; }", 4));
+        ASSERT_EQUALS(4, templateNamePositionHelper("template<class T> std::string foo() { static str::string str; return str; }\n", 4));
+        ASSERT_EQUALS(5, templateNamePositionHelper("template<class T> std::string & foo() { static str::string str; return str; }\n", 4));
+        ASSERT_EQUALS(6, templateNamePositionHelper("template<class T> const std::string & foo() { static str::string str; return str; }\n", 4));
 
-        ASSERT_EQUALS(9, templateNamePositionHelper("template<class T> std::map<int, int> foo() { static std::map<int, int> m; return m; }", 4));
-        ASSERT_EQUALS(10, templateNamePositionHelper("template<class T> std::map<int, int> & foo() { static std::map<int, int> m; return m; }", 4));
-        ASSERT_EQUALS(11, templateNamePositionHelper("template<class T> const std::map<int, int> & foo() { static std::map<int, int> m; return m; }", 4));
+        ASSERT_EQUALS(9, templateNamePositionHelper("template<class T> std::map<int, int> foo() { static std::map<int, int> m; return m; }\n", 4));
+        ASSERT_EQUALS(10, templateNamePositionHelper("template<class T> std::map<int, int> & foo() { static std::map<int, int> m; return m; }\n", 4));
+        ASSERT_EQUALS(11, templateNamePositionHelper("template<class T> const std::map<int, int> & foo() { static std::map<int, int> m; return m; }\n", 4));
         // Class template members
         ASSERT_EQUALS(4, templateNamePositionHelper(
-                          "class A { template<class T> unsigned foo(); }; "
-                          "template<class T> unsigned A::foo() { return 0; }", 19));
+                          "class A { template<class T> unsigned foo(); };\n"
+                          "template<class T> unsigned A::foo() { return 0; }\n", 19));
         ASSERT_EQUALS(5, templateNamePositionHelper(
-                          "class A { template<class T> const unsigned foo(); }; "
-                          "template<class T> const unsigned A::foo() { return 0; }", 20));
+                          "class A { template<class T> const unsigned foo(); };\n"
+                          "template<class T> const unsigned A::foo() { return 0; }\n", 20));
         ASSERT_EQUALS(7, templateNamePositionHelper(
-                          "class A { class B { template<class T> const unsigned foo(); }; } ; "
-                          "template<class T> const unsigned A::B::foo() { return 0; }", 25));
+                          "class A { class B { template<class T> const unsigned foo(); }; } ;\n"
+                          "template<class T> const unsigned A::B::foo() { return 0; }\n", 25));
         ASSERT_EQUALS(8, templateNamePositionHelper(
-                          "class A { class B { template<class T> const unsigned * foo(); }; } ; "
-                          "template<class T> const unsigned * A::B::foo() { return 0; }", 26));
+                          "class A { class B { template<class T> const unsigned * foo(); }; } ;\n"
+                          "template<class T> const unsigned * A::B::foo() { return 0; }\n", 26));
         ASSERT_EQUALS(9, templateNamePositionHelper(
-                          "class A { class B { template<class T> const unsigned ** foo(); }; } ; "
-                          "template<class T> const unsigned ** A::B::foo() { return 0; }", 27));
+                          "class A { class B { template<class T> const unsigned ** foo(); }; } ;\n"
+                          "template<class T> const unsigned ** A::B::foo() { return 0; }\n", 27));
         // Template class member
         ASSERT_EQUALS(6, templateNamePositionHelper(
-                          "template<class T> class A { A(); }; "
-                          "template<class T> A<T>::A() {}", 18));
+                          "template<class T> class A { A(); };\n"
+                          "template<class T> A<T>::A() {}\n", 18));
         ASSERT_EQUALS(8, templateNamePositionHelper(
-                          "template<class T, class U> class A { A(); }; "
-                          "template<class T, class U> A<T, U>::A() {}", 24));
+                          "template<class T, class U> class A { A(); };\n"
+                          "template<class T, class U> A<T, U>::A() {}\n", 24));
         ASSERT_EQUALS(7, templateNamePositionHelper(
-                          "template<class T> class A { unsigned foo(); }; "
-                          "template<class T> unsigned A<T>::foo() { return 0; }", 19));
+                          "template<class T> class A { unsigned foo(); };\n"
+                          "template<class T> unsigned A<T>::foo() { return 0; }\n", 19));
         ASSERT_EQUALS(9, templateNamePositionHelper(
-                          "template<class T, class U> class A { unsigned foo(); }; "
-                          "template<class T, class U> unsigned A<T, U>::foo() { return 0; }", 25));
+                          "template<class T, class U> class A { unsigned foo(); };\n"
+                          "template<class T, class U> unsigned A<T, U>::foo() { return 0; }\n", 25));
         ASSERT_EQUALS(12, templateNamePositionHelper(
-                          "template<> unsigned A<int, v<char> >::foo() { return 0; }", 2));
+                          "template<> unsigned A<int, v<char> >::foo() { return 0; }\n", 2));
     }
 
     // Helper function to unit test TemplateSimplifier::findTemplateDeclarationEnd
@@ -5682,14 +5682,14 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void findTemplateDeclarationEnd() {
-        ASSERT(findTemplateDeclarationEndHelper("template <typename T> class Fred { }; int x;", "; int x ;"));
-        ASSERT(findTemplateDeclarationEndHelper("template <typename T> void Fred() { } int x;", "} int x ;"));
-        ASSERT(findTemplateDeclarationEndHelper("template <typename T> int Fred = 0; int x;", "; int x ;"));
-        ASSERT(findTemplateDeclarationEndHelper("template <typename T> constexpr auto func = [](auto x){ return T(x);}; int x;", "; int x ;"));
-        ASSERT(findTemplateDeclarationEndHelper("template <class, class a> auto b() -> decltype(a{}.template b<void(int, int)>); int x;", "; int x ;"));
-        ASSERT(findTemplateDeclarationEndHelper("template <class, class a> auto b() -> decltype(a{}.template b<void(int, int)>){} int x;", "} int x ;"));
-        ASSERT(findTemplateDeclarationEndHelper("template <typename... f, c<h<e<typename f::d...>>::g>> void i(); int x;", "; int x ;"));
-        ASSERT(findTemplateDeclarationEndHelper("template <typename... f, c<h<e<typename f::d...>>::g>> void i(){} int x;", "} int x ;"));
+        ASSERT(findTemplateDeclarationEndHelper("template <typename T> class Fred { }; int x;\n", "; int x ;"));
+        ASSERT(findTemplateDeclarationEndHelper("template <typename T> void Fred() { } int x;\n", "} int x ;"));
+        ASSERT(findTemplateDeclarationEndHelper("template <typename T> int Fred = 0; int x;\n", "; int x ;"));
+        ASSERT(findTemplateDeclarationEndHelper("template <typename T> constexpr auto func = [](auto x){ return T(x);}; int x;\n", "; int x ;"));
+        ASSERT(findTemplateDeclarationEndHelper("template <class, class a> auto b() -> decltype(a{}.template b<void(int, int)>); int x;\n", "; int x ;"));
+        ASSERT(findTemplateDeclarationEndHelper("template <class, class a> auto b() -> decltype(a{}.template b<void(int, int)>){} int x;\n", "} int x ;"));
+        ASSERT(findTemplateDeclarationEndHelper("template <typename... f, c<h<e<typename f::d...>>::g>> void i(); int x;\n", "; int x ;"));
+        ASSERT(findTemplateDeclarationEndHelper("template <typename... f, c<h<e<typename f::d...>>::g>> void i(){} int x;\n", "} int x ;"));
     }
 
     // Helper function to unit test TemplateSimplifier::getTemplateParametersInDeclaration
@@ -5717,22 +5717,22 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void getTemplateParametersInDeclaration() {
-        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T> class Fred {};", std::vector<std::string> {"T"}));
-        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T=int> class Fred {};", std::vector<std::string> {"T"}));
-        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T,typename U> class Fred {};", std::vector<std::string> {"T","U"}));
-        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T,typename U=int> class Fred {};", std::vector<std::string> {"T","U"}));
-        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T=int,typename U=int> class Fred {};", std::vector<std::string> {"T","U"}));
+        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T> class Fred {};\n", std::vector<std::string> {"T"}));
+        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T=int> class Fred {};\n", std::vector<std::string> {"T"}));
+        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T,typename U> class Fred {};\n", std::vector<std::string> {"T","U"}));
+        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T,typename U=int> class Fred {};\n", std::vector<std::string> {"T","U"}));
+        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T=int,typename U=int> class Fred {};\n", std::vector<std::string> {"T","U"}));
     }
 
     void expandSpecialized1() {
-        ASSERT_EQUALS("class A<int> { } ;", tok("template<> class A<int> {};"));
-        ASSERT_EQUALS("class A<int> : public B { } ;", tok("template<> class A<int> : public B {};"));
-        ASSERT_EQUALS("class A<int> { A<int> ( ) ; ~ A<int> ( ) ; } ;", tok("template<> class A<int> { A(); ~A(); };"));
-        ASSERT_EQUALS("class A<int> { A<int> ( ) { } ~ A<int> ( ) { } } ;", tok("template<> class A<int> { A() {} ~A() {} };"));
+        ASSERT_EQUALS("class A<int> { } ;", tok("template<> class A<int> {};\n"));
+        ASSERT_EQUALS("class A<int> : public B { } ;", tok("template<> class A<int> : public B {};\n"));
+        ASSERT_EQUALS("class A<int> { A<int> ( ) ; ~ A<int> ( ) ; } ;", tok("template<> class A<int> { A(); ~A(); };\n"));
+        ASSERT_EQUALS("class A<int> { A<int> ( ) { } ~ A<int> ( ) { } } ;", tok("template<> class A<int> { A() {} ~A() {} };\n"));
         ASSERT_EQUALS("class A<int> { A<int> ( ) ; ~ A<int> ( ) ; } ; A<int> :: A<int> ( ) { } ~ A<int> :: A<int> ( ) { }",
-                      tok("template<> class A<int> { A(); ~A(); }; A<int>::A() { } ~A<int>::A() {}"));
+                      tok("template<> class A<int> { A(); ~A(); }; A<int>::A() { } ~A<int>::A() {}\n"));
         ASSERT_EQUALS("class A<int> { A<int> ( ) ; A<int> ( const A<int> & ) ; A<int> foo ( ) ; } ; A<int> :: A<int> ( ) { } A<int> :: A<int> ( const A<int> & ) { } A<int> A<int> :: foo ( ) { A<int> a ; return a ; }",
-                      tok("template<> class A<int> { A(); A(const A &) ; A foo(); }; A<int>::A() { } A<int>::A(const A &) { } A<int> A<int>::foo() { A a; return a; }"));
+                      tok("template<> class A<int> { A(); A(const A &) ; A foo(); }; A<int>::A() { } A<int>::A(const A &) { } A<int> A<int>::foo() { A a; return a; }\n"));
     }
 
     void expandSpecialized2() {
@@ -5764,7 +5764,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "   C(const C &) { }\n"
                                 "   ~C() { }\n"
                                 "   C & operator=(const C &) { return *this; }\n"
-                                "};";
+                                "};\n";
             const char expected[] = "class C<float> { "
                                     "public: "
                                     "C<float> ( ) { } "
@@ -5814,7 +5814,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "C::C() { }\n"
                                 "C::C(const C &) { }\n"
                                 "C::~C() { }\n"
-                                "C & C::operator=(const C &) { return *this; }";
+                                "C & C::operator=(const C &) { return *this; }\n";
             const char expected[] = "class C<float> { "
                                     "public: "
                                     "C<float> ( ) ; "
@@ -5836,7 +5836,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    void operator()(unsigned short) const;\n"
                             "private:\n"
                             "    std::basic_ostream<unsigned char> &outputStream_;\n"
-                            "};";
+                            "};\n";
         const char expected[] = "struct OutputU16<unsignedchar> { "
                                 "explicit OutputU16<unsignedchar> ( std :: basic_ostream < unsigned char > & t ) : outputStream_ ( t ) { } "
                                 "void operator() ( unsigned short ) const ; "
@@ -5849,7 +5849,7 @@ class TestSimplifyTemplate : public TestFixture {
     void expandSpecialized4() {
         {
             const char code[] = "template<> class C<char> { };\n"
-                                "map<int> m;";
+                                "map<int> m;\n";
             const char expected[] = "class C<char> { } ; "
                                     "map < int > m ;";
             ASSERT_EQUALS(expected, tok(code));
@@ -5857,7 +5857,7 @@ class TestSimplifyTemplate : public TestFixture {
         {
             const char code[] = "template<> class C<char> { };\n"
                                 "map<int> m;\n"
-                                "C<char> c;";
+                                "C<char> c;\n";
             const char expected[] = "class C<char> { } ; "
                                     "map < int > m ; "
                                     "C<char> c ;";
@@ -5877,7 +5877,7 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "template<typename T> class C { };\n"
                                 "template<> class C<char> { };\n"
                                 "map<int> m;\n"
-                                "C<int> i;";
+                                "C<int> i;\n";
             const char expected[] = "class C<char> ; "
                                     "class C<int> ; "
                                     "class C<char> { } ; "
@@ -5891,7 +5891,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "template<> class C<char> { };\n"
                                 "map<int> m;\n"
                                 "C<int> i;\n"
-                                "C<char> c;";
+                                "C<char> c;\n";
             const char expected[] = "class C<char> ; "
                                     "class C<int> ; "
                                     "class C<char> { } ; "
@@ -5969,7 +5969,7 @@ class TestSimplifyTemplate : public TestFixture {
     void templateAlias3() { // #8315
         const char code[] = "template <int> struct Tag {};\n"
                             "template <int ID> using SPtr = std::shared_ptr<void(Tag<ID>)>;\n"
-                            "SPtr<0> s;";
+                            "SPtr<0> s;\n";
         const char expected[] = "struct Tag<0> ; "
                                 "std :: shared_ptr < void ( Tag<0> ) > s ; "
                                 "struct Tag<0> { } ;";
@@ -5980,7 +5980,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template <class T>\n"
                             "using IntrusivePtr = boost::intrusive_ptr<T>;\n"
                             "template <class T> class Vertex { };\n"
-                            "IntrusivePtr<Vertex<int>> p;";
+                            "IntrusivePtr<Vertex<int>> p;\n";
         const char expected[] = "class Vertex<int> ; "
                                 "boost :: intrusive_ptr < Vertex<int> > p ; "
                                 "class Vertex<int> { } ;";
@@ -5991,7 +5991,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template<typename T> using A = int;\n"
                             "template<typename T> using B = T;\n"
                             "A<char> a;\n"
-                            "B<char> b;";
+                            "B<char> b;\n";
         const char expected[] = "int a ; "
                                 "char b ;";
         ASSERT_EQUALS(expected, tok(code));
@@ -6010,25 +6010,25 @@ class TestSimplifyTemplate : public TestFixture {
     void instantiateMatchTest() {
         // Ticket #8175
         ASSERT_EQUALS(false,
-                      instantiateMatch("ConvertHelper < From, To > c ;",
+                      instantiateMatch("ConvertHelper < From, To > c ;\n",
                                        2, ":: %name% ("));
         ASSERT_EQUALS(true,
-                      instantiateMatch("ConvertHelper < From, To > :: Create ( ) ;",
+                      instantiateMatch("ConvertHelper < From, To > :: Create ( ) ;\n",
                                        2, ":: %name% ("));
         ASSERT_EQUALS(false,
-                      instantiateMatch("integral_constant < bool, sizeof ( ConvertHelper < From, To > :: Create ( ) ) > ;",
+                      instantiateMatch("integral_constant < bool, sizeof ( ConvertHelper < From, To > :: Create ( ) ) > ;\n",
                                        2, ":: %name% ("));
         ASSERT_EQUALS(false,
-                      instantiateMatch("integral_constant < bool, sizeof ( ns :: ConvertHelper < From, To > :: Create ( ) ) > ;",
+                      instantiateMatch("integral_constant < bool, sizeof ( ns :: ConvertHelper < From, To > :: Create ( ) ) > ;\n",
                                        2, ":: %name% ("));
     }
 
     void templateParameterWithoutName() {
-        ASSERT_EQUALS(1U, templateParameters("template<typename = void> struct s;"));
+        ASSERT_EQUALS(1U, templateParameters("template<typename = void> struct s;\n"));
         ASSERT_EQUALS(1U, templateParameters("template<template<typename = float> typename T> struct A {\n"
                                              "    void f();\n"
                                              "    void g();\n"
-                                             "};n"));
+                                             "};n\n"));
     }
 
     void templateTypeDeduction1() { // #8962
@@ -6057,7 +6057,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    f(L\"string\");\n"
                             "    f(true);\n"
                             "    f(false);\n"
-                            "}";
+                            "}\n";
         const char expected[] = "void f<int> ( int n ) ; "
                                 "void f<unsignedint> ( unsigned int n ) ; "
                                 "void f<long> ( long n ) ; "
@@ -6121,7 +6121,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "static void func() {\n"
                             "    f(0, 0.0);\n"
                             "    f(0.0, 0);\n"
-                            "}";
+                            "}\n";
 
         const char expected[] = "void f<int,double> ( int t , double u ) ; "
                                 "void f<double,int> ( double t , int u ) ; "
@@ -6150,7 +6150,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "int main() {\n"
                             "    A a;\n"
                             "    a.f();\n"
-                            "}";
+                            "}\n";
         const char exp[]  = "struct A { "
                             "int a ; a = 1 ; "
                             "void f ( ) { g<int> ( 1 ) ; } "
@@ -6167,7 +6167,7 @@ class TestSimplifyTemplate : public TestFixture {
         {
             const char code[] = "int a = 1;\n"
                                 "template <typename T> void f(T x, T y) { a = x + y; }\n"
-                                "void test() { f(0, 0); }";
+                                "void test() { f(0, 0); }\n";
             const char exp[]  = "int a ; a = 1 ; "
                                 "void f<int> ( int x , int y ) ; "
                                 "void test ( ) { f<int> ( 0 , 0 ) ; } "
@@ -6177,7 +6177,7 @@ class TestSimplifyTemplate : public TestFixture {
         {
             const char code[] = "int a = 1;\n"
                                 "template <typename T> void f(T x, double y) { a = x + y; }\n"
-                                "void test() { f(0, 0.0); }";
+                                "void test() { f(0, 0.0); }\n";
             const char exp[]  = "int a ; a = 1 ; "
                                 "void f<int> ( int x , double y ) ; "
                                 "void test ( ) { f<int> ( 0 , 0.0 ) ; } "
@@ -6187,7 +6187,7 @@ class TestSimplifyTemplate : public TestFixture {
         {
             const char code[] = "int a = 1;\n"
                                 "template <typename T> void f(double x, T y) { a = x + y; }\n"
-                                "void test() { f(0.0, 0); }";
+                                "void test() { f(0.0, 0); }\n";
             const char exp[]  = "int a ; a = 1 ; "
                                 "void f<int> ( double x , int y ) ; "
                                 "void test ( ) { f<int> ( 0.0 , 0 ) ; } "
@@ -6204,7 +6204,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "    f(0.0, 0);\n"
                                 "    f(0, 0.0);\n"
                                 "    f(0.0, 0.0);\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "int a ; a = 1 ; "
                                 "void f<int> ( int x , int y ) ; "
                                 "void f<int> ( double x , int y ) ; "
@@ -6237,7 +6237,7 @@ class TestSimplifyTemplate : public TestFixture {
         {
             const char code[] = "int a = 1;\n"
                                 "template <typename T, typename U> void f(T x, U y) { a = x + y; }\n"
-                                "void test() { f(0, 0.0); }";
+                                "void test() { f(0, 0.0); }\n";
             const char exp[]  = "int a ; a = 1 ; "
                                 "void f<int,double> ( int x , double y ) ; "
                                 "void test ( ) { f<int,double> ( 0 , 0.0 ) ; } "
@@ -6258,7 +6258,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "Fred fred1 = Fred(0);\n"
                                 "Fred fred2 = Fred(0.0);\n"
                                 "Fred fred3 = Fred(\"zero\");\n"
-                                "Fred fred4 = Fred(false);";
+                                "Fred fred4 = Fred(false);\n";
             const char exp[]  = "class Fred { "
                                 "public: "
                                 "Fred<int> ( int t ) ; "
@@ -6317,26 +6317,26 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void simplifyTemplateArgs1() {
-        ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < ( 2 ) >;"));
-        ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < 1 + 1 >;"));
-        ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < ( 1 + 1 ) >;"));
+        ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < ( 2 ) >;\n"));
+        ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < 1 + 1 >;\n"));
+        ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < ( 1 + 1 ) >;\n"));
 
-        ASSERT_EQUALS("foo<2,2> = 4 ; foo<2,2> ;", tok("template<int N, int M> foo = N * M; foo < ( 2 ), ( 2 ) >;"));
-        ASSERT_EQUALS("foo<2,2> = 4 ; foo<2,2> ;", tok("template<int N, int M> foo = N * M; foo < 1 + 1, 1 + 1 >;"));
-        ASSERT_EQUALS("foo<2,2> = 4 ; foo<2,2> ;", tok("template<int N, int M> foo = N * M; foo < ( 1 + 1 ), ( 1 + 1 ) >;"));
+        ASSERT_EQUALS("foo<2,2> = 4 ; foo<2,2> ;", tok("template<int N, int M> foo = N * M; foo < ( 2 ), ( 2 ) >;\n"));
+        ASSERT_EQUALS("foo<2,2> = 4 ; foo<2,2> ;", tok("template<int N, int M> foo = N * M; foo < 1 + 1, 1 + 1 >;\n"));
+        ASSERT_EQUALS("foo<2,2> = 4 ; foo<2,2> ;", tok("template<int N, int M> foo = N * M; foo < ( 1 + 1 ), ( 1 + 1 ) >;\n"));
 
-        ASSERT_EQUALS("foo<true> = true ; foo<true> ;", tok("template<bool N> foo = N; foo < true ? true : false >;"));
-        ASSERT_EQUALS("foo<false> = false ; foo<false> ;", tok("template<bool N> foo = N; foo < false ? true : false >;"));
-        ASSERT_EQUALS("foo<true> = true ; foo<true> ;", tok("template<bool N> foo = N; foo < 1 ? true : false >;"));
-        ASSERT_EQUALS("foo<false> = false ; foo<false> ;", tok("template<bool N> foo = N; foo < 0 ? true : false >;"));
-        ASSERT_EQUALS("foo<true> = true ; foo<true> ;", tok("template<bool N> foo = N; foo < (1 + 1 ) ? true : false >;"));
-        ASSERT_EQUALS("foo<false> = false ; foo<false> ;", tok("template<bool N> foo = N; foo < ( 1 - 1) ? true : false >;"));
+        ASSERT_EQUALS("foo<true> = true ; foo<true> ;", tok("template<bool N> foo = N; foo < true ? true : false >;\n"));
+        ASSERT_EQUALS("foo<false> = false ; foo<false> ;", tok("template<bool N> foo = N; foo < false ? true : false >;\n"));
+        ASSERT_EQUALS("foo<true> = true ; foo<true> ;", tok("template<bool N> foo = N; foo < 1 ? true : false >;\n"));
+        ASSERT_EQUALS("foo<false> = false ; foo<false> ;", tok("template<bool N> foo = N; foo < 0 ? true : false >;\n"));
+        ASSERT_EQUALS("foo<true> = true ; foo<true> ;", tok("template<bool N> foo = N; foo < (1 + 1 ) ? true : false >;\n"));
+        ASSERT_EQUALS("foo<false> = false ; foo<false> ;", tok("template<bool N> foo = N; foo < ( 1 - 1) ? true : false >;\n"));
     }
 
     void simplifyTemplateArgs2() {
         const char code[] = "template<bool T> struct a_t { static const bool t = T; };\n"
                             "typedef a_t<sizeof(void*) == sizeof(char)> a;\n"
-                            "void foo() { bool b = a::t; }";
+                            "void foo() { bool b = a::t; }\n";
         const char expected[] = "struct a_t<false> ; "
                                 "void foo ( ) { bool b ; b = a_t<false> :: t ; } "
                                 "struct a_t<false> { static const bool t = false ; } ;";
@@ -6374,7 +6374,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template_variadic_1() { // #9144
         const char code[] = "template <typename...> struct e {};\n"
-                            "static_assert(sizeof(e<>) == sizeof(e<int,int>), \"\");";
+                            "static_assert(sizeof(e<>) == sizeof(e<int,int>), \"\");\n";
         const char expected[] = "struct e<> ; struct e<int,int> ; "
                                 "static_assert ( sizeof ( e<> ) == sizeof ( e<int,int> ) , \"\" ) ; "
                                 "struct e<> { } ; struct e<int,int> { } ;";
@@ -6387,7 +6387,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "\n"
                             "int main() {\n"
                             "    printf<int, float>(\"\", foo, bar);\n"
-                            "}";
+                            "}\n";
         const char expected[] = "void printf<int,float> ( const char * s , int value , float ) ; "
                                 "int main ( ) { printf<int,float> ( \"\" , foo , bar ) ; } "
                                 "void printf<int,float> ( const char * s , int value , float ) { }";
@@ -6395,14 +6395,14 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template_variadic_3() { // #6172
-        const char code[] = "template<int N, int ... M> struct A { "
-                            "  static void foo() { "
-                            "    int i = N; "
-                            "  } "
-                            "}; "
-                            "void bar() { "
-                            "  A<0>::foo(); "
-                            "}";
+        const char code[] = "template<int N, int ... M> struct A {\n"
+                            "  static void foo() {\n"
+                            "    int i = N;\n"
+                            "  }\n"
+                            "};\n"
+                            "void bar() {\n"
+                            "  A<0>::foo();\n"
+                            "}\n";
         const char expected[] = "struct A<0> ; "
                                 "void bar ( ) { A<0> :: foo ( ) ; } "
                                 "struct A<0> { static void foo ( ) { int i ; i = ( int ) 0 ; } } ;";
@@ -6457,28 +6457,28 @@ class TestSimplifyTemplate : public TestFixture {
     void template_variable_1() {
         {
             const char code[] = "template <int N> const int foo = N*N;\n"
-                                "int x = foo<7>;";
+                                "int x = foo<7>;\n";
             const char expected[] = "const int foo<7> = 49 ; "
                                     "int x ; x = foo<7> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template <int> const int foo = 7;\n"
-                                "int x = foo<7>;";
+                                "int x = foo<7>;\n";
             const char expected[] = "const int foo<7> = 7 ; "
                                     "int x ; x = foo<7> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template <int N = 7> const int foo = N*N;\n"
-                                "int x = foo<7>;";
+                                "int x = foo<7>;\n";
             const char expected[] = "const int foo<7> = 49 ; "
                                     "int x ; x = foo<7> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template <int N = 7> const int foo = N*N;\n"
-                                "int x = foo<>;";
+                                "int x = foo<>;\n";
             const char expected[] = "const int foo<7> = 49 ; "
                                     "int x ; x = foo<7> ;";
             ASSERT_EQUALS(expected, tok(code));
@@ -6488,28 +6488,28 @@ class TestSimplifyTemplate : public TestFixture {
     void template_variable_2() {
         {
             const char code[] = "template<class T> constexpr T pi = T(3.1415926535897932385L);\n"
-                                "float x = pi<float>;";
+                                "float x = pi<float>;\n";
             const char expected[] = "constexpr float pi<float> = float ( 3.1415926535897932385L ) ; "
                                     "float x ; x = pi<float> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class> constexpr float pi = float(3.1415926535897932385L);\n"
-                                "float x = pi<float>;";
+                                "float x = pi<float>;\n";
             const char expected[] = "constexpr float pi<float> = float ( 3.1415926535897932385L ) ; "
                                     "float x ; x = pi<float> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class T = float> constexpr T pi = T(3.1415926535897932385L);\n"
-                                "float x = pi<float>;";
+                                "float x = pi<float>;\n";
             const char expected[] = "constexpr float pi<float> = float ( 3.1415926535897932385L ) ; "
                                     "float x ; x = pi<float> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class T = float> constexpr T pi = T(3.1415926535897932385L);\n"
-                                "float x = pi<>;";
+                                "float x = pi<>;\n";
             const char expected[] = "constexpr float pi<float> = float ( 3.1415926535897932385L ) ; "
                                     "float x ; x = pi<float> ;";
             ASSERT_EQUALS(expected, tok(code));
@@ -6519,35 +6519,35 @@ class TestSimplifyTemplate : public TestFixture {
     void template_variable_3() {
         {
             const char code[] = "template<class T, int N> constexpr T foo = T(N*N);\n"
-                                "float x = foo<float,7>;";
+                                "float x = foo<float,7>;\n";
             const char expected[] = "constexpr float foo<float,7> = float ( 49 ) ; "
                                     "float x ; x = foo<float,7> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class,int> constexpr float foo = float(7);\n"
-                                "float x = foo<float,7>;";
+                                "float x = foo<float,7>;\n";
             const char expected[] = "constexpr float foo<float,7> = float ( 7 ) ; "
                                     "float x ; x = foo<float,7> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class T = float, int N = 7> constexpr T foo = T(7);\n"
-                                "double x = foo<double, 14>;";
+                                "double x = foo<double, 14>;\n";
             const char expected[] = "constexpr double foo<double,14> = double ( 7 ) ; "
                                     "double x ; x = foo<double,14> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class T = float, int N = 7> constexpr T foo = T(7);\n"
-                                "float x = foo<>;";
+                                "float x = foo<>;\n";
             const char expected[] = "constexpr float foo<float,7> = float ( 7 ) ; "
                                     "float x ; x = foo<float,7> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class T = float, int N = 7> constexpr T foo = T(7);\n"
-                                "double x = foo<double>;";
+                                "double x = foo<double>;\n";
             const char expected[] = "constexpr double foo<double,7> = double ( 7 ) ; "
                                     "double x ; x = foo<double,7> ;";
             ASSERT_EQUALS(expected, tok(code));
@@ -6557,7 +6557,7 @@ class TestSimplifyTemplate : public TestFixture {
     void template_variable_4() {
         const char code[] = "template<typename T> void test() { }\n"
                             "template<typename T> decltype(test<T>)* foo = &(test<T>);\n"
-                            "void bar() { foo<int>(); }";
+                            "void bar() { foo<int>(); }\n";
         const char expected[] = "void test<int> ( ) ; "
                                 "decltype ( test<int> ) * foo<int> = & ( test<int> ) ; "
                                 "void bar ( ) { foo<int> ( ) ; } "
@@ -6576,7 +6576,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "type<decltype(0ULL)> ull;\n"
                             "type<decltype(0.0)> d;\n"
                             "type<decltype(0.0F)> f;\n"
-                            "type<decltype(0.0L)> ld;";
+                            "type<decltype(0.0L)> ld;\n";
         const char expected[] = "class type<bool> ; "
                                 "class type<int> ; "
                                 "class type<unsignedint> ; "
@@ -6615,7 +6615,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <typename TC> class Base {};\n"
                             "template <typename TC> class Derived : private Base<TC> {};\n"
                             "typedef Derived<C<static_cast<int>(-1)> > C_;\n"
-                            "class C3 { C_ c; };";
+                            "class C3 { C_ c; };\n";
         const char expected[] = "template < int N > class C { } ; "
                                 "class Base<C<static_cast<int>(-1)>> ; "
                                 "class Derived<C<static_cast<int>(-1)>> ; "
@@ -6627,63 +6627,63 @@ class TestSimplifyTemplate : public TestFixture {
 
     void fold_expression_1() {
         const char code[] = "template<typename... Args> bool all(Args... args) { return (... && args); }\n"
-                            "x=all(true,false,true,true);";
+                            "x=all(true,false,true,true);\n";
         const char expected[] = "template < typename ... Args > bool all ( Args ... args ) { return ( __cppcheck_fold_&&__ ( args ... ) ) ; } x = all ( true , false , true , true ) ;";
         ASSERT_EQUALS(expected, tok(code));
     }
 
     void fold_expression_2() {
         const char code[] = "template<typename... Args> bool all(Args... args) { return (args && ...); }\n"
-                            "x=all(true,false,true,true);";
+                            "x=all(true,false,true,true);\n";
         const char expected[] = "template < typename ... Args > bool all ( Args ... args ) { return ( __cppcheck_fold_&&__ ( args ... ) ) ; } x = all ( true , false , true , true ) ;";
         ASSERT_EQUALS(expected, tok(code));
     }
 
     void fold_expression_3() {
         const char code[] = "template<typename... Args> int foo(Args... args) { return (12 * ... * args); }\n"
-                            "x=foo(1,2);";
+                            "x=foo(1,2);\n";
         const char expected[] = "template < typename ... Args > int foo ( Args ... args ) { return ( __cppcheck_fold_*__ ( args ... ) ) ; } x = foo ( 1 , 2 ) ;";
         ASSERT_EQUALS(expected, tok(code));
     }
 
     void fold_expression_4() {
         const char code[] = "template<typename... Args> int foo(Args... args) { return (args * ... * 123); }\n"
-                            "x=foo(1,2);";
+                            "x=foo(1,2);\n";
         const char expected[] = "template < typename ... Args > int foo ( Args ... args ) { return ( __cppcheck_fold_*__ ( args ... ) ) ; } x = foo ( 1 , 2 ) ;";
         ASSERT_EQUALS(expected, tok(code));
     }
 
     void concepts1() {
         const char code[] = "template <my_concept T> void f(T v) {}\n"
-                            "f<int>(123);";
+                            "f<int>(123);\n";
         const char expected[] = "void f<int> ( int v ) ; f<int> ( 123 ) ; void f<int> ( int v ) { }";
         ASSERT_EQUALS(expected, tok(code));
     }
 
     void requires1() {
         const char code[] = "template <class T> requires my_concept<T> void f(T v) {}\n"
-                            "f<int>(123);";
+                            "f<int>(123);\n";
         const char expected[] = "void f<int> ( int v ) ; f<int> ( 123 ) ; void f<int> ( int v ) { }";
         ASSERT_EQUALS(expected, tok(code));
     }
 
     void requires2() {
         const char code[] = "template<class T> requires (sizeof(T) > 1 && get_value<T>()) void f(T v){}\n"
-                            "f<int>(123);";
+                            "f<int>(123);\n";
         const char expected[] = "void f<int> ( int v ) ; f<int> ( 123 ) ; void f<int> ( int v ) { }";
         ASSERT_EQUALS(expected, tok(code));
     }
 
     void requires3() {
         const char code[] = "template<class T> requires c1<T> && c2<T> void f(T v){}\n"
-                            "f<int>(123);";
+                            "f<int>(123);\n";
         const char expected[] = "void f<int> ( int v ) ; f<int> ( 123 ) ; void f<int> ( int v ) { }";
         ASSERT_EQUALS(expected, tok(code));
     }
 
     void requires4() {
         const char code[] = "template <class T> void f(T v) requires my_concept<T> {}\n"
-                            "f<int>(123);";
+                            "f<int>(123);\n";
         const char expected[] = "void f<int> ( int v ) ; f<int> ( 123 ) ; void f<int> ( int v ) { }";
         ASSERT_EQUALS(expected, tok(code));
     }
@@ -6692,7 +6692,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template <class T>\n"
                             "  requires requires (T x) { x + x; }\n"
                             "  T add(T a, T b) { return a + b; }\n"
-                            "add<int>(123,456);";
+                            "add<int>(123,456);\n";
         const char expected[] = "int add<int> ( int a , int b ) ; add<int> ( 123 , 456 ) ; int add<int> ( int a , int b ) { return a + b ; }";
         ASSERT_EQUALS(expected, tok(code));
     }
@@ -6714,12 +6714,12 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void explicitBool1() {
-        const char code[] = "class Fred { explicit(true) Fred(int); };";
+        const char code[] = "class Fred { explicit(true) Fred(int); };\n";
         ASSERT_EQUALS("class Fred { explicit Fred ( int ) ; } ;", tok(code));
     }
 
     void explicitBool2() {
-        const char code[] = "class Fred { explicit(false) Fred(int); };";
+        const char code[] = "class Fred { explicit(false) Fred(int); };\n";
         ASSERT_EQUALS("class Fred { Fred ( int ) ; } ;", tok(code));
     }
 
@@ -6742,7 +6742,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "template <long long> struct S { };\n"
                             "S<(0x8000000000000000 << 1)> s1;\n"
                             "S<(1 << 0x8000000000000000)> s2;\n"
-                            "S<(1 >> 0x8000000000000000)> s3;";
+                            "S<(1 >> 0x8000000000000000)> s3;\n";
         const char expected[] = "struct S<9223372036854775808U> ; struct S<1> ; "
                                 "S<9223372036854775808U> s1 ; S<1> s2 ; S<1> s3 ; "
                                 "struct S<9223372036854775808U> { } ; struct S<1> { } ;";
@@ -6751,7 +6751,7 @@ class TestSimplifyTemplate : public TestFixture {
 
     void dumpTemplateArgFrom() {
         const char code[] = "template<class T> void foo(T t) {}\n"
-                            "foo<int>(23);";
+                            "foo<int>(23);\n";
         const std::string d = dump(code);
         ASSERT(!d.empty());
 
diff --git a/test/testsimplifytokens.cpp b/test/testsimplifytokens.cpp
index 2f04653a379..8d941c06464 100644
--- a/test/testsimplifytokens.cpp
+++ b/test/testsimplifytokens.cpp
@@ -232,10 +232,10 @@ class TestSimplifyTokens : public TestFixture {
                              "}\n";
         ASSERT_EQUALS(tok(code2), tok(code1));
 
-        const char code3[] = "x = L\"1\" TEXT(\"2\") L\"3\";";
+        const char code3[] = "x = L\"1\" TEXT(\"2\") L\"3\";\n";
         ASSERT_EQUALS("x = L\"123\" ;", tok(code3, dinit(TokOptions, $.type = Platform::Type::Win64)));
 
-        const char code4[] = "x = TEXT(\"1\") L\"2\";";
+        const char code4[] = "x = TEXT(\"1\") L\"2\";\n";
         ASSERT_EQUALS("x = L\"1\" L\"2\" ;", tok(code4, dinit(TokOptions, $.type = Platform::Type::Win64)));
     }
 
@@ -251,7 +251,7 @@ class TestSimplifyTokens : public TestFixture {
     }
 
     void combine_ustrings() {
-        const char code[] =  "abcd = u\"ab\" u\"cd\";";
+        const char code[] =  "abcd = u\"ab\" u\"cd\";\n";
 
         const char expected[] =  "abcd = u\"abcd\" ;";
 
@@ -262,7 +262,7 @@ class TestSimplifyTokens : public TestFixture {
     }
 
     void combine_Ustrings() {
-        const char code[] =  "abcd = U\"ab\" U\"cd\";";
+        const char code[] =  "abcd = U\"ab\" U\"cd\";\n";
 
         const char expected[] =  "abcd = U\"abcd\" ;";
 
@@ -273,7 +273,7 @@ class TestSimplifyTokens : public TestFixture {
     }
 
     void combine_u8strings() {
-        const char code[] =  "abcd = u8\"ab\" u8\"cd\";";
+        const char code[] =  "abcd = u8\"ab\" u8\"cd\";\n";
 
         const char expected[] =  "abcd = u8\"abcd\" ;";
 
@@ -284,7 +284,7 @@ class TestSimplifyTokens : public TestFixture {
     }
 
     void combine_mixedstrings() {
-        const char code[] = "abcdef = \"ab\" L\"cd\" \"ef\";";
+        const char code[] = "abcdef = \"ab\" L\"cd\" \"ef\";\n";
 
         const char expected[] =  "abcdef = L\"abcdef\" ;";
 
@@ -462,24 +462,25 @@ class TestSimplifyTokens : public TestFixture {
 
 
     void declareVar() {
-        const char code[] = "void f ( ) { char str [ 100 ] = \"100\" ; }";
-        ASSERT_EQUALS(code, tok(code));
+        const char code[] = "void f ( ) { char str [ 100 ] = \"100\" ; }\n";
+        const char expected[] = "void f ( ) { char str [ 100 ] = \"100\" ; }";
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void declareArray() {
-        const char code1[] = "void f ( ) { char str [ ] = \"100\" ; }";
+        const char code1[] = "void f ( ) { char str [ ] = \"100\" ; }\n";
         const char expected1[] = "void f ( ) { char str [ 4 ] = \"100\" ; }";
         ASSERT_EQUALS(expected1, tok(code1));
 
-        const char code2[] = "char str [ ] = \"\\x00\";";
+        const char code2[] = "char str [ ] = \"\\x00\";\n";
         const char expected2[] = "char str [ 2 ] = \"\\0\" ;";
         ASSERT_EQUALS(expected2, tok(code2));
 
-        const char code3[] = "char str [ ] = \"\\0\";";
+        const char code3[] = "char str [ ] = \"\\0\";\n";
         const char expected3[] = "char str [ 2 ] = \"\\0\" ;";
         ASSERT_EQUALS(expected3, tok(code3));
 
-        const char code4[] = "char str [ ] = \"\\n\\n\";";
+        const char code4[] = "char str [ ] = \"\\n\\n\";\n";
         const char expected4[] = "char str [ 3 ] = \"\\n\\n\" ;";
         ASSERT_EQUALS(expected4, tok(code4));
     }
@@ -512,11 +513,11 @@ class TestSimplifyTokens : public TestFixture {
 
 
     void elseif1() {
-        const char code[] = "void f(){ if(x) {} else if(ab) { cd } else { ef }gh; }";
+        const char code[] = "void f(){ if(x) {} else if(ab) { cd } else { ef }gh; }\n";
         ASSERT_EQUALS("\n\n##file 0\n1: void f ( ) { if ( x ) { } else { if ( ab ) { cd } else { ef } } gh ; }\n", tokenizeDebugListing(code));
 
         // syntax error: assert there is no segmentation fault
-        ASSERT_EQUALS("\n\n##file 0\n1: void f ( ) { if ( x ) { } else { if ( x ) { } } }\n", tokenizeDebugListing("void f(){ if(x) {} else if (x) { } }"));
+        ASSERT_EQUALS("\n\n##file 0\n1: void f ( ) { if ( x ) { } else { if ( x ) { } } }\n", tokenizeDebugListing("void f(){ if(x) {} else if (x) { } }\n"));
 
         {
             const char src[] =  "void f(int g,int f) {\n"
@@ -527,7 +528,7 @@ class TestSimplifyTokens : public TestFixture {
                                " else if( f==1)\n"
                                "  goo();\n"
                                "}\n"
-                               "}";
+                               "}\n";
 
             const char expected[] = "void f ( int g , int f ) "
                                     "{ "
@@ -544,23 +545,23 @@ class TestSimplifyTokens : public TestFixture {
                                     "} "
                                     "} "
                                     "} "
-                                    "}";
+                                    "}\n";
             ASSERT_EQUALS(tok(expected), tok(src));
         }
 
         // Ticket #6860 - lambdas
         {
-            const char src[] = "( []{if (ab) {cd}else if(ef) { gh } else { ij }kl}() );";
+            const char src[] = "( []{if (ab) {cd}else if(ef) { gh } else { ij }kl}() );\n";
             const char expected[] = "\n\n##file 0\n1: ( [ ] { if ( ab ) { cd } else { if ( ef ) { gh } else { ij } } kl } ( ) ) ;\n";
             ASSERT_EQUALS(expected, tokenizeDebugListing(src));
         }
         {
-            const char src[] = "[ []{if (ab) {cd}else if(ef) { gh } else { ij }kl}() ];";
+            const char src[] = "[ []{if (ab) {cd}else if(ef) { gh } else { ij }kl}() ];\n";
             const char expected[] = "\n\n##file 0\n1: [ [ ] { if ( ab ) { cd } else { if ( ef ) { gh } else { ij } } kl } ( ) ] ;\n";
             ASSERT_EQUALS(expected, tokenizeDebugListing(src));
         }
         {
-            const char src[] = "= { []{if (ab) {cd}else if(ef) { gh } else { ij }kl}() }";
+            const char src[] = "= { []{if (ab) {cd}else if(ef) { gh } else { ij }kl}() }\n";
             const char expected[] = "\n\n##file 0\n1: = { [ ] { if ( ab ) { cd } else { if ( ef ) { gh } else { ij } } kl } ( ) }\n";
             ASSERT_EQUALS(expected, tokenizeDebugListing(src));
         }
@@ -569,19 +570,19 @@ class TestSimplifyTokens : public TestFixture {
 
     void namespaces() {
         {
-            const char code[] = "namespace std { }";
+            const char code[] = "namespace std { }\n";
 
             ASSERT_EQUALS(";", tok(code));
         }
 
         {
-            const char code[] = "; namespace std { }";
+            const char code[] = "; namespace std { }\n";
 
             ASSERT_EQUALS(";", tok(code));
         }
 
         {
-            const char code[] = "using namespace std; namespace a{ namespace b{ void f(){} } }";
+            const char code[] = "using namespace std; namespace a{ namespace b{ void f(){} } }\n";
 
             const char expected[] = "namespace a { namespace b { void f ( ) { } } }";
 
@@ -589,7 +590,7 @@ class TestSimplifyTokens : public TestFixture {
         }
 
         {
-            const char code[] = "namespace b{ void f(){} }";
+            const char code[] = "namespace b{ void f(){} }\n";
 
             const char expected[] = "namespace b { void f ( ) { } }";
 
@@ -597,78 +598,78 @@ class TestSimplifyTokens : public TestFixture {
         }
 
         {
-            const char code[] = "void f(int namespace) { }";
+            const char code[] = "void f(int namespace) { }\n";
 
             ASSERT_THROW_INTERNAL(tok(code), SYNTAX);
         }
     }
 
     void not1() {
-        ASSERT_EQUALS("void f ( ) { if ( ! p ) { ; } }", tok("void f() { if (not p); }", dinit(TokOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( p && ! q ) { ; } }", tok("void f() { if (p && not q); }", dinit(TokOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { a = ! ( p && q ) ; }", tok("void f() { a = not(p && q); }", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( ! p ) { ; } }", tok("void f() { if (not p); }\n", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( p && ! q ) { ; } }", tok("void f() { if (p && not q); }\n", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { a = ! ( p && q ) ; }", tok("void f() { a = not(p && q); }\n", dinit(TokOptions, $.cpp = false)));
         // Don't simplify 'not' or 'compl' if they are defined as a type;
         // in variable declaration and in function declaration/definition
-        ASSERT_EQUALS("struct not { int x ; } ;", tok("struct not { int x; };", dinit(TokOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { not p ; compl c ; }", tok(" void f() { not p; compl c; }", dinit(TokOptions, $.cpp = false)));
-        ASSERT_EQUALS("void foo ( not i ) ;", tok("void foo(not i);", dinit(TokOptions, $.cpp = false)));
-        ASSERT_EQUALS("int foo ( not i ) { return g ( i ) ; }", tok("int foo(not i) { return g(i); }", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("struct not { int x ; } ;", tok("struct not { int x; };\n", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { not p ; compl c ; }", tok(" void f() { not p; compl c; }\n", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void foo ( not i ) ;", tok("void foo(not i);\n", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("int foo ( not i ) { return g ( i ) ; }", tok("int foo(not i) { return g(i); }\n", dinit(TokOptions, $.cpp = false)));
     }
 
     void and1() {
         ASSERT_EQUALS("void f ( ) { if ( p && q ) { ; } }",
-                      tok("void f() { if (p and q) ; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { if (p and q) ; }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { if ( foo ( ) && q ) { ; } }",
-                      tok("void f() { if (foo() and q) ; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { if (foo() and q) ; }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { if ( foo ( ) && bar ( ) ) { ; } }",
-                      tok("void f() { if (foo() and bar()) ; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { if (foo() and bar()) ; }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { if ( p && bar ( ) ) { ; } }",
-                      tok("void f() { if (p and bar()) ; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { if (p and bar()) ; }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { if ( p && ! q ) { ; } }",
-                      tok("void f() { if (p and not q) ; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { if (p and not q) ; }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { r = a && b ; }",
-                      tok("void f() { r = a and b; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { r = a and b; }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { r = ( a || b ) && ( c || d ) ; }",
-                      tok("void f() { r = (a || b) and (c || d); }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { r = (a || b) and (c || d); }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { if ( test1 [ i ] == 'A' && test2 [ i ] == 'C' ) { } }",
-                      tok("void f() { if (test1[i] == 'A' and test2[i] == 'C') {} }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { if (test1[i] == 'A' and test2[i] == 'C') {} }\n", dinit(TokOptions, $.cpp = false)));
     }
 
     void or1() {
         ASSERT_EQUALS("void f ( ) { if ( p || q ) { ; } }",
-                      tok("void f() { if (p or q) ; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { if (p or q) ; }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { if ( foo ( ) || q ) { ; } }",
-                      tok("void f() { if (foo() or q) ; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { if (foo() or q) ; }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { if ( foo ( ) || bar ( ) ) { ; } }",
-                      tok("void f() { if (foo() or bar()) ; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { if (foo() or bar()) ; }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { if ( p || bar ( ) ) { ; } }",
-                      tok("void f() { if (p or bar()) ; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { if (p or bar()) ; }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { if ( p || ! q ) { ; } }",
-                      tok("void f() { if (p or not q) ; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { if (p or not q) ; }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { r = a || b ; }",
-                      tok("void f() { r = a or b; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { r = a or b; }\n", dinit(TokOptions, $.cpp = false)));
 
         ASSERT_EQUALS("void f ( ) { r = ( a && b ) || ( c && d ) ; }",
-                      tok("void f() { r = (a && b) or (c && d); }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { r = (a && b) or (c && d); }\n", dinit(TokOptions, $.cpp = false)));
     }
 
     void cAlternativeTokens() {
         ASSERT_EQUALS("void f ( ) { err |= ( ( r & s ) && ! t ) ; }",
-                      tok("void f() { err or_eq ((r bitand s) and not t); }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() { err or_eq ((r bitand s) and not t); }\n", dinit(TokOptions, $.cpp = false)));
         ASSERT_EQUALS("void f ( ) const { r = f ( a [ 4 ] | 0x0F , ~ c , ! d ) ; }",
-                      tok("void f() const { r = f(a[4] bitor 0x0F, compl c, not d) ; }", dinit(TokOptions, $.cpp = false)));
+                      tok("void f() const { r = f(a[4] bitor 0x0F, compl c, not d) ; }\n", dinit(TokOptions, $.cpp = false)));
 
     }
 
@@ -789,8 +790,9 @@ class TestSimplifyTokens : public TestFixture {
 
         {
             // #4786 - don't replace , with ; in ".. : public B, C .." code
-            const char code[] = "template < class T = X > class A : public B , C { } ;";
-            ASSERT_EQUALS(code, tok(code));
+            const char code[] = "template < class T = X > class A : public B , C { } ;\n";
+            const char expected[] = "template < class T = X > class A : public B , C { } ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
     }
 
@@ -828,12 +830,12 @@ class TestSimplifyTokens : public TestFixture {
                           "};\n"
                           "TClass::TClass(const TClass &other) {\n"
                           "    operator=(other);\n"
-                          "}"));
+                          "}\n"));
     }
 
     void simplifyArrayAccessSyntax() {
         ASSERT_EQUALS("\n\n##file 0\n"
-                      "1: int a@1 ; a@1 [ 13 ] ;\n", tokenizeDebugListing("int a; 13[a];"));
+                      "1: int a@1 ; a@1 [ 13 ] ;\n", tokenizeDebugListing("int a; 13[a];\n"));
     }
 
 
@@ -893,282 +895,282 @@ class TestSimplifyTokens : public TestFixture {
 
     void simplifyStructDecl1() {
         {
-            const char code[] = "struct ABC { } abc;";
+            const char code[] = "struct ABC { } abc;\n";
             const char expected[] = "struct ABC { } ; struct ABC abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct ABC { } * pabc;";
+            const char code[] = "struct ABC { } * pabc;\n";
             const char expected[] = "struct ABC { } ; struct ABC * pabc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct ABC { } abc[4];";
+            const char code[] = "struct ABC { } abc[4];\n";
             const char expected[] = "struct ABC { } ; struct ABC abc [ 4 ] ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct ABC { } abc, def;";
+            const char code[] = "struct ABC { } abc, def;\n";
             const char expected[] = "struct ABC { } ; struct ABC abc ; struct ABC def ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct ABC { } abc, * pabc;";
+            const char code[] = "struct ABC { } abc, * pabc;\n";
             const char expected[] = "struct ABC { } ; struct ABC abc ; struct ABC * pabc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct ABC { struct DEF {} def; } abc;";
+            const char code[] = "struct ABC { struct DEF {} def; } abc;\n";
             const char expected[] = "struct ABC { struct DEF { } ; struct DEF def ; } ; struct ABC abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct { } abc;";
+            const char code[] = "struct { } abc;\n";
             const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct { } * pabc;";
+            const char code[] = "struct { } * pabc;\n";
             const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 * pabc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct { } abc[4];";
+            const char code[] = "struct { } abc[4];\n";
             const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc [ 4 ] ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct {int a;} const array[3] = {0};";
+            const char code[] = "struct {int a;} const array[3] = {0};\n";
             const char expected[] = "struct Anonymous0 { int a ; } ; struct Anonymous0 const array [ 3 ] = { 0 } ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "static struct {int a;} const array[3] = {0};";
+            const char code[] = "static struct {int a;} const array[3] = {0};\n";
             const char expected[] = "struct Anonymous0 { int a ; } ; static struct Anonymous0 const array [ 3 ] = { 0 } ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct { } abc, def;";
+            const char code[] = "struct { } abc, def;\n";
             const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc ; struct Anonymous0 def ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct { } abc, * pabc;";
+            const char code[] = "struct { } abc, * pabc;\n";
             const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc ; struct Anonymous0 * pabc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct { struct DEF {} def; } abc;";
+            const char code[] = "struct { struct DEF {} def; } abc;\n";
             const char expected[] = "struct Anonymous0 { struct DEF { } ; struct DEF def ; } ; struct Anonymous0 abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct ABC { struct {} def; } abc;";
+            const char code[] = "struct ABC { struct {} def; } abc;\n";
             const char expected[] = "struct ABC { struct Anonymous0 { } ; struct Anonymous0 def ; } ; struct ABC abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct { struct {} def; } abc;";
+            const char code[] = "struct { struct {} def; } abc;\n";
             const char expected[] = "struct Anonymous0 { struct Anonymous1 { } ; struct Anonymous1 def ; } ; struct Anonymous0 abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "union ABC { int i; float f; } abc;";
+            const char code[] = "union ABC { int i; float f; } abc;\n";
             const char expected[] = "union ABC { int i ; float f ; } ; union ABC abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct ABC { struct {} def; };";
+            const char code[] = "struct ABC { struct {} def; };\n";
             const char expected[] = "struct ABC { struct Anonymous0 { } ; struct Anonymous0 def ; } ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct ABC : public XYZ { struct {} def; };";
+            const char code[] = "struct ABC : public XYZ { struct {} def; };\n";
             const char expected[] = "struct ABC : public XYZ { struct Anonymous0 { } ; struct Anonymous0 def ; } ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct { int x; }; int y;";
+            const char code[] = "struct { int x; }; int y;\n";
             const char expected[] = "int x ; int y ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct { int x; };";
+            const char code[] = "struct { int x; };\n";
             const char expected[] = "int x ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct { };";
+            const char code[] = "struct { };\n";
             const char expected[] = ";";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct { struct { struct { } ; } ; };";
+            const char code[] = "struct { struct { struct { } ; } ; };\n";
             const char expected[] = ";";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         // ticket 2464
         {
-            const char code[] = "static struct ABC { } abc ;";
+            const char code[] = "static struct ABC { } abc ;\n";
             const char expected[] = "struct ABC { } ; static struct ABC abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         // ticket #980
         {
-            const char code[] = "void f() { int A(1),B(2),C=3,D,E(5),F=6; }";
+            const char code[] = "void f() { int A(1),B(2),C=3,D,E(5),F=6; }\n";
             const char expected[] = "void f ( ) { int A ( 1 ) ; int B ( 2 ) ; int C ; C = 3 ; int D ; int E ( 5 ) ; int F ; F = 6 ; }";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         // ticket #8284
         {
-            const char code[] = "void f() { class : foo<int> { } abc; }";
+            const char code[] = "void f() { class : foo<int> { } abc; }\n";
             const char expected[] = "void f ( ) { class Anonymous0 : foo < int > { } ; Anonymous0 abc ; }";
             ASSERT_EQUALS(expected, tok(code));
         }
     }
 
     void simplifyStructDecl2() { // ticket #2479 (segmentation fault)
-        const char code[] = "struct { char c; }";
+        const char code[] = "struct { char c; }\n";
         const char expected[] = "struct { char c ; }";
         ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyStructDecl3() {
         {
-            const char code[] = "class ABC { } abc;";
+            const char code[] = "class ABC { } abc;\n";
             const char expected[] = "class ABC { } ; ABC abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class ABC { } * pabc;";
+            const char code[] = "class ABC { } * pabc;\n";
             const char expected[] = "class ABC { } ; ABC * pabc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class ABC { } abc[4];";
+            const char code[] = "class ABC { } abc[4];\n";
             const char expected[] = "class ABC { } ; ABC abc [ 4 ] ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class ABC { } abc, def;";
+            const char code[] = "class ABC { } abc, def;\n";
             const char expected[] = "class ABC { } ; ABC abc ; ABC def ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class ABC { } abc, * pabc;";
+            const char code[] = "class ABC { } abc, * pabc;\n";
             const char expected[] = "class ABC { } ; ABC abc ; ABC * pabc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class ABC { class DEF {} def; } abc;";
+            const char code[] = "class ABC { class DEF {} def; } abc;\n";
             const char expected[] = "class ABC { class DEF { } ; DEF def ; } ; ABC abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class { } abc;";
+            const char code[] = "class { } abc;\n";
             const char expected[] = "class { } abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class { } * pabc;";
+            const char code[] = "class { } * pabc;\n";
             const char expected[] = "class { } * pabc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class { } abc[4];";
+            const char code[] = "class { } abc[4];\n";
             const char expected[] = "class { } abc [ 4 ] ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class { } abc, def;";
+            const char code[] = "class { } abc, def;\n";
             const char expected[] = "class { } abc , def ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class { } abc, * pabc;";
+            const char code[] = "class { } abc, * pabc;\n";
             const char expected[] = "class { } abc , * pabc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "struct { class DEF {} def; } abc;";
+            const char code[] = "struct { class DEF {} def; } abc;\n";
             const char expected[] = "struct Anonymous0 { class DEF { } ; DEF def ; } ; struct Anonymous0 abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class ABC { struct {} def; } abc;";
+            const char code[] = "class ABC { struct {} def; } abc;\n";
             const char expected[] = "class ABC { struct Anonymous0 { } ; struct Anonymous0 def ; } ; ABC abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class { class {} def; } abc;";
+            const char code[] = "class { class {} def; } abc;\n";
             const char expected[] = "class { class { } def ; } abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class ABC { struct {} def; };";
+            const char code[] = "class ABC { struct {} def; };\n";
             const char expected[] = "class ABC { struct Anonymous0 { } ; struct Anonymous0 def ; } ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class ABC : public XYZ { struct {} def; };";
+            const char code[] = "class ABC : public XYZ { struct {} def; };\n";
             const char expected[] = "class ABC : public XYZ { struct Anonymous0 { } ; struct Anonymous0 def ; } ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class { int x; }; int y;";
+            const char code[] = "class { int x; }; int y;\n";
             const char expected[] = "class { int x ; } ; int y ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class { int x; };";
+            const char code[] = "class { int x; };\n";
             const char expected[] = "class { int x ; } ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "class { };";
+            const char code[] = "class { };\n";
             const char expected[] = "class { } ;";
             ASSERT_EQUALS(expected, tok(code));
         }
@@ -1207,28 +1209,28 @@ class TestSimplifyTokens : public TestFixture {
                       "} ; struct A arrays ; arrays = { { 0 } } ;",
                       tok("struct A {\n"
                           "    char integers[X];\n"
-                          "} arrays = {{0}};"));
+                          "} arrays = {{0}};\n"));
     }
 
     void simplifyStructDecl7() {
         ASSERT_EQUALS("struct Anonymous0 { char x ; } ; struct Anonymous0 a [ 2 ] ;",
-                      tok("struct { char x; } a[2];"));
+                      tok("struct { char x; } a[2];\n"));
         ASSERT_EQUALS("struct Anonymous0 { char x ; } ; static struct Anonymous0 a [ 2 ] ;",
-                      tok("static struct { char x; } a[2];"));
+                      tok("static struct { char x; } a[2];\n"));
     }
 
     void simplifyStructDecl8() {
-        ASSERT_EQUALS("enum A { x , y , z } ; enum A a ; a = x ;", tok("enum A { x, y, z } a(x);"));
-        ASSERT_EQUALS("enum B { x , y , z } ; enum B b ; b = x ;", tok("enum B { x , y, z } b{x};"));
-        ASSERT_EQUALS("struct C { int i ; } ; struct C c ; c = C { 0 } ;", tok("struct C { int i; } c{0};"));
-        ASSERT_EQUALS("enum Anonymous0 { x , y , z } ; enum Anonymous0 d ; d = x ;", tok("enum { x, y, z } d(x);"));
-        ASSERT_EQUALS("enum Anonymous0 { x , y , z } ; enum Anonymous0 e ; e = x ;", tok("enum { x, y, z } e{x};"));
-        ASSERT_EQUALS("struct Anonymous0 { int i ; } ; struct Anonymous0 f ; f = Anonymous0 { 0 } ;", tok("struct { int i; } f{0};"));
-        ASSERT_EQUALS("struct Anonymous0 { } ; struct Anonymous0 x ; x = { 0 } ;", tok("struct {} x = {0};"));
-        ASSERT_EQUALS("enum G : short { x , y , z } ; enum G g ; g = x ;", tok("enum G : short { x, y, z } g(x);"));
-        ASSERT_EQUALS("enum H : short { x , y , z } ; enum H h ; h = x ;", tok("enum H : short { x, y, z } h{x};"));
-        ASSERT_EQUALS("enum class I : short { x , y , z } ; enum I i ; i = x ;", tok("enum class I : short { x, y, z } i(x);"));
-        ASSERT_EQUALS("enum class J : short { x , y , z } ; enum J j ; j = x ;", tok("enum class J : short { x, y, z } j{x};"));
+        ASSERT_EQUALS("enum A { x , y , z } ; enum A a ; a = x ;", tok("enum A { x, y, z } a(x);\n"));
+        ASSERT_EQUALS("enum B { x , y , z } ; enum B b ; b = x ;", tok("enum B { x , y, z } b{x};\n"));
+        ASSERT_EQUALS("struct C { int i ; } ; struct C c ; c = C { 0 } ;", tok("struct C { int i; } c{0};\n"));
+        ASSERT_EQUALS("enum Anonymous0 { x , y , z } ; enum Anonymous0 d ; d = x ;", tok("enum { x, y, z } d(x);\n"));
+        ASSERT_EQUALS("enum Anonymous0 { x , y , z } ; enum Anonymous0 e ; e = x ;", tok("enum { x, y, z } e{x};\n"));
+        ASSERT_EQUALS("struct Anonymous0 { int i ; } ; struct Anonymous0 f ; f = Anonymous0 { 0 } ;", tok("struct { int i; } f{0};\n"));
+        ASSERT_EQUALS("struct Anonymous0 { } ; struct Anonymous0 x ; x = { 0 } ;", tok("struct {} x = {0};\n"));
+        ASSERT_EQUALS("enum G : short { x , y , z } ; enum G g ; g = x ;", tok("enum G : short { x, y, z } g(x);\n"));
+        ASSERT_EQUALS("enum H : short { x , y , z } ; enum H h ; h = x ;", tok("enum H : short { x, y, z } h{x};\n"));
+        ASSERT_EQUALS("enum class I : short { x , y , z } ; enum I i ; i = x ;", tok("enum class I : short { x, y, z } i(x);\n"));
+        ASSERT_EQUALS("enum class J : short { x , y , z } ; enum J j ; j = x ;", tok("enum class J : short { x, y, z } j{x};\n"));
     }
 
     void simplifyStructDecl9() {
@@ -1289,74 +1291,74 @@ class TestSimplifyTokens : public TestFixture {
     }
 
     void removeUnwantedKeywords() {
-        ASSERT_EQUALS("int var ;", tok("register int var ;"));
-        ASSERT_EQUALS("short var ;", tok("register short int var ;"));
-        ASSERT_EQUALS("int foo ( ) { }", tok("inline int foo ( ) { }"));
-        ASSERT_EQUALS("int foo ( ) { }", tok("__inline int foo ( ) { }"));
-        ASSERT_EQUALS("int foo ( ) { }", tok("__forceinline int foo ( ) { }"));
-        ASSERT_EQUALS("constexpr int foo ( ) { }", tok("constexpr int foo() { }"));
-        ASSERT_EQUALS("constexpr int foo ( ) { }", tok("consteval int foo() { }"));
-        ASSERT_EQUALS("int x ; x = 0 ;", tok("constinit int x = 0;"));
-        ASSERT_EQUALS("void f ( ) { int final [ 10 ] ; }", tok("void f() { int final[10]; }"));
-        ASSERT_EQUALS("int * p ;", tok("int * __restrict p;", dinit(TokOptions, $.cpp = false)));
-        ASSERT_EQUALS("int * * p ;", tok("int * __restrict__ * p;", dinit(TokOptions, $.cpp = false)));
-        ASSERT_EQUALS("void foo ( float * a , float * b ) ;", tok("void foo(float * __restrict__ a, float * __restrict__ b);", dinit(TokOptions, $.cpp = false)));
-        ASSERT_EQUALS("int * p ;", tok("int * restrict p;", dinit(TokOptions, $.cpp = false)));
-        ASSERT_EQUALS("int * * p ;", tok("int * restrict * p;", dinit(TokOptions, $.cpp = false)));
-        ASSERT_EQUALS("void foo ( float * a , float * b ) ;", tok("void foo(float * restrict a, float * restrict b);", dinit(TokOptions, $.cpp = false)));
-        ASSERT_EQUALS("void foo ( int restrict ) ;", tok("void foo(int restrict);"));
-        ASSERT_EQUALS("int * p ;", tok("typedef int * __restrict__ rint; rint p;", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("int var ;", tok("register int var ;\n"));
+        ASSERT_EQUALS("short var ;", tok("register short int var ;\n"));
+        ASSERT_EQUALS("int foo ( ) { }", tok("inline int foo ( ) { }\n"));
+        ASSERT_EQUALS("int foo ( ) { }", tok("__inline int foo ( ) { }\n"));
+        ASSERT_EQUALS("int foo ( ) { }", tok("__forceinline int foo ( ) { }\n"));
+        ASSERT_EQUALS("constexpr int foo ( ) { }", tok("constexpr int foo() { }\n"));
+        ASSERT_EQUALS("constexpr int foo ( ) { }", tok("consteval int foo() { }\n"));
+        ASSERT_EQUALS("int x ; x = 0 ;", tok("constinit int x = 0;\n"));
+        ASSERT_EQUALS("void f ( ) { int final [ 10 ] ; }", tok("void f() { int final[10]; }\n"));
+        ASSERT_EQUALS("int * p ;", tok("int * __restrict p;\n", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("int * * p ;", tok("int * __restrict__ * p;\n", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void foo ( float * a , float * b ) ;", tok("void foo(float * __restrict__ a, float * __restrict__ b);\n", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("int * p ;", tok("int * restrict p;\n", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("int * * p ;", tok("int * restrict * p;\n", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void foo ( float * a , float * b ) ;", tok("void foo(float * restrict a, float * restrict b);\n", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void foo ( int restrict ) ;", tok("void foo(int restrict);\n"));
+        ASSERT_EQUALS("int * p ;", tok("typedef int * __restrict__ rint; rint p;\n", dinit(TokOptions, $.cpp = false)));
 
         // don't remove struct members:
-        ASSERT_EQUALS("a = b . _inline ;", tok("a = b._inline;"));
+        ASSERT_EQUALS("a = b . _inline ;", tok("a = b._inline;\n"));
 
-        ASSERT_EQUALS("int i ; i = 0 ;", tok("auto int i = 0;", dinit(TokOptions, $.cpp = false)));
-        ASSERT_EQUALS("auto i ; i = 0 ;", tok("auto i = 0;"));
+        ASSERT_EQUALS("int i ; i = 0 ;", tok("auto int i = 0;\n", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("auto i ; i = 0 ;", tok("auto i = 0;\n"));
     }
 
     void simplifyCallingConvention() {
-        ASSERT_EQUALS("int f ( ) ;", tok("int __cdecl f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __stdcall f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __fastcall f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __clrcall f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __thiscall f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __syscall f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __pascal f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __fortran f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __cdecl f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __stdcall f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __fastcall f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __clrcall f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __thiscall f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __syscall f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __pascal f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __fortran f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("int WINAPI f();", dinit(TokOptions, $.type = Platform::Type::Win32A)));
-        ASSERT_EQUALS("int f ( ) ;", tok("int APIENTRY f();", dinit(TokOptions, $.type = Platform::Type::Win32A)));
-        ASSERT_EQUALS("int f ( ) ;", tok("int CALLBACK f();", dinit(TokOptions, $.type = Platform::Type::Win32A)));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __cdecl f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __stdcall f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __fastcall f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __clrcall f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __thiscall f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __syscall f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __pascal f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __fortran f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __cdecl f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __stdcall f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __fastcall f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __clrcall f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __thiscall f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __syscall f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __pascal f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __fortran f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int WINAPI f();\n", dinit(TokOptions, $.type = Platform::Type::Win32A)));
+        ASSERT_EQUALS("int f ( ) ;", tok("int APIENTRY f();\n", dinit(TokOptions, $.type = Platform::Type::Win32A)));
+        ASSERT_EQUALS("int f ( ) ;", tok("int CALLBACK f();\n", dinit(TokOptions, $.type = Platform::Type::Win32A)));
 
         // don't simplify Microsoft defines in unix code (#7554)
-        ASSERT_EQUALS("enum E { CALLBACK } ;", tok("enum E { CALLBACK } ;", dinit(TokOptions, $.type = Platform::Type::Unix32)));
+        ASSERT_EQUALS("enum E { CALLBACK } ;", tok("enum E { CALLBACK } ;\n", dinit(TokOptions, $.type = Platform::Type::Unix32)));
     }
 
     void simplifyAttribute() {
-        ASSERT_EQUALS("int f ( ) ;", tok("__attribute__ ((visibility(\"default\"))) int f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("__attribute__((visibility(\"default\"))) int f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("__attribute ((visibility(\"default\"))) int f();"));
-        ASSERT_EQUALS("int f ( ) ;", tok("__attribute__ ((visibility(\"default\"))) __attribute__ ((warn_unused_result)) int f();"));
-        ASSERT_EQUALS("blah :: blah f ( ) ;", tok("__attribute__ ((visibility(\"default\"))) blah::blah f();"));
-        ASSERT_EQUALS("template < T > Result < T > f ( ) ;", tok("template<T> __attribute__ ((warn_unused_result)) Result<T> f();"));
-        ASSERT_EQUALS("template < T , U > Result < T , U > f ( ) ;", tok("template<T, U> __attribute__ ((warn_unused_result)) Result<T, U> f();"));
-        ASSERT_EQUALS("void ( * fp ) ( ) ; fp = nullptr ;", tok("typedef void (*fp_t)() __attribute__((noreturn)); fp_t fp = nullptr;")); // #12137
+        ASSERT_EQUALS("int f ( ) ;", tok("__attribute__ ((visibility(\"default\"))) int f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("__attribute__((visibility(\"default\"))) int f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("__attribute ((visibility(\"default\"))) int f();\n"));
+        ASSERT_EQUALS("int f ( ) ;", tok("__attribute__ ((visibility(\"default\"))) __attribute__ ((warn_unused_result)) int f();\n"));
+        ASSERT_EQUALS("blah :: blah f ( ) ;", tok("__attribute__ ((visibility(\"default\"))) blah::blah f();\n"));
+        ASSERT_EQUALS("template < T > Result < T > f ( ) ;", tok("template<T> __attribute__ ((warn_unused_result)) Result<T> f();\n"));
+        ASSERT_EQUALS("template < T , U > Result < T , U > f ( ) ;", tok("template<T, U> __attribute__ ((warn_unused_result)) Result<T, U> f();\n"));
+        ASSERT_EQUALS("void ( * fp ) ( ) ; fp = nullptr ;", tok("typedef void (*fp_t)() __attribute__((noreturn)); fp_t fp = nullptr;\n")); // #12137
     }
 
     void simplifyFunctorCall() {
-        ASSERT_EQUALS("IncrementFunctor ( ) ( a ) ;", tok("IncrementFunctor()(a);"));
+        ASSERT_EQUALS("IncrementFunctor ( ) ( a ) ;", tok("IncrementFunctor()(a);\n"));
     }
 
     // #ticket #5339 (simplify function pointer after comma)
     void simplifyFunctionPointer() {
-        ASSERT_EQUALS("f ( double x , double ( * y ) ( ) ) ;", tok("f (double x, double (*y) ());"));
+        ASSERT_EQUALS("f ( double x , double ( * y ) ( ) ) ;", tok("f (double x, double (*y) ());\n"));
     }
 
     void simplifyFunctionReturn() {
@@ -1368,7 +1370,7 @@ class TestSimplifyTokens : public TestFixture {
                                 "    void ( * get2 ( ) ) ( ) { return 0 ; }\n"
                                 "    testfp get3();\n"
                                 "    void ( * get4 ( ) ) ( );\n"
-                                "};";
+                                "};\n";
             const char expected[] = "struct Fred "
                                     "{ "
                                     "void * get1 ( ) { return 0 ; } "
@@ -1383,7 +1385,7 @@ class TestSimplifyTokens : public TestFixture {
                                 "    std::string s;\n"
                                 "    const std::string & foo();\n"
                                 "};\n"
-                                "const std::string & Fred::foo() { return \"\"; }";
+                                "const std::string & Fred::foo() { return \"\"; }\n";
             const char expected[] = "class Fred { "
                                     "std :: string s ; "
                                     "const std :: string & foo ( ) ; "
@@ -1412,17 +1414,17 @@ class TestSimplifyTokens : public TestFixture {
                                 "int main() {\n"
                                 "  fact2<3> ();\n"
                                 "  fact2<2> ();\n"
-                                "}";
+                                "}\n";
             (void)tok(code);
         }
     }
 
     void consecutiveBraces() {
-        ASSERT_EQUALS("void f ( ) { }", tok("void f(){{}}"));
-        ASSERT_EQUALS("void f ( ) { }", tok("void f(){{{}}}"));
-        ASSERT_EQUALS("void f ( ) { for ( ; ; ) { } }", tok("void f () { for(;;){} }"));
-        ASSERT_EQUALS("void f ( ) { { scope_lock lock ; foo ( ) ; } { scope_lock lock ; bar ( ) ; } }", tok("void f () { {scope_lock lock; foo();} {scope_lock lock; bar();} }"));
-        ASSERT_EQUALS("std :: map < int , int > m { { } } ;", tok("std::map<int, int> m{ {} };"));
+        ASSERT_EQUALS("void f ( ) { }", tok("void f(){{}}\n"));
+        ASSERT_EQUALS("void f ( ) { }", tok("void f(){{{}}}\n"));
+        ASSERT_EQUALS("void f ( ) { for ( ; ; ) { } }", tok("void f () { for(;;){} }\n"));
+        ASSERT_EQUALS("void f ( ) { { scope_lock lock ; foo ( ) ; } { scope_lock lock ; bar ( ) ; } }", tok("void f () { {scope_lock lock; foo();} {scope_lock lock; bar();} }\n"));
+        ASSERT_EQUALS("std :: map < int , int > m { { } } ;", tok("std::map<int, int> m{ {} };\n"));
     }
 
     void simplifyOverride() { // ticket #5069
@@ -1435,35 +1437,35 @@ class TestSimplifyTokens : public TestFixture {
     }
 
     void simplifyNestedNamespace() {
-        ASSERT_EQUALS("namespace A { namespace B { namespace C { int i ; } } }", tok("namespace A::B::C { int i; }"));
+        ASSERT_EQUALS("namespace A { namespace B { namespace C { int i ; } } }", tok("namespace A::B::C { int i; }\n"));
     }
 
     void simplifyNamespaceAliases1() {
         ASSERT_EQUALS(";",
-                      tok("namespace ios = boost::iostreams;"));
+                      tok("namespace ios = boost::iostreams;\n"));
         ASSERT_EQUALS("boost :: iostreams :: istream foo ( \"foo\" ) ;",
-                      tok("namespace ios = boost::iostreams; ios::istream foo(\"foo\");"));
+                      tok("namespace ios = boost::iostreams; ios::istream foo(\"foo\");\n"));
         ASSERT_EQUALS("boost :: iostreams :: istream foo ( \"foo\" ) ;",
-                      tok("using namespace std; namespace ios = boost::iostreams; ios::istream foo(\"foo\");"));
+                      tok("using namespace std; namespace ios = boost::iostreams; ios::istream foo(\"foo\");\n"));
         ASSERT_EQUALS(";",
-                      tok("using namespace std; namespace ios = boost::iostreams;"));
+                      tok("using namespace std; namespace ios = boost::iostreams;\n"));
         ASSERT_EQUALS("namespace NS { boost :: iostreams :: istream foo ( \"foo\" ) ; }",
-                      tok("namespace NS { using namespace std; namespace ios = boost::iostreams; ios::istream foo(\"foo\"); }"));
+                      tok("namespace NS { using namespace std; namespace ios = boost::iostreams; ios::istream foo(\"foo\"); }\n"));
 
         // duplicate namespace aliases
         ASSERT_EQUALS(";",
-                      tok("namespace ios = boost::iostreams;\nnamespace ios = boost::iostreams;"));
+                      tok("namespace ios = boost::iostreams;\nnamespace ios = boost::iostreams;\n"));
         ASSERT_EQUALS(";",
-                      tok("namespace ios = boost::iostreams;\nnamespace ios = boost::iostreams;\nnamespace ios = boost::iostreams;"));
+                      tok("namespace ios = boost::iostreams;\nnamespace ios = boost::iostreams;\nnamespace ios = boost::iostreams;\n"));
         ASSERT_EQUALS("namespace A { namespace B { void foo ( ) { bar ( A :: B :: ab ( ) ) ; } } }",
-                      tok("namespace A::B {"
-                          "namespace AB = A::B;"
-                          "void foo() {"
-                          "    namespace AB = A::B;" // duplicate declaration
-                          "    bar(AB::ab());"
-                          "}"
-                          "namespace AB = A::B;" //duplicate declaration
-                          "}"));
+                      tok("namespace A::B {\n"
+                          "namespace AB = A::B;\n"
+                          "void foo() {\n"
+                          "    namespace AB = A::B;\n" // duplicate declaration
+                          "    bar(AB::ab());\n"
+                          "}\n"
+                          "namespace AB = A::B;\n" //duplicate declaration
+                          "}\n"));
         ASSERT_EQUALS(";",
                       tok("namespace p = boost::python;\n"
                           "namespace np = boost::numpy;\n"));
@@ -1471,19 +1473,19 @@ class TestSimplifyTokens : public TestFixture {
         // redeclared nested namespace aliases
         TODO_ASSERT_EQUALS("namespace A { namespace B { void foo ( ) { bar ( A :: B :: ab ( ) ) ; { baz ( A :: a ( ) ) ; } bar ( A :: B :: ab ( ) ) ; } } }",
                            "namespace A { namespace B { void foo ( ) { bar ( A :: B :: ab ( ) ) ; { baz ( A :: B :: a ( ) ) ; } bar ( A :: B :: ab ( ) ) ; } } }",
-                           tok("namespace A::B {"
-                               "namespace AB = A::B;"
-                               "void foo() {"
-                               "    namespace AB = A::B;" // duplicate declaration
-                               "    bar(AB::ab());"
-                               "    {"
-                               "         namespace AB = A;"
-                               "         baz(AB::a());" // redeclaration OK
-                               "    }"
-                               "    bar(AB::ab());"
-                               "}"
-                               "namespace AB = A::B;" //duplicate declaration
-                               "}"));
+                           tok("namespace A::B {\n"
+                               "namespace AB = A::B;\n"
+                               "void foo() {\n"
+                               "    namespace AB = A::B;\n" // duplicate declaration
+                               "    bar(AB::ab());\n"
+                               "    {\n"
+                               "         namespace AB = A;\n"
+                               "         baz(AB::a());\n" // redeclaration OK
+                               "    }\n"
+                               "    bar(AB::ab());\n"
+                               "}\n"
+                               "namespace AB = A::B;\n" //duplicate declaration
+                               "}\n"));
 
         // variable and namespace alias with same name
         ASSERT_EQUALS("namespace external { namespace ns { "
@@ -1495,16 +1497,16 @@ class TestSimplifyTokens : public TestFixture {
                       "namespace external { namespace ns { "
                       "void A :: f ( const std :: string & json ) { } "
                       "} }",
-                      tok("namespace external::ns {"
-                          "    class A {"
-                          "    public:"
-                          "        static void f(const std::string& json);"
-                          "    };"
-                          "}"
-                          "namespace json = rapidjson;"
-                          "namespace external::ns {"
-                          "    void A::f(const std::string& json) { }"
-                          "}"));
+                      tok("namespace external::ns {\n"
+                          "    class A {\n"
+                          "    public:\n"
+                          "        static void f(const std::string& json);\n"
+                          "    };\n"
+                          "}\n"
+                          "namespace json = rapidjson;\n"
+                          "namespace external::ns {\n"
+                          "    void A::f(const std::string& json) { }\n"
+                          "}\n"));
     }
 
     void simplifyNamespaceAliases2() {
@@ -1512,11 +1514,11 @@ class TestSimplifyTokens : public TestFixture {
                       "{ "
                       "int maxResults ; maxResults = :: a :: b :: c :: d :: ef :: MAX ; "
                       "}",
-                      tok("namespace ef = ::a::b::c::d::ef;"
-                          "void foo()"
-                          "{"
-                          "  int maxResults = ::a::b::c::d::ef::MAX;"
-                          "}"));
+                      tok("namespace ef = ::a::b::c::d::ef;\n"
+                          "void foo()\n"
+                          "{\n"
+                          "  int maxResults = ::a::b::c::d::ef::MAX;\n"
+                          "}\n"));
     }
 
     void simplifyNamespaceAliases3() {
@@ -1608,33 +1610,34 @@ class TestSimplifyTokens : public TestFixture {
 
     void simplifyKnownVariables14() {
         // ticket #753
-        const char code[] = "void f ( ) { int n ; n = 1 ; do { ++ n ; } while ( n < 10 ) ; }";
-        ASSERT_EQUALS(code, simplifyKnownVariables(code));
+        const char code[] = "void f ( ) { int n ; n = 1 ; do { ++ n ; } while ( n < 10 ) ; }\n";
+        const char expected[] = "void f ( ) { int n ; n = 1 ; do { ++ n ; } while ( n < 10 ) ; }";
+        ASSERT_EQUALS(expected, simplifyKnownVariables(code));
     }
 
     void simplifyKnownVariables16() {
         // ticket #807 - segmentation fault when macro isn't found
-        const char code[] = "void f ( ) { int n = 1; DISPATCH(while); }";
+        const char code[] = "void f ( ) { int n = 1; DISPATCH(while); }\n";
         ASSERT_THROW_INTERNAL(simplifyKnownVariables(code), UNKNOWN_MACRO);
     }
 
     void simplifyKnownVariables17() {
         // ticket #807 - segmentation fault when macro isn't found
-        const char code[] = "void f ( ) { char *s = malloc(100);mp_ptr p = s; p++; }";
+        const char code[] = "void f ( ) { char *s = malloc(100);mp_ptr p = s; p++; }\n";
         ASSERT_EQUALS(
             "void f ( ) { char * s ; s = malloc ( 100 ) ; mp_ptr p ; p = s ; p ++ ; }",
             simplifyKnownVariables(code));
     }
 
     void simplifyKnownVariables18() {
-        const char code[] = "void f ( ) { char *s = malloc(100);mp_ptr p = s; ++p; }";
+        const char code[] = "void f ( ) { char *s = malloc(100);mp_ptr p = s; ++p; }\n";
         ASSERT_EQUALS(
             "void f ( ) { char * s ; s = malloc ( 100 ) ; mp_ptr p ; p = s ; ++ p ; }",
             simplifyKnownVariables(code));
     }
 
     void simplifyKnownVariables19() {
-        const char code[] = "void f ( ) { int i=0; do { if (i>0) { a(); } i=b(); } while (i != 12); }";
+        const char code[] = "void f ( ) { int i=0; do { if (i>0) { a(); } i=b(); } while (i != 12); }\n";
         ASSERT_EQUALS(
             "void f ( ) { int i ; i = 0 ; do { if ( i > 0 ) { a ( ) ; } i = b ( ) ; } while ( i != 12 ) ; }",
             simplifyKnownVariables(code));
@@ -1643,7 +1646,7 @@ class TestSimplifyTokens : public TestFixture {
     void simplifyKnownVariables21() {
         ASSERT_EQUALS(
             "void foo ( int i ) { int n ; n = i ; for ( i = 0 ; i < n ; ++ i ) { } }",
-            simplifyKnownVariables("void foo(int i) { int n = i; for (i = 0; i < n; ++i) { } }"));
+            simplifyKnownVariables("void foo(int i) { int n = i; for (i = 0; i < n; ++i) { } }\n"));
     }
 
     void simplifyKnownVariables25() {
@@ -2059,11 +2062,14 @@ class TestSimplifyTokens : public TestFixture {
     void simplifyKnownVariables36() {
 
         // Ticket #5972
-        const char code2[] = "void f() {"
-                             "  char buf[10] = \"ab\";"
-                             "    memset(buf, 0, 10);"
-                             "}";
-        const char expected2[] = "void f ( ) { char buf [ 10 ] = \"ab\" ; memset ( buf , 0 , 10 ) ; }";
+        const char code2[] = "void f() {\n"
+                             "  char buf[10] = \"ab\";\n"
+                             "    memset(buf, 0, 10);\n"
+                             "}\n";
+        const char expected2[] = "void f ( ) {\n"
+                                 "char buf [ 10 ] = \"ab\" ;\n"
+                                 "memset ( buf , 0 , 10 ) ;\n"
+                                 "}";
         ASSERT_EQUALS(expected2, tokenizeAndStringify(code2));
     }
 
@@ -2073,7 +2079,7 @@ class TestSimplifyTokens : public TestFixture {
                                 "   char a[10];\n"
                                 "   strcpy(a, \"hello\");\n"
                                 "   strcat(a, \"!\");\n"
-                                "}";
+                                "}\n";
             const char expected[] = "void f ( ) {\n"
                                     "char a [ 10 ] ;\n"
                                     "strcpy ( a , \"hello\" ) ;\n"
@@ -2083,27 +2089,27 @@ class TestSimplifyTokens : public TestFixture {
         }
 
         {
-            const char code[] = "void f() {"
-                                "    char *s = malloc(10);"
-                                "    strcpy(s, \"\");"
-                                "    free(s);"
-                                "}";
-            const char expected[] = "void f ( ) {"
-                                    " char * s ; s = malloc ( 10 ) ;"
-                                    " strcpy ( s , \"\" ) ;"
-                                    " free ( s ) ; "
+            const char code[] = "void f() {\n"
+                                "    char *s = malloc(10);\n"
+                                "    strcpy(s, \"\");\n"
+                                "    free(s);\n"
+                                "}\n";
+            const char expected[] = "void f ( ) {\n"
+                                    "char * s ; s = malloc ( 10 ) ;\n"
+                                    "strcpy ( s , \"\" ) ;\n"
+                                    "free ( s ) ;\n"
                                     "}";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
 
         {
-            const char code[] = "void f(char *p, char *q) {"
-                                "    strcpy(p, \"abc\");"
-                                "    q = p;"
-                                "}";
-            const char expected[] = "void f ( char * p , char * q ) {"
-                                    " strcpy ( p , \"abc\" ) ;"
-                                    " q = p ; "
+            const char code[] = "void f(char *p, char *q) {\n"
+                                "    strcpy(p, \"abc\");\n"
+                                "    q = p;\n"
+                                "}\n";
+            const char expected[] = "void f ( char * p , char * q ) {\n"
+                                    "strcpy ( p , \"abc\" ) ;\n"
+                                    "q = p ;\n"
                                     "}";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
@@ -2114,7 +2120,7 @@ class TestSimplifyTokens : public TestFixture {
                                 "    char s[10];\n"
                                 "    strcpy(s, \"123\");\n"
                                 "    if (s[6] == ' ');\n"
-                                "}";
+                                "}\n";
             const char expected[] = "void f ( ) {\n"
                                     "char s [ 10 ] ;\n"
                                     "strcpy ( s , \"123\" ) ;\n"
@@ -2130,7 +2136,7 @@ class TestSimplifyTokens : public TestFixture {
             const char code[] = "void f() {\n"
                                 "    int a, *p; p = &a;\n"
                                 "    { int a = *p; }\n"
-                                "}";
+                                "}\n";
             const char expected[] = "void f ( ) {\n"
                                     "int a ; int * p ; p = & a ;\n"
                                     "{ int a ; a = * p ; }\n"
@@ -2142,7 +2148,7 @@ class TestSimplifyTokens : public TestFixture {
             const char code[] = "void f() {\n"
                                 "    int *a, **p; p = &a;\n"
                                 "    { int *a = *p; }\n"
-                                "}";
+                                "}\n";
             const char expected[] = "void f ( ) {\n"
                                     "int * a ; int * * p ; p = & a ;\n"
                                     "{ int * a ; a = * p ; }\n"
@@ -2155,7 +2161,7 @@ class TestSimplifyTokens : public TestFixture {
         const char code[] = "void a() {\n"
                             "    static int i = 10;\n"
                             "    b(i++);\n"
-                            "}";
+                            "}\n";
         const char expected[] = "void a ( ) {\n"
                                 "static int i = 10 ;\n"
                                 "b ( i ++ ) ;\n"
@@ -2168,7 +2174,7 @@ class TestSimplifyTokens : public TestFixture {
                             "    int x = 0;\n"
                             "    cin >> x;\n"
                             "    return x;\n"
-                            "}";
+                            "}\n";
 
         const char expected[] = "void f ( ) {\n"
                                 "int x ; x = 0 ;\n"
@@ -2186,7 +2192,7 @@ class TestSimplifyTokens : public TestFixture {
         const char code[] = "void f() {\n"
                             "    int x = 0;\n"
                             "    cin >> std::hex >> x;\n"
-                            "}";
+                            "}\n";
         const char expected[] = "void f ( ) {\n"
                                 "int x ; x = 0 ;\n"
                                 "cin >> std :: hex >> x ;\n"
@@ -2202,7 +2208,7 @@ class TestSimplifyTokens : public TestFixture {
         const char code[] = "void f(int sz) {\n"
                             "    int i;\n"
                             "    for (i = 0; ((i<sz) && (sz>3)); ++i) { }\n"
-                            "}";
+                            "}\n";
         const char expected[] = "void f ( int sz ) {\n"
                                 "int i ;\n"
                                 "for ( i = 0 ; ( i < sz ) && ( sz > 3 ) ; ++ i ) { }\n"
@@ -2217,7 +2223,7 @@ class TestSimplifyTokens : public TestFixture {
                             "    case 1: sz = 2; continue;\n"
                             "    case 2: x = sz; break;\n"
                             "    }\n"
-                            "}";
+                            "}\n";
         const char expected[] = "void f ( int sz ) {\n"
                                 "switch ( x ) {\n"
                                 "case 1 : ; sz = 2 ; continue ;\n"
@@ -2248,8 +2254,25 @@ class TestSimplifyTokens : public TestFixture {
                                 "v = { & x6 } ;\n"
                                 "const char x7 = 'b' ;\n"
                                 "return & x7 ;\n"
-                                "}";
-            ASSERT_EQUALS(code, tokenizeAndStringify(code));
+                                "}\n";
+
+            const char expected[] = "const char * foo ( ) {\n"
+                                    "const char x1 = 'b' ;\n"
+                                    "f ( & x1 ) ;\n"
+                                    "const char x2 = 'b' ;\n"
+                                    "f ( y , & x2 ) ;\n"
+                                    "const char x3 = 'b' ;\n"
+                                    "t = & x3 ;\n"
+                                    "const char x4 = 'b' ;\n"
+                                    "t = y + & x4 ;\n"
+                                    "const char x5 = 'b' ;\n"
+                                    "z [ & x5 ] = y ;\n"
+                                    "const char x6 = 'b' ;\n"
+                                    "v = { & x6 } ;\n"
+                                    "const char x7 = 'b' ;\n"
+                                    "return & x7 ;\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
             ASSERT_EQUALS(
                 "[test.cpp:5:5]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable y [valueFlowBailoutIncompleteVar]\n",
                 errout_str());
@@ -2271,8 +2294,25 @@ class TestSimplifyTokens : public TestFixture {
                                 "v = { & x6 } ;\n"
                                 "const int x7 = 1 ;\n"
                                 "return & x7 ;\n"
-                                "}";
-            ASSERT_EQUALS(code, tokenizeAndStringify(code));
+                                "}\n";
+
+            const char expected[] = "const int * foo ( ) {\n"
+                                    "const int x1 = 1 ;\n"
+                                    "f ( & x1 ) ;\n"
+                                    "const int x2 = 1 ;\n"
+                                    "f ( y , & x2 ) ;\n"
+                                    "const int x3 = 1 ;\n"
+                                    "t = & x3 ;\n"
+                                    "const int x4 = 1 ;\n"
+                                    "t = y + & x4 ;\n"
+                                    "const int x5 = 1 ;\n"
+                                    "z [ & x5 ] = y ;\n"
+                                    "const int x6 = 1 ;\n"
+                                    "v = { & x6 } ;\n"
+                                    "const int x7 = 1 ;\n"
+                                    "return & x7 ;\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
             ASSERT_EQUALS(
                 "[test.cpp:5:5]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable y [valueFlowBailoutIncompleteVar]\n",
                 errout_str());
@@ -2284,17 +2324,17 @@ class TestSimplifyTokens : public TestFixture {
                             "  TYPE *x=&x, **p=x, **q = NULL;\n"
                             "  BENCH1(q = _mhz_M(n); n = 1;)\n"
                             "  use_pointer(q);\n"
-                            "}";
+                            "}\n";
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code), UNKNOWN_MACRO);
     }
 
     void simplifyKnownVariables54() { // #4913
-        ASSERT_EQUALS("void f ( int * p ) { * -- p = 0 ; * p = 0 ; }", tokenizeAndStringify("void f(int*p) { *--p=0; *p=0; }"));
+        ASSERT_EQUALS("void f ( int * p ) { * -- p = 0 ; * p = 0 ; }", tokenizeAndStringify("void f(int*p) { *--p=0; *p=0; }\n"));
     }
 
     void simplifyKnownVariables56() { // ticket #5301 - >>
         ASSERT_EQUALS("void f ( ) { int a ; a = 0 ; int b ; b = 0 ; * p >> a >> b ; return a / b ; }",
-                      tokenizeAndStringify("void f() { int a=0,b=0; *p>>a>>b; return a/b; }"));
+                      tokenizeAndStringify("void f() { int a=0,b=0; *p>>a>>b; return a/b; }\n"));
         ASSERT_EQUALS(
             "[test.cpp:1:26]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
             errout_str());
@@ -2309,7 +2349,7 @@ class TestSimplifyTokens : public TestFixture {
                             "} "
                             "int baz() { "
                             "  return sizeof(arr_t); "
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("enum e { VAL1 = 1 , VAL2 } ; "
                       "int foo ( int ) ; "
                       "void bar ( ) { "
@@ -2326,7 +2366,7 @@ class TestSimplifyTokens : public TestFixture {
                             "  for(i = 0, j = 1; i < 3, j < 12; i++,j++) {\n"
                             "    a[i] = 0;\n"
                             "  }\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("void f ( ) {\n"
                       "int a [ 3 ] ; int i ; int j ;\n"
                       "for ( i = 0 , j = 1 ; i < 3 , j < 12 ; i ++ , j ++ ) {\n"
@@ -2344,7 +2384,7 @@ class TestSimplifyTokens : public TestFixture {
                                              "    Other\n"
                                              "  };\n"
                                              "  enum { XX };\n"
-                                             "};"));
+                                             "};\n"));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2356,7 +2396,7 @@ class TestSimplifyTokens : public TestFixture {
                       tokenizeAndStringify("void foo(std::string str) {\n"
                                            "  char *p = &str[0];\n"
                                            "  *p = 0;\n"
-                                           "}"));
+                                           "}\n"));
     }
 
     void simplifyKnownVariables63() { // #10798
@@ -2502,24 +2542,33 @@ class TestSimplifyTokens : public TestFixture {
 
     void simplifyKnownVariablesFunctionCalls() {
         {
-            const char code[] = "void a(int &x);" // <- x is passed by reference
-                                "void b() {"
-                                "    int x = 123;"
-                                "    a(x);"       // <- don't replace with a(123);
-                                "}";
-            const char expected[] = "void a ( int & x ) ; void b ( ) { int x ; x = 123 ; a ( x ) ; }";
+            const char code[] = "void a(int &x);\n" // <- x is passed by reference
+                                "void b() {\n"
+                                "    int x = 123;\n"
+                                "    a(x);\n"       // <- don't replace with a(123);
+                                "}\n";
+            const char expected[] = "void a ( int & x ) ;\n"
+                                    "void b ( ) {\n"
+                                    "int x ; x = 123 ;\n"
+                                    "a ( x ) ;\n"
+                                    "}";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
     }
 
     void simplifyKnownVariablesGlobalVars() {
         // #8054
-        const char code[] = "static int x;"
-                            "void f() {"
-                            "    x = 123;"
-                            "    while (!x) { dostuff(); }"
-                            "}";
-        ASSERT_EQUALS("static int x ; void f ( ) { x = 123 ; while ( ! x ) { dostuff ( ) ; } }", tokenizeAndStringify(code));
+        const char code[] = "static int x;\n"
+                            "void f() {\n"
+                            "    x = 123;\n"
+                            "    while (!x) { dostuff(); }\n"
+                            "}\n";
+        const char expected[] = "static int x ;\n"
+                                "void f ( ) {\n"
+                                "x = 123 ;\n"
+                                "while ( ! x ) { dostuff ( ) ; }\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         ASSERT_EQUALS("", filter_valueflow(errout_str()));
     }
 
@@ -2619,7 +2668,7 @@ class TestSimplifyTokens : public TestFixture {
                                 "void bar ( ) {\n"
                                 "foo < 1 ? 0 ? 1 : 6 : 2 > x ;\n"
                                 "foo < 1 ? 0 : 2 > y ;\n"
-                                "}";
+                                "}\n";
             const char exp[] = "template < class T > struct foo ; "
                                "void bar ( ) { "
                                "foo < 6 > x ; "
@@ -2628,7 +2677,7 @@ class TestSimplifyTokens : public TestFixture {
             ASSERT_EQUALS(exp, tok(code));
         }
         {
-            const char code[] = "bool b = true ? false : 1 > 2 ;";
+            const char code[] = "bool b = true ? false : 1 > 2 ;\n";
             const char exp[] = "bool b ; b = true ? false : 1 > 2 ;";
             ASSERT_EQUALS(exp, tok(code));
         }
@@ -2637,12 +2686,12 @@ class TestSimplifyTokens : public TestFixture {
     void simplifyVarDeclInitLists()
     {
         {
-            const char code[] = "std::vector<int> v{a * b, 1};";
+            const char code[] = "std::vector<int> v{a * b, 1};\n";
             const char exp[] = "std :: vector < int > v { a * b , 1 } ;";
             ASSERT_EQUALS(exp, tok(code));
         }
         {
-            const char code[] = "enum E { E0 } e{};";
+            const char code[] = "enum E { E0 } e{};\n";
             const char exp[] = "enum E { E0 } ; enum E e ; e = { } ;";
             ASSERT_EQUALS(exp, tok(code));
         }
diff --git a/test/testsimplifytypedef.cpp b/test/testsimplifytypedef.cpp
index 6e8b8820177..957a1d9e831 100644
--- a/test/testsimplifytypedef.cpp
+++ b/test/testsimplifytypedef.cpp
@@ -366,7 +366,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void c1() {
         const char code[] = "typedef int t;\n"
-                            "t x;";
+                            "t x;\n";
         ASSERT_EQUALS("int x ;", simplifyTypedefC(code));
     }
 
@@ -417,56 +417,56 @@ class TestSimplifyTypedef : public TestFixture {
 
     void cconst() {
         const char code1[] = "typedef void* HWND;\n"
-                             "const HWND x;";
+                             "const HWND x;\n";
         ASSERT_EQUALS("void * const x ;", simplifyTypedef(code1));
 
         const char code2[] = "typedef void (*fp)();\n"
-                             "const fp x;";
+                             "const fp x;\n";
         ASSERT_EQUALS("void ( * const x ) ( ) ;", simplifyTypedef(code2));
     }
 
     void cstruct1() {
         const char code[] = "typedef struct { int a; int b; } t;\n"
-                            "t x;";
+                            "t x;\n";
         ASSERT_EQUALS("struct t { int a ; int b ; } ; struct t x ;", simplifyTypedef(code));
         ASSERT_EQUALS("struct t { int a ; int b ; } ; struct t x ;", simplifyTypedefC(code));
     }
 
     void cstruct2() {
         const char code[] = "typedef enum { A, B } t;\n"
-                            "t x;";
+                            "t x;\n";
         ASSERT_EQUALS("enum t { A , B } ; enum t x ;", simplifyTypedef(code));
         ASSERT_EQUALS("enum t { A , B } ; enum t x ;", simplifyTypedefC(code));
     }
 
     void cstruct3() {
         const char code[] = "typedef struct s { int a; int b; } t;\n"
-                            "t x;";
+                            "t x;\n";
         ASSERT_EQUALS("struct s { int a ; int b ; } ; struct s x ;", simplifyTypedefC(code));
     }
 
     void cstruct4() {
         const char code[] = "typedef struct s { int a; int b; } t;\n"
-                            "struct t x{};";
+                            "struct t x{};\n";
         ASSERT_EQUALS("struct s { int a ; int b ; } ; struct s x { } ;", simplifyTypedefC(code));
     }
 
     void cenum1() {
         const char code[] = "typedef enum { a, b } E;\n"
-                            "E e;";
+                            "E e;\n";
         ASSERT_EQUALS("enum E { a , b } ; enum E e ;", simplifyTypedefC(code));
     }
 
     void cfunction1() {
         const char code[] = "typedef int callback(int);\n"
-                            "callback* cb;";
+                            "callback* cb;\n";
         ASSERT_EQUALS("int ( * cb ) ( int ) ;", simplifyTypedefC(code));
     }
 
     void cfunction2() {
         const char code[] = "typedef int callback(int);\n"
                             "typedef callback* callbackPtr;\n"
-                            "callbackPtr cb;";
+                            "callbackPtr cb;\n";
         ASSERT_EQUALS("int ( * cb ) ( int ) ;", simplifyTypedefC(code));
     }
 
@@ -485,33 +485,33 @@ class TestSimplifyTypedef : public TestFixture {
 
     void cfp1() {
         const char code[] = "typedef void (*fp)(void * p);\n"
-                            "fp x;";
+                            "fp x;\n";
         ASSERT_EQUALS("void ( * x ) ( void * p ) ;", simplifyTypedefC(code));
     }
 
     void cfp2() {
         const char code[] = "typedef void (*const fp)(void * p);\n"
-                            "fp x;";
+                            "fp x;\n";
         ASSERT_EQUALS("void ( * const x ) ( void * p ) ;", simplifyTypedefC(code));
     }
 
     void cfp4() {
         const char code[] = "typedef struct S Stype ;\n"
                             "typedef void ( * F ) ( Stype * ) ;\n"
-                            "F func;";
+                            "F func;\n";
         ASSERT_EQUALS("void ( * func ) ( struct S * ) ;", simplifyTypedefC(code));
     }
 
     void cfp5() {
         const char code[] = "typedef void (*fp)(void);\n"
                             "typedef fp t;\n"
-                            "void foo(t p);";
+                            "void foo(t p);\n";
         ASSERT_EQUALS("void foo ( void ( * p ) ( void ) ) ;", simplifyTypedef(code));
     }
 
     void cfp6() {
         const char code[] = "typedef void (*fp)(void);\n"
-                            "fp a[10];";
+                            "fp a[10];\n";
         ASSERT_EQUALS("void ( * a [ 10 ] ) ( void ) ;", simplifyTypedef(code));
     }
 
@@ -524,13 +524,13 @@ class TestSimplifyTypedef : public TestFixture {
 
     void carray1() {
         const char code[] = "typedef int t[20];\n"
-                            "t x;";
+                            "t x;\n";
         ASSERT_EQUALS("int x [ 20 ] ;", simplifyTypedefC(code));
     }
 
     void carray2() {
         const char code[] = "typedef double t[4];\n"
-                            "t x[10];";
+                            "t x[10];\n";
         ASSERT_EQUALS("double x [ 10 ] [ 4 ] ;", simplifyTypedef(code));
     }
 
@@ -555,7 +555,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void cdonotreplace1() {
         const char code[] = "typedef int t;\n"
-                            "int* t;";
+                            "int* t;\n";
         ASSERT_EQUALS("int * t ;", simplifyTypedefC(code));
     }
 
@@ -563,13 +563,13 @@ class TestSimplifyTypedef : public TestFixture {
     void cppfp1() {
         const char code[] = "typedef void (*fp)(void);\n"
                             "typedef fp t;\n"
-                            "void foo(t p);";
+                            "void foo(t p);\n";
         ASSERT_EQUALS("void foo ( void ( * p ) ( void ) ) ;", tok(code));
     }
 
     void Generic1() {
         const char code[] = "typedef void func(void);\n"
-                            "_Generic((x), func: 1, default: 2);";
+                            "_Generic((x), func: 1, default: 2);\n";
         ASSERT_EQUALS("_Generic ( x , void ( ) : 1 , default : 2 ) ;", tok(code));
     }
 
@@ -586,7 +586,7 @@ class TestSimplifyTypedef : public TestFixture {
                             " duplicate a;\n"
                             " a.foo();\n"
                             " A::duplicate c = 0;\n"
-                            "}";
+                            "}\n";
 
         const char expected[] =
             "class A "
@@ -612,7 +612,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "public:\n"
                             "typedef wchar_t duplicate;\n"
                             "duplicate foo() { wchar_t b; return b; }\n"
-                            "};";
+                            "};\n";
 
         const char expected[] =
             "class A ; "
@@ -637,7 +637,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "int main()\n"
                             "{\n"
                             "duplicate b;\n"
-                            "}";
+                            "}\n";
 
         const char expected[] =
             "class A { } ; "
@@ -662,7 +662,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "    s32 ivar = -2;\n"
                             "    u32 uvar = 2;\n"
                             "    return uvar / ivar;\n"
-                            "}";
+                            "}\n";
 
         const char expected[] =
             "void f ( ) "
@@ -681,7 +681,7 @@ class TestSimplifyTypedef : public TestFixture {
             "void f()\n"
             "{\n"
             "    YY_BUFFER_STATE state;\n"
-            "}";
+            "}\n";
 
         const char expected[] =
             "void f ( ) "
@@ -698,7 +698,7 @@ class TestSimplifyTypedef : public TestFixture {
             "namespace VL {\n"
             "    typedef float float_t ;\n"
             "    inline VL::float_t fast_atan2(VL::float_t y, VL::float_t x){}\n"
-            "}";
+            "}\n";
         const char expected[] =
             "namespace VL { "
             ""
@@ -715,8 +715,8 @@ class TestSimplifyTypedef : public TestFixture {
     }
 
     void simplifyTypedef7() {
-        const char code[] = "typedef int abc ; "
-                            "Fred :: abc f ;";
+        const char code[] = "typedef int abc ;\n"
+                            "Fred :: abc f ;\n";
         const char expected[] = "Fred :: abc f ;";
         ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
@@ -737,7 +737,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "RINT tri;\n"
                             "RUINT trui;\n"
                             "RCINT trci;\n"
-                            "RCUINT trcui;";
+                            "RCUINT trcui;\n";
 
         const char expected[] =
             "int ti ; "
@@ -762,7 +762,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "T t;\n"
                             "TP tp;\n"
                             "U u;\n"
-                            "V v;";
+                            "V v;\n";
 
         const char expected[] =
             "struct t { int a ; } ; "
@@ -788,7 +788,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "T t;\n"
                             "TP tp;\n"
                             "U u;\n"
-                            "V v;";
+                            "V v;\n";
 
         const char expected[] =
             "union t { int a ; float b ; } ; "
@@ -808,7 +808,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "typedef enum { a = 0 , b = 1 , c = 2 } abc;\n"
                             "typedef enum xyz { x = 0 , y = 1 , z = 2 } XYZ;\n"
                             "abc e1;\n"
-                            "XYZ e2;";
+                            "XYZ e2;\n";
 
         const char expected[] = "enum abc { a = 0 , b = 1 , c = 2 } ; "
                                 "enum xyz { x = 0 , y = 1 , z = 2 } ; "
@@ -826,7 +826,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "V1 v1;\n"
                             "V2 v2;\n"
                             "V3 v3;\n"
-                            "IntListIterator iter;";
+                            "IntListIterator iter;\n";
 
         const char expected[] =
             "vector < int > v1 ; "
@@ -839,9 +839,9 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef13() {
         // ticket # 1167 (InternalError)
-        const char code[] = "typedef std::pair<int(*)(void*), void*> Func;"
-                            "typedef std::vector<Func> CallQueue;"
-                            "int main() {}";
+        const char code[] = "typedef std::pair<int(*)(void*), void*> Func;\n"
+                            "typedef std::vector<Func> CallQueue;\n"
+                            "int main() {}\n";
 
         // Tokenize and check output..
         ASSERT_NO_THROW(tok(code));
@@ -850,17 +850,17 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef14() {
         // ticket # 1232
-        const char code[] = "template <typename F, unsigned int N> struct E"
-                            "{"
-                            "    typedef E<F,(N>0)?(N-1):0> v;"
-                            "    typedef typename add<v,v>::val val;"
-                            "    FP_M(val);"
-                            "};"
-                            "template <typename F> struct E <F,0>"
-                            "{"
-                            "    typedef typename D<1>::val val;"
-                            "    FP_M(val);"
-                            "};";
+        const char code[] = "template <typename F, unsigned int N> struct E\n"
+                            "{\n"
+                            "    typedef E<F,(N>0)?(N-1):0> v;\n"
+                            "    typedef typename add<v,v>::val val;\n"
+                            "    FP_M(val);\n"
+                            "};\n"
+                            "template <typename F> struct E <F,0>\n"
+                            "{\n"
+                            "    typedef typename D<1>::val val;\n"
+                            "    FP_M(val);\n"
+                            "};\n";
 
         // Tokenize and check output..
         TODO_ASSERT_THROW(tok(code, dinit(TokOptions, $.debugwarnings = false)), InternalError); // TODO: Do not throw exception
@@ -870,7 +870,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef15() {
         {
             const char code[] = "typedef char frame[10];\n"
-                                "frame f;";
+                                "frame f;\n";
 
             const char expected[] = "char f [ 10 ] ;";
 
@@ -879,7 +879,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef unsigned char frame[10];\n"
-                                "frame f;";
+                                "frame f;\n";
 
             const char expected[] = "unsigned char f [ 10 ] ;";
 
@@ -893,7 +893,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "typedef  MOT8 CHFOO[4096];\n"
                             "typedef struct {\n"
                             "   CHFOO freem;\n"
-                            "} STRFOO;";
+                            "} STRFOO;\n";
 
         // Tokenize and check output..
         ASSERT_NO_THROW(tok(code));
@@ -903,7 +903,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef17() {
         const char code[] = "typedef char * PCHAR, CHAR;\n"
                             "PCHAR pc;\n"
-                            "CHAR c;";
+                            "CHAR c;\n";
 
         const char expected[] =
             "char * pc ; "
@@ -914,7 +914,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef18() {
         const char code[] = "typedef vector<int[4]> a;\n"
-                            "a b;";
+                            "a b;\n";
         ASSERT_EQUALS("vector < int [ 4 ] > b ;", tok(code));
     }
 
@@ -924,7 +924,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "typedef struct {} A, *B, **C;\n"
                                 "A a;\n"
                                 "B b;\n"
-                                "C c;";
+                                "C c;\n";
 
             const char expected[] =
                 "struct A { } ; "
@@ -938,7 +938,7 @@ class TestSimplifyTypedef : public TestFixture {
         {
             const char code[] = "typedef struct {} A, *********B;\n"
                                 "A a;\n"
-                                "B b;";
+                                "B b;\n";
 
             const char expected[] =
                 "struct A { } ; "
@@ -952,7 +952,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "typedef struct {} **********A, *B, C;\n"
                                 "A a;\n"
                                 "B b;\n"
-                                "C c;";
+                                "C c;\n";
 
             const char expected[] =
                 "struct Unnamed0 { } ; "
@@ -966,7 +966,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef20() {
         // ticket #1284
-        const char code[] = "typedef jobject invoke_t (jobject, Proxy *, Method *, JArray< jobject > *);";
+        const char code[] = "typedef jobject invoke_t (jobject, Proxy *, Method *, JArray< jobject > *);\n";
         ASSERT_EQUALS(";", tok(code));
     }
 
@@ -974,7 +974,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "typedef void (* PF)();\n"
                             "typedef void * (* PFV)(void *);\n"
                             "PF pf;\n"
-                            "PFV pfv;";
+                            "PFV pfv;\n";
 
         const char expected[] =
             ""
@@ -991,7 +991,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "    typedef void (*testfp)();\n"
                                 "    testfp get() { return test; }\n"
                                 "    static void test() { }\n"
-                                "};";
+                                "};\n";
 
             const char expected[] =
                 "class Fred { "
@@ -1008,7 +1008,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "    typedef void * (*testfp)(void *);\n"
                                 "    testfp get() { return test; }\n"
                                 "    static void * test(void * p) { return p; }\n"
-                                "};";
+                                "};\n";
 
             const char expected[] =
                 "class Fred { "
@@ -1025,7 +1025,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "    typedef unsigned int * (*testfp)(unsigned int *);\n"
                                 "    testfp get() { return test; }\n"
                                 "    static unsigned int * test(unsigned int * p) { return p; }\n"
-                                "};";
+                                "};\n";
 
             const char expected[] =
                 "class Fred { "
@@ -1042,7 +1042,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "    typedef const unsigned int * (*testfp)(const unsigned int *);\n"
                                 "    testfp get() { return test; }\n"
                                 "    static const unsigned int * test(const unsigned int * p) { return p; }\n"
-                                "};";
+                                "};\n";
 
             // static const gets changed to const static
             const char expected[] =
@@ -1060,7 +1060,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "    typedef void * (*testfp)(void *);\n"
                                 "    testfp get(int i) { return test; }\n"
                                 "    static void * test(void * p) { return p; }\n"
-                                "};";
+                                "};\n";
 
             const char expected[] =
                 "class Fred { "
@@ -1076,7 +1076,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef23() {
         const char code[] = "typedef bool (*Callback) (int i);\n"
                             "void    addCallback(Callback callback) { }\n"
-                            "void    addCallback1(Callback callback, int j) { }";
+                            "void    addCallback1(Callback callback, int j) { }\n";
 
         const char expected[] =
             "void addCallback ( bool ( * callback ) ( int ) ) { } "
@@ -1091,7 +1091,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "void g( fp f )\n"
                                 "{\n"
                                 "  fp f2 = (fp)f;\n"
-                                "}";
+                                "}\n";
 
             const char expected[] =
                 "void g ( int ( * f ) ( ) ) "
@@ -1107,7 +1107,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "void g( fp f )\n"
                                 "{\n"
                                 "  fp f2 = static_cast<fp>(f);\n"
-                                "}";
+                                "}\n";
 
             const char expected[] =
                 "void g ( int ( * f ) ( ) ) "
@@ -1125,7 +1125,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "typedef void (*fill_names_f) (const char *);\n"
                                 "struct vfs_class {\n"
                                 "    void (*fill_names) (struct vfs_class *me, fill_names_f);\n"
-                                "}";
+                                "}\n";
 
             const char expected[] =
                 "struct vfs_class { "
@@ -1139,7 +1139,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "typedef void (*fill_names_f) (const char *);\n"
                                 "struct vfs_class {\n"
                                 "    void (*fill_names) (fill_names_f, struct vfs_class *me);\n"
-                                "}";
+                                "}\n";
 
             const char expected[] =
                 "struct vfs_class { "
@@ -1153,7 +1153,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef26() {
         {
             const char code[] = "typedef void (*Callback) ();\n"
-                                "void    addCallback(Callback (*callback)());";
+                                "void    addCallback(Callback (*callback)());\n";
 
             const char expected[] = "void addCallback ( void ( * ( * callback ) ( ) ) ( ) ) ;";
 
@@ -1165,7 +1165,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "typedef void (*pc_video_update_proc)(bitmap_t *bitmap,\n"
                                 "struct mscrtc6845 *crtc);\n"
                                 "\n"
-                                "struct mscrtc6845 *pc_video_start(pc_video_update_proc (*choosevideomode)(running_machine *machine, int *width, int *height, struct mscrtc6845 *crtc));";
+                                "struct mscrtc6845 *pc_video_start(pc_video_update_proc (*choosevideomode)(running_machine *machine, int *width, int *height, struct mscrtc6845 *crtc));\n";
 
             const char expected[] = "struct mscrtc6845 * pc_video_start ( void ( * ( * choosevideomode ) ( running_machine * machine , int * width , int * height , struct mscrtc6845 * crtc ) ) ( bitmap_t * bitmap , struct mscrtc6845 * crtc ) ) ;";
 
@@ -1179,7 +1179,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "{\n"
                             "    typedef int (*func_ptr)(float, double);\n"
                             "    VERIFY((is_same<result_of<func_ptr(char, float)>::type, int>::value));\n"
-                            "}";
+                            "}\n";
 
         const char expected[] =
             "int main ( ) "
@@ -1196,7 +1196,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef28() {
         const char code[] = "typedef std::pair<double, double> (*F)(double);\n"
-                            "F f;";
+                            "F f;\n";
 
         const char expected[] = "std :: pair < double , double > ( * f ) ( double ) ;";
 
@@ -1212,7 +1212,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "array1 a1;\n"
                             "array2 a2;\n"
                             "int_t t;\n"
-                            "int_array ia;";
+                            "int_array ia;\n";
 
         const char expected[] =
             "int a [ ice_or < is_int < int > :: value , is_int < UDT > :: value > :: value ? 1 : -1 ] ; "
@@ -1230,7 +1230,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "typedef ::std::list<int> int_list_array[10];\n"
                             "int_list il;\n"
                             "int_list_iterator ili;\n"
-                            "int_list_array ila;";
+                            "int_list_array ila;\n";
 
         const char expected[] =
             ":: std :: list < int > il ; "
@@ -1250,7 +1250,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "    INT a;\n"
                                 "};\n"
                                 "A::INT A::get() const { return a; }\n"
-                                "A::INT i = A::a;";
+                                "A::INT i = A::a;\n";
 
             const char expected[] = "class A { "
                                     "public: "
@@ -1273,7 +1273,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "    INT a;\n"
                                 "};\n"
                                 "A::INT A::get() const { return a; }\n"
-                                "A::INT i = A::a;";
+                                "A::INT i = A::a;\n";
 
             const char expected[] = "struct A { "
                                     ""
@@ -1294,7 +1294,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "typedef const CHAR * LPCSTR;\n"
                             "CHAR c;\n"
                             "LPSTR cp;\n"
-                            "LPCSTR ccp;";
+                            "LPCSTR ccp;\n";
 
         const char expected[] =
             "char c ; "
@@ -1330,8 +1330,8 @@ class TestSimplifyTypedef : public TestFixture {
                             "};\n"
                             "A::CHAR_A A::funA() { return a; }\n"
                             "A::B::SHRT_B A::B::funB() { return b; }\n"
-                            "A::B::C::INT_C A::B::C::funC() { return c; }"
-                            "A::B::C::D::LONG_D A::B::C::D::funD() { return d; }";
+                            "A::B::C::INT_C A::B::C::funC() { return c; }\n"
+                            "A::B::C::D::LONG_D A::B::C::D::funD() { return d; }\n";
 
         const char codeFullSpecified[] = "class A {\n"
                                          "public:\n"
@@ -1358,8 +1358,8 @@ class TestSimplifyTypedef : public TestFixture {
                                          "};\n"
                                          "A::CHAR_A A::funA() { return a; }\n"
                                          "A::B::SHRT_B A::B::funB() { return b; }\n"
-                                         "A::B::C::INT_C A::B::C::funC() { return c; }"
-                                         "A::B::C::D::LONG_D A::B::C::D::funD() { return d; }";
+                                         "A::B::C::INT_C A::B::C::funC() { return c; }\n"
+                                         "A::B::C::D::LONG_D A::B::C::D::funD() { return d; }\n";
 
         const char codePartialSpecified[] = "class A {\n"
                                             "public:\n"
@@ -1386,8 +1386,8 @@ class TestSimplifyTypedef : public TestFixture {
                                             "};\n"
                                             "A::CHAR_A A::funA() { return a; }\n"
                                             "A::B::SHRT_B A::B::funB() { return b; }\n"
-                                            "A::B::C::INT_C A::B::C::funC() { return c; }"
-                                            "A::B::C::D::LONG_D A::B::C::D::funD() { return d; }";
+                                            "A::B::C::INT_C A::B::C::funC() { return c; }\n"
+                                            "A::B::C::D::LONG_D A::B::C::D::funD() { return d; }\n";
 
         const char expected[] =
             "class A { "
@@ -1430,7 +1430,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "int main()\n"
                             "{\n"
                             "    foofunc *Foo = new foofunc[2];\n"
-                            "}";
+                            "}\n";
         const char expected[] =
             "class X { } ; "
             "int main ( ) "
@@ -1478,7 +1478,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "    A a = 0;\n"
                             "    S::A s = fun1(a) + fun2(a) - fun3(a);\n"
                             "    return a + s;\n"
-                            "}";
+                            "}\n";
 
         const char expected[] = "class S "
                                 "{ "
@@ -1523,7 +1523,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "void f(va_list ap)\n"
                             "{\n"
                             "    *va_arg(ap, TIFFFaxFillFunc*) = 0;\n"
-                            "}";
+                            "}\n";
         const char expected[] = "void f ( va_list ap ) "
                                 "{ "
                                 "* va_arg ( ap , void ( * * ) ( ) ) = 0 ; "
@@ -1536,7 +1536,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "void f()\n"
                             "{\n"
                             "    INT i; { }\n"
-                            "}";
+                            "}\n";
         const char expected[] = "void f ( ) "
                                 "{ "
                                 "int i ; { } "
@@ -1546,7 +1546,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef38() {
         const char code[] = "typedef C A;\n"
-                            "struct AB : public A, public B { };";
+                            "struct AB : public A, public B { };\n";
         const char expected[] = "struct AB : public C , public B { } ;";
         ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         ASSERT_EQUALS("", errout_str());
@@ -1559,7 +1559,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "struct A\n"
                                 "{\n"
                                 "    int alloclen;\n"
-                                "};";
+                                "};\n";
 
             // The expected result..
             const char expected[] = "struct A "
@@ -1575,7 +1575,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "union A\n"
                                 "{\n"
                                 "    int alloclen;\n"
-                                "};";
+                                "};\n";
 
             // The expected result..
             const char expected[] = "union A "
@@ -1591,7 +1591,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "class A\n"
                                 "{\n"
                                 "    int alloclen;\n"
-                                "};";
+                                "};\n";
 
             // The expected result..
             const char expected[] = "class A "
@@ -1608,7 +1608,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "typedef std::map<std::string, int> Map;\n"
                                 "class MyMap : public Map\n"
                                 "{\n"
-                                "};";
+                                "};\n";
 
             // The expected result..
             const char expected[] = "class MyMap : public std :: map < std :: string , int > "
@@ -1622,7 +1622,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "typedef std::map<std::string, int> Map;\n"
                                 "class MyMap : protected Map\n"
                                 "{\n"
-                                "};";
+                                "};\n";
 
             // The expected result..
             const char expected[] = "class MyMap : protected std :: map < std :: string , int > "
@@ -1636,7 +1636,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "typedef std::map<std::string, int> Map;\n"
                                 "class MyMap : private Map\n"
                                 "{\n"
-                                "};";
+                                "};\n";
 
             // The expected result..
             const char expected[] = "class MyMap : private std :: map < std :: string , int > "
@@ -1650,7 +1650,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "typedef struct foo { } A;\n"
                                 "struct MyA : public A\n"
                                 "{\n"
-                                "};";
+                                "};\n";
 
             // The expected result..
             const char expected[] = "struct foo { } ; "
@@ -1665,7 +1665,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "typedef class foo { } A;\n"
                                 "class MyA : public A\n"
                                 "{\n"
-                                "};";
+                                "};\n";
 
             // The expected result..
             const char expected[] = "class foo { } ; "
@@ -1707,7 +1707,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "void fn() {\n"
                             "    typedef foo<> bar;\n"
                             "    while (0 > bar(1)) {}\n"
-                            "}";
+                            "}\n";
 
         checkSimplifyTypedef(code);
         ASSERT_EQUALS_WITHOUT_LINENUMBERS(
@@ -1718,7 +1718,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef46() {
         const char code[] = "typedef const struct A { int a; } * AP;\n"
-                            "AP ap;";
+                            "AP ap;\n";
 
         // The expected result..
         const char expected[] = "struct A { int a ; } ; "
@@ -1729,7 +1729,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef47() {
         {
             const char code[] = "typedef std::pair<int, int> const I;\n"
-                                "I i;";
+                                "I i;\n";
 
             // The expected result..
             const char expected[] = "const std :: pair < int , int > i ;";
@@ -1738,7 +1738,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (X:: *F)();\n"
-                                "F f;";
+                                "F f;\n";
 
             // The expected result..
             const char expected[] = "void ( * f ) ( ) ;";
@@ -1751,7 +1751,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "void foo (LIST *module_name)\n"
                             "{\n"
                             "    bar(module_name ? module_name->string : 0);\n"
-                            "}";
+                            "}\n";
 
         // The expected result..
         const char expected[] = "struct string { } ; "
@@ -1767,7 +1767,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "typedef const Class & Const_Reference;\n"
                             "void some_method (Const_Reference x) const {}\n"
                             "void another_method (Const_Reference x) const {}\n"
-                            "};";
+                            "};\n";
 
         // The expected result..
         const char expected[] = "class Class2 { "
@@ -1787,7 +1787,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "type1 (*tp1)[2];\n"
                             "type2 t2;\n"
                             "type3 t3;\n"
-                            "type4 t4;";
+                            "type4 t4;\n";
 
         // The expected result..
         const char expected[] = "char ( * t1 ) [ 10 ] ; "
@@ -1801,7 +1801,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef51() {
         const char code[] = "class A { public: int i; };\n"
                             "typedef const char (A :: * type1);\n"
-                            "type1 t1 = &A::i;";
+                            "type1 t1 = &A::i;\n";
 
         // The expected result..
         const char expected[] = "class A { public: int i ; } ; "
@@ -1812,7 +1812,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef52() { // ticket #1782
         {
             const char code[] = "typedef char (* type1)[10];\n"
-                                "type1 foo() { }";
+                                "type1 foo() { }\n";
 
             // The expected result..
             const char expected[] = "char ( * foo ( ) ) [ 10 ] { }";
@@ -1822,7 +1822,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef char (* type1)[10];\n"
-                                "LOCAL(type1) foo() { }";
+                                "LOCAL(type1) foo() { }\n";
 
             // this is invalid C, assert that an "unknown macro" warning is written
             ASSERT_THROW_INTERNAL(checkSimplifyTypedef(code), UNKNOWN_MACRO);
@@ -1841,7 +1841,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "    {\n"
                             "        pthread_exit (0);\n"
                             "    }\n"
-                            "}";
+                            "}\n";
 
         checkSimplifyTypedef(code);
         ASSERT_EQUALS("", errout_str());
@@ -1853,7 +1853,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "typedef int*const *_Iterator;\n"
                             "hwreg_t v1;\n"
                             "t1 v2;\n"
-                            "_Iterator v3;";
+                            "_Iterator v3;\n";
 
         // The expected result..
         const char expected[] = "volatile long * const v1 ; "
@@ -1871,7 +1871,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "    typedef void (*fptr)();\n"
                             "    const fptr pr;\n"
                             "    operator const fptr& () { return pr; }\n"
-                            "};";
+                            "};\n";
 
         // The expected result..
         const char expected[] = "struct C { "
@@ -1887,7 +1887,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "void foo() {\n"
                             "    typedef int A;\n"
                             "    A a = A(1) * A(2);\n"
-                            "};";
+                            "};\n";
 
         // The expected result..
         const char expected[] = "void foo ( ) { "
@@ -1901,7 +1901,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef58() { // ticket #1963
         {
             const char code[] = "typedef int vec2_t[2];\n"
-                                "vec2_t coords[4] = {1,2,3,4,5,6,7,8};";
+                                "vec2_t coords[4] = {1,2,3,4,5,6,7,8};\n";
 
             // The expected result..
             const char expected[] = "int coords [ 4 ] [ 2 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 } ;";
@@ -1911,7 +1911,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef int vec2_t[2];\n"
-                                "vec2_t coords[4][5][6+1] = {1,2,3,4,5,6,7,8};";
+                                "vec2_t coords[4][5][6+1] = {1,2,3,4,5,6,7,8};\n";
 
             // The expected result..
             const char expected[] = "int coords [ 4 ] [ 5 ] [ 6 + 1 ] [ 2 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 } ;";
@@ -1923,7 +1923,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef59() { // ticket #2011
         const char code[] = "template<typename DISPATCHER> class SomeTemplateClass {\n"
                             "    typedef void (SomeTemplateClass<DISPATCHER>::*MessageDispatcherFunc)(SerialInputMessage&);\n"
-                            "};";
+                            "};\n";
         // The expected result..
         const char expected[] = "template < typename DISPATCHER > class SomeTemplateClass { } ;";
         ASSERT_EQUALS(expected, tok(code));
@@ -1937,7 +1937,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "{\n"
                             "    qboolean b;\n"
                             "    localEntitiyAddFunc_t f;\n"
-                            "}";
+                            "}\n";
         // The expected result..
         const char expected[] = "enum qboolean { qfalse , qtrue } ; void f ( ) { enum qboolean b ; enum qboolean ( * f ) ( struct le_s * , entity_t * ) ; }";
         ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
@@ -1946,14 +1946,14 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef61() { // ticket #2074 and 2075
         const char code1[] = "typedef       unsigned char   (*Mf_GetIndexByte_Func)          (void);\n"
-                             "typedef const unsigned char * (*Mf_GetPointerToCurrentPos_Func)(void);";
+                             "typedef const unsigned char * (*Mf_GetPointerToCurrentPos_Func)(void);\n";
 
         // Check for output..
         checkSimplifyTypedef(code1);
         ASSERT_EQUALS("", errout_str());
 
         const char code2[] = "typedef unsigned long uint32_t;\n"
-                             "typedef uint32_t (*write_type_t) (uint32_t);";
+                             "typedef uint32_t (*write_type_t) (uint32_t);\n";
 
         // Check for output..
         checkSimplifyTypedef(code2);
@@ -1965,7 +1965,7 @@ class TestSimplifyTypedef : public TestFixture {
                              "void f()\n"
                              "{\n"
                              "    TString a, b;\n"
-                             "}";
+                             "}\n";
 
         // The expected tokens..
         const char expected1[] = "void f ( ) { char a [ 256 ] ; char b [ 256 ] ; }";
@@ -1976,7 +1976,7 @@ class TestSimplifyTypedef : public TestFixture {
                              "void f()\n"
                              "{\n"
                              "    TString a = { 0 }, b = { 0 };\n"
-                             "}";
+                             "}\n";
 
         // The expected tokens..
         const char expected2[] = "void f ( ) { char a [ 256 ] = { 0 } ; char b [ 256 ] = { 0 } ; }";
@@ -1987,7 +1987,7 @@ class TestSimplifyTypedef : public TestFixture {
                              "void f()\n"
                              "{\n"
                              "    TString a = \"\", b = \"\";\n"
-                             "}";
+                             "}\n";
 
         // The expected tokens..
         const char expected3[] = "void f ( ) { char a [ 256 ] ; a = \"\" ; char b [ 256 ] ; b = \"\" ; }";
@@ -1998,7 +1998,7 @@ class TestSimplifyTypedef : public TestFixture {
                              "void f()\n"
                              "{\n"
                              "    TString a = \"1234\", b = \"5678\";\n"
-                             "}";
+                             "}\n";
 
         // The expected tokens..
         const char expected4[] = "void f ( ) { char a [ 256 ] ; a = \"1234\" ; char b [ 256 ] ; b = \"5678\" ; }";
@@ -2008,7 +2008,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef63() { // ticket #2175 'typedef float x[3];'
         const char code[] = "typedef float x[3];\n"
-                            "x a,b,c;";
+                            "x a,b,c;\n";
         const std::string actual(tok(code));
         ASSERT_EQUALS("float a [ 3 ] ; float b [ 3 ] ; float c [ 3 ] ;", actual);
         ASSERT_EQUALS("", errout_str());
@@ -2016,7 +2016,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef64() {
         const char code[] = "typedef typeof(__type1() + __type2()) __type;"
-                            "__type t;";
+                            "__type t;\n";
         const std::string actual(tok(code));
         ASSERT_EQUALS("typeof ( __type1 ( ) + __type2 ( ) ) t ;", actual);
         ASSERT_EQUALS("", errout_str());
@@ -2027,7 +2027,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "int main() {\n"
                             "    Foo b(0);\n"
                             "    return b > Foo(10);\n"
-                            "}";
+                            "}\n";
         const std::string actual(tok(code, dinit(TokOptions, $.debugwarnings = false)));
         ASSERT_EQUALS("int main ( ) { BAR < int > b ( 0 ) ; return b > BAR < int > ( 10 ) ; }", actual);
         ASSERT_EQUALS("", errout_str());
@@ -2035,7 +2035,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef66() { // ticket #2341
         const char code[] = "typedef long* GEN;\n"
-                            "extern GEN (*foo)(long);";
+                            "extern GEN (*foo)(long);\n";
         (void)tok(code);
         ASSERT_EQUALS("", errout_str());
     }
@@ -2044,7 +2044,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "typedef int ( * Function ) ( ) ;\n"
                             "void f ( ) {\n"
                             "    ((Function * (*) (char *, char *, int, int)) global[6]) ( \"assoc\", \"eggdrop\", 106, 0);\n"
-                            "}";
+                            "}\n";
         // TODO should it be simplified as below instead?
         // "( ( int ( * * ( * ) ( char * , char * , int , int ) ) ( ) ) global [ 6 ] ) ( \"assoc\" , \"eggdrop\" , 106 , 0 ) ; "
         const char expected[] = "void f ( ) { "
@@ -2058,7 +2058,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef68() { // ticket #2355
         const char code[] = "typedef FMAC1 void (* a) ();\n"
-                            "void *(*b) ();";
+                            "void *(*b) ();\n";
         const std::string actual(tok(code));
         ASSERT_EQUALS("void * ( * b ) ( ) ;", actual);
         ASSERT_EQUALS("", errout_str());
@@ -2069,7 +2069,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "typedef struct VirtualMachine\n"
                             "{\n"
                             "    CompilerHook *(*compilerHookVector)(void);\n"
-                            "}VirtualMachine;";
+                            "}VirtualMachine;\n";
         const char expected[] = "struct VirtualMachine "
                                 "{ "
                                 "int ( * * ( * compilerHookVector ) ( void ) ) ( ) ; "
@@ -2080,7 +2080,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef70() { // ticket #2348
         const char code[] = "typedef int pread_f ( int ) ;\n"
-                            "pread_f *(*test_func)(char *filename);";
+                            "pread_f *(*test_func)(char *filename);\n";
         const char expected[] = "int ( * ( * test_func ) ( char * filename ) ) ( int ) ;";
         ASSERT_EQUALS(expected, tok(code));
         ASSERT_EQUALS("", errout_str());
@@ -2089,14 +2089,14 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef71() { // ticket #2348
         {
             const char code[] = "typedef int RexxFunctionHandler();\n"
-                                "RexxFunctionHandler *(efuncs[1]);";
+                                "RexxFunctionHandler *(efuncs[1]);\n";
             const char expected[] = "int ( * ( efuncs [ 1 ] ) ) ( ) ;";
             ASSERT_EQUALS(expected, tok(code));
             ASSERT_EQUALS("", errout_str());
         }
         {
             const char code[] = "typedef int RexxFunctionHandler();\n"
-                                "RexxFunctionHandler *(efuncs[]) = { NULL, NULL };";
+                                "RexxFunctionHandler *(efuncs[]) = { NULL, NULL };\n";
             const char expected[] = "int ( * ( efuncs [ ] ) ) ( ) = { NULL , NULL } ;";
             ASSERT_EQUALS(expected, tok(code));
             ASSERT_EQUALS("", errout_str());
@@ -2109,7 +2109,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "class Fred {\n"
                                 "    typedef int* (Fred::*F);\n"
                                 "    operator F() const { }\n"
-                                "};";
+                                "};\n";
             const char expected[] = "class Fred { "
                                     ""
                                     "operatorint** ( ) const { } "
@@ -2122,7 +2122,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "class Fred {\n"
                                 "    typedef int INT;\n"
                                 "    void f1() const { INT i; }\n"
-                                "};";
+                                "};\n";
             const char expected[] = "class Fred { "
                                     ""
                                     "void f1 ( ) const { int i ; } "
@@ -2136,7 +2136,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "    typedef int INT;\n"
                                 "    void f1() const;\n"
                                 "};\n"
-                                "void Fred::f1() const { INT i; f(i); }";
+                                "void Fred::f1() const { INT i; f(i); }\n";
             const char expected[] = "class Fred { "
                                     ""
                                     "void f1 ( ) const ; "
@@ -2151,7 +2151,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "    typedef int* (Fred::*F);\n"
                                 "    operator F() const;\n"
                                 "};\n"
-                                "Fred::operator F() const { }";
+                                "Fred::operator F() const { }\n";
             const char expected[] = "class Fred { "
                                     ""
                                     "operatorint** ( ) const ; "
@@ -2166,7 +2166,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "struct B {};\n"
                             "typedef struct A : public B {\n"
                             "    void f();\n"
-                            "} a, *aPtr;";
+                            "} a, *aPtr;\n";
         const char expected[] = "struct B { } ; "
                                 "struct A : public B { "
                                 "void f ( ) ; "
@@ -2179,7 +2179,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "typedef long (*state_func_t)(void);\n"
                             "typedef state_func_t (*state_t)(void);\n"
                             "state_t current_state = death;\n"
-                            "static char get_runlevel(const state_t);";
+                            "static char get_runlevel(const state_t);\n";
         const char expected[] = "long ( * ( * current_state ) ( void ) ) ( void ) ; current_state = death ; "
                                 "static char get_runlevel ( long ( * ( * const ) ( void ) ) ( void ) ) ;";
         ASSERT_EQUALS(expected, tok(code));
@@ -2187,17 +2187,17 @@ class TestSimplifyTypedef : public TestFixture {
     }
 
     void simplifyTypedef75() { // ticket #2426
-        const char code[] = "typedef _Packed struct S { long l; };";
+        const char code[] = "typedef _Packed struct S { long l; };\n";
         ASSERT_EQUALS(";", tok(code, dinit(TokOptions, $.debugwarnings = false)));
         ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef76() { // ticket #2453 segmentation fault
-        ASSERT_THROW_INTERNAL(checkSimplifyTypedef("void f1(typedef int x) {}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkSimplifyTypedef("void f1(typedef int x) {}\n"), SYNTAX);
     }
 
     void simplifyTypedef77() { // ticket #2554
-        const char code[] = "typedef char Str[10]; int x = sizeof(Str);";
+        const char code[] = "typedef char Str[10]; int x = sizeof(Str);\n";
         const char expected[] = "int x ; x = sizeof ( char [ 10 ] ) ;";
         ASSERT_EQUALS(expected, tok(code));
     }
@@ -2206,7 +2206,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "typedef struct A A_t;\n"
                             "A_t a;\n"
                             "typedef struct A { } A_t;\n"
-                            "A_t a1;";
+                            "A_t a1;\n";
         const char expected[] = "struct A a ; struct A { } ; struct A a1 ;";
         ASSERT_EQUALS(expected, tok(code));
     }
@@ -2216,7 +2216,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "typedef struct LangVtab\n"
                             "{\n"
                             "    Tcl_ObjCmdProc * (*V_LangOptionCommand);\n"
-                            "} LangVtab;";
+                            "} LangVtab;\n";
         const char expected[] = "struct LangVtab "
                                 "{ "
                                 "int ( * ( * V_LangOptionCommand ) ) ( int x ) ; "
@@ -2228,7 +2228,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "typedef struct s { };\n"
                             "void f() {\n"
                             "    sizeof(struct s);\n"
-                            "};";
+                            "};\n";
         const char expected[] = "struct s { } ; "
                                 "void f ( ) { "
                                 "sizeof ( struct s ) ; "
@@ -2256,13 +2256,13 @@ class TestSimplifyTypedef : public TestFixture {
                              "{\n"
                              "  B * b = new B;\n"
                              "  b->f = new A::F * [ 10 ];\n"
-                             "}");
+                             "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef83() { // ticket #2620
         const char code[] = "typedef char Str[10];\n"
-                            "void f(Str &cl) { }";
+                            "void f(Str &cl) { }\n";
 
         // The expected result..
         const char expected[] = "void f ( char ( & cl ) [ 10 ] ) { }";
@@ -2271,18 +2271,18 @@ class TestSimplifyTypedef : public TestFixture {
     }
 
     void simplifyTypedef84() { // ticket #2630 (segmentation fault)
-        const char code1[] = "typedef y x () x";
+        const char code1[] = "typedef y x () x\n";
         ASSERT_THROW_INTERNAL(checkSimplifyTypedef(code1), SYNTAX);
 
-        const char code2[] = "typedef struct template <>";
+        const char code2[] = "typedef struct template <>\n";
         ASSERT_THROW_INTERNAL(checkSimplifyTypedef(code2), SYNTAX);
 
-        const char code3[] = "typedef ::<>";
+        const char code3[] = "typedef ::<>\n";
         ASSERT_THROW_INTERNAL(checkSimplifyTypedef(code3), SYNTAX);
     }
 
     void simplifyTypedef85() { // ticket #2651
-        const char code[] = "typedef FOO ((BAR)(void, int, const int, int*));";
+        const char code[] = "typedef FOO ((BAR)(void, int, const int, int*));\n";
         const char expected[] = ";";
         ASSERT_EQUALS(expected, tok(code));
         ASSERT_EQUALS("", errout_str());
@@ -2294,7 +2294,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "public:\n"
                             "    operator safe_bool() const;\n"
                             "    safe_bool operator!() const;\n"
-                            "};";
+                            "};\n";
         const char expected[] = "class relational { "
                                 ""
                                 "public: "
@@ -2306,14 +2306,14 @@ class TestSimplifyTypedef : public TestFixture {
     }
 
     void simplifyTypedef87() { // ticket #2651
-        const char code[] = "typedef FOO (*(*BAR)(void, int, const int, int*));";
+        const char code[] = "typedef FOO (*(*BAR)(void, int, const int, int*));\n";
         const char expected[] = ";";
         ASSERT_EQUALS(expected, tok(code));
         ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef88() { // ticket #2675
-        const char code[] = "typedef short int (*x)(...);";
+        const char code[] = "typedef short int (*x)(...);\n";
         const char expected[] = ";";
         ASSERT_EQUALS(expected, tok(code));
         ASSERT_EQUALS("", errout_str());
@@ -2323,7 +2323,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "class Fred {\n"
                             "    typedef void f(int) const;\n"
                             "    f func;\n"
-                            "};";
+                            "};\n";
         const char expected[] = "class Fred { void func ( int ) const ; } ;";
         ASSERT_EQUALS(expected, tok(code));
         ASSERT_EQUALS("", errout_str());
@@ -2331,7 +2331,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef90() { // ticket #2718
         const char code[] = "typedef int IA[2];\n"
-                            "void f(const IA&) {};";
+                            "void f(const IA&) {};\n";
         const char expected[] = "void f ( const int ( & ) [ 2 ] ) { } ;";
         ASSERT_EQUALS(expected, tok(code));
         ASSERT_EQUALS("", errout_str());
@@ -2346,7 +2346,7 @@ class TestSimplifyTypedef : public TestFixture {
                              "}\n"
                              "namespace NS {\n"
                              "    T A::f() {}\n"
-                             "}";
+                             "}\n";
         const char expected1[] = "namespace NS { "
                                  ""
                                  "class A { "
@@ -2365,7 +2365,7 @@ class TestSimplifyTypedef : public TestFixture {
                              "        T f();\n"
                              "    };\n"
                              "}\n"
-                             "NS::T NS::A::f() {}";
+                             "NS::T NS::A::f() {}\n";
         const char expected2[] = "namespace NS { "
                                  ""
                                  "class A { "
@@ -2388,7 +2388,7 @@ class TestSimplifyTypedef : public TestFixture {
                              "    namespace NS2 {\n"
                              "        T A::f() {}\n"
                              "    }\n"
-                             "}";
+                             "}\n";
         const char expected3[] = "namespace NS1 { "
                                  "namespace NS2 { "
                                  ""
@@ -2415,7 +2415,7 @@ class TestSimplifyTypedef : public TestFixture {
                              "}\n"
                              "namespace NS1 {\n"
                              "    NS2::T NS2::A::f() {}\n"
-                             "}";
+                             "}\n";
         const char expected4[] = "namespace NS1 { "
                                  "namespace NS2 { "
                                  ""
@@ -2434,14 +2434,14 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef92() { // ticket #2736 (segmentation fault)
         const char code[] = "typedef long Long;\n"
                             "namespace NS {\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS(";", tok(code));
         ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef93() { // ticket #2738 (syntax error)
         const char code[] = "struct s { double x; };\n"
-                            "typedef struct s (*binop) (struct s, struct s);";
+                            "typedef struct s (*binop) (struct s, struct s);\n";
         const char expected[] = "struct s { double x ; } ;";
         ASSERT_EQUALS(expected, tok(code));
         ASSERT_EQUALS("", errout_str());
@@ -2454,7 +2454,7 @@ class TestSimplifyTypedef : public TestFixture {
                              "    int a[4];\n"
                              "  } data;\n"
                              "};\n"
-                             "A::data d;";
+                             "A::data d;\n";
         const char expected1[] = "class A { "
                                  "public: "
                                  "struct data { "
@@ -2471,7 +2471,7 @@ class TestSimplifyTypedef : public TestFixture {
                              "    int a[4];\n"
                              "  } data;\n"
                              "};\n"
-                             "::A::data d;";
+                             "::A::data d;\n";
         const char expected2[] = "class A { "
                                  "public: "
                                  "struct data { "
@@ -2488,7 +2488,7 @@ class TestSimplifyTypedef : public TestFixture {
                              "    int a[4];\n"
                              "  } data;\n"
                              "};\n"
-                             "class B : public ::A::data { };";
+                             "class B : public ::A::data { };\n";
         const char expected3[] = "class A { "
                                  "public: "
                                  "struct data { "
@@ -2505,7 +2505,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "public:\n"
                             "  typedef expression_error::error_code (*valid_func)(void *cbparam, const char *name, expression_space space);\n"
                             "  valid_func f;\n"
-                            "};";
+                            "};\n";
         const char expected[] = "class symbol_table { "
                                 "public: "
                                 "expression_error :: error_code ( * f ) ( void * , const char * , expression_space ) ; "
@@ -2515,25 +2515,25 @@ class TestSimplifyTypedef : public TestFixture {
     }
 
     void simplifyTypedef96() { // ticket #2886 (segmentation fault)
-        const char code[] = "typedef struct x { }";
+        const char code[] = "typedef struct x { }\n";
         ASSERT_THROW_INTERNAL(tok(code), SYNTAX);
     }
 
     void simplifyTypedef97() { // ticket #2983 (segmentation fault)
         const char code[] = "typedef x y\n"
-                            "(A); y";
+                            "(A); y\n";
         (void)tok(code);
         ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef99() { // ticket #2999
         const char code[] = "typedef struct Fred Fred;\n"
-                            "struct Fred { };";
+                            "struct Fred { };\n";
         (void)tok(code);
         ASSERT_EQUALS("", errout_str());
 
         const char code1[] = "struct Fred { };\n"
-                             "typedef struct Fred Fred;";
+                             "typedef struct Fred Fred;\n";
         (void)tok(code1);
         ASSERT_EQUALS("", errout_str());
     }
@@ -2544,14 +2544,14 @@ class TestSimplifyTypedef : public TestFixture {
                             "    Fred *fred;\n"
                             "    fred = se_alloc(sizeof(struct Fred));\n"
                             "    return fred;\n"
-                            "}";
+                            "}\n";
         (void)tok(code);
         ASSERT_EQUALS_WITHOUT_LINENUMBERS("", errout_str());
     }
 
     void simplifyTypedef101() { // ticket #3003 (segmentation fault)
         const char code[] = "typedef a x[];\n"
-                            "y = x";
+                            "y = x\n";
         ASSERT_EQUALS("y = x", tok(code));
     }
 
@@ -2560,7 +2560,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "void foo()\n"
                             "{\n"
                             "    Fred * Fred;\n"
-                            "}";
+                            "}\n";
         (void)tok(code);
         ASSERT_EQUALS("", errout_str());
     }
@@ -2570,29 +2570,29 @@ class TestSimplifyTypedef : public TestFixture {
                             "void foo()\n"
                             "{\n"
                             "    Fred Fred;\n"
-                            "}";
+                            "}\n";
         (void)tok(code);
         ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef104() { // ticket #3070
-        const char code[] = "typedef int (*in_func) (void FAR *, unsigned char FAR * FAR *);";
+        const char code[] = "typedef int (*in_func) (void FAR *, unsigned char FAR * FAR *);\n";
         ASSERT_EQUALS(";", tok(code));
         ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef105() { // ticket #3616 (segmentation fault)
-        const char code[] = "( int typedef char x; ){}";
+        const char code[] = "( int typedef char x; ){}\n";
         ASSERT_THROW_INTERNAL(tok(code), SYNTAX);
     }
 
     void simplifyTypedef106() { // ticket #3619 (segmentation fault)
-        const char code[] = "typedef void f ();\ntypedef { f }";
+        const char code[] = "typedef void f ();\ntypedef { f }\n";
         ASSERT_THROW_INTERNAL_EQUALS(tok(code), INTERNAL, "Internal error. AST cyclic dependency.");
     }
 
     void simplifyTypedef107() { // ticket #3963 (bad code => segmentation fault)
-        const char code[] = "typedef int x[]; int main() { return x }";
+        const char code[] = "typedef int x[]; int main() { return x }\n";
         ASSERT_EQUALS("int main ( ) { return x }", tok(code));
         ignore_errout(); // we do not care about the output
     }
@@ -2602,7 +2602,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "void sort_factor(GEN *y, long n) {\n"
                             "    GEN a, b;\n"
                             "    foo(a, b);\n"
-                            "}";
+                            "}\n";
         const char expected[] = "void sort_factor ( long * * y , long n ) { "
                                 "long * a ; long * b ; "
                                 "foo ( a , b ) ; "
@@ -2612,7 +2612,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef109() {
         const char code[] = "typedef int&& rref;\n"
-                            "rref var = 0;";
+                            "rref var = 0;\n";
         const char expected[] = "int && var = 0 ;";
         ASSERT_EQUALS(expected, tok(code));
         ASSERT_EQUALS("", errout_str());
@@ -2647,7 +2647,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "            C::D::DKIPtr membervariable5;\n"
                             "        };\n"
                             "    }\n"
-                            "}";
+                            "}\n";
         const char expected[] = "namespace A { "
                                 "namespace B { "
                                 "struct ZClass { "
@@ -2728,7 +2728,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "    enum  {\n"
                             "      domain_dim = TrafoEvaluator::domain_dim,\n"
                             "    };\n"
-                            "};";
+                            "};\n";
 
         const char expected[] = "template < "
                                 "typename DataType , "
@@ -2744,14 +2744,14 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef113() {     // ticket #7030
         const char code[] = "typedef int T;\n"
-                            "void f() { T:; }";
+                            "void f() { T:; }\n";
         const char expected[] = "void f ( ) { T : ; }";
         ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyTypedef114() {     // ticket #7058
         const char code[] = "typedef struct { enum {A,B}; } AB;\n"
-                            "x=AB::B;";
+                            "x=AB::B;\n";
         const char expected[] = "struct AB { enum Anonymous0 { A , B } ; } ; x = AB :: B ;";
         ASSERT_EQUALS(expected, tok(code));
     }
@@ -2759,7 +2759,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef115() {     // ticket #6998
         const char code[] = "typedef unsigned unsignedTypedef;\n"
                             "unsignedTypedef t1 ;\n"
-                            "unsigned t2 ;";
+                            "unsigned t2 ;\n";
         const char expected[] = "unsigned int t1 ; "
                                 "unsigned int t2 ;";
         ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
@@ -2772,7 +2772,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "    CharacterToConversion c2c;\n"
                             "    for (CharacterToConversion::iterator it = c2c.begin(); it != c2c.end(); ++it) {}\n"
                             "    CharacterToConversion().swap(c2c);\n"
-                            "}";
+                            "}\n";
         const char expected[] = "void fn ( ) { "
                                 "std :: vector < CharacterConversion > c2c ; "
                                 "for ( std :: vector < CharacterConversion > :: iterator it = c2c . begin ( ) ; it != c2c . end ( ) ; ++ it ) { } "
@@ -2786,7 +2786,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "typedef struct bstr {} bstr;\n"
                             "struct bstr bstr0(const char *s) {\n"
                             "    return (struct bstr) { (unsigned char *)s, s ? strlen(s) : 0 };\n"
-                            "}";
+                            "}\n";
         const char expected[] = "struct bstr { } ; "
                                 "struct bstr bstr0 ( const char * s ) { "
                                 "return ( struct bstr ) { ( unsigned char * ) s , s ? strlen ( s ) : 0 } ; "
@@ -2801,7 +2801,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "typedef int (ClassyClass::*funky_type);\n"
                             "operator funky_type() {\n"
                             "return &ClassyClass::id;\n"
-                            "}}";
+                            "}}\n";
         const char expected[] = "struct ClassyClass { "
                                 "int id ; "
                                 "operatorintClassyClass::* ( ) { "
@@ -2817,7 +2817,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "  typedef T1 XX;\n"
                             "}\n"
                             "namespace Baz { }\n"
-                            "enum Bar { XX = 1 };";
+                            "enum Bar { XX = 1 };\n";
         const char exp[] = "enum Bar { XX = 1 } ;";
         ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
         ASSERT_EQUALS("", errout_str());
@@ -2826,7 +2826,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedef120() { // #8357
         const char code[] = "typedef char test_utf8_char[5];\n"
                             "static test_utf8_char const bad_chars[] = { };\n"
-                            "static void report_good(bool passed, test_utf8_char const c) { };";
+                            "static void report_good(bool passed, test_utf8_char const c) { };\n";
         const char exp[] = "static const char bad_chars [ ] [ 5 ] = { } ; "
                            "static void report_good ( bool passed , const char c [ 5 ] ) { } ;";
         ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
@@ -2850,7 +2850,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "vec3 & Fred::v() { return v3; }\n"
                             "mat3x3 & Fred::m() { return m3x3; }\n"
                             "const vec3 & Fred::vc() const { return v3; }\n"
-                            "const mat3x3 & Fred::mc() const { return m3x3; }";
+                            "const mat3x3 & Fred::mc() const { return m3x3; }\n";
         const char exp[] = "float v3 [ 3 ] ; "
                            "float m3x3 [ 3 ] [ 3 ] ; "
                            "const float * & gv ( ) { return v3 ; } "
@@ -2871,14 +2871,14 @@ class TestSimplifyTypedef : public TestFixture {
     }
 
     void simplifyTypedef122() { // segmentation fault
-        const char code[] = "int result = [] { return git_run_cmd(\"update-index\",\"update-index -q --refresh\"); }();";
+        const char code[] = "int result = [] { return git_run_cmd(\"update-index\",\"update-index -q --refresh\"); }();\n";
         (void)tok(code);
         ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef123() { // ticket #7406
         const char code[] = "typedef int intvec[1];\n"
-                            "Dummy<intvec> y;";
+                            "Dummy<intvec> y;\n";
         const char exp[] = "Dummy < int [ 1 ] > y ;";
         ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
         ASSERT_EQUALS("", errout_str());
@@ -2886,15 +2886,15 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef124() { // ticket #7792
         const char code[] = "typedef long unsigned int size_t;\n"
-                            "typedef size_t (my_func)(char *, size_t, size_t, void *);"
-                            "size_t f(size_t s);";
+                            "typedef size_t (my_func)(char *, size_t, size_t, void *);\n"
+                            "size_t f(size_t s);\n";
 
         const char exp[] = "long f ( long s ) ;";
         ASSERT_EQUALS(exp, tok(code));
         ASSERT_EQUALS("", errout_str());
 
         const char code1[] = "typedef long unsigned int uint32_t;\n"
-                             "typedef uint32_t (my_func)(char *, uint32_t, uint32_t, void *);";
+                             "typedef uint32_t (my_func)(char *, uint32_t, uint32_t, void *);\n";
 
         // Check for output..
         checkSimplifyTypedef(code1);
@@ -2904,22 +2904,22 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef125() { // #8749
         const char code[] = "typedef char A[3];\n"
-                            "char (*p)[3] = new A[4];";
+                            "char (*p)[3] = new A[4];\n";
         const char exp[] = "char ( * p ) [ 3 ] = new char [ 4 ] [ 3 ] ;";
         ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef126() { // #5953
         const char code[] = "typedef char automap_data_t[100];\n"
-                            "void write_array(automap_data_t *data) {}";
+                            "void write_array(automap_data_t *data) {}\n";
         const char exp[] = "void write_array ( char ( * data ) [ 100 ] ) { }";
         ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef127() { // #8878
-        const char code[] = "class a; typedef int (a::*b); "
-                            "template <long, class> struct c; "
-                            "template <int g> struct d { enum { e = c<g, b>::f }; };";
+        const char code[] = "class a; typedef int (a::*b);\n"
+                            "template <long, class> struct c;\n"
+                            "template <int g> struct d { enum { e = c<g, b>::f }; };\n";
         const char exp[] = "class a ; "
                            "template < long , class > struct c ; "
                            "template < int g > struct d { enum Anonymous0 { e = c < g , int ( a :: * ) > :: f } ; } ;";
@@ -2930,7 +2930,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "typedef int d[4];\n"
                             "void f() {\n"
                             "    dostuff((const d){1,2,3,4});\n"
-                            "}";
+                            "}\n";
         const char exp[] = "void f ( ) { "
                            "dostuff ( ( const int [ 4 ] ) { 1 , 2 , 3 , 4 } ) ; "
                            "}";
@@ -2942,7 +2942,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "class c {\n"
                                 "  typedef char foo[4];\n"
                                 "  foo &f ;\n"
-                                "};";
+                                "};\n";
 
             const char exp[] = "class c { char ( & f ) [ 4 ] ; } ;";
             ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
@@ -2952,7 +2952,7 @@ class TestSimplifyTypedef : public TestFixture {
             const char code[] = "class c {\n"
                                 "  typedef char foo[4];\n"
                                 "  const foo &f;\n"
-                                "};";
+                                "};\n";
 
             const char exp[] = "class c { const char ( & f ) [ 4 ] ; } ;";
             ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
@@ -2963,7 +2963,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "  typedef char foo[4];\n"
                                 "  foo _a;\n"
                                 "  constexpr const foo &c_str() const noexcept { return _a; }\n"
-                                "};";
+                                "};\n";
 
             const char exp[] = "class c { char _a [ 4 ] ; const constexpr char ( & c_str ( ) const noexcept ( true ) ) [ 4 ] { return _a ; } } ;";
             ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
@@ -2974,7 +2974,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "  typedef char foo[4];\n"
                                 "  foo _a;\n"
                                 "  constexpr operator foo &() noexcept { return _a; }\n"
-                                "};";
+                                "};\n";
 
             const char actual[] = "class c { char _a [ 4 ] ; constexpr char ( & operatorchar ( ) noexcept ( true ) ) [ 4 ] { return _a ; } } ;";
             const char exp[] = "class c { char _a [ 4 ] ; char ( & operatorchar ( ) noexcept ( true ) ) [ 4 ] { return _a ; } } ;";
@@ -2986,7 +2986,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "  typedef char foo[4];\n"
                                 "  foo _a;\n"
                                 "  constexpr operator const foo &() const noexcept { return _a; }\n"
-                                "};";
+                                "};\n";
 
             const char actual[] = "class c { char _a [ 4 ] ; constexpr const char ( & operatorconstchar ( ) const noexcept ( true ) ) [ 4 ] { return _a ; } } ;";
             const char exp[] = "class c { char _a [ 4 ] ; const char ( & operatorconstchar ( ) const noexcept ( true ) ) [ 4 ] { return _a ; } } ;";
@@ -2998,7 +2998,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "template <class, class> void a() {\n"
                             "  typedef int(*b)[10];\n"
                             "  a<b, b>();\n"
-                            "}";
+                            "}\n";
 
         const char exp[] = "template < class , class > void a ( ) { "
                            "a < int ( * ) [ 10 ] , int ( * ) [ 10 ] > ( ) ; "
@@ -3012,7 +3012,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "a4 a4obj;\n"
                             "a4 &&  a4_rref = std::move(a4obj);\n"
                             "a4* a4p = &(a4obj);\n"
-                            "a4*&& a4p_rref = std::move(a4p);";
+                            "a4*&& a4p_rref = std::move(a4p);\n";
 
         const char exp[] = "unsigned char a4obj [ 4 ] ; "
                            "unsigned char ( && a4_rref ) [ 4 ] = std :: move ( a4obj ) ; "
@@ -3034,7 +3034,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "\n"
                             "using NamespaceA::MySpecialType;\n"
                             "\n"
-                            "void A::DoSomething( MySpecialType wrongName ) {}";
+                            "void A::DoSomething( MySpecialType wrongName ) {}\n";
 
         const char exp[] = "class A { "
                            "void DoSomething ( int special ) ; "
@@ -3056,7 +3056,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "namespace foo { typedef long long int64; }\n"
                             "typedef int int32;\n"
                             "namespace foo { int64 i; }\n"
-                            "int32 j;";
+                            "int32 j;\n";
         ASSERT_EQUALS("; namespace foo { long long i ; } int j ;", tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
@@ -3076,7 +3076,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "    AstNodePtr range;\n"
                             "    range->createTokens();\n"
                             "}\n"
-                            "void clangimport::AstNode::createScope(const std::vector<AstNodePtr> & children2) { }";
+                            "void clangimport::AstNode::createScope(const std::vector<AstNodePtr> & children2) { }\n";
         const char expected[] = "namespace clangimport { "
                                 "class AstNode ; "
                                 "class AstNode { "
@@ -3105,7 +3105,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "S1 s1;\n"
                             "S2 s2;\n"
                             "S3 s3;\n"
-                            "S4 s4;";
+                            "S4 s4;\n";
 
         const char expected[] = "class C1 { } ; "
                                 "class S1 { } ; "
@@ -3137,7 +3137,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "using namespace external::ns1;\n"
                                 "namespace ns {\n"
                                 "    void A::f(external::ns1::V) {}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "namespace external { "
                                 "namespace ns1 { "
                                 "struct B<1> ; "
@@ -3171,7 +3171,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "}\n"
                                 "namespace ns {\n"
                                 "    void A::f(external::ns1::V) {}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "namespace external { "
                                 "namespace ns1 { "
                                 "struct B<1> ; "
@@ -3205,7 +3205,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "using namespace external::ns1;\n"
                                 "namespace ns {\n"
                                 "    void A::f(V) {}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "namespace external { "
                                 "namespace ns1 { "
                                 "struct B<1> ; "
@@ -3255,7 +3255,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "}\n"
                                 "namespace ns {\n"
                                 "    void A::f(V) {}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "namespace external { "
                                 "namespace ns1 { "
                                 "struct B<1> ; "
@@ -3302,7 +3302,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "}\n"
                                 "namespace ns {\n"
                                 "    void A::f(external::ns1::V) {}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "namespace external { "
                                 "struct B<1> ; "
                                 "} "
@@ -3332,7 +3332,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "}\n"
                                 "namespace ns {\n"
                                 "    void A::f(external::ns1::V) {}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "struct B<1> ; "
                                 "namespace ns { "
                                 "struct A { "
@@ -3874,12 +3874,12 @@ class TestSimplifyTypedef : public TestFixture {
     }
 
     void simplifyTypedef163() {
-        const char code[] = "typedef v *v;";
+        const char code[] = "typedef v *v;\n";
         ASSERT_THROW_INTERNAL(tok(code), INTERNAL);
     }
 
     void simplifyTypedef164() {
-        const char code[] = "typedef struct D{x;}y y;";
+        const char code[] = "typedef struct D{x;}y y;\n";
         ASSERT_THROW_INTERNAL(tok(code), INTERNAL);
 
         const char code2[] = "typedef struct { int t; } t;"; // #14966
@@ -3895,7 +3895,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedefFunction1() {
         {
             const char code[] = "typedef void (*my_func)();\n"
-                                "std::queue<my_func> func_queue;";
+                                "std::queue<my_func> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( ) > func_queue ;";
@@ -3905,7 +3905,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (*my_func)(void);\n"
-                                "std::queue<my_func> func_queue;";
+                                "std::queue<my_func> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( void ) > func_queue ;";
@@ -3915,7 +3915,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (*my_func)(int);\n"
-                                "std::queue<my_func> func_queue;";
+                                "std::queue<my_func> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int ) > func_queue ;";
@@ -3925,7 +3925,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (*my_func)(int*);\n"
-                                "std::queue<my_func> func_queue;";
+                                "std::queue<my_func> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int * ) > func_queue ;";
@@ -3936,7 +3936,7 @@ class TestSimplifyTypedef : public TestFixture {
         {
             // ticket # 1615
             const char code[] = "typedef void (*my_func)(arg_class*);\n"
-                                "std::queue<my_func> func_queue;";
+                                "std::queue<my_func> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( arg_class * ) > func_queue ;";
@@ -3947,7 +3947,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (my_func)();\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( ) > func_queue ;";
@@ -3957,7 +3957,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (my_func)(void);\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( void ) > func_queue ;";
@@ -3967,7 +3967,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (my_func)(int);\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int ) > func_queue ;";
@@ -3977,7 +3977,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (my_func)(int*);\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int * ) > func_queue ;";
@@ -3987,7 +3987,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (my_func)(arg_class*);\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( arg_class * ) > func_queue ;";
@@ -3998,7 +3998,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void my_func();\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( ) > func_queue ;";
@@ -4008,7 +4008,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void my_func(void);\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( void ) > func_queue ;";
@@ -4018,7 +4018,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void my_func(int);\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int ) > func_queue ;";
@@ -4028,7 +4028,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void my_func(int*);\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int * ) > func_queue ;";
@@ -4038,7 +4038,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void my_func(arg_class*);\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( arg_class * ) > func_queue ;";
@@ -4049,7 +4049,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (my_func());\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( ) > func_queue ;";
@@ -4059,7 +4059,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (my_func(void));\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( void ) > func_queue ;";
@@ -4069,7 +4069,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (my_func(int));\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int ) > func_queue ;";
@@ -4079,7 +4079,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (my_func(int*));\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int * ) > func_queue ;";
@@ -4089,7 +4089,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         {
             const char code[] = "typedef void (my_func(arg_class*));\n"
-                                "std::queue<my_func *> func_queue;";
+                                "std::queue<my_func *> func_queue;\n";
 
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( arg_class * ) > func_queue ;";
@@ -4100,7 +4100,7 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedefFunction2() { // ticket #1685
         const char code[] = "typedef void voidfn (int);\n"
-                            "voidfn xxx;";
+                            "voidfn xxx;\n";
 
         // The expected result..
         const char expected[] = "void xxx ( int ) ;";
@@ -4122,7 +4122,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "func4 f4;\n"
                                 "func5 f5;\n"
                                 "func6 f6;\n"
-                                "func7 f7;";
+                                "func7 f7;\n";
 
             // The expected result..
             const char expected[] = "C f1 ( ) ; "
@@ -4150,7 +4150,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "func4 f4;\n"
                                 "func5 f5;\n"
                                 "func6 f6;\n"
-                                "func7 f7;";
+                                "func7 f7;\n";
 
             // The expected result..
             // C const -> const C
@@ -4179,7 +4179,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "func4 f4;\n"
                                 "func5 f5;\n"
                                 "func6 f6;\n"
-                                "func7 f7;";
+                                "func7 f7;\n";
 
             // The expected result..
             const char expected[] = "const C f1 ( ) ; "
@@ -4207,7 +4207,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "func4 f4;\n"
                                 "func5 f5;\n"
                                 "func6 f6;\n"
-                                "func7 f7;";
+                                "func7 f7;\n";
 
             // The expected result..
             const char expected[] = "C * f1 ( ) ; "
@@ -4235,7 +4235,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "func4 f4;\n"
                                 "func5 f5;\n"
                                 "func6 f6;\n"
-                                "func7 f7;";
+                                "func7 f7;\n";
 
             // The expected result..
             const char expected[] = "const C * f1 ( ) ; "
@@ -4263,7 +4263,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "func4 f4;\n"
                                 "func5 f5;\n"
                                 "func6 f6;\n"
-                                "func7 f7;";
+                                "func7 f7;\n";
 
             // The expected result..
             // C const -> const C
@@ -4285,7 +4285,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "typedef int ( * type3 ( bool ) ) ( int , int ) ;\n"
                             "type1 t1;\n"
                             "type2 t2;\n"
-                            "type3 t3;";
+                            "type3 t3;\n";
 
         // The expected result..
         const char expected[] = "int ( * ( * t1 ) ( bool ) ) ( int , int ) ; "
@@ -4319,7 +4319,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "type9 t9;\n"
                             "type10 t10;\n"
                             "type11 t11;\n"
-                            "type12 t12;";
+                            "type12 t12;\n";
 
         // The expected result..
         const char expected[] = "int ( * t1 ) ( float ) ; "
@@ -4348,7 +4348,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "    void ( * get4 ( ) ) ( );\n"
                             "};\n"
                             "testfp Fred::get3() { return 0; }\n"
-                            "void ( * Fred::get4 ( ) ) ( ) { return 0 ; }";
+                            "void ( * Fred::get4 ( ) ) ( ) { return 0 ; }\n";
 
         // The expected result..
         const char expected[] = "struct Fred "
@@ -4366,8 +4366,8 @@ class TestSimplifyTypedef : public TestFixture {
     }
 
     void simplifyTypedefFunction7() {
-        const char code[] = "typedef void ( __gnu_cxx :: _SGIAssignableConcept < _Tp > :: * _func_Tp_SGIAssignableConcept ) () ;"
-                            "_func_Tp_SGIAssignableConcept X;";
+        const char code[] = "typedef void ( __gnu_cxx :: _SGIAssignableConcept < _Tp > :: * _func_Tp_SGIAssignableConcept ) () ;\n"
+                            "_func_Tp_SGIAssignableConcept X;\n";
 
         // The expected result..
         const char expected[] = "void ( __gnu_cxx :: _SGIAssignableConcept < _Tp > :: * X ) ( ) ;";
@@ -4379,7 +4379,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedefFunction8() {
         // #2376 - internal error
         const char code[] = "typedef int f_expand(const nrv_byte *);\n"
-                            "void f(f_expand *(*get_fexp(int))){}";
+                            "void f(f_expand *(*get_fexp(int))){}\n";
         checkSimplifyTypedef(code);
         TODO_ASSERT_EQUALS("", "[test.cpp:2:29]: (debug) Function::addArguments found argument 'int' with varid 0. [varid0]\n", errout_str());  // make sure that there is no internal error
     }
@@ -4393,7 +4393,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "func1 f1;\n"
                                 "func2 f2;\n"
                                 "func3 f3;\n"
-                                "func4 f4;";
+                                "func4 f4;\n";
 
             // The expected result..
             const char expected[] = ":: C ( :: C :: * f1 ) ( ) ; "
@@ -4412,7 +4412,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "func1 f1;\n"
                                 "func2 f2;\n"
                                 "func3 f3;\n"
-                                "func4 f4;";
+                                "func4 f4;\n";
 
             // The expected result..
             const char expected[] = "B :: C ( * f1 ) ( ) ; "
@@ -4431,7 +4431,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "func1 f1;\n"
                                 "func2 f2;\n"
                                 "func3 f3;\n"
-                                "func4 f4;";
+                                "func4 f4;\n";
 
             // The expected result..
             const char expected[] = ":: B :: C ( :: B :: C :: * f1 ) ( ) ; "
@@ -4450,7 +4450,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "func1 f1;\n"
                                 "func2 f2;\n"
                                 "func3 f3;\n"
-                                "func4 f4;";
+                                "func4 f4;\n";
 
             // The expected result..
             const char expected[] = "A :: B :: C ( * f1 ) ( ) ; "
@@ -4470,7 +4470,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "typedef Format_E1 (**PtrToFunPtr_Type1)();\n"
                             "typedef MySpace::Format_E2 (**PtrToFunPtr_Type2)();\n"
                             "PtrToFunPtr_Type1 t1;\n"
-                            "PtrToFunPtr_Type2 t2;";
+                            "PtrToFunPtr_Type2 t2;\n";
         ASSERT_EQUALS("enum Format_E1 { FORMAT11 , FORMAT12 } ; enum Format_E1 Format_T1 ; "
                       "namespace MySpace { "
                       "enum Format_E2 { FORMAT21 , FORMAT22 } ; enum Format_E2 Format_T2 ; "
@@ -4503,15 +4503,15 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedefStruct() {
         const char code1[] = "typedef struct S { int x; } xyz;\n"
-                             "xyz var;";
+                             "xyz var;\n";
         ASSERT_EQUALS("struct S { int x ; } ; struct S var ;", tok(code1,dinit(TokOptions, $.simplify = false)));
 
         const char code2[] = "typedef const struct S { int x; } xyz;\n"
-                             "xyz var;";
+                             "xyz var;\n";
         ASSERT_EQUALS("struct S { int x ; } ; const struct S var ;", tok(code2,dinit(TokOptions, $.simplify = false)));
 
         const char code3[] = "typedef volatile struct S { int x; } xyz;\n"
-                             "xyz var;";
+                             "xyz var;\n";
         ASSERT_EQUALS("struct S { int x ; } ; volatile struct S var ;", tok(code3,dinit(TokOptions, $.simplify = false)));
     }
 
@@ -4519,7 +4519,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "typedef struct { int x; } xyz;;\n"
                             "void f(){\n"
                             "    int abc, xyz;\n" // <- shadow variable
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("struct xyz { int x ; } ; void f ( ) { int abc ; int xyz ; }",
                       tok(code,dinit(TokOptions, $.simplify = false)));
     }
@@ -4531,30 +4531,30 @@ class TestSimplifyTypedef : public TestFixture {
                             "\n"
                             "void foo(index_t prev_segment) {\n"
                             "    if(prev_segment==NO_SEGMENT) {}\n" // <- test that index_t is replaced with uint32_t in the expanded tokens
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("void foo ( uint32_t prev_segment ) { if ( prev_segment == ( ( uint32_t ) 12 ) ) { } }",
                       simplifyTypedefP(code));
     }
 
     void simplifyTypedefOriginalName1() {
-        const char code[] = "typedef unsigned char uint8_t;"
-                            "typedef float (*rFunctionPointer_fp)(uint8_t, uint8_t);"
-                            "typedef enum eEnumDef {"
-                            "  ABC = 0,"
-                            "}eEnum_t;"
-                            "typedef enum {"
-                            "  ABC = 0,"
-                            "}eEnum2_t;"
-                            "typedef short int16_t;"
-                            "typedef struct stStructDef {"
-                            "  int16_t swA;"
-                            "}stStruct_t;"
-                            "double endOfTypeDef;"
-                            "eEnum2_t enum2Type;"
-                            "stStruct_t structType;"
-                            "eEnum_t enumType;"
-                            "uint8_t t;"
-                            "void test(rFunctionPointer_fp functionPointer);";
+        const char code[] = "typedef unsigned char uint8_t;\n"
+                            "typedef float (*rFunctionPointer_fp)(uint8_t, uint8_t);\n"
+                            "typedef enum eEnumDef {\n"
+                            "  ABC = 0,\n"
+                            "}eEnum_t;\n"
+                            "typedef enum {\n"
+                            "  ABC = 0,\n"
+                            "}eEnum2_t;\n"
+                            "typedef short int16_t;\n"
+                            "typedef struct stStructDef {\n"
+                            "  int16_t swA;\n"
+                            "}stStruct_t;\n"
+                            "double endOfTypeDef;\n"
+                            "eEnum2_t enum2Type;\n"
+                            "stStruct_t structType;\n"
+                            "eEnum_t enumType;\n"
+                            "uint8_t t;\n"
+                            "void test(rFunctionPointer_fp functionPointer);\n";
 
         TokenList tokenlist{settings1, Standards::Language::C};
         ASSERT(TokenListHelper::createTokensFromString(tokenlist, code, "file.c"));
@@ -4595,7 +4595,7 @@ class TestSimplifyTypedef : public TestFixture {
     void simplifyTypedefOriginalName2() {
         const char code[] = "typedef unsigned short uint16;\n"
                             "typedef uint16 A;\n"
-                            "A a;";
+                            "A a;\n";
         TokenList tokenlist{ settings1, Standards::Language::C };
         ASSERT(TokenListHelper::createTokensFromString(tokenlist, code, "file.c"));
         TokenizerTest tokenizer(std::move(tokenlist), *this);
@@ -4661,7 +4661,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "void foo(void) {\n"
                             "    typedef signed int MY_INT;\n"
                             "    MY_INT x = 0;\n"
-                            "}";
+                            "}\n";
 
         TokenList tokenlist{settings1, Standards::Language::C};
         ASSERT(TokenListHelper::createTokensFromString(tokenlist, code, "file.c"));
@@ -4679,7 +4679,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "void foo(void) {\n"
                             "    typedef signed int (*F)(int);\n"
                             "    F x = 0;\n"
-                            "}";
+                            "}\n";
 
         TokenList tokenlist{settings1, Standards::Language::C};
         ASSERT(TokenListHelper::createTokensFromString(tokenlist, code, "file.c"));
@@ -4708,7 +4708,7 @@ class TestSimplifyTypedef : public TestFixture {
     }
 
     void typedefInfo1() {
-        const std::string xml = dumpTypedefInfo("typedef int A;\nA x;");
+        const std::string xml = dumpTypedefInfo("typedef int A;\nA x;\n");
         ASSERT_EQUALS("  <typedef-info>\n"
                       "    <info name=\"A\" file=\"file.c\" line=\"1\" column=\"13\" used=\"1\" isFunctionPointer=\"0\"/>\n"
                       "  </typedef-info>\n",
@@ -4770,7 +4770,7 @@ class TestSimplifyTypedef : public TestFixture {
                                                 "    uint16_t x;\n"
                                                 "    uint16_t y;\n"
                                                 "} coord;\n"
-                                                "coord c;");
+                                                "coord c;\n");
         ASSERT_EQUALS("  <typedef-info>\n"
                       "    <info name=\"coord\" originalName=\"coord\" file=\"file.c\" line=\"4\" column=\"3\" tagline=\"1\" tagcolumn=\"16\" used=\"1\" isFunctionPointer=\"0\"/>\n"
                       "  </typedef-info>\n", xml);
diff --git a/test/testsimplifyusing.cpp b/test/testsimplifyusing.cpp
index 5210d484d40..e3c714803cb 100644
--- a/test/testsimplifyusing.cpp
+++ b/test/testsimplifyusing.cpp
@@ -146,7 +146,7 @@ class TestSimplifyUsing : public TestFixture {
                             " duplicate a;\n"
                             " a.foo();\n"
                             " A::duplicate c = 0;\n"
-                            "}";
+                            "}\n";
 
         const char expected[] =
             "class A "
@@ -172,7 +172,7 @@ class TestSimplifyUsing : public TestFixture {
                             "public:\n"
                             "using duplicate = wchar_t;\n"
                             "duplicate foo() { wchar_t b; return b; }\n"
-                            "};";
+                            "};\n";
 
         const char expected[] =
             "class A ; "
@@ -197,7 +197,7 @@ class TestSimplifyUsing : public TestFixture {
                             "int main()\n"
                             "{\n"
                             "duplicate b;\n"
-                            "}";
+                            "}\n";
 
         const char expected[] =
             "class A { } ; "
@@ -222,7 +222,7 @@ class TestSimplifyUsing : public TestFixture {
                             "    s32 ivar = -2;\n"
                             "    u32 uvar = 2;\n"
                             "    return uvar / ivar;\n"
-                            "}";
+                            "}\n";
 
         const char expected[] =
             "void f ( ) "
@@ -240,7 +240,7 @@ class TestSimplifyUsing : public TestFixture {
             "void f()\n"
             "{\n"
             "    YY_BUFFER_STATE state;\n"
-            "}";
+            "}\n";
 
         const char expected[] =
             "void f ( ) "
@@ -256,7 +256,7 @@ class TestSimplifyUsing : public TestFixture {
             "namespace VL {\n"
             "    using float_t = float;\n"
             "    inline VL::float_t fast_atan2(VL::float_t y, VL::float_t x){}\n"
-            "}";
+            "}\n";
 
         const char expected[] =
             "namespace VL { "
@@ -268,8 +268,8 @@ class TestSimplifyUsing : public TestFixture {
     }
 
     void simplifyUsing7() {
-        const char code[] = "using abc = int; "
-                            "Fred :: abc f ;";
+        const char code[] = "using abc = int;\n"
+                            "Fred :: abc f ;\n";
         const char expected[] = "Fred :: abc f ;";
         ASSERT_EQUALS(expected, tok(code));
     }
@@ -290,7 +290,7 @@ class TestSimplifyUsing : public TestFixture {
                             "RINT tri;\n"
                             "RUINT trui;\n"
                             "RCINT trci;\n"
-                            "RCUINT trcui;";
+                            "RCUINT trcui;\n";
 
         const char expected[] =
             "int ti ; "
@@ -319,7 +319,7 @@ class TestSimplifyUsing : public TestFixture {
                             "TP tp;\n"
                             "U u;\n"
                             "V v;\n"
-                            "W w;";
+                            "W w;\n";
 
         const char expected[] =
             "struct t { int a ; } ; "
@@ -350,7 +350,7 @@ class TestSimplifyUsing : public TestFixture {
                             "TP tp;\n"
                             "U u;\n"
                             "V v;\n"
-                            "W w;";
+                            "W w;\n";
 
         const char expected[] =
             "union t { int a ; float b ; } ; "
@@ -371,7 +371,7 @@ class TestSimplifyUsing : public TestFixture {
         const char code[] = "using abc = enum { a = 0 , b = 1 , c = 2 };\n"
                             "using XYZ = enum xyz { x = 0 , y = 1 , z = 2 };\n"
                             "abc e1;\n"
-                            "XYZ e2;";
+                            "XYZ e2;\n";
 
         const char expected[] = "enum abc { a = 0 , b = 1 , c = 2 } ; "
                                 "enum xyz { x = 0 , y = 1 , z = 2 } ; "
@@ -389,7 +389,7 @@ class TestSimplifyUsing : public TestFixture {
                             "V1 v1;\n"
                             "V2 v2;\n"
                             "V3 v3;\n"
-                            "IntListIterator iter;";
+                            "IntListIterator iter;\n";
 
         const char expected[] = "vector < int > v1 ; "
                                 "std :: vector < int > v2 ; "
@@ -404,7 +404,7 @@ class TestSimplifyUsing : public TestFixture {
                             "using CallQueue = std::vector<Func>;\n"
                             "int main() {\n"
                             " CallQueue q;\n"
-                            "}";
+                            "}\n";
 
         const char expected[] = "int main ( ) { "
                                 "std :: vector < std :: pair < int ( * ) ( void * ) , void * > > q ; "
@@ -425,7 +425,7 @@ class TestSimplifyUsing : public TestFixture {
                             "{"
                             "    using nal = typename D<1>::val;"
                             "    FP_M(val);"
-                            "};";
+                            "};\n";
 
         TODO_ASSERT_THROW(tok(code, dinit(TokOptions, $.debugwarnings = false)), InternalError); // TODO: Do not throw AST validation exception
         //ASSERT_EQUALS("", errout_str());
@@ -434,7 +434,7 @@ class TestSimplifyUsing : public TestFixture {
     void simplifyUsing15() {
         {
             const char code[] = "using frame = char [10];\n"
-                                "frame f;";
+                                "frame f;\n";
 
             const char expected[] = "char f [ 10 ] ;";
 
@@ -443,7 +443,7 @@ class TestSimplifyUsing : public TestFixture {
 
         {
             const char code[] = "using frame = unsigned char [10];\n"
-                                "frame f;";
+                                "frame f;\n";
 
             const char expected[] = "unsigned char f [ 10 ] ;";
 
@@ -457,7 +457,7 @@ class TestSimplifyUsing : public TestFixture {
                             "using STRFOO = struct {\n"
                             "   CHFOO freem;\n"
                             "};\n"
-                            "STRFOO s;";
+                            "STRFOO s;\n";
 
         const char expected[] = "struct STRFOO { "
                                 "char freem [ 4096 ] ; "
@@ -477,7 +477,7 @@ class TestSimplifyUsing : public TestFixture {
                             "S1 s1;\n"
                             "S2 s2;\n"
                             "S3 s3;\n"
-                            "S4 s4;";
+                            "S4 s4;\n";
 
         const char expected[] = "class C1 { } ; "
                                 "class S1 { } ; "
@@ -493,7 +493,7 @@ class TestSimplifyUsing : public TestFixture {
     }
 
     void simplifyUsing18() {
-        const char code[] = "{ { { using a = a; using a; } } }";
+        const char code[] = "{ { { using a = a; using a; } } }\n";
         (void)tok(code); // don't crash
     }
 
@@ -505,7 +505,7 @@ class TestSimplifyUsing : public TestFixture {
                             "void foo::e() {\n"
                             "   using b = float;\n"
                             "}\n"
-                            "}";
+                            "}\n";
         (void)tok(code); // don't hang
         ignore_errout(); // we are not interested in the output
     }
@@ -550,14 +550,14 @@ class TestSimplifyUsing : public TestFixture {
                             "   };\n"
                             "   return nullptr;\n"
                             "}\n"
-                            "}}}}}}}";
+                            "}}}}}}}\n";
         (void)tok(code); // don't hang
         ignore_errout(); // we do not care about the output
     }
 
     void simplifyUsing21() {
         const char code[] = "using a = b;\n"
-                            "enum {}";
+                            "enum {}\n";
         (void)tok(code); // don't crash
     }
 
@@ -574,7 +574,7 @@ class TestSimplifyUsing : public TestFixture {
                             "fff::fff() : m_icm(icm) {\n"
                             "    using ESdk = aa::bb::sdk::common::api::Sdk::ESdk;\n"
                             "}\n"
-                            "}}}}}";
+                            "}}}}}\n";
         const char expected[] = "namespace aa { namespace bb { namespace cc { namespace dd { namespace ee { "
                                 "class fff { "
                                 "public: "
@@ -601,7 +601,7 @@ class TestSimplifyUsing : public TestFixture {
                             "   : m_icm(icm)\n"
                             "   , m_rt{rt::UNKNOWN_} {\n"
                             "  using escs = yy::zz::aa::bb::cc::dd::ee;\n"
-                            "}";
+                            "}\n";
         const char expected[] = "class cmcch { "
                                 "public: "
                                 "cmcch ( const icmsp & icm , Rtnf && rtnf = { } ) ; "
@@ -619,7 +619,7 @@ class TestSimplifyUsing : public TestFixture {
 
     void simplifyUsing24() {
         const char code[] = "using value_type = const ValueFlow::Value;\n"
-                            "value_type vt;";
+                            "value_type vt;\n";
         const char expected[] = "const ValueFlow :: Value vt ;";
         ASSERT_EQUALS(expected, tok(code));
     }
@@ -632,7 +632,7 @@ class TestSimplifyUsing : public TestFixture {
                             "namespace vtkm {\n"
                             "template <>\n"
                             "struct VecTraits<UnusualType> : VecTraits<UnusualType::T> { };\n"
-                            "}";
+                            "}\n";
         const char expected[] = "struct UnusualType { "
                                 "vtkm :: Id X ; "
                                 "} ; "
@@ -934,7 +934,7 @@ class TestSimplifyUsing : public TestFixture {
 
     void simplifyUsing39() {
         const char code[] = "using std::wstring;\n" // #14578
-                            "wstring ws;";
+                            "wstring ws;\n";
         const char expected[] = "std :: wstring ws ;";
         ASSERT_EQUALS(expected, tok(code));
         ASSERT_EQUALS("", errout_str());
@@ -944,7 +944,7 @@ class TestSimplifyUsing : public TestFixture {
 
     void simplifyUsing40() {
         const char code[] = "uint8_t f();\n" // #14876
-                            "using ::std::uint8_t;";
+                            "using ::std::uint8_t;\n";
         const char expected[] = "uint8_t f ( ) ;";
         ASSERT_EQUALS(expected, tok(code));
     }
@@ -960,7 +960,7 @@ class TestSimplifyUsing : public TestFixture {
         const char code[] = "using V = std::vector<int>;\n"
                             "struct A {\n"
                             "    V p;\n"
-                            "};";
+                            "};\n";
 
         const char expected[] = "struct A { "
                                 "std :: vector < int > p ; "
@@ -979,7 +979,7 @@ class TestSimplifyUsing : public TestFixture {
                             "private:\n"
                             "    A::V v_;\n"
                             "    V v2_;\n"
-                            "};";
+                            "};\n";
 
         const char expected[] = "class A { "
                                 "public: "
@@ -994,7 +994,7 @@ class TestSimplifyUsing : public TestFixture {
     }
 
     void simplifyUsing8976() {
-        const char code[] = "using mystring = std::string;";
+        const char code[] = "using mystring = std::string;\n";
 
         const char exp[] = ";";
 
@@ -1002,7 +1002,7 @@ class TestSimplifyUsing : public TestFixture {
     }
 
     void simplifyUsing9040() {
-        const char code[] = "using BOOL = unsigned; int i;";
+        const char code[] = "using BOOL = unsigned; int i;\n";
 
         const char exp[] = "int i ;";
 
@@ -1021,7 +1021,7 @@ class TestSimplifyUsing : public TestFixture {
                             "};\n"
                             "template <class T>\n"
                             "class s {};\n"
-                            "using BOOL = char;";
+                            "using BOOL = char;\n";
 
         const char exp[] = "template < class T > "
                            "class c { "
@@ -1046,7 +1046,7 @@ class TestSimplifyUsing : public TestFixture {
                             "void f2() {\n"
                             "  using namespace NS1::NS2;\n"
                             "  _LONG A;\n"
-                            "}";
+                            "}\n";
 
         const char exp[] = "void f1 ( ) { "
                            "using namespace NS1 ; "
@@ -1071,7 +1071,7 @@ class TestSimplifyUsing : public TestFixture {
                             "    };\n"
                             "    void A::func(UniqueResultPtr) {\n"
                             "    }\n"
-                            "}";
+                            "}\n";
         const char exp[] = "namespace ns { "
                            "class Result ; "
                            "class A { "
@@ -1096,7 +1096,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "};\n"
                                 "A::A(Foo) { }\n"
                                 "A::~A() { Foo foo; }\n"
-                                "void A::func(Foo) { }";
+                                "void A::func(Foo) { }\n";
             const char exp[] = "class A { "
                                "public: "
                                "A ( int foo ) ; "
@@ -1120,7 +1120,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "};\n"
                                 "A::B::B(Foo) { }\n"
                                 "A::B::~B() { Foo foo; }\n"
-                                "void A::B::func(Foo) { }";
+                                "void A::B::func(Foo) { }\n";
             const char exp[] = "class A { "
                                "public: "
                                "struct B { "
@@ -1143,7 +1143,7 @@ class TestSimplifyUsing : public TestFixture {
                             "    A(Type&);\n"
                             "    Type& t_;\n"
                             "};\n"
-                            "A::A(Type& t) : t_(t) { }";
+                            "A::A(Type& t) : t_(t) { }\n";
         const char exp[] = "class A { "
                            "public: "
                            "A ( int & ) ; "
@@ -1156,7 +1156,7 @@ class TestSimplifyUsing : public TestFixture {
     void simplifyUsing9518() {
         const char code[] = "namespace a {\n"
                             "using a = enum {};\n"
-                            "}";
+                            "}\n";
         const char exp[] = "namespace a { "
                            "enum a { } ; "
                            "}";
@@ -1169,7 +1169,7 @@ class TestSimplifyUsing : public TestFixture {
                             "template<> class MappedType<Type_t::Nil> { using type = void; };\n"
                             "std::string to_string (Example::Type_t type) {\n"
                             "   switch (type) {}\n"
-                            "}";
+                            "}\n";
         const char exp[] = "enum class Type_t { Nil = 0 } ; "
                            "class MappedType<Type_t::Nil> ; "
                            "template < Type_t type > class MappedType { } ; "
@@ -1186,7 +1186,7 @@ class TestSimplifyUsing : public TestFixture {
                             "using namespace ns;\n"
                             "static void f() {\n"
                             "    const ArrayType arr;\n"
-                            "}";
+                            "}\n";
         const char exp[] = "using namespace ns ; "
                            "static void f ( ) { "
                            "const std :: vector < int > arr ; "
@@ -1211,7 +1211,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "using namespace external::ns1;\n"
                                 "namespace ns {\n"
                                 "    void A::f(external::ns1::V) {}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "namespace external { "
                                 "namespace ns1 { "
                                 "struct B<1> ; "
@@ -1245,7 +1245,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "}\n"
                                 "namespace ns {\n"
                                 "    void A::f(external::ns1::V) {}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "namespace external { "
                                 "namespace ns1 { "
                                 "struct B<1> ; "
@@ -1279,7 +1279,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "using namespace external::ns1;\n"
                                 "namespace ns {\n"
                                 "    void A::f(V) {}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "namespace external { "
                                 "namespace ns1 { "
                                 "struct B<1> ; "
@@ -1314,7 +1314,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "}\n"
                                 "namespace ns {\n"
                                 "    void A::f(V) {}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "namespace external { "
                                 "namespace ns1 { "
                                 "struct B<1> ; "
@@ -1347,7 +1347,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "}\n"
                                 "namespace ns {\n"
                                 "    void A::f(external::ns1::V) {}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "namespace external { "
                                 "struct B<1> ; "
                                 "} "
@@ -1377,7 +1377,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "}\n"
                                 "namespace ns {\n"
                                 "    void A::f(external::ns1::V) {}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "struct B<1> ; "
                                 "namespace ns { "
                                 "struct A { "
@@ -1404,7 +1404,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "public:\n"
                                 "    void f(const V&) const override;\n"
                                 "};\n"
-                                "void A::f(const std::vector<char>&) const { }";
+                                "void A::f(const std::vector<char>&) const { }\n";
             const char exp[]  = "class B { "
                                 "public: "
                                 "virtual void f ( const std :: vector < char > & ) const = 0 ; "
@@ -1445,7 +1445,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "    NS1::B::V v;\n"
                                 "    a.f(v);\n"
                                 "    c.f(v);\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "namespace NS1 { "
                                 "class B { "
                                 "public: "
@@ -1500,7 +1500,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "   using MLSource = foo::s::Literal;\n"
                                 "   auto ret = foo::ResultCodes_e::NO_ERROR;\n"
                                 "   return ret;\n"
-                                "}";
+                                "}\n";
             (void)tok(code); // don't crash
             ignore_errout(); // we do not care about the output
         }
@@ -1520,7 +1520,7 @@ class TestSimplifyUsing : public TestFixture {
                             "}\n"
                             "namespace ns {\n"
                             "    void B::f(const std::vector<unsigned char>&) const { }\n"
-                            "}";
+                            "}\n";
         const char exp[] = "namespace ns { "
                            "class A { "
                            "public: "
@@ -1551,7 +1551,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "}\n"
                                 "namespace ns {\n"
                                 "    void B::f(h) { }\n"
-                                "}";
+                                "}\n";
             const char exp[] = "namespace ns { "
                                "class A { "
                                "public: "
@@ -1582,7 +1582,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "namespace external {\n"
                                 "void B::f(h) {}\n"
                                 "}\n"
-                                "}";
+                                "}\n";
             const char exp[] = "namespace ns { "
                                "namespace external { "
                                "class A { "
@@ -1614,7 +1614,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "}\n"
                                 "void bar() {\n"
                                 "   Pr<st> p;\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "std :: ostream & operator<< ( std :: ostream & s , const Pr < st > p ) { "
                                 "return s ; "
                                 "} "
@@ -1638,7 +1638,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "void xxx::foobar() {\n"
                                 "   using NS1 = v1::l;\n"
                                 "}\n"
-                                "}";
+                                "}\n";
             const char exp[]  = "namespace defsa { "
                                 "void xxx :: foo ( ) { "
                                 "} "
@@ -1654,7 +1654,7 @@ class TestSimplifyUsing : public TestFixture {
 
     void simplifyUsing10335() {
         const char code[] = "using uint8_t = unsigned char;\n"
-                            "enum E : uint8_t { E0 };";
+                            "enum E : uint8_t { E0 };\n";
         const char exp[]  = "enum E : unsigned char { E0 } ;";
         ASSERT_EQUALS(exp, tok(code));
     }
@@ -1685,7 +1685,7 @@ class TestSimplifyUsing : public TestFixture {
     }
 
     void simplifyUsing14877() {
-        const char code[] = "using C = struct C { C() {} };";
+        const char code[] = "using C = struct C { C() {} };\n";
         const char expected[] = "struct C { C ( ) { } } ;";
         ASSERT_EQUALS(expected, tok(code));
     }
@@ -1696,7 +1696,7 @@ class TestSimplifyUsing : public TestFixture {
                             "};\n"
                             "\n"
                             "namespace spdlog { class logger; }\n"
-                            "using LoggerPtr = std::shared_ptr<spdlog::logger>;";
+                            "using LoggerPtr = std::shared_ptr<spdlog::logger>;\n";
         (void)tok(code);
         ASSERT_EQUALS("", errout_str());
     }
diff --git a/test/testsingleexecutor.cpp b/test/testsingleexecutor.cpp
index d3f42868a4d..fe5cdf8181d 100644
--- a/test/testsingleexecutor.cpp
+++ b/test/testsingleexecutor.cpp
@@ -94,7 +94,7 @@ class TestSingleExecutorBase : public TestFixture {
         s.quiet = opt.quiet;
         if (opt.plistOutput)
             s.plistOutput = opt.plistOutput;
-        s.templateFormat = "{callstack}: ({severity}) {inconclusive:inconclusive: }{message}"; // TODO: remove when we only longer rely on toString() in unique message handling?
+        s.templateFormat = "{callstack}: ({severity}) {inconclusive:inconclusive: }{message}\n"; // TODO: remove when we only longer rely on toString() in unique message handling?
 
         Suppressions supprs;
         std::unique_ptr<TimerResults> timerResults;
@@ -142,8 +142,8 @@ class TestSingleExecutorBase : public TestFixture {
               "void f()\n"
               "{\n"
               "  (void)(*((int*)0));\n"
-              "}", dinit(CheckOptions,
-                         $.quiet = false));
+              "}\n", dinit(CheckOptions,
+                           $.quiet = false));
         {
             std::string expected;
             for (int i = 1; i <= num_files; ++i) {
@@ -167,7 +167,7 @@ class TestSingleExecutorBase : public TestFixture {
               "void f()\n"
               "{\n"
               "  (void)(*((int*)0));\n"
-              "}", dinit(CheckOptions, $.showtime = Settings::ShowTime::SUMMARY));
+              "}\n", dinit(CheckOptions, $.showtime = Settings::ShowTime::SUMMARY));
         // we are not interested in the results - so just consume them
         ignore_errout();
     }
@@ -180,7 +180,7 @@ class TestSingleExecutorBase : public TestFixture {
               "void f()\n"
               "{\n"
               "  (void)(*((int*)0));\n"
-              "}", dinit(CheckOptions, $.plistOutput = plistOutput.c_str()));
+              "}\n", dinit(CheckOptions, $.plistOutput = plistOutput.c_str()));
         // we are not interested in the results - so just consume them
         ignore_errout();
     }
@@ -190,7 +190,7 @@ class TestSingleExecutorBase : public TestFixture {
               "int main()\n"
               "{\n"
               "  return 0;\n"
-              "}");
+              "}\n");
     }
 
     void no_errors_less_files() {
@@ -198,7 +198,7 @@ class TestSingleExecutorBase : public TestFixture {
               "int main()\n"
               "{\n"
               "  return 0;\n"
-              "}");
+              "}\n");
     }
 
     void no_errors_equal_amount_files() {
@@ -206,7 +206,7 @@ class TestSingleExecutorBase : public TestFixture {
               "int main()\n"
               "{\n"
               "  return 0;\n"
-              "}");
+              "}\n");
     }
 
     void one_error_less_files() {
@@ -214,7 +214,7 @@ class TestSingleExecutorBase : public TestFixture {
               "void f()\n"
               "{\n"
               "  (void)(*((int*)0));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[" + fprefix() + "_" + zpad3(1) + ".c:3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
     }
 
@@ -224,7 +224,7 @@ class TestSingleExecutorBase : public TestFixture {
               "void f()\n"
               "{\n"
               "  (void)(*((int*)0));\n"
-              "}");
+              "}\n");
         {
             std::string expected;
             for (int i = 1; i <= num_files; ++i) {
@@ -239,7 +239,7 @@ class TestSingleExecutorBase : public TestFixture {
     void showtime_top5_file() {
         REDIRECT;
         check(2, 0,
-              "int main() {}",
+              "int main() {}\n",
               dinit(CheckOptions,
                     $.showtime = Settings::ShowTime::TOP5_FILE));
         const std::string output_s = GET_REDIRECT_OUTPUT;
@@ -250,7 +250,7 @@ class TestSingleExecutorBase : public TestFixture {
     void showtime_file() {
         REDIRECT;
         check(2, 0,
-              "int main() {}",
+              "int main() {}\n",
               dinit(CheckOptions,
                     $.showtime = Settings::ShowTime::FILE));
         const std::string output_s = GET_REDIRECT_OUTPUT;
@@ -260,7 +260,7 @@ class TestSingleExecutorBase : public TestFixture {
     void showtime_file_total() {
         REDIRECT;
         check(2, 0,
-              "int main() {}",
+              "int main() {}\n",
               dinit(CheckOptions,
                     $.showtime = Settings::ShowTime::FILE_TOTAL));
         const std::string output_s = GET_REDIRECT_OUTPUT;
@@ -277,7 +277,7 @@ class TestSingleExecutorBase : public TestFixture {
               "void f()\n"
               "{\n"
               "  (void)(*((int*)0));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         settings = settingsOld;
     }
@@ -288,9 +288,9 @@ class TestSingleExecutorBase : public TestFixture {
                          "inline void f()\n"
                          "{\n"
                          "  (void)(*((int*)0));\n"
-                         "}");
+                         "}\n");
         check(2, 2,
-              "#include \"" + inc_h.name() + "\"");
+              "#include \"" + inc_h.name() + "\"\n");
         // these are not actually made unique by the implementation. That needs to be done by the given ErrorLogger
         ASSERT_EQUALS(
             "[" + inc_h.name() + ":3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n"
diff --git a/test/testsizeof.cpp b/test/testsizeof.cpp
index f955242019f..0367c993951 100644
--- a/test/testsizeof.cpp
+++ b/test/testsizeof.cpp
@@ -74,48 +74,48 @@ class TestSizeof : public TestFixture {
         check("void foo()\n"
               "{\n"
               "    int i = sizeof sizeof char;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (warning) Calling 'sizeof' on 'sizeof'. [sizeofsizeof]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    int i = sizeof (sizeof long);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (warning) Calling 'sizeof' on 'sizeof'. [sizeofsizeof]\n", errout_str());
 
         check("void foo(long *p)\n"
               "{\n"
               "    int i = sizeof (sizeof (p));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (warning) Calling 'sizeof' on 'sizeof'. [sizeofsizeof]\n", errout_str());
     }
 
     void sizeofCalculation() {
-        check("int a, b; int a,sizeof(a+b)");
+        check("int a, b; int a,sizeof(a+b)\n");
         ASSERT_EQUALS("[test.cpp:1:25]: (warning) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
 
-        check("int a, b; sizeof(a*b)");
+        check("int a, b; sizeof(a*b)\n");
         ASSERT_EQUALS("[test.cpp:1:19]: (warning) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
 
-        check("int a, b; sizeof(-a)");
+        check("int a, b; sizeof(-a)\n");
         ASSERT_EQUALS("[test.cpp:1:18]: (warning) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
 
-        check("int a, b; sizeof(*a)");
+        check("int a, b; sizeof(*a)\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("sizeof(void * const)");
+        check("sizeof(void * const)\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("sizeof(int*[2])");
+        check("sizeof(int*[2])\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("sizeof(Fred**)");
+        check("sizeof(Fred**)\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("sizeof(foo++)");
+        check("sizeof(foo++)\n");
         ASSERT_EQUALS("[test.cpp:1:11]: (warning) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
 
-        check("sizeof(--foo)");
+        check("sizeof(--foo)\n");
         ASSERT_EQUALS("[test.cpp:1:8]: (warning) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
 
         // #6888
@@ -129,7 +129,7 @@ class TestSizeof : public TestFixture {
                "  VOIDCAST2(SIZEOF1);\n"
                "  VOIDCAST2(SIZEOF2);\n"
                "  return i + foo(1);\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkP("#define SIZEOF1   sizeof(i != 2)\n"
@@ -138,12 +138,12 @@ class TestSizeof : public TestFixture {
                "  SIZEOF1;\n"
                "  SIZEOF2;\n"
                "  return i + foo(1);\n"
-               "}");
+               "}\n");
         ASSERT_EQUALS("[test.cpp:4:3]: (warning, inconclusive) Found calculation inside sizeof(). [sizeofCalculation]\n"
                       "[test.cpp:5:3]: (warning, inconclusive) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
 
         checkP("#define MACRO(data)  f(data, sizeof(data))\n"
-               "x = MACRO((unsigned int *)data + 4);");
+               "x = MACRO((unsigned int *)data + 4);\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
     }
 
@@ -152,7 +152,7 @@ class TestSizeof : public TestFixture {
               "{\n"
               "    int bar() { return 1; };\n"
               "}\n"
-              "Foo f;int a=sizeof(f.bar());");
+              "Foo f;int a=sizeof(f.bar());\n");
         ASSERT_EQUALS("[test.cpp:5:13]: (warning) Found function call inside sizeof(). [sizeofFunctionCall]\n", errout_str());
 
         check("class Foo\n"
@@ -160,35 +160,35 @@ class TestSizeof : public TestFixture {
               "    int bar() { return 1; };\n"
               "    int bar() const { return 1; };\n"
               "}\n"
-              "Foo f;int a=sizeof(f.bar());");
+              "Foo f;int a=sizeof(f.bar());\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Foo\n"
               "{\n"
               "    int bar() { return 1; };\n"
               "}\n"
-              "Foo * fp;int a=sizeof(fp->bar());");
+              "Foo * fp;int a=sizeof(fp->bar());\n");
         ASSERT_EQUALS("[test.cpp:5:16]: (warning) Found function call inside sizeof(). [sizeofFunctionCall]\n", errout_str());
 
-        check("int a=sizeof(foo());");
+        check("int a=sizeof(foo());\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int foo() { return 1; }; int a=sizeof(foo());");
+        check("int foo() { return 1; }; int a=sizeof(foo());\n");
         ASSERT_EQUALS("[test.cpp:1:32]: (warning) Found function call inside sizeof(). [sizeofFunctionCall]\n", errout_str());
 
-        check("int foo() { return 1; }; sizeof(decltype(foo()));");
+        check("int foo() { return 1; }; sizeof(decltype(foo()));\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int foo(int) { return 1; }; int a=sizeof(foo(0))");
+        check("int foo(int) { return 1; }; int a=sizeof(foo(0))\n");
         ASSERT_EQUALS("[test.cpp:1:35]: (warning) Found function call inside sizeof(). [sizeofFunctionCall]\n", errout_str());
 
-        check("char * buf; int a=sizeof(*buf);");
+        check("char * buf; int a=sizeof(*buf);\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int a=sizeof(foo())");
+        check("int a=sizeof(foo())\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("int foo(int) { return 1; }; char buf[1024]; int a=sizeof(buf), foo(0)");
+        check("int foo(int) { return 1; }; char buf[1024]; int a=sizeof(buf), foo(0)\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template<class T>\n"
@@ -204,7 +204,7 @@ class TestSizeof : public TestFixture {
               "        Y = sizeof(f(g() << h())) == sizeof(A),\n"
               "        Z = X & Y\n"
               "    };\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int g();\n"
@@ -217,7 +217,7 @@ class TestSizeof : public TestFixture {
         check("void f() {\n"
               "    int a[10];\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -225,7 +225,7 @@ class TestSizeof : public TestFixture {
               "    unsigned int b = 2;\n"
               "    int c[(a+b)];\n"
               "    std::cout << sizeof(c) / sizeof(int) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -233,7 +233,7 @@ class TestSizeof : public TestFixture {
               "    unsigned int b[] = { 0 };\n"
               "    int c[a[b[0]]];\n"
               "    std::cout << sizeof(c) / sizeof(int) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -242,36 +242,36 @@ class TestSizeof : public TestFixture {
               "    unsigned int b = 2;\n"
               "    int c[(a[0]+b)];\n"
               "    std::cout << sizeof(c) / sizeof(int) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a[] = { 1, 2, 3 };\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a[3] = { 1, 2, 3 };\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f( int a[]) {\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Using 'sizeof' on array given as "
                       "function argument returns size of a pointer. [sizeofwithsilentarraypointer]\n", errout_str());
 
         check("void f( int a[]) {\n"
               "    std::cout << sizeof a / sizeof(int) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Using 'sizeof' on array given as "
                       "function argument returns size of a pointer. [sizeofwithsilentarraypointer]\n", errout_str());
 
         check("void f( int a[3] ) {\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Using 'sizeof' on array given as "
                       "function argument returns size of a pointer. [sizeofwithsilentarraypointer]\n", errout_str());
 
@@ -279,19 +279,19 @@ class TestSizeof : public TestFixture {
               "int f2(Fixname& f2v) {\n"
               "  int i = sizeof(f2v);\n"
               "  printf(\"sizeof f2v %d\", i);\n"
-              "   }");
+              "   }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p) {\n"
               "    p[0] = 0;\n"
               "    int unused = sizeof(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char p[] = \"test\";\n"
               "    int unused = sizeof(p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #2495
@@ -305,33 +305,33 @@ class TestSizeof : public TestFixture {
               "      {1,0,1},\n"
               "    };\n"
               "    const int COL_MAX=sizeof(col)/sizeof(col[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #155
         check("void f() {\n"
               "    char buff1[1024*64],buff2[sizeof(buff1)*2];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #2510
         check("void f( int a[], int b) {\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Using 'sizeof' on array given as "
                       "function argument returns size of a pointer. [sizeofwithsilentarraypointer]\n", errout_str());
 
         // ticket #2510
         check("void f( int a[3] , int b[2] ) {\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Using 'sizeof' on array given as "
                       "function argument returns size of a pointer. [sizeofwithsilentarraypointer]\n", errout_str());
 
         // ticket #2510
         check("void f() {\n"
               "    char buff1[1024*64],buff2[sizeof(buff1)*(2+1)];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(std::array<int, 2> a) {\n" // #14860
@@ -347,22 +347,22 @@ class TestSizeof : public TestFixture {
     void sizeofForNumericParameter() {
         check("void f() {\n"
               "    std::cout << sizeof(10) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Suspicious usage of 'sizeof' with a numeric constant as parameter. [sizeofwithnumericparameter]\n", errout_str());
 
         check("void f() {\n"
               "    std::cout << sizeof(-10) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Suspicious usage of 'sizeof' with a numeric constant as parameter. [sizeofwithnumericparameter]\n", errout_str());
 
         check("void f() {\n"
               "    std::cout << sizeof 10  << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Suspicious usage of 'sizeof' with a numeric constant as parameter. [sizeofwithnumericparameter]\n", errout_str());
 
         check("void f() {\n"
               "    std::cout << sizeof -10  << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Suspicious usage of 'sizeof' with a numeric constant as parameter. [sizeofwithnumericparameter]\n", errout_str());
     }
 
@@ -370,51 +370,51 @@ class TestSizeof : public TestFixture {
         check("void f() {\n"
               "  int* p;\n"
               "  return sizeof(p)/5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (warning, inconclusive) Division of result of sizeof() on pointer type. [divideSizeof]\n", errout_str());
 
         check("void f() {\n"
               "  unknown p;\n"
               "  return sizeof(p)/5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  return sizeof(unknown)/5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int p;\n"
               "  return sizeof(p)/5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int* p[5];\n"
               "  return sizeof(p)/5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
         check("void f() {\n"
               "  return sizeof(foo)*sizeof(bar);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning, inconclusive) Multiplying sizeof() with sizeof() indicates a logic error. [multiplySizeof]\n", errout_str());
 
         check("void f() {\n"
               "  return (foo)*sizeof(bar);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  return sizeof(foo)*bar;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  return (end - source) / sizeof(encode_block_type) * sizeof(encode_block_type);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S { T* t; };\n" // #10179
@@ -471,49 +471,49 @@ class TestSizeof : public TestFixture {
         check("void f() {\n"
               "    char *x = malloc(10);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(*x));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(x));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = (int*)malloc(sizeof(x));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = static_cast<int*>(malloc(sizeof(x)));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(&x));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int*));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
@@ -521,155 +521,155 @@ class TestSizeof : public TestFixture {
               "    free(x);\n"
               "    int **y = malloc(sizeof(int*));\n"
               "    free(y);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(100 * sizeof(x));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(x) * 100);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof *x);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof x);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(100 * sizeof x);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = calloc(1, sizeof(*x));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = calloc(1, sizeof *x);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = calloc(1, sizeof(x));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = calloc(1, sizeof x);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = calloc(1, sizeof(int));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char x[10];\n"
               "    memset(x, 0, sizeof(x));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char* x[10];\n"
               "    memset(x, 0, sizeof(x));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char x[10];\n"
               "    memset(x, 0, sizeof x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
               "    memset(x, 0, sizeof(int));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
               "    memset(x, 0, sizeof(*x));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
               "    memset(x, 0, sizeof *x);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
               "    memset(x, 0, sizeof x);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
               "    memset(x, 0, sizeof(x));\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int) * 10);\n"
               "    memset(x, 0, sizeof(x) * 10);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int) * 10);\n"
               "    memset(x, 0, sizeof x * 10);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int) * 10);\n"
               "    memset(x, 0, sizeof(*x) * 10);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int) * 10);\n"
               "    memset(x, 0, sizeof *x * 10);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int) * 10);\n"
               "    memset(x, 0, sizeof(int) * 10);\n"
               "    free(x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check(
@@ -677,18 +677,18 @@ class TestSizeof : public TestFixture {
             "{\n"
             "  const char *buf1_ex = \"foobarbaz\";\n"
             "  return strncmp(buf1, buf1_ex, sizeof(buf1_ex)) == 0;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:4:24]: (warning) Size of pointer 'buf1_ex' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check(
             "int fun(const char *buf1) {\n"
             "  return strncmp(buf1, foo(buf2), sizeof(buf1)) == 0;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (warning) Size of pointer 'buf1' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("int fun(const char *buf2) {\n"
               "  return strncmp(buf1, buf2, sizeof(char*)) == 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:24]: (warning) Size of pointer 'buf2' used instead of size of its data. [pointerSize]\n", errout_str());
 
         // #ticket 3874
@@ -696,25 +696,25 @@ class TestSizeof : public TestFixture {
               "{\n"
               " int * pIntArray[10];\n"
               " memset(pIntArray, 0, sizeof(pIntArray));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void FreeFileName(const char *s) {\n"
               "  CxString tbuf;\n"
               "  const char *p;\n"
               "  memcpy(s, siezof(s));\n" // non-standard memcpy
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "  module_config_t *tab = module;\n"
               "  memset(tab + confsize, 0, sizeof(tab[confsize]));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(char* aug) {\n"
               "  memmove(aug + extra_string, aug, buf - (bfd_byte *)aug);\n" // #7100
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7518
@@ -722,19 +722,19 @@ class TestSizeof : public TestFixture {
               "  cpp_token *token;\n"
               "  cpp_hashnode **params = malloc(sizeof(cpp_hashnode *) * macro->paramc);\n"
               "  memcpy(params, macro->params, sizeof(cpp_hashnode *) * macro->paramc);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void* foo() {\n"
               "  void* AtomName = malloc(sizeof(char *) * 34);\n"
               "  return AtomName;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void* f(size_t n) {\n" // #11754
               "    char* p = malloc(n * sizeof(void*));\n"
               "    return p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -742,7 +742,7 @@ class TestSizeof : public TestFixture {
         check("void f() {\n"
               "    struct foo *ptr;\n"
               "    memset( ptr->bar, 0, sizeof ptr->bar );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -750,7 +750,7 @@ class TestSizeof : public TestFixture {
               "        char bar[10];\n"
               "    }* ptr;\n"
               "    memset( ptr->bar, 0, sizeof ptr->bar );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -758,27 +758,27 @@ class TestSizeof : public TestFixture {
               "        char *bar;\n"
               "    }* ptr;\n"
               "    memset( ptr->bar, 0, sizeof ptr->bar );\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:18]: (warning) Size of pointer 'bar' used instead of size of its data. [pointerSize]\n", errout_str());
     }
 
     void sizeofDivisionMemset() {
         check("void foo(memoryMapEntry_t* entry, memoryMapEntry_t* memoryMapEnd) {\n"
               "    memmove(entry, entry + 1, (memoryMapEnd - entry) / sizeof(entry));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:56]: (warning, inconclusive) Division of result of sizeof() on pointer type. [divideSizeof]\n"
                       "[test.cpp:2:54]: (warning) Division by result of sizeof(). memmove() expects a size in bytes, did you intend to multiply instead? [sizeofDivisionMemfunc]\n",
                       errout_str());
 
         check("Foo* allocFoo(int num) {\n"
               "    return malloc(num / sizeof(Foo));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:23]: (warning) Division by result of sizeof(). malloc() expects a size in bytes, did you intend to multiply instead? [sizeofDivisionMemfunc]\n", errout_str());
 
         check("void f() {\n"
               "  char str[100];\n"
               "  strncpy(str, xyz, sizeof(str)/sizeof(str[0]));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #9648
@@ -793,13 +793,13 @@ class TestSizeof : public TestFixture {
     void sizeofVoid() {
         check("void f() {\n"
               "  int size = sizeof(void);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (portability) Behaviour of 'sizeof(void)' is not covered by the ISO C standard. [sizeofVoid]\n", errout_str());
 
         check("void f() {\n"
               "  void* p;\n"
               "  int size = sizeof(*p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (portability) '*p' is of type 'void', the behaviour of 'sizeof(void)' is not covered by the ISO C standard. [sizeofDereferencedVoidPointer]\n", errout_str());
 
         check("void f() {\n"
@@ -807,7 +807,7 @@ class TestSizeof : public TestFixture {
               "  int* p2 = p + 4;\n"
               "  int* p3 = p - 1;\n"
               "  int* p4 = 1 + p;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (portability) 'p' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n"
                       "[test.cpp:4:15]: (portability) 'p' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n"
                       "[test.cpp:5:15]: (portability) 'p' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
@@ -817,7 +817,7 @@ class TestSizeof : public TestFixture {
               "  void* p2 = malloc(5);\n"
               "  p1--;\n"
               "  p2++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (portability) 'p1' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n"
                       "[test.cpp:5:5]: (portability) 'p2' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
@@ -826,7 +826,7 @@ class TestSizeof : public TestFixture {
               "  void* p2 = malloc(5);\n"
               "  p1-=4;\n"
               "  p2+=4;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (portability) 'p1' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n"
                       "[test.cpp:5:5]: (portability) 'p2' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
@@ -834,54 +834,54 @@ class TestSizeof : public TestFixture {
               "  void* p = malloc(10);\n"
               "  int* p2 = &p + 4;\n"
               "  int* p3 = &p - 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  void** p1 = malloc(10);\n"
               "  p1--;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  void** p1;\n"
               "  int j = sizeof(*p1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  void* p1[5];\n"
               "  int j = sizeof(*p1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Calculations on void* with casts
 
         check("void f(void *data) {\n"
               "  *((unsigned char *)data + 1) = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(void *data) {\n"
               "  *((unsigned char *)(data) + 1) = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(void *data) {\n"
               "  unsigned char* c = (unsigned char *)(data + 1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:45]: (portability) 'data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         check("void f(void *data) {\n"
               "  unsigned char* c = (unsigned char *)data++;\n"
               "  unsigned char* c2 = (unsigned char *)++data;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:43]: (portability) 'data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n"
                       "[test.cpp:3:40]: (portability) 'data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         check("void f(void *data) {\n"
               "  void* data2 = data + 1;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (portability) 'data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         // #4908 (void pointer as a member of a struct/class)
@@ -892,7 +892,7 @@ class TestSizeof : public TestFixture {
               "  char x = *((char*)(foo.data+1));\n"
               "  foo.data++;\n"
               "  return x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:30]: (portability) 'foo.data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n"
                       "[test.cpp:6:11]: (portability) 'foo.data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
@@ -916,7 +916,7 @@ class TestSizeof : public TestFixture {
               "};\n"
               "void f4(struct BOO* boo) {\n"
               "  char c = *((char*)boo->data.data + 1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct FOO {\n"
@@ -924,7 +924,7 @@ class TestSizeof : public TestFixture {
               "};\n"
               "char f(struct FOO* foo) {\n"
               "  *(foo[1].data + 1) = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:17]: (portability) 'foo[1].data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         check("struct FOO {\n"
@@ -932,12 +932,12 @@ class TestSizeof : public TestFixture {
               "};\n"
               "void f2(struct FOO* foo) {\n"
               "  (foo[0]).data++;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:16]: (portability) '(foo[0]).data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         // #6050 arithmetic on void**
         check("void* array[10];\n"
-              "void** b = array + 3;");
+              "void** b = array + 3;\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -946,7 +946,7 @@ class TestSizeof : public TestFixture {
         check("char strncat ();\n"
               "int main () {\n"
               "  return strncat ();\n"
-              "}");
+              "}\n");
     }
 
 };
diff --git a/test/teststl.cpp b/test/teststl.cpp
index 1cc11029804..636ae664367 100644
--- a/test/teststl.cpp
+++ b/test/teststl.cpp
@@ -250,19 +250,19 @@ class TestStl : public TestFixture {
         checkNormal("void f() {\n"
                     "  std::string s;\n"
                     "  s[10] = 1;\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("[test.cpp:3:4]: error: Out of bounds access in expression 's[10]' because 's' is empty. [containerOutOfBounds]\n", errout_str());
 
         checkNormal("void f() {\n"
                     "  std::string s = \"abcd\";\n"
                     "  s[10] = 1;\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("[test.cpp:3:4]: error: Out of bounds access in 's[10]', if 's' size is 4 and '10' is 10 [containerOutOfBounds]\n", errout_str());
 
         checkNormal("void f(std::vector<int> v) {\n"
                     "    v.front();\n"
                     "    if (v.empty()) {}\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: warning: Either the condition 'v.empty()' is redundant or expression 'v.front()' causes access out of bounds. [containerOutOfBounds]\n"
                       "[test.cpp:3:16]: note: condition 'v.empty()'\n"
                       "[test.cpp:2:12]: note: Access out of bounds\n", errout_str());
@@ -270,7 +270,7 @@ class TestStl : public TestFixture {
         checkNormal("void f(std::vector<int> v) {\n"
                     "    if (v.size() == 3) {}\n"
                     "    v[16] = 0;\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: warning: Either the condition 'v.size()==3' is redundant or size of 'v' can be 3. Expression 'v[16]' causes access out of bounds. [containerOutOfBounds]\n"
                       "[test.cpp:2:18]: note: condition 'v.size()==3'\n"
                       "[test.cpp:3:6]: note: Access out of bounds\n", errout_str());
@@ -280,7 +280,7 @@ class TestStl : public TestFixture {
                     "    if (v.size() == 3) {\n"
                     "        v[i] = 0;\n"
                     "    }\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: warning: Either the condition 'v.size()==3' is redundant or size of 'v' can be 3. Expression 'v[i]' causes access out of bounds. [containerOutOfBounds]\n"
                       "[test.cpp:3:18]: note: condition 'v.size()==3'\n"
                       "[test.cpp:4:10]: note: Access out of bounds\n", errout_str());
@@ -288,19 +288,19 @@ class TestStl : public TestFixture {
         checkNormal("void f(std::vector<int> v, int i) {\n"
                     "    if (v.size() == 3 || i == 16) {}\n"
                     "    v[i] = 0;\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNormal("void f(std::map<int,int> x) {\n"
                     "    if (x.empty()) { x[1] = 2; }\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNormal("void f(std::string s) {\n"
                     "    if (s.size() == 1) {\n"
                     "        s[2] = 0;\n"
                     "    }\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: warning: Either the condition 's.size()==1' is redundant or size of 's' can be 1. Expression 's[2]' causes access out of bounds. [containerOutOfBounds]\n"
                       "[test.cpp:2:18]: note: condition 's.size()==1'\n"
                       "[test.cpp:3:10]: note: Access out of bounds\n", errout_str());
@@ -310,25 +310,25 @@ class TestStl : public TestFixture {
                     "  std::string b[];\n"
                     "  for (auto c : b)\n"
                     "    c.data();\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNormal("std::string f(std::string x) {\n"
                     "  if (x.empty()) return {};\n"
                     "  x[0];\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNormal("std::string f(std::string x) {\n"
                     "  if (x.empty()) return std::string{};\n"
                     "  x[0];\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNormal("void f() {\n"
                     "  std::string s;\n"
                     "  x = s.begin() + 1;\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:17]: error: Out of bounds access in expression 's.begin()+1' because 's' is empty. [containerOutOfBounds]\n"
             "[test.cpp:3:17]: error: Out of bounds access in expression 's.begin()+1' because 's' is empty. [containerOutOfBounds]\n",   // duplicate
@@ -337,29 +337,29 @@ class TestStl : public TestFixture {
         checkNormal("void f(int x) {\n"
                     "  std::string s;\n"
                     "  auto it = s.begin() + x;\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("[test.cpp:3:23]: error: Out of bounds access in expression 's.begin()+x' because 's' is empty and 'x' may be non-zero. [containerOutOfBounds]\n", errout_str());
 
         checkNormal("char fstr1(){const std::string s = \"<a><b>\"; return s[42]; }\n"
-                    "wchar_t fwstr1(){const std::wstring s = L\"<a><b>\"; return s[42]; }");
+                    "wchar_t fwstr1(){const std::wstring s = L\"<a><b>\"; return s[42]; }\n");
         ASSERT_EQUALS("[test.cpp:1:54]: error: Out of bounds access in 's[42]', if 's' size is 6 and '42' is 42 [containerOutOfBounds]\n"
                       "[test.cpp:2:60]: error: Out of bounds access in 's[42]', if 's' size is 6 and '42' is 42 [containerOutOfBounds]\n", errout_str());
 
         checkNormal("char fstr1(){const std::string s = \"<a><b>\"; return s[1]; }\n"
-                    "wchar_t fwstr1(){const std::wstring s = L\"<a><b>\"; return s[1]; }");
+                    "wchar_t fwstr1(){const std::wstring s = L\"<a><b>\"; return s[1]; }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNormal("int f() {\n"
                     "    std::vector<int> v;\n"
                     "    std::vector<int> * pv = &v;\n"
                     "    return (*pv)[42];\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("[test.cpp:4:17]: error: Out of bounds access in expression '(*pv)[42]' because '*pv' is empty. [containerOutOfBounds]\n", errout_str());
 
         checkNormal("void f() {\n"
                     "  std::string s;\n"
                     "  ++abc[s];\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // # 9274
@@ -368,7 +368,7 @@ class TestStl : public TestFixture {
                     "    int x = 6;\n"
                     "    if(b) ++x;\n"
                     "    return s[x];\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS(
             "[test.cpp:5:13]: error: Out of bounds access in 's[x]', if 's' size is 6 and 'x' is 7 [containerOutOfBounds]\n",
             errout_str());
@@ -377,7 +377,7 @@ class TestStl : public TestFixture {
                     "    static const int N = 4;\n"
                     "    std::array<int, N> x;\n"
                     "    x[0] = 0;\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkNormal("void f(bool b) {\n"
@@ -1040,22 +1040,22 @@ class TestStl : public TestFixture {
 
         checkNormal("void f(std::string s) {\n"
                     "  s[s.size()] = 1;\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: error: Out of bounds access of s, index 's.size()' is out of bounds. [containerOutOfBoundsIndexExpression]\n", errout_str());
 
         checkNormal("void f(std::string s) {\n"
                     "  s[s.size()+1] = 1;\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: error: Out of bounds access of s, index 's.size()+1' is out of bounds. [containerOutOfBoundsIndexExpression]\n", errout_str());
 
         checkNormal("void f(std::string s) {\n"
                     "  s[1+s.size()] = 1;\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: error: Out of bounds access of s, index '1+s.size()' is out of bounds. [containerOutOfBoundsIndexExpression]\n", errout_str());
 
         checkNormal("void f(std::string s) {\n"
                     "  s[x*s.size()] = 1;\n"
-                    "}");
+                    "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: error: Out of bounds access of s, index 'x*s.size()' is out of bounds. [containerOutOfBoundsIndexExpression]\n", errout_str());
 
         checkNormal("bool f(std::string_view& sv) {\n" // #10031
@@ -1131,7 +1131,7 @@ class TestStl : public TestFixture {
               "    std::list<int> l2;\n"
               "    for (std::list<int>::iterator it = l1.begin(); it != l2.end(); ++it)\n"
               "    { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:40]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -1141,7 +1141,7 @@ class TestStl : public TestFixture {
               "    std::list<int> l2;\n"
               "    for (std::list<int>::iterator it = l1.begin(); l2.end() != it; ++it)\n"
               "    { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:52]: (error) Iterators of different containers 'l2' and 'l1' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -1151,7 +1151,7 @@ class TestStl : public TestFixture {
               "    for (it = l1.begin(); it != l1.end(); ++it) { }\n"
               "    C c;\n"
               "    for (it = c.l1.begin(); it != c.l1.end(); ++it) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Same check with reverse iterator
@@ -1161,7 +1161,7 @@ class TestStl : public TestFixture {
               "    std::list<int> l2;\n"
               "    for (std::list<int>::const_reverse_iterator it = l1.rbegin(); it != l2.rend(); ++it)\n"
               "    { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:54]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
                       errout_str());
     }
@@ -1176,7 +1176,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        ++it;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:35]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -1189,7 +1189,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        ++it;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:12]: (error) Iterators of different containers 'l2' and 'l1' are used together. [mismatchingContainers]\n",
                       errout_str());
     }
@@ -1201,7 +1201,7 @@ class TestStl : public TestFixture {
               "    std::list<int> l2;\n"
               "    std::list<int>::iterator it = l1.begin();\n"
               "    l2.insert(it, 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (error) Same iterator is used with different containers 'l1' and 'l2'. [iterators1]\n"
                       "[test.cpp:6:5]: (error) Iterator 'it' referring to container 'l1' is used with container 'l2'. [mismatchingContainerIterator]\n",
                       errout_str());
@@ -1211,7 +1211,7 @@ class TestStl : public TestFixture {
               "    std::list<int> l2;\n"
               "    std::list<int>::iterator it = l1.begin();\n"
               "    l2.insert(it, l1.end());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n" // #7658
@@ -1220,7 +1220,7 @@ class TestStl : public TestFixture {
               "    std::list<int>::iterator it = l1.begin();\n"
               "    std::list<int>::iterator end = l1.end();\n"
               "    l2.insert(it, end);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // only warn for insert when there are preciself 2 arguments.
@@ -1229,14 +1229,14 @@ class TestStl : public TestFixture {
               "    std::list<int> l2;\n"
               "    std::list<int>::iterator it = l1.begin();\n"
               "    l2.insert(it);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void foo() {\n"
               "    std::list<int> l1;\n"
               "    std::list<int> l2;\n"
               "    std::list<int>::iterator it = l1.begin();\n"
               "    l2.insert(it,0,1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
     }
@@ -1251,7 +1251,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        result.insert(cit->size());\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1259,7 +1259,7 @@ class TestStl : public TestFixture {
         check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
               "    std::vector<int>::iterator it = std::find(ints1.begin(), ints2.end(), 22);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:47]: (error) Iterators of different containers 'ints1' and 'ints2' are used together. [mismatchingContainers]\n",
                       errout_str());
     }
@@ -1272,7 +1272,7 @@ class TestStl : public TestFixture {
               "    std::set<int>::iterator it1 = ints1.begin();\n"
               "    std::set<int>::iterator it2 = ints1.end();\n"
               "    ints2.insert(it1, it2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(const std::set<int> &ints1)\n"
@@ -1281,7 +1281,7 @@ class TestStl : public TestFixture {
               "    std::set<int>::iterator it1 = ints1.begin();\n"
               "    std::set<int>::iterator it2 = ints2.end();\n"
               "    ints2.insert(it1, it2);\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Iterators of different containers are used together.\n", "", errout_str());
     }
 
@@ -1289,14 +1289,14 @@ class TestStl : public TestFixture {
         check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
               "    std::vector<int>::iterator it = std::inplace_merge(ints1.begin(), std::advance(ints1.rbegin(), 5), ints2.end());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:56]: (error) Iterators of different containers 'ints1' and 'ints2' are used together. [mismatchingContainers]\n",
                       errout_str());
 
         check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
               "    std::vector<int>::iterator it = std::inplace_merge(ints1.begin(), std::advance(ints2.rbegin(), 5), ints1.end());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1304,28 +1304,28 @@ class TestStl : public TestFixture {
         check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
               "    std::vector<int>::iterator it = std::find_first_of(ints1.begin(), ints2.end(), ints1.begin(), ints1.end());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:56]: (error) Iterators of different containers 'ints1' and 'ints2' are used together. [mismatchingContainers]\n",
                       errout_str());
 
         check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
               "    std::vector<int>::iterator it = std::find_first_of(ints1.begin(), ints1.end(), ints2.begin(), ints1.end());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:84]: (error) Iterators of different containers 'ints2' and 'ints1' are used together. [mismatchingContainers]\n",
                       errout_str());
 
         check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
               "    std::vector<int>::iterator it = std::find_first_of(foo.bar.begin(), foo.bar.end()-6, ints2.begin(), ints1.end());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:90]: (error) Iterators of different containers 'ints2' and 'ints1' are used together. [mismatchingContainers]\n",
                       errout_str());
 
         check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
               "    std::vector<int>::iterator it = std::find_first_of(ints1.begin(), ints1.end(), ints2.begin(), ints2.end());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6839
@@ -1336,7 +1336,7 @@ class TestStl : public TestFixture {
               "    const std::u32string tp4(b.begin(), a.end());\n"
               "    const std::string fp1 = std::string(a.begin(), a.end());\n"
               "    const std::string tp2(a.begin(), a.end());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS( // TODO "[test.cpp:2]: (error) Iterators of different containers are used together.\n"
             // TODO "[test.cpp:3]: (error) Iterators of different containers are used together.\n"
             "[test.cpp:4:26]: (error) Iterators of different containers 'tp3' and 'a' are used together. [mismatchingContainers]\n"
@@ -1358,7 +1358,7 @@ class TestStl : public TestFixture {
               "        }\n"
               "        ++aI;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #2481
@@ -1374,7 +1374,7 @@ class TestStl : public TestFixture {
               "        }\n"
               "        ++aI;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Execution path checking..
@@ -1393,7 +1393,7 @@ class TestStl : public TestFixture {
               "        }\n"
               "        ++aI;\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:14] (error) After insert(), the iterator 'aI' may be invalid.", "", errout_str());
     }
 
@@ -1408,7 +1408,7 @@ class TestStl : public TestFixture {
               "        if (true) { }\n"
               "        if (it != s2.end()) continue;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:39]: (error) Iterators of different containers 's1' and 's2' are used together. [mismatchingContainers]\n",
                       errout_str());
     }
@@ -1420,7 +1420,7 @@ class TestStl : public TestFixture {
               "    vector<string> myVector;\n"
               "    for(vector<int>::iterator x = myVector.begin(); x != myVector.end(); x++)\n"
               "        myMap.erase(*x);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1430,8 +1430,8 @@ class TestStl : public TestFixture {
               "    std::map<int, int> map1;\n"
               "    std::map<int, int> map2;\n"
               "    std::map<int, int>::const_iterator it = map1.find(123);\n"
-              "    if (it == map2.end()) { }"
-              "}");
+              "    if (it == map2.end()) { }\n"
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:45]: (error) Iterators of different containers 'map1' and 'map2' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -1439,8 +1439,8 @@ class TestStl : public TestFixture {
               "    std::map<int, int> map1;\n"
               "    std::map<int, int> map2;\n"
               "    std::map<int, int>::const_iterator it = map1.find(123);\n"
-              "    if (map2.end() == it) { }"
-              "}");
+              "    if (map2.end() == it) { }\n"
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9]: (error) Iterators of different containers 'map2' and 'map1' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -1448,7 +1448,7 @@ class TestStl : public TestFixture {
               "    int pos = s.find(x);\n"
               "    s.erase(pos);\n"
               "    s.erase(pos);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1463,7 +1463,7 @@ class TestStl : public TestFixture {
               "    it = t.begin();\n"
               "    while (it!=a.end())\n"
               "        ++it;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:10]: (error) Iterators of different containers 't' and 'a' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -1478,7 +1478,7 @@ class TestStl : public TestFixture {
               "    it = t.begin();\n"
               "    while (it!=t.end())\n"
               "        ++it;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -1493,7 +1493,7 @@ class TestStl : public TestFixture {
               "        ++it;\n"
               "    while (!z && it!=t.end())\n"
               "        ++it;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1502,7 +1502,7 @@ class TestStl : public TestFixture {
               "    std::map<int,Foo> x;\n"
               "    std::map<int,Foo>::const_iterator it;\n"
               "    for (it = x.find(0)->second.begin(); it != x.find(0)->second.end(); ++it) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1510,7 +1510,7 @@ class TestStl : public TestFixture {
         check("void f(C1* x, std::list<int> a) {\n"
               "  std::list<int>::iterator pos = a.begin();\n"
               "  for(pos = x[0]->plist.begin(); pos != x[0]->plist.end(); ++pos) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1525,7 +1525,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        ++it1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -1539,7 +1539,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        ++it2;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:36]: (error) Iterators of different containers 'l2' and 'l1' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -1553,7 +1553,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        ++it1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -1567,7 +1567,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        ++it1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:35]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
                       errout_str());
     }
@@ -1584,7 +1584,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        ++it1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -1599,7 +1599,7 @@ class TestStl : public TestFixture {
               "        ++it1;\n"
               "    }\n"
               "    it2 = l2.end();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -1614,7 +1614,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        ++it1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
@@ -1630,7 +1630,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        ++it1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
                       errout_str());
     }
@@ -1643,7 +1643,7 @@ class TestStl : public TestFixture {
               "    while (++it1 != --it2)\n"
               "    {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(std::list<int> l1, std::list<int> l2)\n"
@@ -1653,7 +1653,7 @@ class TestStl : public TestFixture {
               "    while (it1++ != --it2)\n"
               "    {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(std::list<int> l1, std::list<int> l2)\n"
@@ -1663,7 +1663,7 @@ class TestStl : public TestFixture {
               "    if (--it2 > it1++)\n"
               "    {\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("", "[test.cpp:5:15]: (error) Dangerous comparison using operator< on iterator. [stlBoundaries]\n", errout_str());
     }
 
@@ -1678,7 +1678,7 @@ class TestStl : public TestFixture {
               "        {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:7:13] -> [test.cpp:4:36]: (error) Same iterator is used with containers 'l1' that are temporaries or defined in different scopes. [iterators3]\n",
             errout_str());
@@ -1693,7 +1693,7 @@ class TestStl : public TestFixture {
               "        {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS(
             "[test.cpp:7] -> [test.cpp:4]: (error) Same iterator is used with containers 'l1' that are defined in different scopes.\n",
             "[test.cpp:7:19] -> [test.cpp:7:13]: (error) Same iterator is used with containers 'l1' that are temporaries or defined in different scopes. [iterators3]\n"
@@ -1711,7 +1711,7 @@ class TestStl : public TestFixture {
               "        {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:8:13] -> [test.cpp:4:36]: (error) Same iterator is used with containers 'l1' that are temporaries or defined in different scopes. [iterators3]\n",
             errout_str());
@@ -1727,7 +1727,7 @@ class TestStl : public TestFixture {
               "        {\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:8:13] -> [test.cpp:7:40]: (error) Same iterator is used with containers 'l1' that are temporaries or defined in different scopes. [iterators3]\n",
             errout_str());
@@ -1767,7 +1767,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        ++it1;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:36]: (error) Iterators of different containers 'l2' and 'l1' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -1787,7 +1787,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        ++it1;\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:13] -> [test.cpp:10] -> [test.cpp:11]: (error) Comparison of iterators from containers 'l1' and 'l2'.\n", "", errout_str());
 
     }
@@ -1805,7 +1805,7 @@ class TestStl : public TestFixture {
               "    if (it2 != it1)\n"
               "    {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n"
                       "[test.cpp:6:36]: (error) Iterators of different containers 'l2' and 'l1' are used together. [mismatchingContainers]\n",
                       errout_str());
@@ -1819,7 +1819,7 @@ class TestStl : public TestFixture {
               "    if (it1 != it2 && it1 != it2)\n"
               "    {\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n"
                       "[test.cpp:5:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n", // duplicate
                       errout_str());
@@ -1830,7 +1830,7 @@ class TestStl : public TestFixture {
               "    std::list<int> &l = x.l;\n"
               "    std::list<int>::iterator it = l.find(123);\n"
               "    x.l.erase(it);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1845,7 +1845,7 @@ class TestStl : public TestFixture {
               "};\n"
               "bool A::B::operator==(const A::B& b) const {\n"
               "    return std::tie(x, y, z) == std::tie(b.x, b.y, b.z);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1853,29 +1853,29 @@ class TestStl : public TestFixture {
         // #9556
         check("void f(int a, int b) {\n"
               "  if (&a == &b) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int a, int b) {\n"
               "  if (std::for_each(&a, &b + 1, [](auto) {})) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (error) Iterators of different containers 'a' and 'b' are used together. [mismatchingContainers]\n",
                       errout_str());
 
         check("void f(int a, int b) {\n"
               "  if (std::for_each(&a, &b, [](auto) {})) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (error) Iterators of different containers 'a' and 'b' are used together. [mismatchingContainers]\n",
                       errout_str());
 
         check("void f(int a) {\n"
               "  if (std::for_each(&a, &a, [](auto) {})) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:21]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
 
         check("void f(int a) {\n"
               "  if (std::for_each(&a, &a + 1, [](auto) {})) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1888,7 +1888,7 @@ class TestStl : public TestFixture {
               "    bool operator()(const S& lhs, const S& rhs) const {\n"
               "        return &lhs.v != &rhs.v;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2016,7 +2016,7 @@ class TestStl : public TestFixture {
               "std::vector<int>& g();\n"
               "void foo() {\n"
               "    (void)std::find(f().begin(), g().end(), 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:22]: (error) Iterators of different containers 'f()' and 'g()' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -2024,7 +2024,7 @@ class TestStl : public TestFixture {
               "std::vector<int>& g();\n"
               "void foo() {\n"
               "    if(f().begin() == g().end()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Iterators of different containers 'f()' and 'g()' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -2032,7 +2032,7 @@ class TestStl : public TestFixture {
               "std::vector<int>& g();\n"
               "void foo() {\n"
               "    auto size = f().end() - g().begin();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (error) Iterators of different containers 'f()' and 'g()' are used together. [mismatchingContainers]\n",
                       errout_str());
 
@@ -2042,7 +2042,7 @@ class TestStl : public TestFixture {
               "};\n"
               "void foo() {\n"
               "    (void)std::find(A().f().begin(), A().g().end(), 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:6:26]: (error) Iterators of different containers 'A().f()' and 'A().g()' are used together. [mismatchingContainers]\n",
             errout_str());
@@ -2053,7 +2053,7 @@ class TestStl : public TestFixture {
               "};\n"
               "void foo() {\n"
               "    (void)std::find(A{} .f().begin(), A{} .g().end(), 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:6:27]: (error) Iterators of different containers 'A{}.f()' and 'A{}.g()' are used together. [mismatchingContainers]\n",
             errout_str());
@@ -2062,7 +2062,7 @@ class TestStl : public TestFixture {
               "std::vector<int>& g();\n"
               "void foo() {\n"
               "    (void)std::find(begin(f()), end(g()), 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:28]: (warning) Iterators to containers from different expressions 'f()' and 'g()' are used together. [mismatchingContainerExpression]\n", errout_str());
 
         check("struct A {\n"
@@ -2071,14 +2071,14 @@ class TestStl : public TestFixture {
               "};\n"
               "void foo() {\n"
               "    (void)std::find(A().f().begin(), A().f().end(), 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int>& f();\n"
               "std::vector<int>& g();\n"
               "void foo() {\n"
               "    if(bar(f().begin()) == g().end()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int>& f();\n"
@@ -2102,7 +2102,7 @@ class TestStl : public TestFixture {
               "    (void)std::find(begin(f()) + 1, end(f()), 0);\n"
               "    (void)std::find(begin(f()), end(f()) - 1, 0);\n"
               "    (void)std::find(begin(f()) + 1, end(f()) - 1, 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:30]: (error) Dereference of an invalid iterator: f().end()+1 [derefInvalidIterator]\n", errout_str());
 
         check("std::vector<int>& f();\n"
@@ -2111,7 +2111,7 @@ class TestStl : public TestFixture {
               "    if(f().begin() == f().end()+1) {}\n"
               "    if(f().begin()+1 == f().end()) {}\n"
               "    if(f().begin()+1 == f().end()+1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:32]: (error) Dereference of an invalid iterator: f().end()+1 [derefInvalidIterator]\n"
                       "[test.cpp:6:34]: (error) Dereference of an invalid iterator: f().end()+1 [derefInvalidIterator]\n",
                       errout_str());
@@ -2122,7 +2122,7 @@ class TestStl : public TestFixture {
               "    if(std::begin(f()) == std::end(f())+1) {}\n"
               "    if(std::begin(f())+1 == std::end(f())) {}\n"
               "    if(std::begin(f())+1 == std::end(f())+1) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:40]: (error) Dereference of an invalid iterator: std::end(f())+1 [derefInvalidIterator]\n"
                       "[test.cpp:6:42]: (error) Dereference of an invalid iterator: std::end(f())+1 [derefInvalidIterator]\n",
                       errout_str());
@@ -2131,23 +2131,23 @@ class TestStl : public TestFixture {
               "std::vector<int>& f();\n"
               "void foo() {\n"
               "    if(f<1>().begin() == f<1>().end()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  if (a.begin().x == b.begin().x) {}\n"
               "  if (begin(a).x == begin(b).x) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::list<int*> a, std::list<int*> b) {\n"
               "  if (*a.begin() == *b.begin()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if(f().begin(1) == f().end()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(const uint8_t* data, const uint32_t dataLength) {\n"
@@ -2177,35 +2177,35 @@ class TestStl : public TestFixture {
     void iteratorSameExpression() {
         check("void f(std::vector<int> v) {\n"
               "    std::for_each(v.begin(), v.begin(), [](int){});\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:26]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
 
         check("std::vector<int>& g();\n"
               "void f() {\n"
               "    std::for_each(g().begin(), g().begin(), [](int){});\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:28]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
 
         check("void f(std::vector<int> v) {\n"
               "    std::for_each(v.end(), v.end(), [](int){});\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:24]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
 
         check("std::vector<int>& g();\n"
               "void f() {\n"
               "    std::for_each(g().end(), g().end(), [](int){});\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:26]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
 
         check("std::vector<int>::iterator g();\n"
               "void f(std::vector<int> v) {\n"
               "    std::for_each(g(), g(), [](int){});\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:20]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
 
         check("void f(std::vector<int>::iterator it) {\n"
               "    std::for_each(it, it, [](int){});\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:19]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
     }
 
@@ -2214,13 +2214,13 @@ class TestStl : public TestFixture {
               "    std::vector<int> a, b;\n"
               "    a.insert(b.end(), value);\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Iterator 'b.end()' referring to container 'b' is used with container 'a'. [mismatchingContainerIterator]\n", errout_str());
 
         check("std::vector<int> f(std::vector<int> a, std::vector<int> b) {\n"
               "    a.erase(b.begin());\n"
               "    return a;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (error) Iterator 'b.begin()' referring to container 'b' is used with container 'a'. [mismatchingContainerIterator]\n", errout_str());
 
         // #9973
@@ -2824,7 +2824,7 @@ class TestStl : public TestFixture {
               "    iter = ints.begin() + 2;\n"
               "    ints.erase(iter);\n"
               "    std::cout << (*iter) << std::endl;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         TODO_ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:6] -> [test.cpp:3] -> [test.cpp:7]: (error) Using iterator to local container 'ints' that may be invalid.\n", "[test.cpp:5:22] -> [test.cpp:6:10] -> [test.cpp:3:22] -> [test.cpp:7:20]: (error, inconclusive) Using iterator to local container 'ints' that may be invalid. [invalidContainer]\n", errout_str());
 
         // #6554 "False positive eraseDereference - erase in while() loop"
@@ -2836,7 +2836,7 @@ class TestStl : public TestFixture {
               "        waitingPackets.erase(wpi);\n"
               "        for (unsigned pos = 0; pos < buf.size(); ) {     }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8509 Uniform initialization ignored for iterator
@@ -2844,7 +2844,7 @@ class TestStl : public TestFixture {
               "  std::vector<int> ints;\n"
               "  std::vector<int>::const_iterator iter {ints.cbegin()};\n"
               "  std::cout << (*iter) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2861,7 +2861,7 @@ class TestStl : public TestFixture {
               "            break;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2873,7 +2873,7 @@ class TestStl : public TestFixture {
               "    iter = ints.begin();\n"
               "    ints.erase(iter);\n"
               "    std::cout << iter->first << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:18] -> [test.cpp:6:5]: (error) Iterator 'iter' used after element has been erased. [eraseDereference]\n"
                       "[test.cpp:6:10]: (error) Calling function 'erase()' on the iterator 'iter' which is out of bounds. [eraseIteratorOutOfBounds]\n",
                       errout_str());
@@ -2886,7 +2886,7 @@ class TestStl : public TestFixture {
               "    iter = ints.rbegin();\n"
               "    ints.erase(iter);\n"
               "    std::cout << iter->first << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:18] -> [test.cpp:6:5]: (error) Iterator 'iter' used after element has been erased. [eraseDereference]\n"
                       "[test.cpp:6:10]: (error) Calling function 'erase()' on the iterator 'iter' which is out of bounds. [eraseIteratorOutOfBounds]\n",
                       errout_str());
@@ -2899,14 +2899,14 @@ class TestStl : public TestFixture {
               "    auto iter = ints.begin() + 2;\n"
               "    ints.erase(iter);\n"
               "    std::cout << (*iter) << std::endl;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         TODO_ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:5] -> [test.cpp:3] -> [test.cpp:6]: (error) Using iterator to local container 'ints' that may be invalid.\n", "[test.cpp:4:27] -> [test.cpp:5:10] -> [test.cpp:3:22] -> [test.cpp:6:20]: (error, inconclusive) Using iterator to local container 'ints' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("void f() {\n"
               "    auto x = *myList.begin();\n"
               "    myList.erase(x);\n"
               "    auto b = x.first;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("const CXXRecordDecl *CXXRecordDecl::getTemplateInstantiationPattern() const {\n"
@@ -2914,7 +2914,7 @@ class TestStl : public TestFixture {
               "        auto From = TD->getInstantiatedFrom();\n"
               "    }\n"
               "    return nullptr;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2926,7 +2926,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "       foo[ii] = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:6:11]: (error) Out of bounds access in expression 'foo[ii]' because 'foo' is empty. [containerOutOfBounds]\n",
             errout_str());
@@ -2935,21 +2935,21 @@ class TestStl : public TestFixture {
               "    for (unsigned int ii = 0; ii <= foo.size(); ++ii) {\n"
               "       foo.at(ii) = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (error) When ii==foo.size(), foo.at(ii) is out of bounds. [stlOutOfBounds]\n", errout_str());
 
         check("void foo(std::string& foo) {\n"
               "    for (unsigned int ii = 0; ii <= foo.length(); ++ii) {\n"
               "       foo[ii] = 'x';\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (error) When ii==foo.size(), foo[ii] is out of bounds. [stlOutOfBounds]\n", errout_str());
 
         check("void foo(std::string& foo, unsigned int ii) {\n"
               "    if (ii <= foo.length()) {\n"
               "       foo[ii] = 'x';\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (error) When ii==foo.size(), foo[ii] is out of bounds. [stlOutOfBounds]\n", errout_str());
 
         check("void foo(std::string& foo, unsigned int ii) {\n"
@@ -2957,7 +2957,7 @@ class TestStl : public TestFixture {
               "       foo[ii] = 'x';\n"
               "       ++i;\n"
               "    } while(ii <= foo.length());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (error) When ii==foo.size(), foo[ii] is out of bounds. [stlOutOfBounds]\n", errout_str());
 
         check("void foo(std::string& foo, unsigned int ii) {\n"
@@ -2965,7 +2965,7 @@ class TestStl : public TestFixture {
               "    } else if (ii <= foo.length()) {\n"
               "       foo[ii] = 'x';\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (error) When ii==foo.size(), foo[ii] is out of bounds. [stlOutOfBounds]\n", errout_str());
 
         check("void foo()\n"
@@ -2977,19 +2977,19 @@ class TestStl : public TestFixture {
               "    }\n"
               "    int ii = 0;\n"
               "    foo[ii] = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    for (B b : D()) {}\n" // Don't crash on range-based for-loop
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(std::vector<int> foo) {\n"
               "    for (unsigned int ii = 0; ii <= foo.size() + 1; ++ii) {\n"
               "       foo.at(ii) = 0;\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3:11]: (error) When ii==foo.size(), foo.at(ii) is out of bounds. [stlOutOfBounds]\n", "", errout_str());
     }
 
@@ -3002,7 +3002,7 @@ class TestStl : public TestFixture {
                   "    {\n"
                   "       foo[ii] = 0;\n"
                   "    }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("", errout_str());
         }
 
@@ -3013,7 +3013,7 @@ class TestStl : public TestFixture {
                   "    for (unsigned int ii = 0; ii <= foo.size(); ++ii)\n"
                   "    {\n"
                   "    }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("", errout_str());
         }
 
@@ -3031,7 +3031,7 @@ class TestStl : public TestFixture {
                   "            foo[ii] = 0;\n"
                   "        }\n"
                   "    }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS(
                 "[test.cpp:11:16]: (error) Out of bounds access in expression 'foo[ii]' because 'foo' is empty. [containerOutOfBounds]\n",
                 errout_str());
@@ -3042,7 +3042,7 @@ class TestStl : public TestFixture {
                   "    int i = x;"
                   "    for (int i = 5; i <= data.size(); i++)\n"
                   "        data[i] = 0;\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("", errout_str());
         }
 
@@ -3051,7 +3051,7 @@ class TestStl : public TestFixture {
                   "    for (unsigned int ii = 0; ii <= foo.size() - 1; ++ii) {\n"
                   "       foo.at(ii) = 0;\n"
                   "    }\n"
-                  "}");
+                  "}\n");
             ASSERT_EQUALS("", errout_str());
         }
     }
@@ -3059,7 +3059,7 @@ class TestStl : public TestFixture {
     void negativeIndex() {
         check("void f(const std::vector<int> &v) {\n"
               "  v[-11] = 123;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: (error) Array index -11 is out of bounds. [negativeContainerIndex]\n", errout_str());
 
         check("int f(int x, const std::vector<int>& a) {\n"
@@ -3067,7 +3067,7 @@ class TestStl : public TestFixture {
               "        return a[x - 5];\n"
               "    else\n"
               "        return a[4 - x];\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::array<int,6> values;\n"
@@ -3147,7 +3147,7 @@ class TestStl : public TestFixture {
               "    for (it = foo.begin(); it != foo.end(); ++it) {\n"
               "        foo.erase(it);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:5:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n"
                       "[test.cpp:7:5] -> [test.cpp:8:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
@@ -3156,7 +3156,7 @@ class TestStl : public TestFixture {
               "    std::list<int>::iterator i = ints.begin();\n"
               "    i = ints.erase(i);\n"
               "    *i = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -3164,7 +3164,7 @@ class TestStl : public TestFixture {
               "    std::list<int>::iterator i;\n"
               "    while (i != x.y.end())\n"
               "        i = x.y.erase(i);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #2101
@@ -3175,7 +3175,7 @@ class TestStl : public TestFixture {
               "        if (*it % 2)\n"
               "            it = ints[i].erase(it);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3188,7 +3188,7 @@ class TestStl : public TestFixture {
               "        next++;\n"
               "        foo.erase(it);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3198,7 +3198,7 @@ class TestStl : public TestFixture {
               "    std::list<abc>::iterator it = foo.begin();\n"
               "    foo.erase(it->a);\n"
               "    if (it->b);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3210,7 +3210,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        foo.erase(it);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:6:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
         check("void f()\n"
@@ -3220,7 +3220,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        foo.erase(it);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:6:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
         check("void f()\n"
@@ -3230,7 +3230,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        foo.erase(it);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:6:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
         check("void f()\n"
@@ -3240,7 +3240,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        foo.erase(++it);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:6:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
     }
 
@@ -3254,7 +3254,7 @@ class TestStl : public TestFixture {
               "        if (*it == 123)\n"
               "            foo.erase(it);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:5] -> [test.cpp:8:22]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
     }
 
@@ -3267,7 +3267,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        vec.erase(it);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3280,7 +3280,7 @@ class TestStl : public TestFixture {
               "        if (x)"
               "            break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:5:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
         check("void f()\n"
@@ -3292,7 +3292,7 @@ class TestStl : public TestFixture {
               "            break;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int x)\n"
@@ -3303,7 +3303,7 @@ class TestStl : public TestFixture {
               "        if (x)"
               "            return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:5:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
     }
@@ -3320,7 +3320,7 @@ class TestStl : public TestFixture {
               "            continue;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::map<uint32, uint32> my_map) {\n" // #7365
@@ -3333,7 +3333,7 @@ class TestStl : public TestFixture {
               "    itr->second = 1;\n"
               "    break;\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3347,7 +3347,7 @@ class TestStl : public TestFixture {
               "        foo.erase(it);\n"
               "        return;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3367,7 +3367,7 @@ class TestStl : public TestFixture {
               "            return;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3386,7 +3386,7 @@ class TestStl : public TestFixture {
               "            return;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -3402,7 +3402,7 @@ class TestStl : public TestFixture {
               "                *it = 0;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS(
             "[test.cpp:5] -> [test.cpp:7] -> [test.cpp:8] -> [test.cpp:8] -> [test.cpp:7] -> [test.cpp:5] -> [test.cpp:9] -> [test.cpp:3] -> [test.cpp:5]: (error) Using iterator to local container 'foo' that may be invalid.\n",
             "[test.cpp:5:24] -> [test.cpp:7:13] -> [test.cpp:8:17] -> [test.cpp:8:17] -> [test.cpp:7:13] -> [test.cpp:5:31] -> [test.cpp:9:21] -> [test.cpp:3:22] -> [test.cpp:5:28]: (error, inconclusive) Using iterator to local container 'foo' that may be invalid. [invalidContainer]\n",
@@ -3418,7 +3418,7 @@ class TestStl : public TestFixture {
               "        goto abc;\n"
               "    }\n"
               "bar:\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3430,7 +3430,7 @@ class TestStl : public TestFixture {
               "        foo.erase(it);\n"
               "        it = foo.begin();\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3448,7 +3448,7 @@ class TestStl : public TestFixture {
               "            ++it;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3457,7 +3457,7 @@ class TestStl : public TestFixture {
               "    std::list<std::list<int> >::const_iterator i = l.begin();\n"
               "    std::list<int>::const_iterator j = (*i).begin();\n"
               "    cout << *j << endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3466,14 +3466,14 @@ class TestStl : public TestFixture {
               "  std::list<int>::const_iterator it = data.begin();\n"
               "  it = data.erase(it);\n"
               "  it = data.erase(it);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(Data data) {\n"
               "  std::list<int>::const_iterator it = data.ints.begin();\n"
               "  it = data.ints.erase(it);\n"
               "  it = data.ints.erase(it);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3482,7 +3482,7 @@ class TestStl : public TestFixture {
               "    std::list<foo>::const_iterator i;\n"
               "    bar(i);\n"
               "    cout << *i;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3493,7 +3493,7 @@ class TestStl : public TestFixture {
               "    iter = ints.begin() + 2;\n"
               "    ints.erase(iter);\n"
               "    ints.erase(iter);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         TODO_ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:4] -> [test.cpp:5] -> [test.cpp:1] -> [test.cpp:6]: (error) Using iterator to local container 'ints' that may be invalid.\n", "[test.cpp:1:31] -> [test.cpp:4:22] -> [test.cpp:5:10] -> [test.cpp:1:27] -> [test.cpp:6:16]: (error, inconclusive) Using iterator to local container 'ints' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
@@ -3505,21 +3505,21 @@ class TestStl : public TestFixture {
               "    {\n"
               "        foo.erase(*it);\n"
               "    }\n"
-              "}");
+              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Iterator 'it' becomes invalid when deleted by value from 'foo'\n", "", errout_str());
 
         check("int f(std::set<int> foo) {\n"
               "    std::set<int>::iterator it = foo.begin();\n"
               "    foo.erase(*it);\n"
               "    return *it;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12] -> [test.cpp:3:5]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
         check("void f(std::set<int> foo)\n"
               "{\n"
               "    std::set<int>::iterator it = foo.begin();\n"
               "    foo.erase(*it);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5669
@@ -3527,14 +3527,14 @@ class TestStl : public TestFixture {
               "    HashSet_Ref::iterator aIt = m_ImplementationMap.find( xEle );\n"
               "    m_SetLoadedFactories.erase(*aIt);\n"
               "    m_SetLoadedFactories.erase(aIt);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::list<int>& m_ImplementationMap) {\n"
               "    std::list<int>::iterator aIt = m_ImplementationMap.begin();\n"
               "    m_ImplementationMap.erase(*aIt);\n"
               "    m_ImplementationMap.erase(aIt);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Invalid iterator: aIt [invalidIterator1]\n", errout_str());
 
         check("void f(const std::list<int>& m_ImplementationMap) {\n"
@@ -3542,7 +3542,7 @@ class TestStl : public TestFixture {
               "    std::list<int>::iterator bIt = m_ImplementationMap.begin();\n"
               "    m_ImplementationMap.erase(*bIt);\n"
               "    m_ImplementationMap.erase(aIt);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3556,7 +3556,7 @@ class TestStl : public TestFixture {
               "                 return;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5] -> [test.cpp:4:26]: (error) Iterator 'str' used after element has been erased. [eraseDereference]\n", errout_str());
     }
 
@@ -3565,7 +3565,7 @@ class TestStl : public TestFixture {
               "    std::vector<int>::iterator aIt = v.begin();\n"
               "    v.erase(something(unknown));\n" // All iterators become invalidated when erasing from std::vector
               "    v.erase(aIt);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:27] -> [test.cpp:2:45] -> [test.cpp:3:7] -> [test.cpp:1:26] -> [test.cpp:4:13]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("void f(std::vector<int>& v) {\n"
@@ -3573,7 +3573,7 @@ class TestStl : public TestFixture {
               "    std::vector<int>::iterator bIt = v.begin();\n"
               "    v.erase(bIt);\n" // All iterators become invalidated when erasing from std::vector
               "    aIt = v.erase(aIt);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:27] -> [test.cpp:2:45] -> [test.cpp:4:7] -> [test.cpp:1:26] -> [test.cpp:5:19]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
@@ -3583,7 +3583,7 @@ class TestStl : public TestFixture {
               "    std::vector<int>::const_iterator it = foo.begin();\n"
               "    foo.push_back(123);\n"
               "    *it;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:35] -> [test.cpp:3:52] -> [test.cpp:4:9] -> [test.cpp:1:32] -> [test.cpp:5:6]: (error) Using iterator to local container 'foo' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
@@ -3596,7 +3596,7 @@ class TestStl : public TestFixture {
               "        int *it = &foo[0];\n"
               "        *it = 456;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3610,7 +3610,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        foo.push_back(123);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:24] -> [test.cpp:6:31] -> [test.cpp:8:13] -> [test.cpp:3:22] -> [test.cpp:6:28]: (error) Using iterator to local container 'foo' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
@@ -3622,7 +3622,7 @@ class TestStl : public TestFixture {
               "    int *first = &ints[0];\n"
               "    ints.push_back(2);\n"
               "    *first;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:18] -> [test.cpp:6:10] -> [test.cpp:3:22] -> [test.cpp:7:6]: (error) Using pointer to local variable 'ints' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
@@ -3639,7 +3639,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        v.push_back(*i);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3655,7 +3655,7 @@ class TestStl : public TestFixture {
               "        if (*it == 1)\n"
               "            v.push_back(10);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:49] -> [test.cpp:8:17] -> [test.cpp:8:17] -> [test.cpp:6:56] -> [test.cpp:9:15] -> [test.cpp:3:22] -> [test.cpp:6:53]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("void f()\n"
@@ -3668,7 +3668,7 @@ class TestStl : public TestFixture {
               "        if (*it == 1)\n"
               "            v.push_back(10);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:49] -> [test.cpp:8:17] -> [test.cpp:8:17] -> [test.cpp:6:56] -> [test.cpp:9:15] -> [test.cpp:3:22] -> [test.cpp:6:53]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
@@ -3682,7 +3682,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        foo.push_back(123);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:24] -> [test.cpp:6:31] -> [test.cpp:8:13] -> [test.cpp:3:22] -> [test.cpp:6:28]: (error) Using iterator to local container 'foo' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
@@ -3698,7 +3698,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        sum += *it;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:13]: (style) Consider using std::accumulate algorithm instead of a raw loop. [useStlAlgorithm]\n"
                       "[test.cpp:4:52] -> [test.cpp:5:10] -> [test.cpp:3:22] -> [test.cpp:8:35]: (error) Using iterator to local container 'ints' that may be invalid. [invalidContainer]\n",
                       errout_str());
@@ -3720,7 +3720,7 @@ class TestStl : public TestFixture {
               "        a.ints.push_back(*i);\n"
               "        ++i;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3730,7 +3730,7 @@ class TestStl : public TestFixture {
               "    std::vector<int>::const_iterator it = foo.begin();\n"
               "    foo.reserve(100);\n"
               "    *it = 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:29] -> [test.cpp:3:52] -> [test.cpp:4:9] -> [test.cpp:1:26] -> [test.cpp:5:6]: (error) Using iterator to local container 'foo' that may be invalid. [invalidContainer]\n", errout_str());
 
         // in loop
@@ -3743,7 +3743,7 @@ class TestStl : public TestFixture {
               "    {\n"
               "        foo.reserve(123);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:24] -> [test.cpp:6:31] -> [test.cpp:8:13] -> [test.cpp:3:22] -> [test.cpp:6:28]: (error) Using iterator to local container 'foo' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
@@ -3757,7 +3757,7 @@ class TestStl : public TestFixture {
               "    } else {\n"
               "        ints.insert(it,0);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3773,7 +3773,7 @@ class TestStl : public TestFixture {
               "        {}\n"
               "        *it;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:54] -> [test.cpp:6:13] -> [test.cpp:3:25] -> [test.cpp:9:10]: (error, inconclusive) Using iterator to local container 'vec' that may be invalid. [invalidContainer]\n",
             errout_str());
@@ -3785,7 +3785,7 @@ class TestStl : public TestFixture {
               "    FilenameBuffer.resize(PreAppendSize + CurTok.getLength());\n"
               "    const char *BufPtr = &FilenameBuffer[PreAppendSize];\n"
               "    return true;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3795,7 +3795,7 @@ class TestStl : public TestFixture {
               "    std::vector<int>::iterator iter = ints.begin() + 5;\n"
               "    ints.insert(ints.begin(), 1);\n"
               "    ++iter;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:30] -> [test.cpp:3:49] -> [test.cpp:4:10] -> [test.cpp:1:26] -> [test.cpp:5:7]: (error) Using iterator to local container 'ints' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("void f()\n"
@@ -3803,7 +3803,7 @@ class TestStl : public TestFixture {
               "    std::vector<int> ints;\n"
               "    std::vector<int>::iterator iter = ints.begin();\n"
               "    ints.insert(iter, 1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -3812,7 +3812,7 @@ class TestStl : public TestFixture {
               "    std::vector<int>::iterator iter = ints.begin();\n"
               "    ints.insert(iter, 1);\n"
               "    ints.insert(iter, 2);\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         TODO_ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:5] -> [test.cpp:3] -> [test.cpp:6]: (error) Using iterator to local container 'ints' that may be invalid.\n", "[test.cpp:4:49] -> [test.cpp:5:10] -> [test.cpp:3:22] -> [test.cpp:6:17]: (error, inconclusive) Using iterator to local container 'ints' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("void* f(const std::vector<Bar>& bars) {\n"
@@ -3820,21 +3820,21 @@ class TestStl : public TestFixture {
               "    bars.insert(Bar());\n"
               "    void* v = &i->foo;\n"
               "    return v;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:37] -> [test.cpp:2:46] -> [test.cpp:3:10] -> [test.cpp:1:33] -> [test.cpp:4:16]: (error) Using iterator to local container 'bars' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("Foo f(const std::vector<Bar>& bars) {\n"
               "    std::vector<Bar>::iterator i = bars.begin();\n"
               "    bars.insert(Bar());\n"
               "    return i->foo;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:35] -> [test.cpp:2:46] -> [test.cpp:3:10] -> [test.cpp:1:31] -> [test.cpp:4:12]: (error) Using iterator to local container 'bars' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("void f(const std::vector<Bar>& bars) {\n"
               "    for(std::vector<Bar>::iterator i = bars.begin(); i != bars.end(); ++i) {\n"
               "        i = bars.insert(i, bar);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // TODO: This shouldn't be inconclusive
@@ -3843,7 +3843,7 @@ class TestStl : public TestFixture {
               "        bars.insert(i, bar);\n"
               "        i = bars.insert(i, bar);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:36] -> [test.cpp:2:50] -> [test.cpp:3:14] -> [test.cpp:1:32] -> [test.cpp:4:25]: (error, inconclusive) Using iterator to local container 'bars' that may be invalid. [invalidContainer]\n", errout_str());
 
         // TODO: This shouldn't be inconclusive
@@ -3853,7 +3853,7 @@ class TestStl : public TestFixture {
               "    i = bars.insert(i, Bar());\n"
               "    void* v = &i->foo;\n"
               "    return v;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:37] -> [test.cpp:2:46] -> [test.cpp:3:10] -> [test.cpp:1:33] -> [test.cpp:4:21]: (error, inconclusive) Using iterator to local container 'bars' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
@@ -3865,7 +3865,7 @@ class TestStl : public TestFixture {
               "        vec.insert(iter, 0);\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::vector<int> &vec) {\n"
@@ -3876,7 +3876,7 @@ class TestStl : public TestFixture {
               "            return;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3916,7 +3916,7 @@ class TestStl : public TestFixture {
                   "    std::" + stlCont[i] + "<int>::iterator it;\n"
                   "    for (it = ab.begin(); it < ab.end(); ++it)\n"
                   "        ;\n"
-                  "}");
+                  "}\n");
 
             ASSERT_EQUALS_MSG("[test.cpp:4:25]: (error) Dangerous comparison using operator< on iterator. [stlBoundaries]\n", errout_str(), stlCont[i]);
         }
@@ -3924,14 +3924,14 @@ class TestStl : public TestFixture {
         check("void f() {\n"
               "    std::forward_list<int>::iterator it;\n"
               "    for (it = ab.begin(); ab.end() > it; ++it) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:36]: (error) Dangerous comparison using operator< on iterator. [stlBoundaries]\n", errout_str());
 
         // #5926 no FP Dangerous comparison using operator< on iterator on std::deque
         check("void f() {\n"
               "    std::deque<int>::iterator it;\n"
               "    for (it = ab.begin(); ab.end() > it; ++it) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3942,7 +3942,7 @@ class TestStl : public TestFixture {
               "    std::vector<std::string>::const_iterator it;\n"
               "    for (it = files.begin(); it < files.end(); it++) { }\n"
               "    for (it = files.begin(); it < files.end(); it++) { };\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3956,14 +3956,14 @@ class TestStl : public TestFixture {
               "    {\n"
               "       assert(*current < 100)\n"
               "    }\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
         check("bool f() {\n"
               "    static set<Foo>::const_iterator current;\n"
               "    return 25 > current->bar;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (error) Invalid iterator 'current' used. [eraseDereference]\n", errout_str());
     }
 
@@ -3972,13 +3972,13 @@ class TestStl : public TestFixture {
         check("void f() {\n"
               "    std::forward_list<std::vector<std::vector<int>>>::iterator it;\n"
               "    for (it = ab.begin(); ab.end() > it; ++it) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:36]: (error) Dangerous comparison using operator< on iterator. [stlBoundaries]\n", errout_str());
 
         // don't crash
         check("void f() {\n"
               "    if (list < 0) ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -3986,7 +3986,7 @@ class TestStl : public TestFixture {
               "        std::forward_list<std::vector<std::vector<int>>>::iterator it;\n"
               "        for (it = ab.begin(); ab.end() > it; ++it) {}\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:40]: (error) Dangerous comparison using operator< on iterator. [stlBoundaries]\n", errout_str());
     }
 
@@ -3995,7 +3995,7 @@ class TestStl : public TestFixture {
               "int foo() {\n"
               "    iterator i;\n"
               "    return i.foo();;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
         check("class iterator {\n"
@@ -4006,7 +4006,7 @@ class TestStl : public TestFixture {
               "int foo() {\n"
               "    iterator i;\n"
               "    return i.foo();;\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:8:12]: (error, inconclusive) Invalid iterator 'i' used. [eraseDereference]\n", errout_str());
     }
 
@@ -4017,7 +4017,7 @@ class TestStl : public TestFixture {
               "        {\n"
               "        }\n"
               "    }\n"
-              "}", dinit(CheckOptions, $.inconclusive = true));
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4031,109 +4031,109 @@ class TestStl : public TestFixture {
         check("void f(std::set<int> s)\n"
               "{\n"
               "    if (s.find(12)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (pointer)
         check("void f(std::set<int> *s)\n"
               "{\n"
               "    if ((*s).find(12)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (pointer)
         check("void f(std::set<int> *s)\n"
               "{\n"
               "    if (s->find(12)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (array-like pointer)
         check("void f(std::set<int> *s)\n"
               "{\n"
               "    if (s[0].find(12)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (array)
         check("void f(std::set<int> s [10])\n"
               "{\n"
               "    if (s[0].find(12)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (undefined length array)
         check("void f(std::set<int> s [])\n"
               "{\n"
               "    if (s[0].find(12)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (vector)
         check("void f(std::vector<std::set<int> > s)\n"
               "{\n"
               "    if (s[0].find(12)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (assignment)
         check("void f(std::set<int> s)\n"
               "{\n"
               "    if (a || (x = s.find(12))) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // ok (simple)
         check("void f(std::set<int> s)\n"
               "{\n"
               "    if (s.find(123) != s.end()) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ok (pointer)
         check("void f(std::set<int> *s)\n"
               "{\n"
               "    if ((*s).find(12) != s.end()) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ok (array-like pointer)
         check("void f(std::set<int> *s)\n"
               "{\n"
               "    if (s[0].find(12) != s->end()) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ok (array)
         check("void f(std::set<int> s [10])\n"
               "{\n"
               "    if (s[0].find(123) != s->end()) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ok (undefined length array)
         check("void f(std::set<int> s [])\n"
               "{\n"
               "    if (s[0].find(123) != s->end()) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ok (assignment)
         check("void f(std::set<int> s)\n"
               "{\n"
               "    if (a || (x = s.find(12)) != s.end()) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ok (dereference, #6402)
         check("void f(std::set<Foo> s) {\n"
               "    if (s.find(12).member) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::set<int> s) {\n"
               "    if (auto result = s.find(123); result != s.end()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ---------------------------
@@ -4144,33 +4144,33 @@ class TestStl : public TestFixture {
         check("void f()\n"
               "{\n"
               "    if (std::find(a,b,c)) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // ok
         check("void f()\n"
               "{\n"
               "    if (std::find(a,b,c) != c) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ok (less than comparison, #6217)
         check("void f(std::vector<int> s)\n"
               "{\n"
               "    if (std::find(a, b, c) < d) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3714 - segmentation fault for syntax error
         ASSERT_THROW_INTERNAL(check("void f() {\n"
                                     "    if (()) { }\n"
-                                    "}"),
+                                    "}\n"),
                               AST);
 
         // #3865
         check("void f() {\n"
               "    if ((std::find(a,b,c)) != b) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4179,57 +4179,57 @@ class TestStl : public TestFixture {
         check("void f(const std::string &s)\n"
               "{\n"
               "    if (s.find(\"abc\")) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster. [stlIfStrFind]\n", errout_str());
 
         // error (pointer)
         check("void f(const std::string *s)\n"
               "{\n"
               "    if ((*s).find(\"abc\")) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster. [stlIfStrFind]\n", errout_str());
 
         // error (pointer)
         check("void f(const std::string *s)\n"
               "{\n"
               "    if (s->find(\"abc\")) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster. [stlIfStrFind]\n", errout_str());
 
         // error (vector)
         check("void f(const std::vector<std::string> &s)\n"
               "{\n"
               "    if (s[0].find(\"abc\")) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster. [stlIfStrFind]\n", errout_str());
 
         // #3162
         check("void f(const std::string& s1, const std::string& s2)\n"
               "{\n"
               "    if ((!s1.empty()) && (0 == s1.find(s2))) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:32]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster. [stlIfStrFind]\n", errout_str());
 
         // #4102
         check("void f(const std::string &define) {\n"
               "    if (define.find(\"=\") + 1U == define.size());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::string a, std::string b) {\n"  // #4480
               "    if (a.find(\"<\") < b.find(\">\")) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::string &s) {\n"
               "    if (foo(s.find(\"abc\"))) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7349 - std::string::find_first_of
         check("void f(const std::string &s) {\n"
               "    if (s.find_first_of(\"abc\")==0) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // # 10153
@@ -4240,7 +4240,7 @@ class TestStl : public TestFixture {
               "      return 1;\n"
               "  }\n"
               "  return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4254,7 +4254,7 @@ class TestStl : public TestFixture {
                                 "void Fred::foo()\n"
                                 "{\n"
                                 "    if (x.size() == 0) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:7:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4266,7 +4266,7 @@ class TestStl : public TestFixture {
                                 "void f()\n"
                                 "{\n"
                                 "    if (x.size() == 0) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4278,7 +4278,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    if (x.size() == 0) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4290,7 +4290,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    if (0 == x.size()) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4302,7 +4302,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    if (x.size() != 0) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4314,7 +4314,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    if (0 != x.size()) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4326,7 +4326,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    if (x.size() > 0) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4338,7 +4338,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    if (0 < x.size()) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:13]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4350,7 +4350,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    if (x.size() >= 1) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4362,7 +4362,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    if (x.size() < 1) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4374,7 +4374,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    if (1 <= x.size()) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4386,7 +4386,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    if (1 > x.size()) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:13]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4398,7 +4398,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    if (x.size()) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4410,7 +4410,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    if (!x.size()) {}\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:10]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4421,7 +4421,7 @@ class TestStl : public TestFixture {
               "{\n"
               "    std::list<int> x;\n"
               "    fun(x.size());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         {
@@ -4429,7 +4429,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    fun(!x.size());\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:10]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4441,7 +4441,7 @@ class TestStl : public TestFixture {
                                 "{\n"
                                 "    std::list<int> x;\n"
                                 "    fun(a && x.size());\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS("[test.cpp:4:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
             check(code);
@@ -4451,19 +4451,19 @@ class TestStl : public TestFixture {
         check("void f() {\n" // #4039
               "    std::list<int> x;\n"
               "    fun(width % x.size() != 0);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4584
         check("void f() {\n"
               "    std::list<int> x;\n"
               "    if (foo + 1 > x.size()) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         check("void f() {\n"
               "    std::list<int> x;\n"
               "    if (x.size() < 1 + foo) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4478,7 +4478,7 @@ class TestStl : public TestFixture {
                             "void Wilma::foo()\n"
                             "{\n"
                             "    if (f.x.size() == 0) {}\n"
-                            "}";
+                            "}\n";
         check(code, settingsCpp03);
         ASSERT_EQUALS(
             "[test.cpp:10:11]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n"
@@ -4501,7 +4501,7 @@ class TestStl : public TestFixture {
                                 "Zzz * zzz;\n"
                                 "int main() {\n"
                                 "    if (zzz->x.size() > 0) { }\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS(
                 "[test.cpp:10:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n"
@@ -4520,7 +4520,7 @@ class TestStl : public TestFixture {
                                 "int main() {\n"
                                 "    Zzz * zzz;\n"
                                 "    if (zzz->x.size() > 0) { }\n"
-                                "}";
+                                "}\n";
             check(code, settingsCpp03);
             ASSERT_EQUALS(
                 "[test.cpp:10:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n"
@@ -4535,17 +4535,17 @@ class TestStl : public TestFixture {
     void size4() { // #2652 - don't warn about vector/deque
         check("void f(std::vector<int> &v) {\n"
               "    if (v.size() > 0U) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::deque<int> &v) {\n"
               "    if (v.size() > 0U) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::array<int,3> &a) {\n"
               "    if (a.size() > 0U) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4554,7 +4554,7 @@ class TestStl : public TestFixture {
               "{\n"
               "    if (haystack.find(needle) != haystack.end())\n"
               "        haystack.remove(needle);"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Redundant checking of STL container element existence before removing it. [redundantIfRemove]\n", errout_str());
 
         check("void g(const std::string&);\n" // #14725
@@ -4575,14 +4575,14 @@ class TestStl : public TestFixture {
               "            it++;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:2:71]: (warning) Missing bounds check for extra iterator increment in loop. [StlMissingComparison]\n", errout_str());
 
         check("void f(std::map<int,int> &ints) {\n"
               "    for (std::map<int,int>::iterator it = ints.begin(); it != ints.end(); ++it) {\n"
               "        ++it->second;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::vector<std::string> &v) {\n"
@@ -4593,7 +4593,7 @@ class TestStl : public TestFixture {
               "            ++it;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4606,7 +4606,7 @@ class TestStl : public TestFixture {
               "                return;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4616,7 +4616,7 @@ class TestStl : public TestFixture {
               "        for (std::set<int>::iterator it = ints2.begin(); it != ints2.end(); ++it)\n"
               "        { }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4628,7 +4628,7 @@ class TestStl : public TestFixture {
               "            break;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:23]: (style) Consider using std::find_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("function f1(std::list<int> &l1) {\n"
@@ -4638,7 +4638,7 @@ class TestStl : public TestFixture {
               "            return;\n"
               "        }\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:23]: (style) Consider using std::find_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
     }
 
@@ -4647,7 +4647,7 @@ class TestStl : public TestFixture {
               "    for(it = map1.begin(); it != map1.end(); it++) {\n"
               "        str[i++] = (*it).first;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4656,7 +4656,7 @@ class TestStl : public TestFixture {
               "    for(string::iterator it = s.begin(); it != s.end(); it++) {\n"
               "        it = s.insert(++it, 0);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4664,50 +4664,50 @@ class TestStl : public TestFixture {
         check("void f() {\n"
               "    std::string errmsg;\n"
               "    throw errmsg.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after throwing exception. [stlcstrthrow]\n", errout_str());
 
         check("const char *get_msg() {\n"
               "    std::string errmsg;\n"
               "    return errmsg.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("const char *get_msg() {\n"
               "    std::ostringstream errmsg;\n"
               "    return errmsg.str().c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("const char *get_msg() {\n"
               "    std::string errmsg;\n"
               "    return std::string(\"ERROR: \" + errmsg).c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("const char *get_msg() {\n"
               "    std::string errmsg;\n"
               "    return (\"ERROR: \" + errmsg).c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("const char *get_msg() {\n"
               "    std::string errmsg;\n"
               "    return (\"ERROR: \" + std::string(\"crash me\")).c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("void f() {\n"
               "    std::ostringstream errmsg;\n"
               "    const char *c = errmsg.str().c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("std::string f();\n"
               "\n"
               "void foo() {\n"
               "    const char *c = f().c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:17]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("class Foo {\n"
@@ -4716,7 +4716,7 @@ class TestStl : public TestFixture {
               "const char *Foo::f() {\n"
               "    std::string s;\n"
               "    return s.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("class Foo {\n"
@@ -4725,27 +4725,27 @@ class TestStl : public TestFixture {
               "const char *f() {\n"
               "    Foo f;\n"
               "    return f.GetVal().c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("const char* foo() {\n"
               "    static std::string text;\n"
               "    text = \"hello world\\n\";\n"
               "    return text.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str()); // #3427
 
         // Implicit conversion back to std::string
         check("std::string get_msg() {\n"
               "    std::string errmsg;\n"
               "    return errmsg.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (performance) Returning the result of c_str() in a function that returns std::string is slow and redundant. [stlcstrReturn]\n", errout_str());
 
         check("const std::string& get_msg() {\n"
               "    std::string errmsg;\n"
               "    return errmsg.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (performance) Returning the result of c_str() in a function that returns std::string is slow and redundant. [stlcstrReturn]\n", errout_str());
 
         check("class Foo {\n"
@@ -4754,19 +4754,19 @@ class TestStl : public TestFixture {
               "std::string f() {\n"
               "    Foo f;\n"
               "    return f.GetVal().c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (performance) Returning the result of c_str() in a function that returns std::string is slow and redundant. [stlcstrReturn]\n", errout_str());
 
         check("std::string get_msg() {\n"
               "    std::string errmsg;\n"
               "    return errmsg;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::string get_msg() {\n" // #3678
               "    MyStringClass errmsg;\n"
               "    return errmsg.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void Foo1(const std::string& str) {}\n"
@@ -4786,7 +4786,7 @@ class TestStl : public TestFixture {
               "    Foo4(str, str.c_str());\n"
               "    Foo4(ss.str(), ss.str().c_str());\n"
               "    Foo4(str.c_str(), str.c_str());\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("[test.cpp:9:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
                       "[test.cpp:11:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 2 is slow and redundant. [stlcstrParam]\n"
@@ -4802,7 +4802,7 @@ class TestStl : public TestFixture {
               "    std::string str = \"bar\";\n"
               "    Foo1(str, foo);\n" // Don't crash
               "    Foo2(str.c_str());\n" // Don't crash
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Foo {\n"
@@ -4816,7 +4816,7 @@ class TestStl : public TestFixture {
               "    func(str.c_str());\n"
               "    Foo::sfunc(str.c_str());\n"
               "    foo.func(str.c_str());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:9:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
                       "[test.cpp:10:10]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
                       "[test.cpp:11:9]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n",
@@ -4851,7 +4851,7 @@ class TestStl : public TestFixture {
               "    std::string str = \"bar\";\n"
               "    std::ofstream svgFile(filename.c_str(), std::ios::trunc);\n"
               "    svgFile << \"test\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void Foo(const char* p) {}\n"
@@ -4860,12 +4860,12 @@ class TestStl : public TestFixture {
               "    std::string str = \"bar\";\n"
               "    Foo(str);\n"
               "    Foo(str.c_str());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int atoi(const std::string& str) {\n" // #3729: Don't suggest recursive call
               "    return atoi(str.c_str());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::string hello()\n"
@@ -4876,7 +4876,7 @@ class TestStl : public TestFixture {
               "const char *f()\n"
               "{\n"
               "    return hello().c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("class Fred {\n"
@@ -4890,7 +4890,7 @@ class TestStl : public TestFixture {
               "const char *Fred::f()\n"
               "{\n"
               "    return hello().c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:11:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         // #4183 - using MyStringClass.c_str()
@@ -4899,12 +4899,12 @@ class TestStl : public TestFixture {
               "void b() {\n"
               "    MyStringClass s;\n"
               "    a(s.c_str());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("std::string Format(const char * name) {\n" // #4938
               "    return String::Format(\"%s:\", name).c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7480
@@ -4914,7 +4914,7 @@ class TestStl : public TestFixture {
               "const char* GetMapAuthor(int index) {\n"
               "    const InternalMapInfo* mapInfo = &internal_getMapInfo;\n"
               "    return mapInfo->author.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct InternalMapInfo {\n"
@@ -4923,7 +4923,7 @@ class TestStl : public TestFixture {
               "std::string GetMapAuthor(int index) {\n"
               "    const InternalMapInfo* mapInfo = &internal_getMapInfo;\n"
               "    return mapInfo->author.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (performance) Returning the result of c_str() in a function that returns std::string is slow and redundant. [stlcstrReturn]\n", errout_str());
 
         check("struct InternalMapInfo {\n"
@@ -4932,7 +4932,7 @@ class TestStl : public TestFixture {
               "const char* GetMapAuthor(int index) {\n"
               "    const InternalMapInfo mapInfo = internal_getMapInfo;\n"
               "    return mapInfo.author.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("struct S {\n" // #7656
@@ -4942,7 +4942,7 @@ class TestStl : public TestFixture {
               "const char* test() {\n"
               "    const struct S &s = getS();\n"
               "    return s.data.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n" // #7930
@@ -4952,7 +4952,7 @@ class TestStl : public TestFixture {
               "    S s;\n"
               "    std::string &ref = s.data;\n"
               "    return ref.c_str();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:7:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("void f(const wchar_t* w, int i = 0, ...);\n" // #10357
@@ -5151,7 +5151,7 @@ class TestStl : public TestFixture {
               "    string s1, s2;\n"
               "    s1.swap(s2);\n"
               "    s2.swap(s2);\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -5159,7 +5159,7 @@ class TestStl : public TestFixture {
               "    std::string s1, s2;\n"
               "    s1.swap(s2);\n"
               "    s2.swap(s2);\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:5]: (performance) It is inefficient to swap a object with itself by calling 's2.swap(s2)' [uselessCallsSwap]\n", errout_str());
 
         check("void f()\n"
@@ -5169,7 +5169,7 @@ class TestStl : public TestFixture {
               "    s2.compare(s2);\n"
               "    s1.compare(s2.c_str());\n"
               "    s1.compare(0, s1.size(), s1);\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:16]: (warning) It is inefficient to call 's2.compare(s2)' as it always returns 0. [uselessCallsCompare]\n", errout_str());
 
         // #7370 False positive uselessCallsCompare on unknown type
@@ -5180,7 +5180,7 @@ class TestStl : public TestFixture {
               "    return (cmp);\n"
               "  }\n"
               "  WT_CURSOR *cursor_;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
@@ -5192,7 +5192,7 @@ class TestStl : public TestFixture {
               "    s1 = s2.substr(0, x);\n"
               "    s1 = s2.substr(0,std::string::npos);\n"
               "    s1 = s2.substr(x+5-n, 0);\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (performance) Ineffective call of function \'substr\' because it returns a copy of "
                       "the object. Use operator= instead. [uselessCallsSubstr]\n"
                       "[test.cpp:8:10]: (performance) Ineffective call of function \'substr\' because it returns a copy of "
@@ -5208,26 +5208,26 @@ class TestStl : public TestFixture {
               "    s1 = s2.substr(0, x);\n"
               "    s1 = s2.substr(0,std::string::npos);\n"
               "    s1 = s2.substr(x+5-n, 0);\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int main()\n"
               "{\n"
               "    std::string str = \"a1b1\";\n"
               "    return str.find(str[1], 2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool foo(std::vector<int>& v) {\n"
               "    v.empty();\n"
               "    return v.empty();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) Ineffective call of function 'empty()'. Did you intend to call 'clear()' instead? [uselessCallsEmpty]\n", errout_str());
 
         check("void f() {\n" // #4938
               "    OdString str;\n"
               "    str.empty();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #4032
@@ -5235,7 +5235,7 @@ class TestStl : public TestFixture {
               "    const std::string::size_type npos = greeting.rfind(\" \");\n"
               "    if (npos != std::string::npos)\n"
               "        std::cout << greeting.substr(0, npos) << std::endl;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(std::vector<int> a) {\n"
@@ -5245,7 +5245,7 @@ class TestStl : public TestFixture {
               "    x = std::remove(a.begin(), a.end(), val);\n"
               "    a.erase(std::remove(a.begin(), a.end(), val));\n"
               "    std::remove(\"foo.txt\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:5]: (warning) Return value of std::remove() ignored. Elements remain in container. [uselessCallsRemove]\n"
                       "[test.cpp:3:5]: (warning) Return value of std::remove_if() ignored. Elements remain in container. [uselessCallsRemove]\n"
                       "[test.cpp:4:5]: (warning) Return value of std::unique() ignored. Elements remain in container. [uselessCallsRemove]\n", errout_str());
@@ -5253,19 +5253,19 @@ class TestStl : public TestFixture {
         check("void f(std::string& s) {\n" // #14764
               "    auto it{ std::remove(s.begin(), s.end(), 'a') };\n"
               "    s.erase(it, s.end());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4431 - fp
         check("bool f() {\n"
               "    return x ? true : (y.empty());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8360
         check("void f(std::string s) {\n"
               "    for (;s.empty();) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #11166
@@ -5330,7 +5330,7 @@ class TestStl : public TestFixture {
               "        EffectivityRange<int> er;\n"
               "    }\n"
               "    void shift() { EffectivityRangeData<int>::iterator it;  }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5340,7 +5340,7 @@ class TestStl : public TestFixture {
               "    if (std::isalpha(*i) && i != str.end()) {\n"
               "        std::cout << *i;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         check("void foo(std::string::iterator& i) {\n"
@@ -5348,7 +5348,7 @@ class TestStl : public TestFixture {
               "    else if (std::isalpha(*i) && i != str.end()) {\n"
               "        std::cout << *i;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:27]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test suggested correction doesn't report an error
@@ -5356,7 +5356,7 @@ class TestStl : public TestFixture {
               "    if (i != str.end() && std::isalpha(*i)) {\n"
               "        std::cout << *i;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Test "while" with "&&" case
@@ -5365,7 +5365,7 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:25]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         check("void foo(std::string::iterator& i) {\n"
@@ -5373,7 +5373,7 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    } while (std::isalpha(*i) && i != str.end());\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:27]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test "while" with "||" case
@@ -5382,7 +5382,7 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:28]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test fix for "while" with "||" case
@@ -5391,7 +5391,7 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Test "for" with "&&" case
@@ -5400,7 +5400,7 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:25]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test "for" with "||" case
@@ -5409,7 +5409,7 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:25]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test that a dereference outside the condition part of a "for"
@@ -5419,7 +5419,7 @@ class TestStl : public TestFixture {
               "        std::cout << c;\n"
               "        i ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Test that other "&&" terms in the condition don't invalidate the check
@@ -5427,7 +5427,7 @@ class TestStl : public TestFixture {
               "    if (*c && std::isalpha(*i) && i != str.end()) {\n"
               "        std::cout << *i;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:28]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test that dereference of different variable doesn't trigger a false positive
@@ -5435,7 +5435,7 @@ class TestStl : public TestFixture {
               "    if (std::isalpha(*c) && i != str.end()) {\n"
               "        std::cout << *c;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Test case involving "rend()" instead of "end()"
@@ -5444,7 +5444,7 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:25]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test that mixed "&&" and "||" don't result in a false positive
@@ -5452,7 +5452,7 @@ class TestStl : public TestFixture {
               "    if ((i == str.end() || *i) || (isFoo() && i != str.end())) {\n"
               "        std::cout << \"foo\";\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
@@ -7381,7 +7381,7 @@ class TestStl : public TestFixture {
                   "      if(x.find(5) == x.end())\n"
                   "         x[5] = data;\n"
                   "   }\n"
-                  "}", s);
+                  "}\n", s);
             ASSERT_EQUALS("", errout_str());
 
             s.standards.cpp = Standards::CPP11;
@@ -7393,7 +7393,7 @@ class TestStl : public TestFixture {
                   "      if(x.find(5) == x.end())\n"
                   "         x[5] = data;\n"
                   "   }\n"
-                  "}", s);
+                  "}\n", s);
             ASSERT_EQUALS("[test.cpp:7:17]: (performance) Searching before insertion is not necessary. Instead of 'x[5]=data' consider using 'x.emplace(5, data);'. [stlFindInsert]\n", errout_str());
 
             check("void foo() {\n"
@@ -7404,7 +7404,7 @@ class TestStl : public TestFixture {
                   "      if(x.find(5) == x.end())\n"
                   "         x[5] = data;\n"
                   "   }\n"
-                  "}"); // TODO: use s?
+                  "}\n"); // TODO: use s?
             ASSERT_EQUALS("[test.cpp:7:17]: (performance) Searching before insertion is not necessary. Instead of 'x[5]=data' consider using 'x.try_emplace(5, data);'. [stlFindInsert]\n", errout_str());
         }
     }
@@ -7496,7 +7496,7 @@ class TestStl : public TestFixture {
               "static void f() {\n"
               "    const ArrayType arr;\n"
               "    for (const auto &a : arr) {}\n"
-              "}",
+              "}\n",
               dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:7:26]: (style) Iterating over container 'arr' that is always empty. [knownEmptyContainer]\n", errout_str());
 
@@ -7743,7 +7743,7 @@ class TestStl : public TestFixture {
               dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("", errout_str());
 
-        check("void foo() { int f = 0; auto g(f); g = g; }");
+        check("void foo() { int f = 0; auto g(f); g = g; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct foobar {\n"
diff --git a/test/teststring.cpp b/test/teststring.cpp
index 80073ac7d91..e34950d127c 100644
--- a/test/teststring.cpp
+++ b/test/teststring.cpp
@@ -82,25 +82,25 @@ class TestString : public TestFixture {
         check("void f() {\n"
               "  char *abc = \"abc\";\n"
               "  abc[0] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3] -> [test.cpp:2:15]: (error) Modifying string literal \"abc\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n", errout_str());
 
         check("void f() {\n"
               "  char *abc = \"abc\";\n"
               "  *abc = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:4] -> [test.cpp:2:15]: (error) Modifying string literal \"abc\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n", errout_str());
 
         check("void f() {\n"
               "  char *abc = \"A very long string literal\";\n"
               "  abc[0] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3] -> [test.cpp:2:15]: (error) Modifying string literal \"A very long stri..\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n", errout_str());
 
         check("void f() {\n"
               "  QString abc = \"abc\";\n"
               "  abc[0] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo_FP1(char *p) {\n"
@@ -109,7 +109,7 @@ class TestString : public TestFixture {
               "void foo_FP2(void) {\n"
               "  char* s = \"Y\";\n"
               "  foo_FP1(s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:3] -> [test.cpp:5:13]: (error) Modifying string literal \"Y\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n",
             errout_str());
@@ -120,19 +120,19 @@ class TestString : public TestFixture {
               "void foo_FP2(void) {\n"
               "  char s[10] = \"Y\";\n"
               "  foo_FP1(s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  wchar_t *abc = L\"abc\";\n"
               "  abc[0] = u'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3] -> [test.cpp:2:18]: (error) Modifying string literal L\"abc\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n", errout_str());
 
         check("void f() {\n"
               "  char16_t *abc = u\"abc\";\n"
               "  abc[0] = 'a';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:3] -> [test.cpp:2:19]: (error) Modifying string literal u\"abc\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n", errout_str());
 
         check("void foo() {\n" // #8332
@@ -142,7 +142,7 @@ class TestString : public TestFixture {
               "        p[i] = \'X\';\n" // <<
               "    }\n"
               "    printf(\"%s\\n\", p);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:3:16]: (error) Modifying string literal \"string literal\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n", errout_str());
     }
 
@@ -160,7 +160,7 @@ class TestString : public TestFixture {
               "  if (wmemcmp(L\"A\",L\"A\",1)){}\n"
               "  if (wcscmp(L\"A\",L\"A\")){}\n"
               "  if (wcscasecmp(L\"A\",L\"A\")){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
                       "[test.cpp:3:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
                       "[test.cpp:4:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
@@ -180,7 +180,7 @@ class TestString : public TestFixture {
               "     if (!memcmp(p + offset, p, 42)){}\n"
               "     if (!memcmp(offset + p, p, 42)){}\n"
               "     if (!memcmp(p, offset + p, 42)){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // avoid false positives when the address is modified #6415
@@ -189,7 +189,7 @@ class TestString : public TestFixture {
               "     if (!memcmp(c + offset, c, 42)){}\n"
               "     if (!memcmp(offset + c, c, 42)){}\n"
               "     if (!memcmp(c, offset + c, 42)){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // avoid false positives when the address is modified #6415
@@ -198,164 +198,164 @@ class TestString : public TestFixture {
               "     if (!memcmp(s.c_str() + offset, s.c_str(), 42)){}\n"
               "     if (!memcmp(offset + s.c_str(), s.c_str(), 42)){}\n"
               "     if (!memcmp(s.c_str(), offset + s.c_str(), 42)){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f(void) {\n" // #13527
               "    const wchar_t* str1 = L\"Hello\";\n"
               "    return wcsicmp(str1, str1);\n" // <<
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (warning) Comparison of identical string variables. [stringCompare]\n", errout_str());
 
         check("int main()\n"
               "{\n"
-              "  if (strcmp(\"00FF00\", \"00FF00\") == 0)"
-              "  {"
-              "    std::cout << \"Equal\";"
-              "  }"
-              "}");
+              "  if (strcmp(\"00FF00\", \"00FF00\") == 0)\n"
+              "  {\n"
+              "    std::cout << \"Equal\";\n"
+              "  }\n"
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         check("void f() {\n"
-              "  if (strcmp($\"00FF00\", \"00FF00\") == 0) {}"
-              "}");
+              "  if (strcmp($\"00FF00\", \"00FF00\") == 0) {}\n"
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
-              "  if ($strcmp(\"00FF00\", \"00FF00\") == 0) {}"
-              "}");
+              "  if ($strcmp(\"00FF00\", \"00FF00\") == 0) {}\n"
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int main()\n"
               "{\n"
-              "  if (stricmp(\"hotdog\",\"HOTdog\") == 0)"
-              "  {"
-              "    std::cout << \"Equal\";"
-              "  }"
-              "}");
+              "  if (stricmp(\"hotdog\",\"HOTdog\") == 0)\n"
+              "  {\n"
+              "    std::cout << \"Equal\";\n"
+              "  }\n"
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         check("int main()\n"
               "{\n"
-              "  if (QString::compare(\"Hamburger\", \"Hotdog\") == 0)"
-              "  {"
-              "    std::cout << \"Equal\";"
-              "  }"
-              "}");
+              "  if (QString::compare(\"Hamburger\", \"Hotdog\") == 0)\n"
+              "  {\n"
+              "    std::cout << \"Equal\";\n"
+              "  }\n"
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         check("int main()\n"
               "{\n"
-              "  if (QString::compare(argv[2], \"hotdog\") == 0)"
-              "  {"
-              "    std::cout << \"Equal\";"
-              "  }"
-              "}");
+              "  if (QString::compare(argv[2], \"hotdog\") == 0)\n"
+              "  {\n"
+              "    std::cout << \"Equal\";\n"
+              "  }\n"
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int main()\n"
               "{\n"
-              "  if (strncmp(\"hotdog\",\"hotdog\", 6) == 0)"
-              "  {"
-              "    std::cout << \"Equal\";"
-              "  }"
-              "}");
+              "  if (strncmp(\"hotdog\",\"hotdog\", 6) == 0)\n"
+              "  {\n"
+              "    std::cout << \"Equal\";\n"
+              "  }\n"
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         check("int foo(const char *buf)\n"
               "{\n"
-              "  if (strcmp(buf, buf) == 0)"
-              "  {"
-              "    std::cout << \"Equal\";"
-              "  }"
-              "}");
+              "  if (strcmp(buf, buf) == 0)\n"
+              "  {\n"
+              "    std::cout << \"Equal\";\n"
+              "  }\n"
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (warning) Comparison of identical string variables. [stringCompare]\n", errout_str());
 
         check("int foo(const std::string& buf)\n"
               "{\n"
-              "  if (stricmp(buf.c_str(), buf.c_str()) == 0)"
-              "  {"
-              "    std::cout << \"Equal\";"
-              "  }"
-              "}");
+              "  if (stricmp(buf.c_str(), buf.c_str()) == 0)\n"
+              "  {\n"
+              "    std::cout << \"Equal\";\n"
+              "  }\n"
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (warning) Comparison of identical string variables. [stringCompare]\n", errout_str());
 
         check("int main() {\n"
               "  if (\"str\" == \"str\") {\n"
               "    std::cout << \"Equal\";\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:6]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         check("int main() {\n"
               "  if (\"str\" != \"str\") {\n"
               "    std::cout << \"Equal\";\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:6]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         check("int main() {\n"
               "  if (a+\"str\" != \"str\"+b) {\n"
               "    std::cout << \"Equal\";\n"
               "  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void suspiciousStringCompare() {
         check("bool foo(char* c) {\n"
               "    return c == \"x\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (warning) String literal compared with variable 'c'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(char** c) {\n"
               "    return c[3] == \"x\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) String literal compared with variable 'c[3]'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(wchar_t* c) {\n"
               "    return c == L\"x\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (warning) String literal compared with variable 'c'. Did you intend to use wcscmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(const char* c) {\n"
               "    return \"x\" == c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:16]: (warning) String literal compared with variable 'c'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return foo+\"x\" == c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return \"x\" == c+foo;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return \"x\" == c+foo;\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:2:16]: (warning) String literal compared with variable 'c+foo'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(Foo c) {\n"
               "    return \"x\" == c.foo;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool foo(Foo c) {\n"
               "    return \"x\" == c.foo;\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:2:16]: (warning) String literal compared with variable 'c.foo'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(const std::string& c) {\n"
               "    return \"x\" == c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool foo(const Foo* c) {\n"
               "    return \"x\" == c->bar();\n" // #4314
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #4257
@@ -367,33 +367,33 @@ class TestString : public TestFixture {
         // Ticket #4257
         check("bool foo() {\n"
               "MyString *str=Getter();\n"
-              "return *str==\"bug\"; }");
+              "return *str==\"bug\"; }\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #4257
         check("bool foo() {\n"
               "MyString **str=OtherGetter();\n"
-              "return *str==\"bug\"; }", dinit(CheckOptions, $.cpp = false));
+              "return *str==\"bug\"; }\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:3:12]: (warning) String literal compared with variable '*str'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         // Ticket #4257
         check("bool foo() {\n"
               "MyString str=OtherGetter2();\n"
-              "return &str==\"bug\"; }", dinit(CheckOptions, $.cpp = false));
+              "return &str==\"bug\"; }\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:3:12]: (warning) String literal compared with variable '&str'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         // Ticket #5734
         check("int foo(char c) {\n"
-              "return c == '4';}");
+              "return c == '4';}\n");
         ASSERT_EQUALS("", errout_str());
         check("int foo(char c) {\n"
-              "return c == '4';}", dinit(CheckOptions, $.cpp = false));
+              "return c == '4';}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
         check("int foo(char c) {\n"
-              "return c == \"42\"[0];}");
+              "return c == \"42\"[0];}\n");
         ASSERT_EQUALS("", errout_str());
         check("int foo(char c) {\n"
-              "return c == \"42\"[0];}", dinit(CheckOptions, $.cpp = false));
+              "return c == \"42\"[0];}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         // 5639 String literal compared with char buffer in a struct
@@ -418,81 +418,81 @@ class TestString : public TestFixture {
         check("void f(std::vector<std::string> theArgs) {\n"
               "   std::string arg1(*theArgs.begin());\n"
               "   if(arg1 == \"aaa\") {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void suspiciousStringCompare_char() {
         check("bool foo(char* c) {\n"
               "    return c == 'x';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (warning) Char literal compared with pointer 'c'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(wchar_t* c) {\n"
               "    return c == L'x';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:14]: (warning) Char literal compared with pointer 'c'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return '\\0' != c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) Char literal compared with pointer 'c'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(char c) {\n"
               "    return c == '\\0';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return c[0] == '\\0';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool foo(char** c) {\n"
               "    return c[0] == '\\0';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) Char literal compared with pointer 'c[0]'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(char** c) {\n"
               "    return *c == '\\0';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (warning) Char literal compared with pointer '*c'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(char c) {\n"
               "    return c == 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return *c == 0;\n"
-              "}", dinit(CheckOptions, $.cpp = false));
+              "}\n", dinit(CheckOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return *c == 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool foo(Foo* c) {\n"
               "    return 0 == c->x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* c) {\n"
               "    if(c == '\\0') bar();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Char literal compared with pointer 'c'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("void f() {\n"
               "  struct { struct { char *str; } x; } a;\n"
               "  return a.x.str == '\\0';"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:18]: (warning) Char literal compared with pointer 'a.x.str'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("void f() {\n"
               "  struct { struct { char *str; } x; } a;\n"
               "  return *a.x.str == '\\0';"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -502,7 +502,7 @@ class TestString : public TestFixture {
               "{\n"
               "    char buf[100];\n"
               "    snprintf(buf,100,\"%s\",buf);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:27]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in snprintf(). [sprintfOverlappingData]\n", errout_str());
     }
 
@@ -511,7 +511,7 @@ class TestString : public TestFixture {
               "{\n"
               "    char buf[100];\n"
               "    sprintf(buf,\"%s\",buf);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:22]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in sprintf(). [sprintfOverlappingData]\n", errout_str());
     }
 
@@ -520,7 +520,7 @@ class TestString : public TestFixture {
               "{\n"
               "    char buf[100];\n"
               "    sprintf(buf,\"%i\",sizeof(buf));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -530,7 +530,7 @@ class TestString : public TestFixture {
               "    char buf[100];\n"
               "    sprintf(buf,\"%i\",sizeof(buf));\n"
               "    if (buf[0]);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -545,7 +545,7 @@ class TestString : public TestFixture {
               "    const char* filename = \"hello\";\n"
               "    struct A a;\n"
               "    snprintf(a.filename, 128, \"%s\", filename);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -558,7 +558,7 @@ class TestString : public TestFixture {
               "void foo(struct A *a)\n"
               "{\n"
               "    snprintf(a->filename, 128, \"%s\", a->filename);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:8:39]: (error) Undefined behavior: Variable 'a->filename' is used as parameter and destination in snprintf(). [sprintfOverlappingData]\n", errout_str());
     }
 
@@ -567,7 +567,7 @@ class TestString : public TestFixture {
               "{\n"
               "    char buf[100];\n"
               "    sprintf((char*)buf,\"%s\",(char*)buf);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:29]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in sprintf(). [sprintfOverlappingData]\n", errout_str());
     }
 
@@ -576,7 +576,7 @@ class TestString : public TestFixture {
               "{\n"
               "    char buf[100];\n"
               "    sprintf((char*)(void*)buf,\"%s\",(void*)(char*)buf);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:36]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in sprintf(). [sprintfOverlappingData]\n", errout_str());
     }
 
@@ -585,7 +585,7 @@ class TestString : public TestFixture {
               "{\n"
               "    wchar_t buf[100];\n"
               "    swprintf(buf,10, \"%s\",buf);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:27]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in swprintf(). [sprintfOverlappingData]\n", errout_str());
     }
 
@@ -594,7 +594,7 @@ class TestString : public TestFixture {
         check("void foo()\n"
               "{\n"
               "    const char *p = \"/usr\" + '/';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:28]: (error) Unusual pointer arithmetic. A value of type 'char' is added to a string literal. [strPlusChar]\n", errout_str());
     }
 
@@ -604,7 +604,7 @@ class TestString : public TestFixture {
               "{\n"
               "    char ch = 1;\n"
               "    const char *p = ch + \"/usr\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Strange looking pointer arithmetic..
@@ -613,7 +613,7 @@ class TestString : public TestFixture {
               "    int i = 1;\n"
               "    const char* psz = \"Bla\";\n"
               "    const std::string str = i + psz;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -623,7 +623,7 @@ class TestString : public TestFixture {
               "{\n"
               "    std::string temp = \"/tmp\";\n"
               "    std::string path = temp + '/' + \"sub\" + '/';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -632,100 +632,100 @@ class TestString : public TestFixture {
         check("void foo()\n"
               "{\n"
               "    const wchar_t *p = L\"/usr\" + L'/';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:32]: (error) Unusual pointer arithmetic. A value of type 'wchar_t' is added to a string literal. [strPlusChar]\n", errout_str());
 
         check("void foo(wchar_t c)\n"
               "{\n"
               "    const wchar_t *p = L\"/usr\" + c;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:32]: (error) Unusual pointer arithmetic. A value of type 'wchar_t' is added to a string literal. [strPlusChar]\n", errout_str());
     }
 
     void incorrectStringCompare() {
         check("int f() {\n"
               "    return test.substr( 0 , 4 ) == \"Hello\" ? 0 : 1 ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) String literal \"Hello\" doesn't match length argument for substr(). [incorrectStringCompare]\n", errout_str());
 
         check("int f() {\n"
               "    return test.substr( 0 , 4 ) == L\"Hello\" ? 0 : 1 ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) String literal L\"Hello\" doesn't match length argument for substr(). [incorrectStringCompare]\n", errout_str());
 
         check("int f() {\n"
               "    return test.substr( 0 , 5 ) == \"Hello\" ? 0 : 1 ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    return \"Hello\" == test.substr( 0 , 4 ) ? 0 : 1 ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:28]: (warning) String literal \"Hello\" doesn't match length argument for substr(). [incorrectStringCompare]\n", errout_str());
 
         check("int f() {\n"
               "    return \"Hello\" == foo.bar<int>().z[1].substr(i+j*4, 4) ? 0 : 1 ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:43]: (warning) String literal \"Hello\" doesn't match length argument for substr(). [incorrectStringCompare]\n", errout_str());
 
         check("int f() {\n"
               "    return \"Hello\" == test.substr( 0 , 5 ) ? 0 : 1 ;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    if (\"Hello\") { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    if (\"Hello\" && test) { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:9]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    if (test && \"Hello\") { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    while (\"Hello\") { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    return \"Hello\" ? 1 : 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    assert (test || \"Hello\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:21]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    assert (test && \"Hello\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    assert (\"Hello\" || test);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:13]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    assert (\"Hello\" && test);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    BOOST_ASSERT (\"Hello\" && test);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    return f2(\"Hello\");\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7750 warn about char literals in boolean expressions
@@ -734,7 +734,7 @@ class TestString : public TestFixture {
               "  if(L'b'){}\n"
               "  if(1 && 'c'){}\n"
               "  int x = 'd' ? 1 : 2;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:6]: (warning) Conversion of char literal 'a' to bool always evaluates to true. [incorrectCharBooleanError]\n"
                       "[test.cpp:3:6]: (warning) Conversion of char literal L'b' to bool always evaluates to true. [incorrectCharBooleanError]\n"
                       "[test.cpp:4:11]: (warning) Conversion of char literal 'c' to bool always evaluates to true. [incorrectCharBooleanError]\n"
@@ -744,7 +744,7 @@ class TestString : public TestFixture {
         check("void f() {\n"
               "  if('\\0'){}\n"
               "  if(L'\\0'){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:6]: (warning) Conversion of char literal '\\0' to bool always evaluates to false. [incorrectCharBooleanError]\n"
                       "[test.cpp:3:6]: (warning) Conversion of char literal L'\\0' to bool always evaluates to false. [incorrectCharBooleanError]\n",
                       errout_str());
@@ -752,7 +752,7 @@ class TestString : public TestFixture {
         check("void f() {\n"
               "  if('\\0' || cond){}\n"
               "  if(L'\\0' || cond){}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:6]: (warning) Conversion of char literal '\\0' to bool always evaluates to false. [incorrectCharBooleanError]\n"
                       "[test.cpp:3:6]: (warning) Conversion of char literal L'\\0' to bool always evaluates to false. [incorrectCharBooleanError]\n", errout_str());
 
@@ -836,12 +836,12 @@ class TestString : public TestFixture {
     void deadStrcmp() {
         check("void f(const char *str) {\n"
               "  if (strcmp(str, \"abc\") == 0 || strcmp(str, \"def\")) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:40]: (warning) The expression 'strcmp(str,\"def\") != 0' is suspicious. It overlaps 'strcmp(str,\"abc\") == 0'. [overlappingStrcmp]\n", errout_str());
 
         check("void f(const wchar_t *str) {\n"
               "  if (wcscmp(str, L\"abc\") == 0 || wcscmp(str, L\"def\")) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:41]: (warning) The expression 'wcscmp(str,L\"def\") != 0' is suspicious. It overlaps 'wcscmp(str,L\"abc\") == 0'. [overlappingStrcmp]\n", errout_str());
 
         check("struct X {\n"
@@ -850,7 +850,7 @@ class TestString : public TestFixture {
               "\n"
               "void f(const struct X *x) {\n"
               "  if (strcmp(x->str, \"abc\") == 0 || strcmp(x->str, \"def\")) {}\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:6:43]: (warning) The expression 'strcmp(x->str,\"def\") != 0' is suspicious. It overlaps 'strcmp(x->str,\"abc\") == 0'. [overlappingStrcmp]\n", errout_str());
     }
 };
diff --git a/test/testsummaries.cpp b/test/testsummaries.cpp
index 7896ffeb750..34f4ed3412e 100644
--- a/test/testsummaries.cpp
+++ b/test/testsummaries.cpp
@@ -45,15 +45,15 @@ class TestSummaries : public TestFixture {
     }
 
     void createSummaries1() {
-        ASSERT_EQUALS("foo\n", createSummaries("void foo() {}"));
+        ASSERT_EQUALS("foo\n", createSummaries("void foo() {}\n"));
     }
 
     void createSummariesGlobal() {
-        ASSERT_EQUALS("foo global:[x]\n", createSummaries("int x; void foo() { x=0; }"));
+        ASSERT_EQUALS("foo global:[x]\n", createSummaries("int x; void foo() { x=0; }\n"));
     }
 
     void createSummariesNoreturn() {
-        ASSERT_EQUALS("foo call:[bar] noreturn:[bar]\n", createSummaries("void foo() { bar(); }"));
+        ASSERT_EQUALS("foo call:[bar] noreturn:[bar]\n", createSummaries("void foo() { bar(); }\n"));
     }
 };
 
diff --git a/test/testsuppressions.cpp b/test/testsuppressions.cpp
index 949bad20bb4..de990c9fd91 100644
--- a/test/testsuppressions.cpp
+++ b/test/testsuppressions.cpp
@@ -747,7 +747,7 @@ class TestSuppressions : public TestFixture {
                                         "    int a;\n"
                                         "    // cppcheck-suppress uninitvar\n"
                                         "    a++;\n"
-                                        "}",
+                                        "}\n",
                                         ""));
         ASSERT_EQUALS("", errout_str());
 
@@ -969,7 +969,7 @@ class TestSuppressions : public TestFixture {
                                         "    b++;\n"
                                         "    // cppcheck-suppress-end uninitvar\n"
                                         "}\n"
-                                        "// cppcheck-suppress-end [uninitvar, syntaxError]",
+                                        "// cppcheck-suppress-end [uninitvar, syntaxError]\n",
                                         ""));
         ASSERT_EQUALS("[test.cpp:1:1]: (information) Unmatched suppression: syntaxError [unmatchedSuppression]\n", errout_str());
 
@@ -1401,8 +1401,8 @@ class TestSuppressions : public TestFixture {
 
         CppCheck cppCheck(settings, supprs, *this, nullptr, false, nullptr); // <- do not "use global suppressions". pretend this is a thread that just checks a file.
 
-        const char code[] = "int f() { int a; return a; }";
-        ASSERT_EQUALS(0, cppCheck.checkBuffer(FileWithDetails("test.c", Standards::Language::C, 0),code, sizeof(code))); // <- no unsuppressed error is seen
+        const char code[] = "int f() { int a; return a; }\n";
+        ASSERT_EQUALS(0, cppCheck.checkBuffer(FileWithDetails("test.c", Standards::Language::C, 0),code, sizeof(code)-1)); // <- no unsuppressed error is seen
         ASSERT_EQUALS("[test.c:1:25]: (error) Uninitialized variable: a [uninitvar]\n", errout_str()); // <- report error so ThreadExecutor can suppress it and make sure the global suppression is matched.
     }
 
@@ -1440,9 +1440,9 @@ class TestSuppressions : public TestFixture {
             "    int x;\n"
             "    // cppcheck-suppress unusedStructMember\n"
             "    int y;\n"
-            "};";
+            "};\n";
         CppCheck cppCheck(settings, supprs, *this, nullptr, true, nullptr);
-        ASSERT_EQUALS(0, cppCheck.checkBuffer(FileWithDetails("/somewhere/test.cpp", Standards::Language::CPP, 0), code, sizeof(code)));
+        ASSERT_EQUALS(0, cppCheck.checkBuffer(FileWithDetails("/somewhere/test.cpp", Standards::Language::CPP, 0), code, sizeof(code)-1));
         ASSERT_EQUALS("",errout_str());
     }
 
@@ -1471,7 +1471,7 @@ class TestSuppressions : public TestFixture {
                             "   fld   TBYTE PTR [EAX]   ; load an extended real (10 bytes)\n"
                             "   fstp  QWORD PTR result  ; store a double (8 bytes)\n"
                             "   pop   EAX               ; restore EAX\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS(0, (this->*check)(code, ""));
         ASSERT_EQUALS("", errout_str());
     }
@@ -1537,7 +1537,7 @@ class TestSuppressions : public TestFixture {
     }
 
     void unusedFunctionInternal(unsigned int (TestSuppressions::*check)(const char[], const std::string &)) {
-        ASSERT_EQUALS(0, (this->*check)("void f() {}", "unusedFunction"));
+        ASSERT_EQUALS(0, (this->*check)("void f() {}\n", "unusedFunction"));
     }
 
     void unusedFunctionFiles() {
@@ -1549,7 +1549,7 @@ class TestSuppressions : public TestFixture {
     }
 
     void suppressingSyntaxErrorAndExitCodeInternal(unsigned int (TestSuppressions::*check)(const char[], const std::string &)) {
-        const char code[] = "fi if;";
+        const char code[] = "fi if;\n";
 
         ASSERT_EQUALS(0, (this->*check)(code, "*:test.cpp"));
         ASSERT_EQUALS("", errout_str());
@@ -1582,8 +1582,8 @@ class TestSuppressions : public TestFixture {
     void suppressingSyntaxErrorAndExitCodeMultiFileInternal(unsigned int (TestSuppressions::*check)(std::map<std::string, std::string> &f, const std::string &)) {
         // multi files, but only suppression one
         std::map<std::string, std::string> mfiles;
-        mfiles["test.cpp"] = "fi if;";
-        mfiles["test2.cpp"] = "fi if";
+        mfiles["test.cpp"] = "fi if;\n";
+        mfiles["test2.cpp"] = "fi if\n";
         ASSERT_EQUALS(1, (this->*check)(mfiles, "*:test.cpp"));
         ASSERT_EQUALS("[test2.cpp:1:4]: (error) syntax error [syntaxError]\n", errout_str());
     }
diff --git a/test/testsymboldatabase.cpp b/test/testsymboldatabase.cpp
index 8fe107080b6..dfb61665b8a 100644
--- a/test/testsymboldatabase.cpp
+++ b/test/testsymboldatabase.cpp
@@ -644,7 +644,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void array() {
-        GET_SYMBOL_DB_C("int a[10+2];");
+        GET_SYMBOL_DB_C("int a[10+2];\n");
         ASSERT(db != nullptr);
 
         ASSERT(db->variableList().size() == 2); // the first one is not used
@@ -658,7 +658,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void array_ptr() {
         GET_SYMBOL_DB("const char* a[] = { \"abc\" };\n"
-                      "const char* b[] = { \"def\", \"ghijkl\" };");
+                      "const char* b[] = { \"def\", \"ghijkl\" };\n");
         ASSERT(db != nullptr);
 
         ASSERT(db->variableList().size() == 3); // the first one is not used
@@ -680,7 +680,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void stlarray1() {
-        GET_SYMBOL_DB("std::array<int, 16 + 4> arr;");
+        GET_SYMBOL_DB("std::array<int, 16 + 4> arr;\n");
         ASSERT(db != nullptr);
 
         ASSERT_EQUALS(2, db->variableList().size()); // the first one is not used
@@ -693,7 +693,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void stlarray2() {
-        GET_SYMBOL_DB("constexpr int sz = 16; std::array<int, sz + 4> arr;");
+        GET_SYMBOL_DB("constexpr int sz = 16; std::array<int, sz + 4> arr;\n");
         ASSERT(db != nullptr);
 
         ASSERT_EQUALS(3, db->variableList().size()); // the first one is not used
@@ -758,7 +758,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationCanHandleNull() {
         reset();
-        GET_SYMBOL_DB("void main(){}");
+        GET_SYMBOL_DB("void main(){}\n");
         const bool result = db->scopeList.front().isVariableDeclaration(nullptr, vartok, typetok);
         ASSERT_EQUALS(false, result);
         ASSERT(nullptr == vartok);
@@ -768,7 +768,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesSimpleDeclaration() {
         reset();
-        GET_SYMBOL_DB("int x;");
+        GET_SYMBOL_DB("int x;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
@@ -781,7 +781,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesInitialization() {
         reset();
-        GET_SYMBOL_DB("int x (1);");
+        GET_SYMBOL_DB("int x (1);\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
@@ -794,7 +794,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesCpp11Initialization() {
         reset();
-        GET_SYMBOL_DB("int x {1};");
+        GET_SYMBOL_DB("int x {1};\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
@@ -807,7 +807,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesScopedDeclaration() {
         reset();
-        GET_SYMBOL_DB("::int x;");
+        GET_SYMBOL_DB("::int x;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
@@ -820,7 +820,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesStdDeclaration() {
         reset();
-        GET_SYMBOL_DB("std::string x;");
+        GET_SYMBOL_DB("std::string x;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
@@ -833,7 +833,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesScopedStdDeclaration() {
         reset();
-        GET_SYMBOL_DB("::std::string x;");
+        GET_SYMBOL_DB("::std::string x;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
@@ -846,7 +846,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesManyScopes() {
         reset();
-        GET_SYMBOL_DB("AA::BB::CC::DD::EE x;");
+        GET_SYMBOL_DB("AA::BB::CC::DD::EE x;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
@@ -860,7 +860,7 @@ class TestSymbolDatabase : public TestFixture {
     void test_isVariableDeclarationIdentifiesPointers() {
         {
             reset();
-            GET_SYMBOL_DB("int* p;");
+            GET_SYMBOL_DB("int* p;\n");
             const bool result1 = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
             ASSERT_EQUALS(true, result1);
             ASSERT_EQUALS("p", vartok->str());
@@ -873,7 +873,7 @@ class TestSymbolDatabase : public TestFixture {
         {
             reset();
             SimpleTokenizer constpointer(*this);
-            ASSERT(constpointer.tokenize("const int* p;"));
+            ASSERT(constpointer.tokenize("const int* p;\n"));
             Variable v2(constpointer.tokens()->tokAt(3), constpointer.tokens()->next(), constpointer.tokens()->tokAt(2), 0, AccessControl::Public, nullptr, nullptr, settings1);
             ASSERT(false == v2.isArray());
             ASSERT(true == v2.isPointer());
@@ -882,7 +882,7 @@ class TestSymbolDatabase : public TestFixture {
         }
         {
             reset();
-            GET_SYMBOL_DB("int* const p;");
+            GET_SYMBOL_DB("int* const p;\n");
             const bool result2 = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
             ASSERT_EQUALS(true, result2);
             ASSERT_EQUALS("p", vartok->str());
@@ -900,7 +900,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("void slurpInManifest() {\n"
                       "  std::string tmpiostring(*tI);\n"
                       "  if(tmpiostring==\"infoonly\"){}\n"
-                      "}");
+                      "}\n");
 
         const Token *tok = Token::findsimplematch(tokenizer.tokens(), "tmpiostring ==");
         ASSERT(tok->variable());
@@ -909,7 +909,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationDoesNotIdentifyConstness() {
         reset();
-        GET_SYMBOL_DB("const int* cp;");
+        GET_SYMBOL_DB("const int* cp;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(false, result);
         ASSERT(nullptr == vartok);
@@ -918,7 +918,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesFirstOfManyVariables() {
         reset();
-        GET_SYMBOL_DB("int first, second;");
+        GET_SYMBOL_DB("int first, second;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("first", vartok->str());
@@ -931,7 +931,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesScopedPointerDeclaration() {
         reset();
-        GET_SYMBOL_DB("AA::BB::CC::DD::EE* p;");
+        GET_SYMBOL_DB("AA::BB::CC::DD::EE* p;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("p", vartok->str());
@@ -944,7 +944,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesDeclarationWithIndirection() {
         reset();
-        GET_SYMBOL_DB("int** pp;");
+        GET_SYMBOL_DB("int** pp;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("pp", vartok->str());
@@ -957,7 +957,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesDeclarationWithMultipleIndirection() {
         reset();
-        GET_SYMBOL_DB("int***** p;");
+        GET_SYMBOL_DB("int***** p;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("p", vartok->str());
@@ -970,7 +970,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesArray() {
         reset();
-        GET_SYMBOL_DB("::std::string v[3];");
+        GET_SYMBOL_DB("::std::string v[3];\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("v", vartok->str());
@@ -984,7 +984,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesPointerArray() {
         reset();
-        GET_SYMBOL_DB("A *a[5];");
+        GET_SYMBOL_DB("A *a[5];\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("a", vartok->str());
@@ -999,7 +999,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesOfArrayPointers1() {
         reset();
-        GET_SYMBOL_DB("A (*a)[5];");
+        GET_SYMBOL_DB("A (*a)[5];\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("a", vartok->str());
@@ -1014,7 +1014,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesOfArrayPointers2() {
         reset();
-        GET_SYMBOL_DB("A (*const a)[5];");
+        GET_SYMBOL_DB("A (*const a)[5];\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("a", vartok->str());
@@ -1029,7 +1029,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesOfArrayPointers3() {
         reset();
-        GET_SYMBOL_DB("A (** a)[5];");
+        GET_SYMBOL_DB("A (** a)[5];\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("a", vartok->str());
@@ -1044,7 +1044,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void test_isVariableDeclarationIdentifiesArrayOfFunctionPointers() {
         reset();
-        GET_SYMBOL_DB("int (*a[])(int) = { g };"); // #11596
+        GET_SYMBOL_DB("int (*a[])(int) = { g };\n"); // #11596
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("a", vartok->str());
@@ -1060,7 +1060,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void isVariableDeclarationIdentifiesTemplatedPointerVariable() {
         reset();
-        GET_SYMBOL_DB("std::set<char>* chars;");
+        GET_SYMBOL_DB("std::set<char>* chars;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("chars", vartok->str());
@@ -1073,7 +1073,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void isVariableDeclarationIdentifiesTemplatedPointerToPointerVariable() {
         reset();
-        GET_SYMBOL_DB("std::deque<int>*** ints;");
+        GET_SYMBOL_DB("std::deque<int>*** ints;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("ints", vartok->str());
@@ -1086,7 +1086,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void isVariableDeclarationIdentifiesTemplatedArrayVariable() {
         reset();
-        GET_SYMBOL_DB("std::deque<int> ints[3];");
+        GET_SYMBOL_DB("std::deque<int> ints[3];\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("ints", vartok->str());
@@ -1099,7 +1099,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void isVariableDeclarationIdentifiesTemplatedVariable() {
         reset();
-        GET_SYMBOL_DB("std::vector<int> ints;");
+        GET_SYMBOL_DB("std::vector<int> ints;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("ints", vartok->str());
@@ -1112,7 +1112,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void isVariableDeclarationIdentifiesTemplatedVariableIterator() {
         reset();
-        GET_SYMBOL_DB("std::list<int>::const_iterator floats;");
+        GET_SYMBOL_DB("std::list<int>::const_iterator floats;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("floats", vartok->str());
@@ -1125,7 +1125,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void isVariableDeclarationIdentifiesNestedTemplateVariable() {
         reset();
-        GET_SYMBOL_DB("std::deque<std::set<int> > intsets;");
+        GET_SYMBOL_DB("std::deque<std::set<int> > intsets;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("intsets", vartok->str());
@@ -1139,7 +1139,7 @@ class TestSymbolDatabase : public TestFixture {
     void isVariableDeclarationIdentifiesReference() {
         {
             reset();
-            GET_SYMBOL_DB("int& foo;");
+            GET_SYMBOL_DB("int& foo;\n");
             const bool result1 = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
             ASSERT_EQUALS(true, result1);
             Variable v1(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
@@ -1149,7 +1149,7 @@ class TestSymbolDatabase : public TestFixture {
         }
         {
             reset();
-            GET_SYMBOL_DB("foo*& bar;");
+            GET_SYMBOL_DB("foo*& bar;\n");
             const bool result2 = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
             ASSERT_EQUALS(true, result2);
             Variable v2(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
@@ -1159,7 +1159,7 @@ class TestSymbolDatabase : public TestFixture {
         }
         {
             reset();
-            GET_SYMBOL_DB("std::vector<int>& foo;");
+            GET_SYMBOL_DB("std::vector<int>& foo;\n");
             const bool result3 = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
             ASSERT_EQUALS(true, result3);
             Variable v3(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
@@ -1171,21 +1171,21 @@ class TestSymbolDatabase : public TestFixture {
 
     void isVariableDeclarationDoesNotIdentifyTemplateClass() {
         reset();
-        GET_SYMBOL_DB("template <class T> class SomeClass{};");
+        GET_SYMBOL_DB("template <class T> class SomeClass{};\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(false, result);
     }
 
     void isVariableDeclarationDoesNotIdentifyCppCast() {
         reset();
-        GET_SYMBOL_DB("reinterpret_cast <char *> (code)[0] = 0;");
+        GET_SYMBOL_DB("reinterpret_cast <char *> (code)[0] = 0;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(false, result);
     }
 
     void isVariableDeclarationPointerConst() {
         reset();
-        GET_SYMBOL_DB("std::string const* s;");
+        GET_SYMBOL_DB("std::string const* s;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens()->next(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
@@ -1196,7 +1196,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void isVariableDeclarationRValueRef() {
         reset();
-        GET_SYMBOL_DB("int&& i;");
+        GET_SYMBOL_DB("int&& i;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
@@ -1212,8 +1212,8 @@ class TestSymbolDatabase : public TestFixture {
                         "void f() {\n"
                         "  switch (c) {\n"
                         "    case b:;\n"
-                        "  }"
-                        "}");
+                        "  }\n"
+                        "}\n");
         const Variable* b = db->getVariableFromVarId(1);
         ASSERT_EQUALS("b", b->name());
         ASSERT_EQUALS("a", b->typeStartToken()->str());
@@ -1224,7 +1224,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    for (auto& elem : items) {\n"
                       "        if (auto x = bar()) { int y = 3; }\n"
                       "    }\n"
-                      "}");
+                      "}\n");
         const Token *x = Token::findsimplematch(tokenizer.tokens(), "x");
         ASSERT(x);
         ASSERT(x->varId());
@@ -1249,7 +1249,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void VariableValueType1() {
         GET_SYMBOL_DB("typedef uint8_t u8;\n"
-                      "static u8 x;");
+                      "static u8 x;\n");
         const Variable* x = db->getVariableFromVarId(1);
         ASSERT_EQUALS("x", x->name());
         ASSERT(x->valueType()->isIntegral());
@@ -1257,7 +1257,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void VariableValueType2() {
         GET_SYMBOL_DB("using u8 = uint8_t;\n"
-                      "static u8 x;");
+                      "static u8 x;\n");
         const Variable* x = db->getVariableFromVarId(1);
         ASSERT_EQUALS("x", x->name());
         ASSERT(x->valueType()->isIntegral());
@@ -1266,7 +1266,7 @@ class TestSymbolDatabase : public TestFixture {
     void VariableValueType3() {
         // std::string::size_type
         {
-            GET_SYMBOL_DB("void f(std::string::size_type x);");
+            GET_SYMBOL_DB("void f(std::string::size_type x);\n");
             const Variable* const x = db->getVariableFromVarId(1);
             ASSERT_EQUALS("x", x->name());
             // TODO: Configure std::string::size_type somehow.
@@ -1275,7 +1275,7 @@ class TestSymbolDatabase : public TestFixture {
         }
         // std::wstring::size_type
         {
-            GET_SYMBOL_DB("void f(std::wstring::size_type x);");
+            GET_SYMBOL_DB("void f(std::wstring::size_type x);\n");
             const Variable* const x = db->getVariableFromVarId(1);
             ASSERT_EQUALS("x", x->name());
             // TODO: Configure std::wstring::size_type somehow.
@@ -1284,7 +1284,7 @@ class TestSymbolDatabase : public TestFixture {
         }
         // std::u16string::size_type
         {
-            GET_SYMBOL_DB("void f(std::u16string::size_type x);");
+            GET_SYMBOL_DB("void f(std::u16string::size_type x);\n");
             const Variable* const x = db->getVariableFromVarId(1);
             ASSERT_EQUALS("x", x->name());
             // TODO: Configure std::u16string::size_type somehow.
@@ -1293,7 +1293,7 @@ class TestSymbolDatabase : public TestFixture {
         }
         // std::u32string::size_type
         {
-            GET_SYMBOL_DB("void f(std::u32string::size_type x);");
+            GET_SYMBOL_DB("void f(std::u32string::size_type x);\n");
             const Variable* const x = db->getVariableFromVarId(1);
             ASSERT_EQUALS("x", x->name());
             // TODO: Configure std::u32string::size_type somehow.
@@ -1306,7 +1306,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("class C {\n"
                       "public:\n"
                       "  std::shared_ptr<C> x;\n"
-                      "};");
+                      "};\n");
 
         const Variable* const x = db->getVariableFromVarId(1);
         ASSERT(x->valueType());
@@ -1315,7 +1315,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void VariableValueType5() {
         GET_SYMBOL_DB("class C {};\n"
-                      "void foo(std::shared_ptr<C>* p) {}");
+                      "void foo(std::shared_ptr<C>* p) {}\n");
 
         const Variable* const p = db->getVariableFromVarId(1);
         ASSERT(p->valueType());
@@ -1325,7 +1325,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void VariableValueType6() {
         GET_SYMBOL_DB("struct Data{};\n"
-                      "void foo() { std::unique_ptr<Data> data = std::unique_ptr<Data>(new Data); }");
+                      "void foo() { std::unique_ptr<Data> data = std::unique_ptr<Data>(new Data); }\n");
 
         const Token* check = Token::findsimplematch(tokenizer.tokens(), "( new");
         ASSERT(check);
@@ -1633,7 +1633,7 @@ class TestSymbolDatabase : public TestFixture {
                       "{\n"
                       "    struct A::B b;\n"
                       "    b.x = 1;\n"
-                      "}");
+                      "}\n");
         ASSERT(db != nullptr);
 
         const Variable* bvar = db->getVariableFromVarId(1);
@@ -1659,7 +1659,7 @@ class TestSymbolDatabase : public TestFixture {
                       "{\n"
                       "    struct B::C c;\n"
                       "    c.x = 1;\n"
-                      "}");
+                      "}\n");
         ASSERT(db != nullptr);
 
         const Variable* cvar = db->getVariableFromVarId(3);
@@ -1679,7 +1679,7 @@ class TestSymbolDatabase : public TestFixture {
                       "{\n"
                       "    struct A a;\n"
                       "    a.x = 1;\n"
-                      "}");
+                      "}\n");
         (void)db;
         const Variable* avar = Token::findsimplematch(tokenizer.tokens(), "a")->variable();
         ASSERT(avar);
@@ -1690,7 +1690,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("extern \"C\" { typedef int INT; }\n"
                       "void bar() {\n"
                       "    INT x = 3;\n"
-                      "}");
+                      "}\n");
         (void)db;
         const Variable* avar = Token::findsimplematch(tokenizer.tokens(), "x")->variable();
         ASSERT(avar);
@@ -1702,7 +1702,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("void reset() {\n"
                       "    for(auto& e : array)\n"
                       "        foo(e);\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db != nullptr);
 
@@ -1715,7 +1715,7 @@ class TestSymbolDatabase : public TestFixture {
     void isVariableStlType() {
         {
             reset();
-            GET_SYMBOL_DB("std::string s;");
+            GET_SYMBOL_DB("std::string s;\n");
             const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
             ASSERT_EQUALS(true, result);
             Variable v(vartok, tokenizer.tokens(), tokenizer.list.back(), 0, AccessControl::Public, nullptr, nullptr, settings1);
@@ -1728,7 +1728,7 @@ class TestSymbolDatabase : public TestFixture {
         }
         {
             reset();
-            GET_SYMBOL_DB("std::vector<int> v;");
+            GET_SYMBOL_DB("std::vector<int> v;\n");
             const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
             ASSERT_EQUALS(true, result);
             Variable v(vartok, tokenizer.tokens(), tokenizer.list.back(), 0, AccessControl::Public, nullptr, nullptr, settings1);
@@ -1741,7 +1741,7 @@ class TestSymbolDatabase : public TestFixture {
         }
         {
             reset();
-            GET_SYMBOL_DB("SomeClass s;");
+            GET_SYMBOL_DB("SomeClass s;\n");
             const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
             ASSERT_EQUALS(true, result);
             Variable v(vartok, tokenizer.tokens(), tokenizer.list.back(), 0, AccessControl::Public, nullptr, nullptr, settings1);
@@ -1754,7 +1754,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void isVariablePointerToConstPointer() {
         reset();
-        GET_SYMBOL_DB("char* const * s;");
+        GET_SYMBOL_DB("char* const * s;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
@@ -1765,7 +1765,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void isVariablePointerToVolatilePointer() {
         reset();
-        GET_SYMBOL_DB("char* volatile * s;");
+        GET_SYMBOL_DB("char* volatile * s;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
@@ -1776,7 +1776,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void isVariablePointerToConstVolatilePointer() {
         reset();
-        GET_SYMBOL_DB("char* const volatile * s;");
+        GET_SYMBOL_DB("char* const volatile * s;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
@@ -1787,7 +1787,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void isVariableMultiplePointersAndQualifiers() {
         reset();
-        GET_SYMBOL_DB("const char* const volatile * const volatile * const volatile * const volatile s;");
+        GET_SYMBOL_DB("const char* const volatile * const volatile * const volatile * const volatile s;\n");
         const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens()->next(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
@@ -1798,7 +1798,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void variableVolatile() {
         GET_SYMBOL_DB("std::atomic<int> x;\n"
-                      "volatile int y;");
+                      "volatile int y;\n");
 
         const Token *x = Token::findsimplematch(tokenizer.tokens(), "x");
         ASSERT(x);
@@ -1812,7 +1812,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void variableConstexpr() {
-        GET_SYMBOL_DB("constexpr int x = 16;");
+        GET_SYMBOL_DB("constexpr int x = 16;\n");
 
         const Token *x = Token::findsimplematch(tokenizer.tokens(), "x");
         ASSERT(x);
@@ -1869,7 +1869,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void f() {\n"
                       "    struct Bar bar;\n"
                       "    bar.x = 123;\n"  // <- x should get a variable() pointer
-                      "}");
+                      "}\n");
 
         ASSERT(db != nullptr);
         const Token *tok = Token::findsimplematch(tokenizer.tokens(), "x =");
@@ -1900,7 +1900,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void f() {\n"
                       "    struct Foo foo[10];\n"
                       "    foo[1].x = 123;\n"  // <- x should get a variable() pointer
-                      "}");
+                      "}\n");
 
         const Token *tok = Token::findsimplematch(tokenizer.tokens(), ". x");
         tok = tok ? tok->next() : nullptr;
@@ -1916,7 +1916,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void f() {\n"
                       "    struct Foo foo[10][10];\n"
                       "    foo[1][2].x = 123;\n"  // <- x should get a variable() pointer
-                      "}");
+                      "}\n");
 
         const Token *tok = Token::findsimplematch(tokenizer.tokens(), ". x");
         tok = tok ? tok->next() : nullptr;
@@ -1932,7 +1932,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void f() {\n"
                       "    struct Foo foo[10];\n"
                       "    (foo[1]).x = 123;\n"  // <- x should get a variable() pointer
-                      "}");
+                      "}\n");
 
         const Token *tok = Token::findsimplematch(tokenizer.tokens(), ". x");
         tok = tok ? tok->next() : nullptr;
@@ -1958,7 +1958,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("class Foo {\n"
                       "    static const double d;\n"
                       "};\n"
-                      "const double Foo::d = 5.0;");
+                      "const double Foo::d = 5.0;\n");
 
         const Variable* v = db->getVariableFromVarId(1);
         ASSERT(v && db->variableList().size() == 2);
@@ -1967,7 +1967,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void getVariableFromVarIdBoundsCheck() {
         GET_SYMBOL_DB("int x;\n"
-                      "int y;");
+                      "int y;\n");
 
         const Variable* v = db->getVariableFromVarId(2);
         // three elements: varId 0 also counts via a fake-entry
@@ -1984,7 +1984,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasRegularFunction() {
-        GET_SYMBOL_DB("void func() { }");
+        GET_SYMBOL_DB("void func() { }\n");
 
         // 2 scopes: Global and Function
         ASSERT(db && db->scopeList.size() == 2);
@@ -2005,7 +2005,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasRegularFunction_trailingReturnType() {
-        GET_SYMBOL_DB("auto func() -> int { }");
+        GET_SYMBOL_DB("auto func() -> int { }\n");
 
         // 2 scopes: Global and Function
         ASSERT(db && db->scopeList.size() == 2);
@@ -2026,7 +2026,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasInlineClassFunction() {
-        GET_SYMBOL_DB("class Fred { void func() { } };");
+        GET_SYMBOL_DB("class Fred { void func() { } };\n");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
@@ -2053,7 +2053,7 @@ class TestSymbolDatabase : public TestFixture {
 
 
     void hasInlineClassFunction_trailingReturnType() {
-        GET_SYMBOL_DB("class Fred { auto func() -> int { } };");
+        GET_SYMBOL_DB("class Fred { auto func() -> int { } };\n");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
@@ -2079,7 +2079,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasMissingInlineClassFunction() {
-        GET_SYMBOL_DB("class Fred { void func(); };");
+        GET_SYMBOL_DB("class Fred { void func(); };\n");
 
         // 2 scopes: Global and Class (no Function scope because there is no function implementation)
         ASSERT(db && db->scopeList.size() == 2);
@@ -2098,7 +2098,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasInlineClassOperatorTemplate() {
-        GET_SYMBOL_DB("struct Fred { template<typename T> Foo & operator=(const Foo &) { return *this; } };");
+        GET_SYMBOL_DB("struct Fred { template<typename T> Foo & operator=(const Foo &) { return *this; } };\n");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
@@ -2124,7 +2124,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasClassFunction() {
-        GET_SYMBOL_DB("class Fred { void func(); }; void Fred::func() { }");
+        GET_SYMBOL_DB("class Fred { void func(); }; void Fred::func() { }\n");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
@@ -2146,7 +2146,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasClassFunction_trailingReturnType() {
-        GET_SYMBOL_DB("class Fred { auto func() -> int; }; auto Fred::func() -> int { }");
+        GET_SYMBOL_DB("class Fred { auto func() -> int; }; auto Fred::func() -> int { }\n");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
@@ -2169,7 +2169,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void hasClassFunction_decltype_auto()
     {
-        GET_SYMBOL_DB("struct d { decltype(auto) f() {} };");
+        GET_SYMBOL_DB("struct d { decltype(auto) f() {} };\n");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
@@ -2190,7 +2190,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasRegularFunctionReturningFunctionPointer() {
-        GET_SYMBOL_DB("void (*func(int f))(char) { }");
+        GET_SYMBOL_DB("void (*func(int f))(char) { }\n");
 
         // 2 scopes: Global and Function
         ASSERT(db && db->scopeList.size() == 2);
@@ -2209,7 +2209,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasInlineClassFunctionReturningFunctionPointer() {
-        GET_SYMBOL_DB("class Fred { void (*func(int f))(char) { } };");
+        GET_SYMBOL_DB("class Fred { void (*func(int f))(char) { } };\n");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
@@ -2228,7 +2228,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasMissingInlineClassFunctionReturningFunctionPointer() {
-        GET_SYMBOL_DB("class Fred { void (*func(int f))(char); };");
+        GET_SYMBOL_DB("class Fred { void (*func(int f))(char); };\n");
 
         // 2 scopes: Global and Class (no Function scope because there is no function implementation)
         ASSERT(db && db->scopeList.size() == 2);
@@ -2247,7 +2247,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasClassFunctionReturningFunctionPointer() {
-        GET_SYMBOL_DB("class Fred { void (*func(int f))(char); }; void (*Fred::func(int f))(char) { }");
+        GET_SYMBOL_DB("class Fred { void (*func(int f))(char); }; void (*Fred::func(int f))(char) { }\n");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
@@ -2266,7 +2266,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void methodWithRedundantScope() {
-        GET_SYMBOL_DB("class Fred { void Fred::func() {} };");
+        GET_SYMBOL_DB("class Fred { void Fred::func() {} };\n");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
@@ -2294,7 +2294,7 @@ class TestSymbolDatabase : public TestFixture {
                       "float(*(*a2[10])(char))(long);\n"            // array 10 of pointer to func (char) returning pointer to func (long) returning float
                       "short(*(*(*a3[10])(char))(long))(double);\n" // array 10 of pointer to function (char) returning pointer to function (long) returning pointer to function (double) returning short
                       "::boost::rational(&r_)[9];\n"                // reference to array of ::boost::rational
-                      "::boost::rational<T>(&r_)[9];");             // reference to array of ::boost::rational<T> (template!)
+                      "::boost::rational<T>(&r_)[9];\n");             // reference to array of ::boost::rational<T> (template!)
 
         ASSERT(db != nullptr);
 
@@ -2314,7 +2314,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void pointerToMemberFunction() {
-        GET_SYMBOL_DB("bool (A::*pFun)();"); // Pointer to member function of A, returning bool and taking no parameters
+        GET_SYMBOL_DB("bool (A::*pFun)();\n"); // Pointer to member function of A, returning bool and taking no parameters
 
         ASSERT(db != nullptr);
 
@@ -2326,7 +2326,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasSubClassConstructor() {
-        GET_SYMBOL_DB("class Foo { class Sub; }; class Foo::Sub { Sub() {} };");
+        GET_SYMBOL_DB("class Foo { class Sub; }; class Foo::Sub { Sub() {} };\n");
         ASSERT(db != nullptr);
 
         bool seen_something = false;
@@ -2343,73 +2343,73 @@ class TestSymbolDatabase : public TestFixture {
 
     void testConstructors() {
         {
-            GET_SYMBOL_DB("class Foo { Foo(); };");
+            GET_SYMBOL_DB("class Foo { Foo(); };\n");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
             ASSERT(db && ctor && ctor->type == FunctionType::eConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
-            GET_SYMBOL_DB("class Foo { Foo(Foo f); };");
+            GET_SYMBOL_DB("class Foo { Foo(Foo f); };\n");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
             ASSERT(db && ctor && ctor->type == FunctionType::eConstructor && !ctor->isExplicit());
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
-            GET_SYMBOL_DB("class Foo { explicit Foo(Foo f); };");
+            GET_SYMBOL_DB("class Foo { explicit Foo(Foo f); };\n");
             const Function* ctor = tokenizer.tokens()->tokAt(4)->function();
             ASSERT(db && ctor && ctor->type == FunctionType::eConstructor && ctor->isExplicit());
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
-            GET_SYMBOL_DB("class Foo { Foo(Bar& f); };");
+            GET_SYMBOL_DB("class Foo { Foo(Bar& f); };\n");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
             ASSERT(db && ctor && ctor->type == FunctionType::eConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
-            GET_SYMBOL_DB("class Foo { Foo(Foo& f); };");
+            GET_SYMBOL_DB("class Foo { Foo(Foo& f); };\n");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
             ASSERT(db && ctor && ctor->type == FunctionType::eCopyConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
-            GET_SYMBOL_DB("class Foo { Foo(const Foo &f); };");
+            GET_SYMBOL_DB("class Foo { Foo(const Foo &f); };\n");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
             ASSERT(db && ctor && ctor->type == FunctionType::eCopyConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
-            GET_SYMBOL_DB("template <T> class Foo { Foo(Foo<T>& f); };");
+            GET_SYMBOL_DB("template <T> class Foo { Foo(Foo<T>& f); };\n");
             const Function* ctor = tokenizer.tokens()->tokAt(7)->function();
             ASSERT(db && ctor && ctor->type == FunctionType::eCopyConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
-            GET_SYMBOL_DB("class Foo { Foo(Foo& f, int default = 0); };");
+            GET_SYMBOL_DB("class Foo { Foo(Foo& f, int default = 0); };\n");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
             ASSERT(db && ctor && ctor->type == FunctionType::eCopyConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
-            GET_SYMBOL_DB("class Foo { Foo(Foo& f, char noDefault); };");
+            GET_SYMBOL_DB("class Foo { Foo(Foo& f, char noDefault); };\n");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
             ASSERT(db && ctor && ctor->type == FunctionType::eConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
-            GET_SYMBOL_DB("class Foo { Foo(Foo&& f); };");
+            GET_SYMBOL_DB("class Foo { Foo(Foo&& f); };\n");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
             ASSERT(db && ctor && ctor->type == FunctionType::eMoveConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
-            GET_SYMBOL_DB("class Foo { Foo(Foo&& f, int default = 1, bool defaultToo = true); };");
+            GET_SYMBOL_DB("class Foo { Foo(Foo&& f, int default = 1, bool defaultToo = true); };\n");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
             ASSERT(db && ctor && ctor->type == FunctionType::eMoveConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
-            GET_SYMBOL_DB("void f() { extern void f(); }");
+            GET_SYMBOL_DB("void f() { extern void f(); }\n");
             ASSERT(db && db->scopeList.size() == 2);
             const Function* f = findFunctionByName("f", &db->scopeList.back());
             ASSERT(f && f->type == FunctionType::eFunction);
@@ -2417,7 +2417,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void functionDeclarationTemplate() {
-        GET_SYMBOL_DB("std::map<int, string> foo() {}");
+        GET_SYMBOL_DB("std::map<int, string> foo() {}\n");
 
         // 2 scopes: Global and Function
         ASSERT(db && db->scopeList.size() == 2 && findFunctionByName("foo", &db->scopeList.back()));
@@ -2433,7 +2433,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void functionDeclarations() {
-        GET_SYMBOL_DB("void foo();\nvoid foo();\nint foo(int i);\nvoid foo() {}");
+        GET_SYMBOL_DB("void foo();\nvoid foo();\nint foo(int i);\nvoid foo() {}\n");
 
         // 2 scopes: Global and Function
         ASSERT(db && db->scopeList.size() == 2 && findFunctionByName("foo", &db->scopeList.back()));
@@ -2458,7 +2458,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void functionDeclarations2() {
-        GET_SYMBOL_DB("std::array<int,2> foo(int x);");
+        GET_SYMBOL_DB("std::array<int,2> foo(int x);\n");
 
         // 1 scopes: Global
         ASSERT(db && db->scopeList.size() == 1);
@@ -2479,7 +2479,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void constexprFunction() {
-        GET_SYMBOL_DB("constexpr int foo();");
+        GET_SYMBOL_DB("constexpr int foo();\n");
 
         // 1 scopes: Global
         ASSERT(db && db->scopeList.size() == 1);
@@ -2498,7 +2498,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void constructorInitialization() {
         GET_SYMBOL_DB("std::string logfile;\n"
-                      "std::ofstream log(logfile.c_str(), std::ios::out);");
+                      "std::ofstream log(logfile.c_str(), std::ios::out);\n");
 
         // 1 scope: Global
         ASSERT(db && db->scopeList.size() == 1);
@@ -2512,7 +2512,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void ScVbaValidation::getFormula1() {\n"
                       "    sal_uInt16 nFlags = 0;\n"
                       "    if (pDocSh && !getCellRangesForAddress(nFlags)) ;\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db && errout_str().empty());
 
@@ -2526,7 +2526,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void getFormula1() {\n"
                       "    sal_uInt16 nFlags = 0;\n"
                       "    if (pDocSh && !getCellRangesForAddress(nFlags)) ;\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db && errout_str().empty());
 
@@ -2544,7 +2544,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void ScVbaValidation::getFormula1() {\n"
                       "    sal_uInt16 nFlags = 0;\n"
                       "    if (pDocSh && !getCellRangesForAddress(nFlags)) ;\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db && errout_str().empty());
 
@@ -2559,7 +2559,7 @@ class TestSymbolDatabase : public TestFixture {
                       "extern void f3();\n"
                       "void f4();\n"
                       "extern void f5() { };\n"
-                      "void f6() { }");
+                      "void f6() { }\n");
 
         ASSERT(db && errout_str().empty());
 
@@ -2613,7 +2613,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void classWithFriend() {
-        GET_SYMBOL_DB("class Foo {}; class Bar1 { friend class Foo; }; class Bar2 { friend Foo; };");
+        GET_SYMBOL_DB("class Foo {}; class Bar1 { friend class Foo; }; class Bar2 { friend Foo; };\n");
         // 3 scopes: Global, 3 classes
         ASSERT(db && db->scopeList.size() == 4);
 
@@ -2630,7 +2630,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void parseFunctionCorrect() {
         // ticket 3188 - "if" statement parsed as function
-        GET_SYMBOL_DB("void func(i) int i; { if (i == 1) return; }");
+        GET_SYMBOL_DB("void func(i) int i; { if (i == 1) return; }\n");
         ASSERT(db != nullptr);
 
         // 3 scopes: Global, function, if
@@ -2643,7 +2643,7 @@ class TestSymbolDatabase : public TestFixture {
     void parseFunctionDeclarationCorrect() {
         GET_SYMBOL_DB("void func();\n"
                       "int bar() {}\n"
-                      "void func() {}");
+                      "void func() {}\n");
         ASSERT_EQUALS(3, db->findScopeByName("func")->bodyStart->linenr());
     }
 
@@ -2652,12 +2652,12 @@ class TestSymbolDatabase : public TestFixture {
                       "    std::vector<std::string> bar;\n"
                       "    Foo() : bar({\"a\", \"b\"})\n"
                       "    {}\n"
-                      "};");
+                      "};\n");
         ASSERT_EQUALS(4, db->scopeList.front().nestedList.front()->nestedList.front()->bodyStart->linenr());
     }
 
     void hasGlobalVariables1() {
-        GET_SYMBOL_DB("int i;");
+        GET_SYMBOL_DB("int i;\n");
 
         ASSERT(db && db->scopeList.size() == 1);
 
@@ -2669,7 +2669,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasGlobalVariables2() {
-        GET_SYMBOL_DB("int array[2][2];");
+        GET_SYMBOL_DB("int array[2][2];\n");
 
         ASSERT(db && db->scopeList.size() == 1);
 
@@ -2682,7 +2682,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void hasGlobalVariables3() {
-        GET_SYMBOL_DB("int array[2][2] = { { 0, 0 }, { 0, 0 } };");
+        GET_SYMBOL_DB("int array[2][2] = { { 0, 0 }, { 0, 0 } };\n");
 
         ASSERT(db && db->scopeList.size() == 1);
 
@@ -2699,7 +2699,7 @@ class TestSymbolDatabase : public TestFixture {
                       "static const std::string j;\n"
                       "const std::string* k;\n"
                       "const char m[];\n"
-                      "void f(const char* const l) {}");
+                      "void f(const char* const l) {}\n");
 
         ASSERT(db && db->variableList().size() == 6 && db->getVariableFromVarId(1) && db->getVariableFromVarId(2) && db->getVariableFromVarId(3) && db->getVariableFromVarId(4) && db->getVariableFromVarId(5));
 
@@ -2728,12 +2728,12 @@ class TestSymbolDatabase : public TestFixture {
                       "    if (Diags.hasErrorOccurred())\n"
                       "      return;\n"
                       "  }\n"
-                      "};");
+                      "};\n");
         ASSERT_EQUALS("DiagnosticsEngine", db->getVariableFromVarId(1)->typeStartToken()->str());
     }
 
     void checkTypeStartEndToken3() {
-        GET_SYMBOL_DB("void f(const char) {}");
+        GET_SYMBOL_DB("void f(const char) {}\n");
 
         ASSERT(db && db->functionScopes.size()==1U);
 
@@ -2762,7 +2762,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void functionArgs1() {
         {
-            GET_SYMBOL_DB("void f(std::vector<std::string>, const std::vector<int> & v) { }");
+            GET_SYMBOL_DB("void f(std::vector<std::string>, const std::vector<int> & v) { }\n");
             ASSERT_EQUALS(1+1, db->variableList().size());
             const Variable* v = db->getVariableFromVarId(1);
             ASSERT(v && v->isReference() && v->isConst() && v->isArgument());
@@ -2773,7 +2773,7 @@ class TestSymbolDatabase : public TestFixture {
             ASSERT_EQUALS("", errout_str());
         }
         {
-            GET_SYMBOL_DB("void g(std::map<std::string, std::vector<int> > m) { }");
+            GET_SYMBOL_DB("void g(std::map<std::string, std::vector<int> > m) { }\n");
             ASSERT_EQUALS(1+1, db->variableList().size());
             const Variable* m = db->getVariableFromVarId(1);
             ASSERT(m && !m->isReference() && !m->isConst() && m->isArgument() && m->isClass());
@@ -2782,25 +2782,25 @@ class TestSymbolDatabase : public TestFixture {
             ASSERT_EQUALS("", errout_str());
         }
         {
-            GET_SYMBOL_DB("void g(std::map<int, int> m = std::map<int, int>()) { }");
+            GET_SYMBOL_DB("void g(std::map<int, int> m = std::map<int, int>()) { }\n");
             const Scope* g = db->findScopeByName("g");
             ASSERT(g && g->type == ScopeType::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().index() == 0 && g->function->initializedArgCount() == 1);
             ASSERT_EQUALS("", errout_str());
         }
         {
-            GET_SYMBOL_DB("void g(int = 0) { }");
+            GET_SYMBOL_DB("void g(int = 0) { }\n");
             const Scope* g = db->findScopeByName("g");
             ASSERT(g && g->type == ScopeType::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().hasDefault());
             ASSERT_EQUALS("", errout_str());
         }
         {
-            GET_SYMBOL_DB("void g(int*) { }"); // unnamed pointer argument (#8052)
+            GET_SYMBOL_DB("void g(int*) { }\n"); // unnamed pointer argument (#8052)
             const Scope* g = db->findScopeByName("g");
             ASSERT(g && g->type == ScopeType::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().nameToken() == nullptr && g->function->argumentList.front().isPointer());
             ASSERT_EQUALS("", errout_str());
         }
         {
-            GET_SYMBOL_DB("void g(int* const) { }"); // 'const' is not the name of the variable - #5882
+            GET_SYMBOL_DB("void g(int* const) { }\n"); // 'const' is not the name of the variable - #5882
             const Scope* g = db->findScopeByName("g");
             ASSERT(g && g->type == ScopeType::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().nameToken() == nullptr);
             ASSERT_EQUALS("", errout_str());
@@ -2808,7 +2808,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void functionArgs2() {
-        GET_SYMBOL_DB("void f(int a[][4]) { }");
+        GET_SYMBOL_DB("void f(int a[][4]) { }\n");
         const Variable *a = db->getVariableFromVarId(1);
         ASSERT_EQUALS("a", a->nameToken()->str());
         ASSERT_EQUALS(2UL, a->dimensions().size());
@@ -2819,7 +2819,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void functionArgs4() {
-        GET_SYMBOL_DB("void f1(char [10], struct foo [10]);");
+        GET_SYMBOL_DB("void f1(char [10], struct foo [10]);\n");
         ASSERT_EQUALS(true, db->scopeList.front().functionList.size() == 1UL);
         const Function *func = &db->scopeList.front().functionList.front();
         ASSERT_EQUALS(true, func && func->argumentList.size() == 2UL);
@@ -2839,7 +2839,7 @@ class TestSymbolDatabase : public TestFixture {
                       "class Y {\n"
                       "  enum ABC {A,B,C};\n"
                       "  void f(enum ABC abc) {}\n"
-                      "};");
+                      "};\n");
         ASSERT_EQUALS(true, db != nullptr);
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "f ( enum");
         ASSERT_EQUALS(true, f && f->function());
@@ -2854,7 +2854,7 @@ class TestSymbolDatabase : public TestFixture {
                       "class Y {\n"
                       "  enum ABC {A,B,C};\n"
                       "  void f(ABC abc) {}\n"
-                      "};");
+                      "};\n");
         ASSERT_EQUALS(true, db != nullptr);
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "f ( ABC");
         ASSERT_EQUALS(true, f && f->function());
@@ -2871,7 +2871,7 @@ class TestSymbolDatabase : public TestFixture {
                           "void bar() {\n"
                           "  struct AB ab;\n"
                           "  foo(&ab);\n"
-                          "};");
+                          "};\n");
             ASSERT_EQUALS(true, db != nullptr);
             const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( & ab");
             ASSERT_EQUALS(true, f && f->function());
@@ -2886,7 +2886,7 @@ class TestSymbolDatabase : public TestFixture {
                           "void bar() {\n"
                           "  struct AB ab;\n"
                           "  foo(&ab);\n"
-                          "};");
+                          "};\n");
             ASSERT_EQUALS(true, db != nullptr);
             const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( & ab");
             ASSERT_EQUALS(true, f && f->function());
@@ -2901,7 +2901,7 @@ class TestSymbolDatabase : public TestFixture {
                           "void bar() {\n"
                           "  AB ab;\n"
                           "  foo(&ab);\n"
-                          "};");
+                          "};\n");
             ASSERT_EQUALS(true, db != nullptr);
             const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( & ab");
             ASSERT_EQUALS(true, f && f->function());
@@ -2916,7 +2916,7 @@ class TestSymbolDatabase : public TestFixture {
                           "void bar() {\n"
                           "  AB ab;\n"
                           "  foo(&ab);\n"
-                          "};");
+                          "};\n");
             ASSERT_EQUALS(true, db != nullptr);
             const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( & ab");
             ASSERT_EQUALS(true, f && f->function());
@@ -2935,7 +2935,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void bar() {\n"
                       "  struct B b;\n"
                       "  foo(b);\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS(true, db != nullptr);
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( b");
         ASSERT_EQUALS(true, f && f->function());
@@ -2951,7 +2951,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    enum C { };\n"
                       "  };\n"
                       "};\n"
-                      "void foo(A::B::C c) { }");
+                      "void foo(A::B::C c) { }\n");
         ASSERT_EQUALS(true, db != nullptr);
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo (");
         ASSERT_EQUALS(true, f && f->function());
@@ -2966,7 +2966,7 @@ class TestSymbolDatabase : public TestFixture {
                       "public:\n"
                       "  Fred(Whitespace = PRESERVE_WHITESPACE);\n"
                       "};\n"
-                      "Fred::Fred(Whitespace whitespace) { }");
+                      "Fred::Fred(Whitespace whitespace) { }\n");
         ASSERT_EQUALS(true, db != nullptr);
         ASSERT_EQUALS(3, db->scopeList.size());
         auto scope = db->scopeList.cbegin();
@@ -2984,7 +2984,7 @@ class TestSymbolDatabase : public TestFixture {
                       "public:\n"
                       "  void foo(char a[16]);\n"
                       "};\n"
-                      "void Fred::foo(char b[16]) { }");
+                      "void Fred::foo(char b[16]) { }\n");
         ASSERT_EQUALS(true, db != nullptr);
         ASSERT_EQUALS(3, db->scopeList.size());
         auto scope = db->scopeList.cbegin();
@@ -3004,7 +3004,7 @@ class TestSymbolDatabase : public TestFixture {
                       "};\n"
                       "struct B : public A {\n"
                       "    void foo(B::E e) { }\n"
-                      "};");
+                      "};\n");
 
         ASSERT_EQUALS(true, db != nullptr);
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo (");
@@ -3025,7 +3025,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    B(S s);\n"
                       "};\n"
                       "B::B(A::E e) { }\n"
-                      "B::B(A::S s) { }");
+                      "B::B(A::S s) { }\n");
 
         ASSERT_EQUALS(true, db != nullptr);
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "B ( A :: E");
@@ -3044,7 +3044,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void functionArgs14() { // #7697
-        GET_SYMBOL_DB("void f(int (&a)[10], int (&b)[10]);");
+        GET_SYMBOL_DB("void f(int (&a)[10], int (&b)[10]);\n");
         (void)db;
         const Function *func = tokenizer.tokens()->next()->function();
         ASSERT_EQUALS(true, func != nullptr);
@@ -3080,7 +3080,7 @@ class TestSymbolDatabase : public TestFixture {
     void functionArgs16() { // #9591
         const char code[] =
             "struct A { int var; };\n"
-            "void foo(int x, decltype(A::var) *&p) {}";
+            "void foo(int x, decltype(A::var) *&p) {}\n";
         GET_SYMBOL_DB(code);
         ASSERT(db);
         const Scope *scope = db->functionScopes.front();
@@ -3093,7 +3093,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void functionArgs17() {
-        const char code[] = "void f(int (*fp)(), int x, int y) {}";
+        const char code[] = "void f(int (*fp)(), int x, int y) {}\n";
         GET_SYMBOL_DB(code);
         ASSERT(db != nullptr);
         const Scope *scope = db->functionScopes.front();
@@ -3102,7 +3102,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void functionArgs18() {
-        const char code[] = "void f(int (*param1)[2], int param2) {}";
+        const char code[] = "void f(int (*param1)[2], int param2) {}\n";
         GET_SYMBOL_DB(code);
         ASSERT(db != nullptr);
         const Scope *scope = db->functionScopes.front();
@@ -3111,7 +3111,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void functionArgs19() {
-        const char code[] = "void f(int (*fp)(int), int x, int y) {}";
+        const char code[] = "void f(int (*fp)(int), int x, int y) {}\n";
         GET_SYMBOL_DB(code);
         ASSERT(db != nullptr);
         const Scope *scope = db->functionScopes.front();
@@ -3121,7 +3121,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void functionArgs20() {
         {
-            const char code[] = "void f(void *(*g)(void *) = [](void *p) { return p; }) {}"; // #11769
+            const char code[] = "void f(void *(*g)(void *) = [](void *p) { return p; }) {}\n"; // #11769
             GET_SYMBOL_DB(code);
             ASSERT(db != nullptr);
             const Scope *scope = db->functionScopes.front();
@@ -3131,7 +3131,7 @@ class TestSymbolDatabase : public TestFixture {
             TODO_ASSERT(arg->hasDefault());
         }
         {
-            const char code[] = "void f() { auto g = [&](const std::function<int(int)>& h = [](int i) -> int { return i; }) {}; }"; // #12338
+            const char code[] = "void f() { auto g = [&](const std::function<int(int)>& h = [](int i) -> int { return i; }) {}; }\n"; // #12338
             GET_SYMBOL_DB(code);
             ASSERT(db != nullptr);
             ASSERT_EQUALS(3, db->scopeList.size());
@@ -3162,7 +3162,7 @@ class TestSymbolDatabase : public TestFixture {
                             "template<typename T>\n"
                             "struct S { using t = int; };\n"
                             "template<typename T>\n"
-                            "S<T> operator+(const S<T>&lhs, typename S<T>::t) { return lhs; }";
+                            "S<T> operator+(const S<T>&lhs, typename S<T>::t) { return lhs; }\n";
         GET_SYMBOL_DB(code);
         ASSERT(db != nullptr);
         auto it = db->functionScopes.begin();
@@ -3198,7 +3198,7 @@ class TestSymbolDatabase : public TestFixture {
     void functionImplicitlyVirtual() {
         GET_SYMBOL_DB("class base { virtual void f(); };\n"
                       "class derived : base { void f(); };\n"
-                      "void derived::f() {}");
+                      "void derived::f() {}\n");
         ASSERT(db != nullptr);
         ASSERT_EQUALS(4, db->scopeList.size());
         const Function *function = db->scopeList.back().function;
@@ -3224,7 +3224,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void functionIsInlineKeyword() {
-        GET_SYMBOL_DB("inline void fs() {}");
+        GET_SYMBOL_DB("inline void fs() {}\n");
         (void)db;
         const Function *func = db->scopeList.back().function;
         ASSERT(func);
@@ -3232,7 +3232,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void functionStatic() {
-        GET_SYMBOL_DB("static void fs() {  }");
+        GET_SYMBOL_DB("static void fs() {  }\n");
         (void)db;
         const Function *func = db->scopeList.back().function;
         ASSERT(func);
@@ -3240,7 +3240,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void functionReturnsReference() {
-        GET_SYMBOL_DB("Fred::Reference foo();");
+        GET_SYMBOL_DB("Fred::Reference foo();\n");
         ASSERT_EQUALS(1, db->scopeList.back().functionList.size());
         const Function &func = *db->scopeList.back().functionList.cbegin();
         ASSERT(!Function::returnsReference(&func, false));
@@ -3253,7 +3253,7 @@ class TestSymbolDatabase : public TestFixture {
                       "        class X { X(int); };\n"
                       "    }\n"
                       "}\n"
-                      "namespace barney { X::X(int) { } }");
+                      "namespace barney { X::X(int) { } }\n");
 
         // Locate the scope for the class..
         auto it = std::find_if(db->scopeList.cbegin(), db->scopeList.cend(), [](const Scope& s) {
@@ -3284,7 +3284,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    namespace barney {\n"
                       "        X::X(int) { }\n"
                       "    }\n"
-                      "}");
+                      "}\n");
 
         // Locate the scope for the class..
         auto it = std::find_if(db->scopeList.cbegin(), db->scopeList.cend(), [](const Scope& s) {
@@ -3307,7 +3307,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void namespaces3() { // #3854 - namespace with unknown macro
         GET_SYMBOL_DB("namespace fred UNKNOWN_MACRO(default) {\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS(2U, db->scopeList.size());
         ASSERT_EQUALS_ENUM(ScopeType::eGlobal, db->scopeList.front().type);
         ASSERT_EQUALS_ENUM(ScopeType::eNamespace, db->scopeList.back().type);
@@ -3316,7 +3316,7 @@ class TestSymbolDatabase : public TestFixture {
     void namespaces4() { // #4698 - type lookup
         GET_SYMBOL_DB("struct A { int a; };\n"
                       "namespace fred { struct A {}; }\n"
-                      "fred::A fredA;");
+                      "fred::A fredA;\n");
         const Variable *fredA = db->getVariableFromVarId(2U);
         ASSERT_EQUALS("fredA", fredA->name());
         const Type *fredAType = fredA->type();
@@ -3370,7 +3370,7 @@ class TestSymbolDatabase : public TestFixture {
                            "    catch (const X::Error2 & x) { }\n"
                            "    catch (Error3 x) { }\n"
                            "    catch (X::Error4 x) { }\n"
-                           "}";
+                           "}\n";
         GET_SYMBOL_DB(str);
         ASSERT_EQUALS("", errout_str());
         ASSERT(db && db->variableList().size() == 5); // index 0 + 4 variables
@@ -3381,11 +3381,11 @@ class TestSymbolDatabase : public TestFixture {
     void symboldatabase1() {
         check("namespace foo {\n"
               "    class bar;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class foo : public bar < int, int> {\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3393,13 +3393,13 @@ class TestSymbolDatabase : public TestFixture {
         check("class foo {\n"
               "public:\n"
               "foo() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class foo {\n"
               "class bar;\n"
               "foo() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3407,7 +3407,7 @@ class TestSymbolDatabase : public TestFixture {
         check("typedef void (func_type)();\n"
               "struct A {\n"
               "    friend func_type f : 2;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3415,14 +3415,14 @@ class TestSymbolDatabase : public TestFixture {
         check("static void function_declaration_before(void) __attribute__((__used__));\n"
               "static void function_declaration_before(void) {}\n"
               "static void function_declaration_after(void) {}\n"
-              "static void function_declaration_after(void) __attribute__((__used__));");
+              "static void function_declaration_after(void) __attribute__((__used__));\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("main(int argc, char *argv[]) { }", true, false);
+        check("main(int argc, char *argv[]) { }\n", true, false);
         ASSERT_EQUALS("", errout_str());
 
         const Settings s = settingsBuilder(settings1).severity(Severity::portability).build();
-        check("main(int argc, char *argv[]) { }", false, false, &s);
+        check("main(int argc, char *argv[]) { }\n", false, false, &s);
         ASSERT_EQUALS("[test.c:1:1]: (portability) Omitted return type of function 'main' defaults to int, this is not supported by ISO C99 and later standards. [returnImplicitInt]\n",
                       errout_str());
 
@@ -3431,7 +3431,7 @@ class TestSymbolDatabase : public TestFixture {
               "    {\n"
               "        return std::locale();\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("namespace X {\n"
@@ -3439,12 +3439,12 @@ class TestSymbolDatabase : public TestFixture {
               "    static void function_declaration_before(void) {}\n"
               "    static void function_declaration_after(void) {}\n"
               "    static void function_declaration_after(void) __attribute__((__used__));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("testing::testing()\n"
               "{\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:1:10]: (debug) Executable scope 'testing' with unknown function. [symbolDatabaseWarning]\n"
             "[test.cpp:1:10]: (debug) Executable scope 'testing' with unknown function. [symbolDatabaseWarning]\n", // duplicate
@@ -3455,7 +3455,7 @@ class TestSymbolDatabase : public TestFixture {
         // ticket #2178 - segmentation fault
         ASSERT_THROW_INTERNAL(check("int CL_INLINE_DECL(integer_decode_float) (int x) {\n"
                                     "    return (sign ? cl_I() : 0);\n"
-                                    "}"), UNKNOWN_MACRO);
+                                    "}\n"), UNKNOWN_MACRO);
     }
 
     void symboldatabase6() {
@@ -3481,7 +3481,7 @@ class TestSymbolDatabase : public TestFixture {
               "{\n"
               "public:\n"
               "    int f() { return C< ::D,int>::f(); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3494,7 +3494,7 @@ class TestSymbolDatabase : public TestFixture {
               "    {\n"
               "        return vcl::unotools::createStandardColorSpace();\n"
               "    }\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3521,7 +3521,7 @@ class TestSymbolDatabase : public TestFixture {
               "};\n"
               "class B {\n"
               "  friend void A::f();\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3531,7 +3531,7 @@ class TestSymbolDatabase : public TestFixture {
         check("int g ();\n"
               "struct S {\n"
               "  int i : (false ? g () : 1);\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3540,7 +3540,7 @@ class TestSymbolDatabase : public TestFixture {
         // ticket #2547 - segmentation fault
         check("class foo {\n"
               "    void bar2 () = __null;\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3549,7 +3549,7 @@ class TestSymbolDatabase : public TestFixture {
         // ticket #2577 - segmentation fault
         check("class foo {\n"
               "    void bar2 () = A::f;\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3561,14 +3561,14 @@ class TestSymbolDatabase : public TestFixture {
 
     void symboldatabase17() {
         // ticket #2657 - segmentation fault
-        check("{return f(){}}");
+        check("{return f(){}}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase19() {
         // ticket #2991 - segmentation fault
-        check("::y(){x}");
+        check("::y(){x}\n");
 
         ASSERT_EQUALS(
             "[test.cpp:1:3]: (debug) Executable scope 'y' with unknown function. [symbolDatabaseWarning]\n"
@@ -3589,7 +3589,7 @@ class TestSymbolDatabase : public TestFixture {
               "};\n"
               "Fred::func() const {\n"
               "    Foo foo;\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -3597,13 +3597,13 @@ class TestSymbolDatabase : public TestFixture {
     // ticket 3437 (segmentation fault)
     void symboldatabase22() {
         check("template <class C> struct A {};\n"
-              "A<int> a;");
+              "A<int> a;\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     // ticket 3435 (std::vector)
     void symboldatabase23() {
-        GET_SYMBOL_DB("class A { std::vector<int*> ints; };");
+        GET_SYMBOL_DB("class A { std::vector<int*> ints; };\n");
         ASSERT_EQUALS(2U, db->scopeList.size());
         const Scope &scope = db->scopeList.back();
         ASSERT_EQUALS(1U, scope.varlist.size());
@@ -3619,7 +3619,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    Fred();\n"
                       "};\n"
                       "Fred::Fred() { }\n"
-                      "Fred::~Fred() { }");
+                      "Fred::~Fred() { }\n");
         // Global scope, Fred, Fred::Fred, Fred::~Fred
         ASSERT_EQUALS(4U, db->scopeList.size());
 
@@ -3656,7 +3656,7 @@ class TestSymbolDatabase : public TestFixture {
         const char str[] = "int main() {\n"
                            "    foo bar;\n"
                            "    throw bar;\n"
-                           "}";
+                           "}\n";
         GET_SYMBOL_DB(str);
         ASSERT_EQUALS("", errout_str());
         ASSERT(db && db->variableList().size() == 2); // index 0 + 1 variable
@@ -3666,7 +3666,7 @@ class TestSymbolDatabase : public TestFixture {
     void symboldatabase26() {
         const char str[] = "int main() {\n"
                            "    throw bar;\n"
-                           "}";
+                           "}\n";
         GET_SYMBOL_DB_C(str);
         ASSERT_EQUALS("", errout_str());
         ASSERT(db && db->variableList().size() == 2); // index 0 + 1 variable
@@ -3678,13 +3678,13 @@ class TestSymbolDatabase : public TestFixture {
               "{\n"
               "    B1()\n"
               "    {} C(int) : B1() class\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase28() {
         GET_SYMBOL_DB("struct S {};\n"
-                      "void foo(struct S s) {}");
+                      "void foo(struct S s) {}\n");
         ASSERT(db && db->getVariableFromVarId(1) && db->getVariableFromVarId(1)->typeScope() && db->getVariableFromVarId(1)->typeScope()->className == "S");
     }
 
@@ -3692,13 +3692,13 @@ class TestSymbolDatabase : public TestFixture {
     void symboldatabase29() {
         check("struct B : A {\n"
               "    B() : A {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase30() {
         GET_SYMBOL_DB("struct A { void foo(const int a); };\n"
-                      "void A::foo(int a) { }");
+                      "void A::foo(int a) { }\n");
         ASSERT(db && db->functionScopes.size() == 1 && db->functionScopes[0]->functionOf);
     }
 
@@ -3725,7 +3725,7 @@ class TestSymbolDatabase : public TestFixture {
                       "::Foo::Sub::Sub() { }\n"
                       "class Foo;\n"
                       "class Bar;\n"
-                      "class Sub;");
+                      "class Sub;\n");
         ASSERT(db && db->typeList.size() == 5);
 
         auto i = db->typeList.cbegin();
@@ -3748,7 +3748,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    void foo() {}\n"
                       "};\n"
                       "class Deri : Base {\n"
-                      "};");
+                      "};\n");
         ASSERT(db && db->findScopeByName("Deri") && db->findScopeByName("Deri")->definedType->getFunction("foo"));
     }
 
@@ -3758,7 +3758,7 @@ class TestSymbolDatabase : public TestFixture {
                       "static struct A::B u(0);\n"
                       "static struct A::B v{0};\n"
                       "static struct A::B w({0});\n"
-                      "void foo() { }");
+                      "void foo() { }\n");
         ASSERT(db && db->functionScopes.size() == 1);
     }
 
@@ -3767,18 +3767,18 @@ class TestSymbolDatabase : public TestFixture {
               "typedef _Atomic(int)&atomic_int_ref;\n"
               "struct S {\n"
               "  _Atomic union { int n; };\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:2:1]: (debug) Failed to parse 'typedef _Atomic ( int ) & atomic_int_ref ;'. The checking continues anyway. [simplifyTypedef]\n", errout_str());
     }
 
     void symboldatabase35() { // ticket #4806 and #4841
         check("class FragmentQueue : public CL_NS(util)::PriorityQueue<CL_NS(util)::Deletor::Object<TextFragment> >\n"
-              "{};");
+              "{};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase36() { // ticket #4892
-        ASSERT_THROW_INTERNAL(check("void struct ( ) { if ( 1 ) } int main ( ) { }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(check("void struct ( ) { if ( 1 ) } int main ( ) { }\n"), SYNTAX);
     }
 
     void symboldatabase37() {
@@ -3792,7 +3792,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    Fred(const struct Barney & b) { barney = b; }\n"
                       "private:\n"
                       "    struct Barney barney;\n"
-                      "};");
+                      "};\n");
         ASSERT(db && db->typeList.size() == 3);
 
         auto i = db->typeList.cbegin();
@@ -3818,24 +3818,24 @@ class TestSymbolDatabase : public TestFixture {
               "{\n"
               "  scoped_service( T* ptr ) : scoped_service<service>(ptr), m_ptr(ptr) {}\n"
               "  T* const m_ptr;\n"
-              "};");
+              "};\n");
     }
 
     void symboldatabase40() { // ticket #5153
         check("void f() {\n"
               "    try {  }\n"
               "    catch (std::bad_alloc) {  }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase41() { // ticket #5197 (unknown macro)
-        GET_SYMBOL_DB("struct X1 { MACRO1 f(int spd) MACRO2; };");
+        GET_SYMBOL_DB("struct X1 { MACRO1 f(int spd) MACRO2; };\n");
         ASSERT(db && db->findScopeByName("X1") && db->findScopeByName("X1")->functionList.size() == 1 && !db->findScopeByName("X1")->functionList.front().hasBody());
     }
 
     void symboldatabase42() { // only put variables in variable list
-        GET_SYMBOL_DB("void f() { extern int x(); }");
+        GET_SYMBOL_DB("void f() { extern int x(); }\n");
         ASSERT(db != nullptr);
         const Scope * const fscope = db ? db->findScopeByName("f") : nullptr;
         ASSERT(fscope != nullptr);
@@ -3845,7 +3845,7 @@ class TestSymbolDatabase : public TestFixture {
     void symboldatabase43() { // ticket #4738
         check("void f() {\n"
               "    new int;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3855,7 +3855,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void foo() {\n"
                       "    int k { 1 };\n"
                       "    int l ( 1 );\n"
-                      "}");
+                      "}\n");
         ASSERT(db != nullptr);
         ASSERT_EQUALS(4U, db->variableList().size() - 1);
         ASSERT_EQUALS(2U, db->scopeList.size());
@@ -3876,7 +3876,7 @@ class TestSymbolDatabase : public TestFixture {
                       "        .span = (S) { 0UL },\n"
                       "        .flags = (x ? 256 : 0),\n"
                       "    };\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db != nullptr);
         ASSERT_EQUALS(4U, db->variableList().size() - 1);
@@ -3898,7 +3898,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("struct S { };\n"
                       "namespace {\n"
                       "    struct S { };\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db != nullptr);
         ASSERT_EQUALS(4U, db->scopeList.size());
@@ -3924,7 +3924,7 @@ class TestSymbolDatabase : public TestFixture {
                       "using namespace NS;\n"
                       "MyClass::~MyClass() {\n"
                       "    delete Example;\n"
-                      "}");
+                      "}\n");
         ASSERT(db && !db->functionScopes.empty() && db->functionScopes.front()->function && db->functionScopes.front()->function->functionScope == db->functionScopes.front());
     }
 
@@ -3937,7 +3937,7 @@ class TestSymbolDatabase : public TestFixture {
                       "}\n"
                       "using namespace NS;\n"
                       "MyClass::~MyClass() { }\n"
-                      "MyClass::MyClass() { }");
+                      "MyClass::MyClass() { }\n");
         ASSERT(db && !db->functionScopes.empty() && db->functionScopes.front()->function && db->functionScopes.front()->function->functionScope == db->functionScopes.front());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "MyClass ( ) ;");
@@ -3952,7 +3952,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("namespace Ns { class C; }\n"
                       "void f1() { char *p; *p = 0; }\n"
                       "class Ns::C* p;\n"
-                      "void f2() { char *p; *p = 0; }");
+                      "void f2() { char *p; *p = 0; }\n");
         ASSERT(db != nullptr);
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "p ; void f2");
         ASSERT_EQUALS(true, db && f && f->variable());
@@ -3977,7 +3977,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    : object_(object),\n"
                       "      member_(member) {\n"
                       "  }\n"
-                      "};");
+                      "};\n");
         ASSERT(db != nullptr);
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "_ConstTessMemberResultCallback_0_0 (");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->isConstructor());
@@ -3989,7 +3989,7 @@ class TestSymbolDatabase : public TestFixture {
                       "static const float f3 = 2 * std::foo3(a, b);\n"
                       "static const float f4 = c * foo4(a, b);\n"
                       "static const int i1 = 2 & foo5(a, b);\n"
-                      "static const bool b1 = 2 > foo6(a, b);");
+                      "static const bool b1 = 2 > foo6(a, b);\n");
         ASSERT(db != nullptr);
         ASSERT(findFunctionByName("foo1", &db->scopeList.front()) == nullptr);
         ASSERT(findFunctionByName("foo2", &db->scopeList.front()) == nullptr);
@@ -4003,7 +4003,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("void foo() {\n"
                       "    int i = 0;\n"
                       "    S s{ { i }, 0 };\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db != nullptr);
         ASSERT_EQUALS(2, db->scopeList.size());
@@ -4013,8 +4013,8 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void symboldatabase53() { // #7124
-        GET_SYMBOL_DB("int32_t x;"
-                      "std::int32_t y;");
+        GET_SYMBOL_DB("int32_t x;\n"
+                      "std::int32_t y;\n");
 
         ASSERT(db != nullptr);
         ASSERT(db->getVariableFromVarId(1) != nullptr);
@@ -4028,7 +4028,7 @@ class TestSymbolDatabase : public TestFixture {
                       "  void getReg() const override {\n"
                       "    assert(Kind == k_ShiftExtend);\n"
                       "  }\n"
-                      "};");
+                      "};\n");
 
         ASSERT(db != nullptr);
         ASSERT_EQUALS(1U, db->functionScopes.size());
@@ -4039,7 +4039,7 @@ class TestSymbolDatabase : public TestFixture {
     void symboldatabase55() { // #7767
         GET_SYMBOL_DB("PRIVATE S32 testfunc(void) {\n"
                       "    return 0;\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db != nullptr);
         ASSERT_EQUALS(1U, db->functionScopes.size());
@@ -4054,7 +4054,7 @@ class TestSymbolDatabase : public TestFixture {
                           "        virtual void f();\n"
                           "    };\n"
                           "    friend void NestedClass::f();\n"
-                          "}");
+                          "}\n");
 
             ASSERT(db != nullptr);
             ASSERT_EQUALS(0U, db->functionScopes.size());
@@ -4065,7 +4065,7 @@ class TestSymbolDatabase : public TestFixture {
             GET_SYMBOL_DB("class Class {\n"
                           "    friend void f1();\n"
                           "    friend void f2() { }\n"
-                          "}");
+                          "}\n");
 
             ASSERT(db != nullptr);
             ASSERT_EQUALS(1U, db->functionScopes.size());
@@ -4074,7 +4074,7 @@ class TestSymbolDatabase : public TestFixture {
         }
         {
             GET_SYMBOL_DB_C("friend f1();\n"
-                            "friend f2() { }");
+                            "friend f2() { }\n");
 
             ASSERT(db != nullptr);
             ASSERT_EQUALS(2U, db->scopeList.size());
@@ -4089,7 +4089,7 @@ class TestSymbolDatabase : public TestFixture {
                       "         return 1;\n"
                       "    else\n"
                       "         return 1;\n"
-                      "}");
+                      "}\n");
         ASSERT(db != nullptr);
         ASSERT(db->scopeList.size() == 4U);
         auto it = db->scopeList.cbegin();
@@ -4109,7 +4109,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    class A : public B\n"
                       "    {\n"
                       "    };\n"
-                      "};");
+                      "};\n");
         ASSERT(db != nullptr);
         ASSERT(db->typeList.size() == 3U);
         auto it = db->typeList.cbegin();
@@ -4124,13 +4124,13 @@ class TestSymbolDatabase : public TestFixture {
 
     void symboldatabase59() { // #8465
         GET_SYMBOL_DB("struct A::B ab[10];\n"
-                      "void f() {}");
+                      "void f() {}\n");
         ASSERT(db != nullptr);
         ASSERT(db && db->scopeList.size() == 2);
     }
 
     void symboldatabase60() { // #8470
-        GET_SYMBOL_DB("struct A::someType A::bar() { return 0; }");
+        GET_SYMBOL_DB("struct A::someType A::bar() { return 0; }\n");
         ASSERT(db != nullptr);
         ASSERT(db && db->scopeList.size() == 2);
     }
@@ -4144,7 +4144,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    info = new (nothrow) struct Fred::Info();\n"
                       "    info = new struct Fred::Info();\n"
                       "    memset(info, 0, sizeof(struct Fred::Info));\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db != nullptr);
         ASSERT(db && db->scopeList.size() == 4);
@@ -4161,7 +4161,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    for (std::vector<struct A::X>::const_iterator it = includes.begin(); it != includes.end(); ++it) {\n"
                           "        const struct A::X currentIncList = *it;\n"
                           "    }\n"
-                          "}");
+                          "}\n");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 5);
             const Scope *scope = db->findScopeByName("A");
@@ -4180,7 +4180,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    for (std::vector<class A::X>::const_iterator it = includes.begin(); it != includes.end(); ++it) {\n"
                           "        const class A::X currentIncList = *it;\n"
                           "    }\n"
-                          "}");
+                          "}\n");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 5);
             const Scope *scope = db->findScopeByName("A");
@@ -4199,7 +4199,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    for (std::vector<union A::X>::const_iterator it = includes.begin(); it != includes.end(); ++it) {\n"
                           "        const union A::X currentIncList = *it;\n"
                           "    }\n"
-                          "}");
+                          "}\n");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 5);
             const Scope *scope = db->findScopeByName("A");
@@ -4218,7 +4218,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    for (std::vector<enum A::X>::const_iterator it = includes.begin(); it != includes.end(); ++it) {\n"
                           "        const enum A::X currentIncList = *it;\n"
                           "    }\n"
-                          "}");
+                          "}\n");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 5);
             const Scope *scope = db->findScopeByName("A");
@@ -4231,12 +4231,12 @@ class TestSymbolDatabase : public TestFixture {
 
     void symboldatabase63() {
         {
-            GET_SYMBOL_DB("template class T<int> ; void foo() { }");
+            GET_SYMBOL_DB("template class T<int> ; void foo() { }\n");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 2);
         }
         {
-            GET_SYMBOL_DB("template struct T<int> ; void foo() { }");
+            GET_SYMBOL_DB("template struct T<int> ; void foo() { }\n");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 2);
         }
@@ -4250,7 +4250,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    ~impl() { }\n"
                           "    impl(const impl &) { }\n"
                           "    void foo(const impl &, const impl &) const { }\n"
-                          "};");
+                          "};\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 7);
@@ -4293,7 +4293,7 @@ class TestSymbolDatabase : public TestFixture {
                           "Fred::impl::impl() { }\n"
                           "Fred::impl::~impl() { }\n"
                           "Fred::impl::impl(const Fred::impl &) { }\n"
-                          "void Fred::impl::foo(const Fred::impl &, const Fred::impl &) const { }");
+                          "void Fred::impl::foo(const Fred::impl &, const Fred::impl &) const { }\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 7);
@@ -4334,7 +4334,7 @@ class TestSymbolDatabase : public TestFixture {
                           "        impl(const impl &) { }\n"
                           "        void foo(const impl &, const impl &) const { }\n"
                           "    };\n"
-                          "}");
+                          "}\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4379,7 +4379,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    Fred::impl::~impl() { }\n"
                           "    Fred::impl::impl(const Fred::impl &) { }\n"
                           "    void Fred::impl::foo(const Fred::impl &, const Fred::impl &) const { }\n"
-                          "}");
+                          "}\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4424,7 +4424,7 @@ class TestSymbolDatabase : public TestFixture {
                           "NS::Fred::impl::impl() { }\n"
                           "NS::Fred::impl::~impl() { }\n"
                           "NS::Fred::impl::impl(const NS::Fred::impl &) { }\n"
-                          "void NS::Fred::impl::foo(const NS::Fred::impl &, const NS::Fred::impl &) const { }");
+                          "void NS::Fred::impl::foo(const NS::Fred::impl &, const NS::Fred::impl &) const { }\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4465,7 +4465,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    ~impl() { }\n"
                           "    impl(const impl &) { }\n"
                           "    void foo(const impl &, const impl &) const { }\n"
-                          "};");
+                          "};\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4510,7 +4510,7 @@ class TestSymbolDatabase : public TestFixture {
                           "NS::Fred::impl::impl() { }\n"
                           "NS::Fred::impl::~impl() { }\n"
                           "NS::Fred::impl::impl(const NS::Fred::impl &) { }\n"
-                          "void NS::Fred::impl::foo(const NS::Fred::impl &, const NS::Fred::impl &) const { }");
+                          "void NS::Fred::impl::foo(const NS::Fred::impl &, const NS::Fred::impl &) const { }\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4557,7 +4557,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    Fred::impl::~impl() { }\n"
                           "    Fred::impl::impl(const Fred::impl &) { }\n"
                           "    void Fred::impl::foo(const Fred::impl &, const Fred::impl &) const { }\n"
-                          "}");
+                          "}\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4603,7 +4603,7 @@ class TestSymbolDatabase : public TestFixture {
                           "Fred::impl::impl() { }\n"
                           "Fred::impl::~impl() { }\n"
                           "Fred::impl::impl(const Fred::impl &) { }\n"
-                          "void Fred::impl::foo(const Fred::impl &, const Fred::impl &) const { }");
+                          "void Fred::impl::foo(const Fred::impl &, const Fred::impl &) const { }\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4642,7 +4642,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    ~impl() { }\n"
                           "    impl(const impl &) { }\n"
                           "    void foo(const impl &, const impl &) const { }\n"
-                          "};");
+                          "};\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 7);
@@ -4685,7 +4685,7 @@ class TestSymbolDatabase : public TestFixture {
                           "template <typename A> Fred<A>::impl::impl() { }\n"
                           "template <typename A> Fred<A>::impl::~impl() { }\n"
                           "template <typename A> Fred<A>::impl::impl(const Fred<A>::impl &) { }\n"
-                          "template <typename A> void Fred<A>::impl::foo(const Fred<A>::impl &, const Fred<A>::impl &) const { }");
+                          "template <typename A> void Fred<A>::impl::foo(const Fred<A>::impl &, const Fred<A>::impl &) const { }\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 7);
@@ -4726,7 +4726,7 @@ class TestSymbolDatabase : public TestFixture {
                           "        impl(const impl &) { }\n"
                           "        void foo(const impl &, const impl &) const { }\n"
                           "    };\n"
-                          "}");
+                          "}\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4771,7 +4771,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    template <typename A> Fred<A>::impl::~impl() { }\n"
                           "    template <typename A> Fred<A>::impl::impl(const Fred<A>::impl &) { }\n"
                           "    template <typename A> void Fred<A>::impl::foo(const Fred<A>::impl &, const Fred<A>::impl &) const { }\n"
-                          "}");
+                          "}\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4816,7 +4816,7 @@ class TestSymbolDatabase : public TestFixture {
                           "template <typename A> NS::Fred<A>::impl::impl() { }\n"
                           "template <typename A> NS::Fred<A>::impl::~impl() { }\n"
                           "template <typename A> NS::Fred<A>::impl::impl(const NS::Fred<A>::impl &) { }\n"
-                          "template <typename A> void NS::Fred<A>::impl::foo(const NS::Fred<A>::impl &, const NS::Fred<A>::impl &) const { }");
+                          "template <typename A> void NS::Fred<A>::impl::foo(const NS::Fred<A>::impl &, const NS::Fred<A>::impl &) const { }\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4857,7 +4857,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    ~impl() { }\n"
                           "    impl(const impl &) { }\n"
                           "    void foo(const impl &, const impl &) const { }\n"
-                          "};");
+                          "};\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4902,7 +4902,7 @@ class TestSymbolDatabase : public TestFixture {
                           "template <typename A> NS::Fred<A>::impl::impl() { }\n"
                           "template <typename A> NS::Fred<A>::impl::~impl() { }\n"
                           "template <typename A> NS::Fred<A>::impl::impl(const NS::Fred<A>::impl &) { }\n"
-                          "template <typename A> void NS::Fred<A>::impl::foo(const NS::Fred<A>::impl &, const NS::Fred<A>::impl &) const { }");
+                          "template <typename A> void NS::Fred<A>::impl::foo(const NS::Fred<A>::impl &, const NS::Fred<A>::impl &) const { }\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4949,7 +4949,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    template <typename A> Fred<A>::impl::~impl() { }\n"
                           "    template <typename A> Fred<A>::impl::impl(const Fred<A>::impl &) { }\n"
                           "    template <typename A> void Fred<A>::impl::foo(const Fred<A>::impl &, const Fred<A>::impl &) const { }\n"
-                          "}");
+                          "}\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4995,7 +4995,7 @@ class TestSymbolDatabase : public TestFixture {
                           "template <typename A> Fred<A>::impl::impl() { }\n"
                           "template <typename A> Fred<A>::impl::~impl() { }\n"
                           "template <typename A> Fred<A>::impl::impl(const Fred<A>::impl &) { }\n"
-                          "template <typename A> void Fred<A>::impl::foo(const Fred<A>::impl &, const Fred<A>::impl &) const { }");
+                          "template <typename A> void Fred<A>::impl::foo(const Fred<A>::impl &, const Fred<A>::impl &) const { }\n");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -5031,7 +5031,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void symboldatabase65() {
         // don't crash on missing links from instantiation of template with typedef
-        check("int ( * X0 ) ( long ) < int ( ) ( long ) > :: f0 ( int * ) { return 0 ; }");
+        check("int ( * X0 ) ( long ) < int ( ) ( long ) > :: f0 ( int * ) { return 0 ; }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int g();\n" // #11385
@@ -5044,14 +5044,14 @@ class TestSymbolDatabase : public TestFixture {
     void symboldatabase66() { // #8540
         GET_SYMBOL_DB("enum class ENUM1;\n"
                       "enum class ENUM2 { MEMBER2 };\n"
-                      "enum class ENUM3 : int { MEMBER1, };");
+                      "enum class ENUM3 : int { MEMBER1, };\n");
         ASSERT(db != nullptr);
         ASSERT(db && db->scopeList.size() == 3);
         ASSERT(db && db->typeList.size() == 3);
     }
 
     void symboldatabase67() { // #8538
-        GET_SYMBOL_DB("std::string get_endpoint_url() const noexcept override;");
+        GET_SYMBOL_DB("std::string get_endpoint_url() const noexcept override;\n");
         const Function *f = db ? &db->scopeList.front().functionList.front() : nullptr;
         ASSERT(f != nullptr);
         ASSERT(f && f->hasOverrideSpecifier());
@@ -5065,7 +5065,7 @@ class TestSymbolDatabase : public TestFixture {
                       "};\n"
                       "struct Foo : Bar {\n"
                       "    virtual std::string get_endpoint_url() const noexcept override final;\n"
-                      "};");
+                      "};\n");
         const Token *f = db ? Token::findsimplematch(tokenizer.tokens(), "get_endpoint_url ( ) const noexcept ( true ) ;") : nullptr;
         ASSERT(f != nullptr);
         ASSERT(f && f->function() && f->function()->token->linenr() == 2);
@@ -5091,7 +5091,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    void foo() volatile { }\n"
                       "    void foo() const { }\n"
                       "    void foo() { }\n"
-                      "};");
+                      "};\n");
         const Token *f = db ? Token::findsimplematch(tokenizer.tokens(), "foo ( ) const volatile {") : nullptr;
         ASSERT(f != nullptr);
         ASSERT(f && f->function() && f->function()->token->linenr() == 3);
@@ -5116,20 +5116,20 @@ class TestSymbolDatabase : public TestFixture {
 
     void symboldatabase70() {
         {
-            GET_SYMBOL_DB("class Map<String,Entry>::Entry* e;");
+            GET_SYMBOL_DB("class Map<String,Entry>::Entry* e;\n");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 1);
             ASSERT(db && db->variableList().size() == 2);
         }
         {
-            GET_SYMBOL_DB("template class boost::token_iterator_generator<boost::offset_separator>::type; void foo() { }");
+            GET_SYMBOL_DB("template class boost::token_iterator_generator<boost::offset_separator>::type; void foo() { }\n");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 2);
         }
         {
             GET_SYMBOL_DB("void foo() {\n"
                           "    return class Arm_relocate_functions<big_endian>::thumb32_branch_offset(upper_insn, lower_insn);\n"
-                          "}");
+                          "}\n");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 2);
         }
@@ -5137,7 +5137,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void symboldatabase71() {
         GET_SYMBOL_DB("class A { };\n"
-                      "class B final : public A { };");
+                      "class B final : public A { };\n");
         ASSERT(db && db->scopeList.size() == 3);
         ASSERT(db && db->typeList.size() == 2);
     }
@@ -5147,7 +5147,7 @@ class TestSymbolDatabase : public TestFixture {
                       "struct A::B {\n"
                       "    B() = default;\n"
                       "    B(const B&) {}\n"
-                      "};");
+                      "};\n");
 
         ASSERT(db && db->scopeList.size() == 4);
         ASSERT(db && db->typeList.size() == 2);
@@ -5159,7 +5159,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void symboldatabase74() { // #8838 - final
         GET_SYMBOL_DB("class Base { virtual int f() const = 0; };\n"
-                      "class Derived : Base { virtual int f() const final { return 6; } };");
+                      "class Derived : Base { virtual int f() const final { return 6; } };\n");
 
         ASSERT_EQUALS(4, db->scopeList.size());
         ASSERT_EQUALS(1, db->functionScopes.size());
@@ -5182,7 +5182,7 @@ class TestSymbolDatabase : public TestFixture {
                           "auto optional<T>::value() && -> T && {}\n"
                           "template <typename T>\n"
                           "auto optional<T>::value() const & -> T const & {}\n"
-                          "optional<int> i;");
+                          "optional<int> i;\n");
 
             ASSERT_EQUALS(5, db->scopeList.size());
             ASSERT_EQUALS(3, db->functionScopes.size());
@@ -5227,7 +5227,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("namespace foo {\n"
                       "  using namespace bar::baz;\n"
                       "  auto func(int arg) -> bar::quux {}\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS(2, db->mVariableList.size());
     }
 
@@ -5236,7 +5236,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void f() {\n"
                       "  using T3 = typename T1::template T3<T2>;\n"
                       "  T3 t;\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS(2, db->mVariableList.size());
     }
 
@@ -5247,7 +5247,7 @@ class TestSymbolDatabase : public TestFixture {
                       "template <template <class> class c, class... f, template <class...> class d>\n"
                       "struct b<c<f...>, d<>>;\n"
                       "}\n"
-                      "void e() { using c = a<>; }");
+                      "void e() { using c = a<>; }\n");
         ASSERT(db != nullptr);
         ASSERT_EQUALS("", errout_str());
     }
@@ -5255,7 +5255,7 @@ class TestSymbolDatabase : public TestFixture {
     void symboldatabase79() { // #9392
         {
             GET_SYMBOL_DB("class C { C(); };\n"
-                          "C::C() = default;");
+                          "C::C() = default;\n");
             ASSERT(db->scopeList.size() == 2);
             ASSERT(db->scopeList.back().functionList.size() == 1);
             ASSERT(db->scopeList.back().functionList.front().isDefault() == true);
@@ -5265,14 +5265,14 @@ class TestSymbolDatabase : public TestFixture {
                           "class C { C(); };\n"
                           "}\n"
                           "using namespace ns;\n"
-                          "C::C() = default;");
+                          "C::C() = default;\n");
             ASSERT(db->scopeList.size() == 3);
             ASSERT(db->scopeList.back().functionList.size() == 1);
             ASSERT(db->scopeList.back().functionList.front().isDefault() == true);
         }
         {
             GET_SYMBOL_DB("class C { ~C(); };\n"
-                          "C::~C() = default;");
+                          "C::~C() = default;\n");
             ASSERT(db->scopeList.size() == 2);
             ASSERT(db->scopeList.back().functionList.size() == 1);
             ASSERT(db->scopeList.back().functionList.front().isDefault() == true);
@@ -5283,7 +5283,7 @@ class TestSymbolDatabase : public TestFixture {
                           "class C { ~C(); };\n"
                           "}\n"
                           "using namespace ns;\n"
-                          "C::~C() = default;");
+                          "C::~C() = default;\n");
             ASSERT(db->scopeList.size() == 3);
             ASSERT(db->scopeList.back().functionList.size() == 1);
             ASSERT(db->scopeList.back().functionList.front().isDefault() == true);
@@ -5301,7 +5301,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    void f(const ns::A&);\n"
                           "};\n"
                           "using namespace ns;\n"
-                          "void AA::f(const A&) { }");
+                          "void AA::f(const A&) { }\n");
             ASSERT(db->scopeList.size() == 5);
             ASSERT(db->functionScopes.size() == 1);
             const Scope *scope = db->findScopeByName("AA");
@@ -5321,7 +5321,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    void f(const ns::ns1::A&);\n"
                           "};\n"
                           "using namespace ns::ns1;\n"
-                          "void AA::f(const A&) { }");
+                          "void AA::f(const A&) { }\n");
             ASSERT(db->scopeList.size() == 6);
             ASSERT(db->functionScopes.size() == 1);
             const Scope *scope = db->findScopeByName("AA");
@@ -5341,7 +5341,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    void f(const ns::ns1::A&);\n"
                           "};\n"
                           "using namespace ns;\n"
-                          "void AA::f(const ns1::A&) { }");
+                          "void AA::f(const ns1::A&) { }\n");
             ASSERT(db->scopeList.size() == 6);
             ASSERT(db->functionScopes.size() == 1);
             const Scope *scope = db->findScopeByName("AA");
@@ -5363,7 +5363,7 @@ class TestSymbolDatabase : public TestFixture {
                           "using namespace std;\n"
                           "using namespace Parser;\n"
                           "using namespace Terminal;\n"
-                          "string Complete::act(const Action *act) { }");
+                          "string Complete::act(const Action *act) { }\n");
             ASSERT(db->scopeList.size() == 4);
             ASSERT(db->functionScopes.size() == 1);
             const Scope *scope = db->findScopeByName("Complete");
@@ -5382,7 +5382,7 @@ class TestSymbolDatabase : public TestFixture {
                           "using namespace std;\n"
                           "using namespace Foo::Parser;\n"
                           "using namespace Terminal;\n"
-                          "string Complete::act(const Action *act) { }");
+                          "string Complete::act(const Action *act) { }\n");
             ASSERT(db->scopeList.size() == 4);
             ASSERT(db->functionScopes.size() == 1);
             const Scope *scope = db->findScopeByName("Complete");
@@ -5394,14 +5394,14 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void symboldatabase82() {
-        GET_SYMBOL_DB("namespace foo { void foo() {} }");
+        GET_SYMBOL_DB("namespace foo { void foo() {} }\n");
         ASSERT(db->functionScopes.size() == 1);
         ASSERT_EQUALS(false, db->functionScopes[0]->function->isConstructor());
     }
 
     void symboldatabase83() { // #9431
         GET_SYMBOL_DB_DBG("struct a { a() noexcept; };\n"
-                          "a::a() noexcept = default;");
+                          "a::a() noexcept = default;\n");
         const Scope *scope = db->findScopeByName("a");
         ASSERT(scope);
         ASSERT(scope->functionList.size() == 1);
@@ -5416,7 +5416,7 @@ class TestSymbolDatabase : public TestFixture {
     void symboldatabase84() {
         {
             GET_SYMBOL_DB_DBG("struct a { a() noexcept(false); };\n"
-                              "a::a() noexcept(false) = default;");
+                              "a::a() noexcept(false) = default;\n");
             const Scope *scope = db->findScopeByName("a");
             ASSERT(scope);
             ASSERT(scope->functionList.size() == 1);
@@ -5429,7 +5429,7 @@ class TestSymbolDatabase : public TestFixture {
         }
         {
             GET_SYMBOL_DB_DBG("struct a { a() noexcept(true); };\n"
-                              "a::a() noexcept(true) = default;");
+                              "a::a() noexcept(true) = default;\n");
             const Scope *scope = db->findScopeByName("a");
             ASSERT(scope);
             ASSERT(scope->functionList.size() == 1);
@@ -5448,7 +5448,7 @@ class TestSymbolDatabase : public TestFixture {
                       "  void f() { _mode = x; }\n"
                       "  Mode _mode;\n"
                       "  DECLARE_PROPERTY_FIELD(_mode);\n"
-                      "};");
+                      "};\n");
         const Token *vartok1 = Token::findsimplematch(tokenizer.tokens(), "_mode =");
         ASSERT(vartok1);
         ASSERT(vartok1->variable());
@@ -5460,7 +5460,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void symboldatabase86() {
         GET_SYMBOL_DB("class C { auto operator=(const C&) -> C&; };\n"
-                      "auto C::operator=(const C&) -> C& = default;");
+                      "auto C::operator=(const C&) -> C& = default;\n");
         ASSERT(db->scopeList.size() == 2);
         ASSERT(db->scopeList.back().functionList.size() == 1);
         ASSERT(db->scopeList.back().functionList.front().isDefault() == true);
@@ -5468,7 +5468,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void symboldatabase87() { // #9922 'extern const char ( * x [ 256 ] ) ;'
-        GET_SYMBOL_DB("extern const char ( * x [ 256 ] ) ;");
+        GET_SYMBOL_DB("extern const char ( * x [ 256 ] ) ;\n");
         const Token *xtok = Token::findsimplematch(tokenizer.tokens(), "x");
         ASSERT(xtok->variable());
     }
@@ -5506,7 +5506,7 @@ class TestSymbolDatabase : public TestFixture {
                       "}\n"
                       "}\n"
                       "using namespace external::ns1;\n"
-                      "A a{AS};");
+                      "A a{AS};\n");
         const Token *vartok1 = Token::findsimplematch(tokenizer.tokens(), "A a");
         ASSERT(vartok1);
         ASSERT(vartok1->next());
@@ -5519,7 +5519,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("struct Fred {\n"
                       "    void foo(const int * const x);\n"
                       "};\n"
-                      "void Fred::foo(const int * x) { }");
+                      "void Fred::foo(const int * x) { }\n");
         ASSERT_EQUALS("", errout_str());
         const Token *functok = Token::findsimplematch(tokenizer.tokens(), "foo ( const int * x )");
         ASSERT(functok);
@@ -5532,7 +5532,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    struct Value {};\n"
                       "    void foo(const std::vector<std::function<void(const Fred::Value &)>> &callbacks);\n"
                       "}\n"
-                      "void Fred::foo(const std::vector<std::function<void(const Fred::Value &)>> &callbacks) { }");
+                      "void Fred::foo(const std::vector<std::function<void(const Fred::Value &)>> &callbacks) { }\n");
         ASSERT_EQUALS("", errout_str());
         const Token *functok = Token::findsimplematch(tokenizer.tokens(),
                                                       "foo ( const std :: vector < std :: function < void ( const Fred :: Value & ) > > & callbacks ) { }");
@@ -5546,11 +5546,11 @@ class TestSymbolDatabase : public TestFixture {
             GET_SYMBOL_DB("template <size_t, typename...> struct a;\n"
                           "template <size_t b, typename c, typename... d>\n"
                           "struct a<b, c, d...> : a<1, d...> {};\n"
-                          "template <typename... e> struct f : a<0, e...> {};");
+                          "template <typename... e> struct f : a<0, e...> {};\n");
             ASSERT_EQUALS("", errout_str());
         }
         {
-            GET_SYMBOL_DB("b.f();");
+            GET_SYMBOL_DB("b.f();\n");
             ASSERT_EQUALS("", errout_str());
         }
     }
@@ -5565,7 +5565,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void symboldatabase94() { // structured bindings
-        GET_SYMBOL_DB("int foo() { auto [x,y] = xy(); return x+y; }");
+        GET_SYMBOL_DB("int foo() { auto [x,y] = xy(); return x+y; }\n");
         ASSERT(db != nullptr);
         ASSERT(db->getVariableFromVarId(1) != nullptr);
         ASSERT(db->getVariableFromVarId(2) != nullptr);
@@ -5631,7 +5631,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void symboldatabase99() { // #10864
-        check("void f() { std::map<std::string, int> m; }");
+        check("void f() { std::map<std::string, int> m; }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5714,7 +5714,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void symboldatabase102() {
         GET_SYMBOL_DB("std::string f() = delete;\n"
-                      "void g() {}");
+                      "void g() {}\n");
         ASSERT(db);
         ASSERT(db->scopeList.size() == 2);
         ASSERT(db->scopeList.front().type == ScopeType::eGlobal);
@@ -5945,7 +5945,7 @@ class TestSymbolDatabase : public TestFixture {
                       "            i();\n"
                       "            break;\n"
                       "    }\n"
-                      "}");
+                      "}\n");
         ASSERT(db != nullptr);
         ASSERT_EQUALS("", errout_str());
         const Token *case3 = Token::findsimplematch(tokenizer.tokens(), "case 3");
@@ -5991,7 +5991,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void createSymbolDatabaseFindAllScopes1() {
-        GET_SYMBOL_DB("void f() { union {int x; char *p;} a={0}; }");
+        GET_SYMBOL_DB("void f() { union {int x; char *p;} a={0}; }\n");
         ASSERT(db->scopeList.size() == 3);
         ASSERT_EQUALS_ENUM(ScopeType::eUnion, db->scopeList.back().type);
     }
@@ -6192,7 +6192,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    T* x;\n"
                       "    myst(T* y) : x(y){};\n"  // <- myst constructor
                       "  };\n"
-                      "};");
+                      "};\n");
         ASSERT(db);
 
         const Token* myst1 = Token::findsimplematch(tokenizer.tokens(), "myst ( T * y )");
@@ -6372,7 +6372,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void enum1() {
-        GET_SYMBOL_DB("enum BOOL { FALSE, TRUE }; enum BOOL b;");
+        GET_SYMBOL_DB("enum BOOL { FALSE, TRUE }; enum BOOL b;\n");
 
         /* there is a enum scope with the name BOOL */
         ASSERT(db && db->scopeList.back().type == ScopeType::eEnum && db->scopeList.back().className == "BOOL");
@@ -6382,7 +6382,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void enum2() {
-        GET_SYMBOL_DB("enum BOOL { FALSE, TRUE } b;");
+        GET_SYMBOL_DB("enum BOOL { FALSE, TRUE } b;\n");
 
         /* there is a enum scope with the name BOOL */
         ASSERT(db && db->scopeList.back().type == ScopeType::eEnum && db->scopeList.back().className == "BOOL");
@@ -6392,7 +6392,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void enum3() {
-        GET_SYMBOL_DB("enum ABC { A=11,B,C=A+B };");
+        GET_SYMBOL_DB("enum ABC { A=11,B,C=A+B };\n");
         ASSERT(db && db->scopeList.back().type == ScopeType::eEnum);
 
         /* There is an enum A with value 11 */
@@ -6410,7 +6410,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void enum4() { // #7493
         GET_SYMBOL_DB("enum Offsets { O1, O2, O3=5, O4 };\n"
-                      "enum MyEnums { E1=O1+1, E2, E3=O3+1 };");
+                      "enum MyEnums { E1=O1+1, E2, E3=O3+1 };\n");
         ASSERT(db != nullptr);
 
         ASSERT_EQUALS(3U, db->scopeList.size());
@@ -6498,7 +6498,7 @@ class TestSymbolDatabase : public TestFixture {
                       "int b[A];\n"
                       "int c[A + 2];\n"
                       "int d[10 + B];\n"
-                      "int e[A + B];");
+                      "int e[A + B];\n");
         ASSERT(db != nullptr);
 
         ASSERT_EQUALS(2U, db->scopeList.size());
@@ -6553,7 +6553,7 @@ class TestSymbolDatabase : public TestFixture {
                       "};\n"
                       "struct Barney : public Fred {\n"
                       "    Enum func(Enum e) { return e; }\n"
-                      "};");
+                      "};\n");
         ASSERT(db != nullptr);
 
         const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
@@ -6592,7 +6592,7 @@ class TestSymbolDatabase : public TestFixture {
                       "char array9[sizeof(EL)];\n"
                       "char array10[sizeof(L)];\n"
                       "char array11[sizeof(ELL)];\n"
-                      "char array12[sizeof(LL)];");
+                      "char array12[sizeof(LL)];\n");
         ASSERT(db != nullptr);
 
         ASSERT(db->variableList().size() == 13); // the first one is not used
@@ -7035,7 +7035,7 @@ class TestSymbolDatabase : public TestFixture {
                         "   struct deer {\n"
                         "     uint16_t a;\n"
                         "   };\n"
-                        "}");
+                        "}\n");
 
         ASSERT_EQUALS("", errout_str());
         ASSERT(db);
@@ -7068,7 +7068,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void foo() {\n"
                       "    e abc[] = {A,B,C};\n"
                       "    int i = abc[ARRAY_SIZE(cats)];\n"
-                      "}");
+                      "}\n");
         const Token *e = Token::findsimplematch(tokenizer.tokens(), "e abc");
         (void)db->sizeOfType(e);  // <- don't crash
     }
@@ -7080,7 +7080,7 @@ class TestSymbolDatabase : public TestFixture {
                           "};\n"
                           "class Deri : Base {\n"
                           "    void foo() {}\n"
-                          "};");
+                          "};\n");
             ASSERT(db && db->findScopeByName("Deri") && db->findScopeByName("Deri")->functionList.front().isImplicitlyVirtual());
         }
         {
@@ -7092,7 +7092,7 @@ class TestSymbolDatabase : public TestFixture {
                           "};\n"
                           "class Deri2 : Deri1 {\n"
                           "    void foo() {}\n"
-                          "};");
+                          "};\n");
             ASSERT(db && db->findScopeByName("Deri2") && db->findScopeByName("Deri2")->functionList.front().isImplicitlyVirtual());
         }
         {
@@ -7101,7 +7101,7 @@ class TestSymbolDatabase : public TestFixture {
                           "};\n"
                           "class Deri : Base {\n"
                           "    void foo() {}\n"
-                          "};");
+                          "};\n");
             ASSERT(db && db->findScopeByName("Deri") && !db->findScopeByName("Deri")->functionList.front().isImplicitlyVirtual(true));
         }
         {
@@ -7110,7 +7110,7 @@ class TestSymbolDatabase : public TestFixture {
                           "};\n"
                           "class Deri : Base {\n"
                           "    void foo(std::string& s) {}\n"
-                          "};");
+                          "};\n");
             ASSERT(db && db->findScopeByName("Deri") && !db->findScopeByName("Deri")->functionList.front().isImplicitlyVirtual(true));
         }
         {
@@ -7122,7 +7122,7 @@ class TestSymbolDatabase : public TestFixture {
                           "};\n"
                           "class Deri2 : Deri1 {\n"
                           "    void foo() {}\n"
-                          "};");
+                          "};\n");
             ASSERT(db && db->findScopeByName("Deri2") && db->findScopeByName("Deri2")->functionList.front().isImplicitlyVirtual());
         }
         {
@@ -7131,7 +7131,7 @@ class TestSymbolDatabase : public TestFixture {
                           "};\n"
                           "class Deri : Base {\n"
                           "    void foo() {}\n"
-                          "};");
+                          "};\n");
             ASSERT(db && db->findScopeByName("Deri") && db->findScopeByName("Deri")->functionList.front().isImplicitlyVirtual(true)); // Default true -> true
         }
         {
@@ -7140,7 +7140,7 @@ class TestSymbolDatabase : public TestFixture {
                           "};\n"
                           "class Deri : Base {\n"
                           "    void foo() {}\n"
-                          "};");
+                          "};\n");
             ASSERT(db && db->findScopeByName("Deri") && !db->findScopeByName("Deri")->functionList.front().isImplicitlyVirtual(false)); // Default false -> false
         }
         {
@@ -7149,7 +7149,7 @@ class TestSymbolDatabase : public TestFixture {
                           "};\n"
                           "class Deri : Base {\n"
                           "    void foo() {}\n"
-                          "};");
+                          "};\n");
             ASSERT(db && db->findScopeByName("Deri") && db->findScopeByName("Deri")->functionList.front().isImplicitlyVirtual(false)); // Default false, but we saw "virtual" -> true
         }
         // #5289
@@ -7161,7 +7161,7 @@ class TestSymbolDatabase : public TestFixture {
                           "class Bar : private Bar<void, void> {\n"
                           "   void foo() {\n"
                           "   }\n"
-                          "};");
+                          "};\n");
             ASSERT(db && db->findScopeByName("Bar") && !db->findScopeByName("Bar")->functionList.empty() && !db->findScopeByName("Bar")->functionList.front().isImplicitlyVirtual(false));
             ASSERT_EQUALS(1, db->findScopeByName("Bar")->functionList.size());
         }
@@ -7181,7 +7181,7 @@ class TestSymbolDatabase : public TestFixture {
                           "};\n"
                           "void InfiniteA::foo() {\n"
                           "    C a;\n"
-                          "}");
+                          "}\n");
             //ASSERT(db && db->findScopeByName("InfiniteA") && !db->findScopeByName("InfiniteA")->functionList.front().isImplicitlyVirtual());
             TODO_ASSERT_EQUALS(1, 0, db->findScopeByName("InfiniteA")->functionList.size());
         }
@@ -7193,7 +7193,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    C(B b) = 0;\n"
                       "    C(C& c) = default;"
                       "    void g();\n"
-                      "};");
+                      "};\n");
         ASSERT(db && db->scopeList.back().functionList.size() == 4);
         auto it = db->scopeList.back().functionList.cbegin();
         ASSERT((it++)->isPure());
@@ -7206,7 +7206,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("TEST(a,b) {\n"
                       "  std::vector<int> messages;\n"
                       "  foo(messages[2].size());\n"
-                      "}");
+                      "}\n");
         const Variable * const var = db ? db->getVariableFromVarId(1U) : nullptr;
         ASSERT(db &&
                db->findScopeByName("TEST") &&
@@ -7225,7 +7225,7 @@ class TestSymbolDatabase : public TestFixture {
                       "{\n"
                       "    t = PTRRELOC(t);\n"
                       "    *PTRRELOC(&x) = &y;\n"
-                      "}");
+                      "}\n");
         ASSERT(db != nullptr);
         const Token *funcStart, *argStart, *declEnd;
         ASSERT(db && !db->isFunction(Token::findsimplematch(tokenizer.tokens(), "PTRRELOC ( &"), &db->scopeList.back(), funcStart, argStart, declEnd));
@@ -7238,7 +7238,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("std::vector<int>&& f(std::vector<int>& v) {\n"
                       "    v.push_back(1);\n"
                       "    return std::move(v);\n"
-                      "}");
+                      "}\n");
         ASSERT(db != nullptr);
         ASSERT_EQUALS(2, db->scopeList.size());
         const Token* ret = Token::findsimplematch(tokenizer.tokens(), "return");
@@ -7266,7 +7266,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void bar() {\n"    /* 3 */
                       "    foo();\n"      /* 4 */
                       "    foo(1);\n"     /* 5 */
-                      "}");               /* 6 */
+                      "}\n");               /* 6 */
         ASSERT_EQUALS("", errout_str());
         ASSERT(db);
         const Scope * bar = db->findScopeByName("bar");
@@ -7295,7 +7295,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void otherfunc() {\n"
                       "    float t;\n"
                       "    func(x, &t);\n"
-                      "}");
+                      "}\n");
         const Token *callfunc = Token::findsimplematch(tokenizer.tokens(), "func ( x , & t ) ;");
         ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
@@ -7309,7 +7309,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void foo() {\n"
                       "    derived d;\n"
                       "    d.foo();\n"
-                      "}");
+                      "}\n");
 
         const Token *callfunc = Token::findsimplematch(tokenizer.tokens(), "d . foo ( ) ;");
         ASSERT_EQUALS("", errout_str());
@@ -7377,7 +7377,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    foo(crf);\n"
                       "    foo(crd);\n"
                       "    foo(crld);\n"
-                      "}");
+                      "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -7477,7 +7477,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    int syncpos, len;\n"
                       "    Sync(syncpos, type, len);\n"
                       "    Sync(type, len);\n"
-                      "}");
+                      "}\n");
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "Sync ( syncpos");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 3);
 
@@ -7489,7 +7489,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("void addtoken(Token** rettail, const Token *tok);\n"
                       "void CheckMemoryLeakInFunction::getcode(const Token *tok ) {\n"
                       "   addtoken(&rettail, tok);\n"
-                      "}");
+                      "}\n");
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "void addtoken ( Token * *");
         ASSERT_EQUALS(true, db && f && !f->function()); // regression value only
     }
@@ -7505,7 +7505,7 @@ class TestSymbolDatabase : public TestFixture {
                       "        power.nodeResults().size();\n"
                       "        assert(power.nodeResults().size()==ground.nodeResults().size());\n"
                       "    }\n"
-                      "};");
+                      "};\n");
         const Token *callfunc = Token::findsimplematch(tokenizer.tokens(), "power . nodeResults ( ) . size ( ) ;");
         ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true, db != nullptr); // not null
@@ -7533,7 +7533,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void S::g() &&{ }\n"
                       "void S::g() const   { }\n"
                       "void S::g() const & { }\n"
-                      "void S::g() const &&{ }");
+                      "void S::g() const &&{ }\n");
         ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "f ( ) {");
@@ -7595,7 +7595,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("struct Fred {\n"
                       "    void foo(const int * p);\n"
                       "};\n"
-                      "void Fred::foo(const int * const p) { }");
+                      "void Fred::foo(const int * const p) { }\n");
         ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( const int * const p ) {");
@@ -7606,7 +7606,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("struct Fred {\n"
                       "    void foo(const int * p);\n"
                       "};\n"
-                      "void Fred::foo(const int p []) { }");
+                      "void Fred::foo(const int p []) { }\n");
         ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( const int p [ ] ) {");
@@ -7623,7 +7623,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    foo(bar());\n"
                       "    foo(cp);\n"
                       "    foo(\"\");\n"
-                      "}");
+                      "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -7661,7 +7661,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    foo(fp);\n"
                       "    foo(cp);\n"
                       "    foo(\"\");\n"
-                      "}");
+                      "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -7709,7 +7709,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    foo2(0);\n"
                       "    foo2(nullptr);\n"
                       "    foo2(NULL);\n"
-                      "}");
+                      "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -7758,7 +7758,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    foo2(5, L'c');\n"
                       "    foo3(6, 'c');\n"
                       "    foo3(7, L'c');\n"
-                      "}");
+                      "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -7798,7 +7798,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    foo(C::si);\n"
                       "    foo(c.ip);\n"
                       "    foo(c.fp);\n"
-                      "}");
+                      "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -7835,7 +7835,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    foo(!b);\n"
                       "    foo(i > 0);\n"
                       "    foo(f + i);\n"
-                      "}");
+                      "}\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -7861,7 +7861,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    void f(float f) const { }\n"
                       "    void a() { f(1); }\n"
                       "    void b() { f(1.f); }\n"
-                      "};");
+                      "};\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -7906,7 +7906,7 @@ class TestSymbolDatabase : public TestFixture {
                       "        E1                 v13 = e1;     v13 = get(get(v13));\n"
                       "        E2                 v14 = E2::e2; v14 = get(get(v14));\n"
                       "    }\n"
-                      "};");
+                      "};\n");
 
         ASSERT_EQUALS("", errout_str());
         ASSERT(db);
@@ -7999,7 +7999,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    }\n"
                       "    int _x;\n"
                       "    int _y;\n"
-                      "};");
+                      "};\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -8018,7 +8018,7 @@ class TestSymbolDatabase : public TestFixture {
                       "\n"
                       "void f(foo *myFoo) {\n"
                       "    int* myThing = myFoo->GetThing();\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db != nullptr);
 
@@ -8037,7 +8037,7 @@ class TestSymbolDatabase : public TestFixture {
                       "\n"
                       "void f(const foo *myFoo) {\n"
                       "    int* myThing = myFoo->GetThing();\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db != nullptr);
 
@@ -8056,7 +8056,7 @@ class TestSymbolDatabase : public TestFixture {
                       "\n"
                       "void f(foo *myFoo) {\n"
                       "    int* myThing = ((const foo *)myFoo)->GetThing();\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db != nullptr);
 
@@ -8074,7 +8074,7 @@ class TestSymbolDatabase : public TestFixture {
                       "\n"
                       "void f(std::shared_ptr<foo> p) {\n"
                       "  p->dostuff();\n"
-                      "}");
+                      "}\n");
         ASSERT(db != nullptr);
         const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), ". dostuff ( ) ;")->next();
         ASSERT(tok1->function());
@@ -8091,7 +8091,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    {\n"
                       "        p->dostuff();\n"
                       "    }\n"
-                      "}");
+                      "}\n");
         ASSERT(db != nullptr);
         const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), ". dostuff ( ) ;")->next();
         ASSERT(tok1->function());
@@ -8102,7 +8102,7 @@ class TestSymbolDatabase : public TestFixture {
                       "void dostuff(float) {}\n"
                       "void f(int *p) {\n"
                       "  dostuff(p);\n"
-                      "}");
+                      "}\n");
         ASSERT(db != nullptr);
         const Token *dostuff1 = Token::findsimplematch(tokenizer.tokens(), "dostuff ( p ) ;");
         ASSERT(dostuff1->function());
@@ -8112,7 +8112,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void findFunction27() {
         GET_SYMBOL_DB("namespace { void a(int); }\n"
-                      "void f() { a(9); }");
+                      "void f() { a(9); }\n");
         const Token *a = Token::findsimplematch(tokenizer.tokens(), "a ( 9 )");
         ASSERT(a);
         ASSERT(a->function());
@@ -8123,7 +8123,7 @@ class TestSymbolDatabase : public TestFixture {
                       "struct S {\n"
                       "  void foo() { a(7); }\n"
                       "  void a(int);\n"
-                      "};");
+                      "};\n");
         const Token *a = Token::findsimplematch(tokenizer.tokens(), "a ( 7 )");
         ASSERT(a);
         ASSERT(a->function());
@@ -8144,7 +8144,7 @@ class TestSymbolDatabase : public TestFixture {
                       "\n"
                       "void bar(BPtr b) {\n"
                       "    int x = b->a.foo();\n"
-                      "}");
+                      "}\n");
         const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( ) ;");
         ASSERT(foo);
         ASSERT(foo->function());
@@ -8156,7 +8156,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("struct A;\n"
                       "void foo(std::shared_ptr<A> ptr) {\n"
                       "    int x = ptr->bar();\n"
-                      "}");
+                      "}\n");
         const Token *bar = Token::findsimplematch(tokenizer.tokens(), "bar ( ) ;");
         ASSERT(bar);
         ASSERT(!bar->function());
@@ -8165,7 +8165,7 @@ class TestSymbolDatabase : public TestFixture {
     void findFunction31() {
         GET_SYMBOL_DB("void foo(bool);\n"
                       "void foo(std::string s);\n"
-                      "void bar() { foo(\"123\"); }");
+                      "void bar() { foo(\"123\"); }\n");
         const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( \"123\" ) ;");
         ASSERT(foo);
         ASSERT(foo->function());
@@ -8175,7 +8175,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void findFunction32() {
         GET_SYMBOL_DB_C("void foo(char *p);\n"
-                        "void bar() { foo(\"123\"); }");
+                        "void bar() { foo(\"123\"); }\n");
         (void)db;
         const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( \"123\" ) ;");
         ASSERT(foo);
@@ -8197,7 +8197,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    void doIt() const {\n"
                           "        foo();\n"
                           "    }\n"
-                          "};");
+                          "};\n");
             (void)db;
             const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( ) ;");
             ASSERT(foo);
@@ -8217,7 +8217,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    void doIt() const {\n"
                           "        foo(1);\n"
                           "    }\n"
-                          "};");
+                          "};\n");
             (void)db;
             const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( 1 ) ;");
             ASSERT(foo);
@@ -8237,7 +8237,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    void doIt() const {\n"
                           "        foo(1,2);\n"
                           "    }\n"
-                          "};");
+                          "};\n");
             (void)db;
             const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( 1 , 2 ) ;");
             ASSERT(foo);
@@ -8257,7 +8257,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    void doIt() const {\n"
                           "        foo(1);\n"
                           "    }\n"
-                          "};");
+                          "};\n");
             (void)db;
             const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( 1 ) ;");
             ASSERT(foo);
@@ -8277,7 +8277,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    void doIt() const {\n"
                           "        foo(1,2);\n"
                           "    }\n"
-                          "};");
+                          "};\n");
             (void)db;
             const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( 1 , 2 ) ;");
             ASSERT(foo);
@@ -8297,7 +8297,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    void doIt() const {\n"
                           "        foo(1, 2, 3);\n"
                           "    }\n"
-                          "};");
+                          "};\n");
             (void)db;
             const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( 1 , 2 , 3 ) ;");
             ASSERT(foo);
@@ -8318,7 +8318,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    void selectOneVsConfig(cppcheck::Platform::PlatformType);\n"
                       "};\n"
                       "class Settings : public cppcheck::Platform { };\n"
-                      "void ImportProject::selectOneVsConfig(Settings::PlatformType) { }");
+                      "void ImportProject::selectOneVsConfig(Settings::PlatformType) { }\n");
         (void)db;
         const Token *foo = Token::findsimplematch(tokenizer.tokens(), "selectOneVsConfig ( Settings :: PlatformType ) { }");
         ASSERT(foo);
@@ -8336,7 +8336,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    };\n"
                       "}\n"
                       "::clangimport::AstNode::AstNode() { }\n"
-                      "void ::clangimport::AstNode::createTokens() { }");
+                      "void ::clangimport::AstNode::createTokens() { }\n");
         (void)db;
         const Token *foo = Token::findsimplematch(tokenizer.tokens(), "AstNode ( ) { }");
         ASSERT(foo);
@@ -8362,7 +8362,7 @@ class TestSymbolDatabase : public TestFixture {
                       "}\n"
                       "namespace ns {\n"
                       "    void A::f(external::T link_type) { }\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
         const Token *functok = Token::findsimplematch(tokenizer.tokens(), "f ( external :: T link_type )");
         ASSERT(functok);
@@ -8380,7 +8380,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    void f(const ns::V&);\n"
                       "};\n"
                       "using ::ns::V;\n"
-                      "void A::f(const V&) { }");
+                      "void A::f(const V&) { }\n");
         ASSERT_EQUALS("", errout_str());
         const Token *functok = Token::findsimplematch(tokenizer.tokens(), "f ( const :: ns :: V & )");
         ASSERT(functok);
@@ -8398,7 +8398,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    void f(const ns::Var&);\n"
                       "};\n"
                       "using ::ns::Var;\n"
-                      "void A::f(const Var&) {}");
+                      "void A::f(const Var&) {}\n");
         ASSERT_EQUALS("", errout_str());
         const Token *functok = Token::findsimplematch(tokenizer.tokens(), "f ( const :: ns :: V & )");
         ASSERT(functok);
@@ -8418,7 +8418,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    void f(external::V::I);\n"
                       "};\n"
                       "using ::external::V;\n"
-                      "void A::f(V::I) {}");
+                      "void A::f(V::I) {}\n");
         ASSERT_EQUALS("", errout_str());
         const Token *functok = Token::findsimplematch(tokenizer.tokens(), "f ( int )");
         ASSERT(functok);
@@ -8434,7 +8434,7 @@ class TestSymbolDatabase : public TestFixture {
                       "};\n"
                       "const char* E::what() const noexcept {\n"
                       "    return nullptr;\n"
-                      "}");
+                      "}\n");
         ASSERT_EQUALS("", errout_str());
         const Token *functok = Token::findsimplematch(tokenizer.tokens(), "what ( ) const noexcept ( true ) {");
         ASSERT(functok);
@@ -8684,7 +8684,7 @@ class TestSymbolDatabase : public TestFixture {
                           "  B(): b_obj(this) { b_obj->test(\"1\"); }\n"
                           "  void test(const std::string& str_obj);\n"
                           "  B* b_obj;\n"
-                          "};");
+                          "};\n");
             const Token* call = Token::findsimplematch(tokenizer.tokens(), "test ( \"1\" ) ;");
             ASSERT(call);
             ASSERT(call->function());
@@ -8703,7 +8703,7 @@ class TestSymbolDatabase : public TestFixture {
                           "  B(): b_obj(this) { b_obj->test(\"1\"); }\n"
                           "  void test(const STR& str_obj);\n"
                           "  B* b_obj;\n"
-                          "};");
+                          "};\n");
             const Token* call = Token::findsimplematch(tokenizer.tokens(), "test ( \"1\" ) ;");
             ASSERT(call);
             ASSERT(call->function());
@@ -8722,7 +8722,7 @@ class TestSymbolDatabase : public TestFixture {
                           "  B(): b_obj(this) { b_obj->test(\"1\"); }\n"
                           "  void test(const STR& str_obj);\n"
                           "  B* b_obj;\n"
-                          "};");
+                          "};\n");
             const Token* call = Token::findsimplematch(tokenizer.tokens(), "test ( \"1\" ) ;");
             ASSERT(call);
             ASSERT(call->function());
@@ -9033,7 +9033,7 @@ class TestSymbolDatabase : public TestFixture {
             GET_SYMBOL_DB("void dostuff(std::vector<int> v);\n"
                           "void f(std::vector<int> v) {\n"
                           "  dostuff(v);\n"
-                          "}");
+                          "}\n");
             (void)db;
             const Token *dostuff = Token::findsimplematch(tokenizer.tokens(), "dostuff ( v ) ;");
             ASSERT(dostuff->function());
@@ -9045,7 +9045,7 @@ class TestSymbolDatabase : public TestFixture {
                           "void dostuff(int *i);\n"
                           "void f(std::vector<char> v) {\n"
                           "  dostuff(v);\n"
-                          "}");
+                          "}\n");
             (void)db;
             const Token *dostuff = Token::findsimplematch(tokenizer.tokens(), "dostuff ( v ) ;");
             ASSERT(!dostuff->function());
@@ -9056,7 +9056,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("extern \"C\" { void foo(int); }\n"
                       "void bar() {\n"
                       "    foo(42);\n"
-                      "}");
+                      "}\n");
         const Token *a = Token::findsimplematch(tokenizer.tokens(), "foo ( 42 )");
         ASSERT(a);
         ASSERT(a->function());
@@ -9072,7 +9072,7 @@ class TestSymbolDatabase : public TestFixture {
                       "\n"
                       "void S::foo() {\n"
                       "    x = ::bar(x);\n"
-                      "}");
+                      "}\n");
         const Token *bar = Token::findsimplematch(tokenizer.tokens(), "bar ( x )");
         ASSERT(bar);
         ASSERT(bar->function());
@@ -9085,7 +9085,7 @@ class TestSymbolDatabase : public TestFixture {
                       "\n"
                       "void foo(S x) {\n"
                       "    x(123);\n"
-                      "}");
+                      "}\n");
         const Token *tok = Token::findsimplematch(tokenizer.tokens(), "x . operator() ( 123 )");
         ASSERT(tok);
         ASSERT(tok->tokAt(2)->function());
@@ -9122,7 +9122,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("void func1() noexcept;\n"
                       "void func2() noexcept { }\n"
                       "void func3() noexcept(true);\n"
-                      "void func4() noexcept(true) { }");
+                      "void func4() noexcept(true) { }\n");
         ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
 
@@ -9133,7 +9133,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void noexceptFunction2() {
-        GET_SYMBOL_DB("template <class T> void self_assign(T& t) noexcept(noexcept(t = t)) {t = t; }");
+        GET_SYMBOL_DB("template <class T> void self_assign(T& t) noexcept(noexcept(t = t)) {t = t; }\n");
 
         ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
@@ -9162,7 +9162,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    void func11() const noexcept(true) = 0;\n"
                       "    void func12() const noexcept(true) = 0;\n"
                       "    void func13() const noexcept(false) = 0;\n"
-                      "};");
+                      "};\n");
         ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
 
@@ -9194,7 +9194,7 @@ class TestSymbolDatabase : public TestFixture {
                       "   A a;\n"
                       "   B(B&& b) noexcept\n"
                       "   :a(std::move(b.a)) { }\n"
-                      "};");
+                      "};\n");
         ASSERT_EQUALS("", errout_str());
         ASSERT(db != nullptr); // not null
         const Scope *b = db->findScopeByName("B");
@@ -9212,7 +9212,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("void func1() throw();\n"
                       "void func2() throw() { }\n"
                       "void func3() throw(int);\n"
-                      "void func4() throw(int) { }");
+                      "void func4() throw(int) { }\n");
         ASSERT_EQUALS("", errout_str());
         ASSERT(db != nullptr); // not null
 
@@ -9241,7 +9241,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    void func10() throw(int) = 0;\n"
                       "    void func11() const throw() = 0;\n"
                       "    void func12() const throw(int) = 0;\n"
-                      "};");
+                      "};\n");
         ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
 
@@ -9262,7 +9262,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void constAttributeFunction() {
-        GET_SYMBOL_DB("void func(void) __attribute__((const));");
+        GET_SYMBOL_DB("void func(void) __attribute__((const));\n");
         ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true, db != nullptr); // not null
 
@@ -9272,7 +9272,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void pureAttributeFunction() {
-        GET_SYMBOL_DB("void func(void) __attribute__((pure));");
+        GET_SYMBOL_DB("void func(void) __attribute__((pure));\n");
         ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true, db != nullptr); // not null
 
@@ -9283,7 +9283,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void nothrowAttributeFunction() {
         GET_SYMBOL_DB("void func() __attribute__((nothrow));\n"
-                      "void func() { }");
+                      "void func() { }\n");
         ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
 
@@ -9293,7 +9293,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void nothrowDeclspecFunction() {
-        GET_SYMBOL_DB("void __declspec(nothrow) func() { }");
+        GET_SYMBOL_DB("void __declspec(nothrow) func() { }\n");
         ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
 
@@ -9345,7 +9345,7 @@ class TestSymbolDatabase : public TestFixture {
                       "int func1() { }\n"
                       "[[nodiscard]] int func2();\n"
                       "[[nodiscard]] int func3() { }\n"
-                      "template <class T> [[nodiscard]] int func4() { }"
+                      "template <class T> [[nodiscard]] int func4() { }\n"
                       "std::pair<bool, char> [[nodiscard]] func5();\n"
                       "[[nodiscard]] std::pair<bool, char> func6();\n"
                       );
@@ -9378,7 +9378,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void varTypesIntegral() {
-        GET_SYMBOL_DB("void f() { bool b; char c; unsigned char uc; short s; unsigned short us; int i; unsigned u; unsigned int ui; long l; unsigned long ul; long long ll; }");
+        GET_SYMBOL_DB("void f() { bool b; char c; unsigned char uc; short s; unsigned short us; int i; unsigned u; unsigned int ui; long l; unsigned long ul; long long ll; }\n");
         const Variable *b = db->getVariableFromVarId(1);
         ASSERT(b != nullptr);
         ASSERT_EQUALS("b", b->nameToken()->str());
@@ -9437,7 +9437,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void varTypesFloating() {
         {
-            GET_SYMBOL_DB("void f() { float f; double d; long double ld; }");
+            GET_SYMBOL_DB("void f() { float f; double d; long double ld; }\n");
             const Variable *f = db->getVariableFromVarId(1);
             ASSERT(f != nullptr);
             ASSERT_EQUALS("f", f->nameToken()->str());
@@ -9454,7 +9454,7 @@ class TestSymbolDatabase : public TestFixture {
             ASSERT_EQUALS(true, ld->isFloatingType());
         }
         {
-            GET_SYMBOL_DB("void f() { float * f; static const float * scf; }");
+            GET_SYMBOL_DB("void f() { float * f; static const float * scf; }\n");
             const Variable *f = db->getVariableFromVarId(1);
             ASSERT(f != nullptr);
             ASSERT_EQUALS("f", f->nameToken()->str());
@@ -9468,7 +9468,7 @@ class TestSymbolDatabase : public TestFixture {
             ASSERT_EQUALS(true, scf->isArrayOrPointer());
         }
         {
-            GET_SYMBOL_DB("void f() { float fa[42]; }");
+            GET_SYMBOL_DB("void f() { float fa[42]; }\n");
             const Variable *fa = db->getVariableFromVarId(1);
             ASSERT(fa != nullptr);
             ASSERT_EQUALS("fa", fa->nameToken()->str());
@@ -9478,7 +9478,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void varTypesOther() {
-        GET_SYMBOL_DB("void f() { class A {} a; void *b;  }");
+        GET_SYMBOL_DB("void f() { class A {} a; void *b;  }\n");
         const Variable *a = db->getVariableFromVarId(1);
         ASSERT(a != nullptr);
         ASSERT_EQUALS("a", a->nameToken()->str());
@@ -9510,7 +9510,7 @@ class TestSymbolDatabase : public TestFixture {
                       "        y += 10.0f - x;\n"
                       "    }\n"
                       "    lambda();\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db && db->scopeList.size() == 3);
         auto scope = db->scopeList.cbegin();
@@ -9529,7 +9529,7 @@ class TestSymbolDatabase : public TestFixture {
                       "        float x = 1.0f;\n"
                       "    };\n"
                       "    lambda();\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db && db->scopeList.size() == 3);
         auto scope = db->scopeList.cbegin();
@@ -9543,7 +9543,7 @@ class TestSymbolDatabase : public TestFixture {
     void lambda3() {
         GET_SYMBOL_DB("void func() {\n"
                       "    auto f = []() mutable {};\n"
-                      "}");
+                      "}\n");
 
         ASSERT(db && db->scopeList.size() == 3);
         auto scope = db->scopeList.cbegin();
@@ -9609,7 +9609,7 @@ class TestSymbolDatabase : public TestFixture {
               "int main() {\n"
               "	E c;\n"
               "	c.f();\n"
-              "}");
+              "}\n");
     }
 
     void executableScopeWithUnknownFunction() {
@@ -9617,7 +9617,7 @@ class TestSymbolDatabase : public TestFixture {
             GET_SYMBOL_DB("class Fred {\n"
                           "    void foo(const std::string & a = \"\");\n"
                           "};\n"
-                          "Fred::foo(const std::string & b) { }");
+                          "Fred::foo(const std::string & b) { }\n");
 
             ASSERT(db && db->scopeList.size() == 3);
             auto scope = db->scopeList.cbegin();
@@ -9669,232 +9669,232 @@ class TestSymbolDatabase : public TestFixture {
                                          $.platform.long_long_bit = 64);
 
         // numbers
-        ASSERT_EQUALS("signed int", typeOf("1;", "1", false, &s));
-        ASSERT_EQUALS("signed int", typeOf("(-1);", "-1", false, &s));
-        ASSERT_EQUALS("signed int", typeOf("32767;", "32767", false, &s));
-        ASSERT_EQUALS("signed int", typeOf("(-32767);", "-32767", false, &s));
-        ASSERT_EQUALS("signed long", typeOf("32768;", "32768", false, &s));
-        ASSERT_EQUALS("signed long", typeOf("(-32768);", "-32768", false, &s));
-        ASSERT_EQUALS("signed long", typeOf("32768l;", "32768l", false, &s));
-        ASSERT_EQUALS("unsigned int", typeOf("32768U;", "32768U", false, &s));
-        ASSERT_EQUALS("signed long long", typeOf("2147483648;", "2147483648", false, &s));
-        ASSERT_EQUALS("unsigned long", typeOf("2147483648u;", "2147483648u", false, &s));
-        ASSERT_EQUALS("signed long long", typeOf("2147483648L;", "2147483648L", false, &s));
-        ASSERT_EQUALS("unsigned long long", typeOf("18446744069414584320;", "18446744069414584320", false, &s));
-        ASSERT_EQUALS("signed int", typeOf("0xFF;", "0xFF", false, &s));
-        ASSERT_EQUALS("unsigned int", typeOf("0xFFU;", "0xFFU", false, &s));
-        ASSERT_EQUALS("unsigned int", typeOf("0xFFFF;", "0xFFFF", false, &s));
-        ASSERT_EQUALS("signed long", typeOf("0xFFFFFF;", "0xFFFFFF", false, &s));
-        ASSERT_EQUALS("unsigned long", typeOf("0xFFFFFFU;", "0xFFFFFFU", false, &s));
-        ASSERT_EQUALS("unsigned long", typeOf("0xFFFFFFFF;", "0xFFFFFFFF", false, &s));
-        ASSERT_EQUALS("signed long long", typeOf("0xFFFFFFFFFFFF;", "0xFFFFFFFFFFFF", false, &s));
-        ASSERT_EQUALS("unsigned long long", typeOf("0xFFFFFFFFFFFFU;", "0xFFFFFFFFFFFFU", false, &s));
-        ASSERT_EQUALS("unsigned long long", typeOf("0xFFFFFFFF00000000;", "0xFFFFFFFF00000000", false, &s));
-
-        ASSERT_EQUALS("signed long", typeOf("2147483648;", "2147483648", false, &sSameSize));
-        ASSERT_EQUALS("unsigned long", typeOf("0xc000000000000000;", "0xc000000000000000", false, &sSameSize));
-
-        ASSERT_EQUALS("unsigned int", typeOf("1U;", "1U"));
-        ASSERT_EQUALS("signed long", typeOf("1L;", "1L"));
-        ASSERT_EQUALS("unsigned long", typeOf("1UL;", "1UL"));
-        ASSERT_EQUALS("signed long long", typeOf("1LL;", "1LL"));
-        ASSERT_EQUALS("unsigned long long", typeOf("1ULL;", "1ULL"));
-        ASSERT_EQUALS("unsigned long long", typeOf("1LLU;", "1LLU"));
-        ASSERT_EQUALS("signed long long", typeOf("1i64;", "1i64"));
-        ASSERT_EQUALS("unsigned long long", typeOf("1ui64;", "1ui64"));
-        ASSERT_EQUALS("unsigned int", typeOf("1u;", "1u"));
-        ASSERT_EQUALS("signed long", typeOf("1l;", "1l"));
-        ASSERT_EQUALS("unsigned long", typeOf("1ul;", "1ul"));
-        ASSERT_EQUALS("signed long long", typeOf("1ll;", "1ll"));
-        ASSERT_EQUALS("unsigned long long", typeOf("1ull;", "1ull"));
-        ASSERT_EQUALS("unsigned long long", typeOf("1llu;", "1llu"));
-        ASSERT_EQUALS("signed int", typeOf("01;", "01"));
-        ASSERT_EQUALS("unsigned int", typeOf("01U;", "01U"));
-        ASSERT_EQUALS("signed long", typeOf("01L;", "01L"));
-        ASSERT_EQUALS("unsigned long", typeOf("01UL;", "01UL"));
-        ASSERT_EQUALS("signed long long", typeOf("01LL;", "01LL"));
-        ASSERT_EQUALS("unsigned long long", typeOf("01ULL;", "01ULL"));
-        ASSERT_EQUALS("signed int", typeOf("0B1;", "0B1"));
-        ASSERT_EQUALS("signed int", typeOf("0b1;", "0b1"));
-        ASSERT_EQUALS("unsigned int", typeOf("0b1U;", "0b1U"));
-        ASSERT_EQUALS("signed long", typeOf("0b1L;", "0b1L"));
-        ASSERT_EQUALS("unsigned long", typeOf("0b1UL;", "0b1UL"));
-        ASSERT_EQUALS("signed long long", typeOf("0b1LL;", "0b1LL"));
-        ASSERT_EQUALS("unsigned long long", typeOf("0b1ULL;", "0b1ULL"));
-        ASSERT_EQUALS("float", typeOf("1.0F;", "1.0F"));
-        ASSERT_EQUALS("float", typeOf("1.0f;", "1.0f"));
-        ASSERT_EQUALS("double", typeOf("1.0;", "1.0"));
-        ASSERT_EQUALS("double", typeOf("1E3;", "1E3"));
-        ASSERT_EQUALS("double", typeOf("0x1.2p3;", "0x1.2p3"));
-        ASSERT_EQUALS("long double", typeOf("1.23L;", "1.23L"));
-        ASSERT_EQUALS("long double", typeOf("1.23l;", "1.23l"));
+        ASSERT_EQUALS("signed int", typeOf("1;\n", "1", false, &s));
+        ASSERT_EQUALS("signed int", typeOf("(-1);\n", "-1", false, &s));
+        ASSERT_EQUALS("signed int", typeOf("32767;\n", "32767", false, &s));
+        ASSERT_EQUALS("signed int", typeOf("(-32767);\n", "-32767", false, &s));
+        ASSERT_EQUALS("signed long", typeOf("32768;\n", "32768", false, &s));
+        ASSERT_EQUALS("signed long", typeOf("(-32768);\n", "-32768", false, &s));
+        ASSERT_EQUALS("signed long", typeOf("32768l;\n", "32768l", false, &s));
+        ASSERT_EQUALS("unsigned int", typeOf("32768U;\n", "32768U", false, &s));
+        ASSERT_EQUALS("signed long long", typeOf("2147483648;\n", "2147483648", false, &s));
+        ASSERT_EQUALS("unsigned long", typeOf("2147483648u;\n", "2147483648u", false, &s));
+        ASSERT_EQUALS("signed long long", typeOf("2147483648L;\n", "2147483648L", false, &s));
+        ASSERT_EQUALS("unsigned long long", typeOf("18446744069414584320;\n", "18446744069414584320", false, &s));
+        ASSERT_EQUALS("signed int", typeOf("0xFF;\n", "0xFF", false, &s));
+        ASSERT_EQUALS("unsigned int", typeOf("0xFFU;\n", "0xFFU", false, &s));
+        ASSERT_EQUALS("unsigned int", typeOf("0xFFFF;\n", "0xFFFF", false, &s));
+        ASSERT_EQUALS("signed long", typeOf("0xFFFFFF;\n", "0xFFFFFF", false, &s));
+        ASSERT_EQUALS("unsigned long", typeOf("0xFFFFFFU;\n", "0xFFFFFFU", false, &s));
+        ASSERT_EQUALS("unsigned long", typeOf("0xFFFFFFFF;\n", "0xFFFFFFFF", false, &s));
+        ASSERT_EQUALS("signed long long", typeOf("0xFFFFFFFFFFFF;\n", "0xFFFFFFFFFFFF", false, &s));
+        ASSERT_EQUALS("unsigned long long", typeOf("0xFFFFFFFFFFFFU;\n", "0xFFFFFFFFFFFFU", false, &s));
+        ASSERT_EQUALS("unsigned long long", typeOf("0xFFFFFFFF00000000;\n", "0xFFFFFFFF00000000", false, &s));
+
+        ASSERT_EQUALS("signed long", typeOf("2147483648;\n", "2147483648", false, &sSameSize));
+        ASSERT_EQUALS("unsigned long", typeOf("0xc000000000000000;\n", "0xc000000000000000", false, &sSameSize));
+
+        ASSERT_EQUALS("unsigned int", typeOf("1U;\n", "1U"));
+        ASSERT_EQUALS("signed long", typeOf("1L;\n", "1L"));
+        ASSERT_EQUALS("unsigned long", typeOf("1UL;\n", "1UL"));
+        ASSERT_EQUALS("signed long long", typeOf("1LL;\n", "1LL"));
+        ASSERT_EQUALS("unsigned long long", typeOf("1ULL;\n", "1ULL"));
+        ASSERT_EQUALS("unsigned long long", typeOf("1LLU;\n", "1LLU"));
+        ASSERT_EQUALS("signed long long", typeOf("1i64;\n", "1i64"));
+        ASSERT_EQUALS("unsigned long long", typeOf("1ui64;\n", "1ui64"));
+        ASSERT_EQUALS("unsigned int", typeOf("1u;\n", "1u"));
+        ASSERT_EQUALS("signed long", typeOf("1l;\n", "1l"));
+        ASSERT_EQUALS("unsigned long", typeOf("1ul;\n", "1ul"));
+        ASSERT_EQUALS("signed long long", typeOf("1ll;\n", "1ll"));
+        ASSERT_EQUALS("unsigned long long", typeOf("1ull;\n", "1ull"));
+        ASSERT_EQUALS("unsigned long long", typeOf("1llu;\n", "1llu"));
+        ASSERT_EQUALS("signed int", typeOf("01;\n", "01"));
+        ASSERT_EQUALS("unsigned int", typeOf("01U;\n", "01U"));
+        ASSERT_EQUALS("signed long", typeOf("01L;\n", "01L"));
+        ASSERT_EQUALS("unsigned long", typeOf("01UL;\n", "01UL"));
+        ASSERT_EQUALS("signed long long", typeOf("01LL;\n", "01LL"));
+        ASSERT_EQUALS("unsigned long long", typeOf("01ULL;\n", "01ULL"));
+        ASSERT_EQUALS("signed int", typeOf("0B1;\n", "0B1"));
+        ASSERT_EQUALS("signed int", typeOf("0b1;\n", "0b1"));
+        ASSERT_EQUALS("unsigned int", typeOf("0b1U;\n", "0b1U"));
+        ASSERT_EQUALS("signed long", typeOf("0b1L;\n", "0b1L"));
+        ASSERT_EQUALS("unsigned long", typeOf("0b1UL;\n", "0b1UL"));
+        ASSERT_EQUALS("signed long long", typeOf("0b1LL;\n", "0b1LL"));
+        ASSERT_EQUALS("unsigned long long", typeOf("0b1ULL;\n", "0b1ULL"));
+        ASSERT_EQUALS("float", typeOf("1.0F;\n", "1.0F"));
+        ASSERT_EQUALS("float", typeOf("1.0f;\n", "1.0f"));
+        ASSERT_EQUALS("double", typeOf("1.0;\n", "1.0"));
+        ASSERT_EQUALS("double", typeOf("1E3;\n", "1E3"));
+        ASSERT_EQUALS("double", typeOf("0x1.2p3;\n", "0x1.2p3"));
+        ASSERT_EQUALS("long double", typeOf("1.23L;\n", "1.23L"));
+        ASSERT_EQUALS("long double", typeOf("1.23l;\n", "1.23l"));
 
         // Constant calculations
-        ASSERT_EQUALS("signed int", typeOf("1 + 2;", "+"));
-        ASSERT_EQUALS("signed long", typeOf("1L + 2;", "+"));
-        ASSERT_EQUALS("signed long long", typeOf("1LL + 2;", "+"));
-        ASSERT_EQUALS("float", typeOf("1.2f + 3;", "+"));
-        ASSERT_EQUALS("float", typeOf("1 + 2.3f;", "+"));
+        ASSERT_EQUALS("signed int", typeOf("1 + 2;\n", "+"));
+        ASSERT_EQUALS("signed long", typeOf("1L + 2;\n", "+"));
+        ASSERT_EQUALS("signed long long", typeOf("1LL + 2;\n", "+"));
+        ASSERT_EQUALS("float", typeOf("1.2f + 3;\n", "+"));
+        ASSERT_EQUALS("float", typeOf("1 + 2.3f;\n", "+"));
 
         // promotions
-        ASSERT_EQUALS("signed int", typeOf("(char)1 +  (char)2;", "+"));
-        ASSERT_EQUALS("signed int", typeOf("(short)1 + (short)2;", "+"));
-        ASSERT_EQUALS("signed int", typeOf("(signed int)1 + (signed char)2;", "+"));
-        ASSERT_EQUALS("signed int", typeOf("(signed int)1 + (unsigned char)2;", "+"));
-        ASSERT_EQUALS("unsigned int", typeOf("(unsigned int)1 + (signed char)2;", "+"));
-        ASSERT_EQUALS("unsigned int", typeOf("(unsigned int)1 + (unsigned char)2;", "+"));
-        ASSERT_EQUALS("unsigned int", typeOf("(unsigned int)1 + (signed int)2;", "+"));
-        ASSERT_EQUALS("unsigned int", typeOf("(unsigned int)1 + (unsigned int)2;", "+"));
-        ASSERT_EQUALS("signed long", typeOf("(signed long)1 + (unsigned int)2;", "+"));
-        ASSERT_EQUALS("unsigned long", typeOf("(unsigned long)1 + (signed int)2;", "+"));
+        ASSERT_EQUALS("signed int", typeOf("(char)1 +  (char)2;\n", "+"));
+        ASSERT_EQUALS("signed int", typeOf("(short)1 + (short)2;\n", "+"));
+        ASSERT_EQUALS("signed int", typeOf("(signed int)1 + (signed char)2;\n", "+"));
+        ASSERT_EQUALS("signed int", typeOf("(signed int)1 + (unsigned char)2;\n", "+"));
+        ASSERT_EQUALS("unsigned int", typeOf("(unsigned int)1 + (signed char)2;\n", "+"));
+        ASSERT_EQUALS("unsigned int", typeOf("(unsigned int)1 + (unsigned char)2;\n", "+"));
+        ASSERT_EQUALS("unsigned int", typeOf("(unsigned int)1 + (signed int)2;\n", "+"));
+        ASSERT_EQUALS("unsigned int", typeOf("(unsigned int)1 + (unsigned int)2;\n", "+"));
+        ASSERT_EQUALS("signed long", typeOf("(signed long)1 + (unsigned int)2;\n", "+"));
+        ASSERT_EQUALS("unsigned long", typeOf("(unsigned long)1 + (signed int)2;\n", "+"));
 
         // char
-        ASSERT_EQUALS("char", typeOf("'a';", "'a'", true));
-        ASSERT_EQUALS("char", typeOf("'\\\'';", "'\\\''", true));
-        ASSERT_EQUALS("signed int", typeOf("'a';", "'a'", false));
-        ASSERT_EQUALS("wchar_t", typeOf("L'a';", "L'a'", true));
-        ASSERT_EQUALS("wchar_t", typeOf("L'a';", "L'a'", false));
-        ASSERT_EQUALS("signed int", typeOf("'aaa';", "'aaa'", true));
-        ASSERT_EQUALS("signed int", typeOf("'aaa';", "'aaa'", false));
+        ASSERT_EQUALS("char", typeOf("'a';\n", "'a'", true));
+        ASSERT_EQUALS("char", typeOf("'\\\'';\n", "'\\\''", true));
+        ASSERT_EQUALS("signed int", typeOf("'a';\n", "'a'", false));
+        ASSERT_EQUALS("wchar_t", typeOf("L'a';\n", "L'a'", true));
+        ASSERT_EQUALS("wchar_t", typeOf("L'a';\n", "L'a'", false));
+        ASSERT_EQUALS("signed int", typeOf("'aaa';\n", "'aaa'", true));
+        ASSERT_EQUALS("signed int", typeOf("'aaa';\n", "'aaa'", false));
 
         // char *
-        ASSERT_EQUALS("const char *", typeOf("\"hello\" + 1;", "+"));
-        ASSERT_EQUALS("const char",  typeOf("\"hello\"[1];", "["));
-        ASSERT_EQUALS("const char",  typeOf(";*\"hello\";", "*"));
-        ASSERT_EQUALS("const wchar_t *", typeOf("L\"hello\" + 1;", "+"));
+        ASSERT_EQUALS("const char *", typeOf("\"hello\" + 1;\n", "+"));
+        ASSERT_EQUALS("const char",  typeOf("\"hello\"[1];\n", "["));
+        ASSERT_EQUALS("const char",  typeOf(";*\"hello\";\n", "*"));
+        ASSERT_EQUALS("const wchar_t *", typeOf("L\"hello\" + 1;\n", "+"));
 
         // Variable calculations
-        ASSERT_EQUALS("void *", typeOf("void *p; a = p + 1;", "+"));
-        ASSERT_EQUALS("signed int", typeOf("int x; a = x + 1;", "+"));
-        ASSERT_EQUALS("signed int", typeOf("int x; a = x | 1;", "|"));
-        ASSERT_EQUALS("float", typeOf("float x; a = x + 1;", "+"));
-        ASSERT_EQUALS("signed int", typeOf("signed x; a = x + 1;", "x +"));
-        ASSERT_EQUALS("unsigned int", typeOf("unsigned x; a = x + 1;", "x +"));
-        ASSERT_EQUALS("unsigned int", typeOf("unsigned int u1, u2; a = u1 + 1;",  "u1 +"));
-        ASSERT_EQUALS("unsigned int", typeOf("unsigned int u1, u2; a = u1 + 1U;", "u1 +"));
-        ASSERT_EQUALS("unsigned int", typeOf("unsigned int u1, u2; a = u1 + u2;", "u1 +"));
-        ASSERT_EQUALS("unsigned int", typeOf("unsigned int u1, u2; a = u1 * 2;",  "u1 *"));
-        ASSERT_EQUALS("unsigned int", typeOf("unsigned int u1, u2; a = u1 * u2;", "u1 *"));
-        ASSERT_EQUALS("signed int *", typeOf("int x; a = &x;", "&"));
-        ASSERT_EQUALS("signed int *", typeOf("int x; a = &x;", "&"));
-        ASSERT_EQUALS("long double", typeOf("long double x; dostuff(x,1);", "x ,"));
-        ASSERT_EQUALS("long double *", typeOf("long double x; dostuff(&x,1);", "& x ,"));
-        ASSERT_EQUALS("signed int", typeOf("struct X {int i;}; void f(struct X x) { x.i }", "."));
-        ASSERT_EQUALS("signed int *", typeOf("int *p; a = p++;", "++"));
-        ASSERT_EQUALS("signed int", typeOf("int x; a = x++;", "++"));
-        ASSERT_EQUALS("signed int *", typeOf("enum AB {A,B}; AB *ab; x=ab+2;", "+"));
-        ASSERT_EQUALS("signed int *", typeOf("enum AB {A,B}; enum AB *ab; x=ab+2;", "+"));
-        ASSERT_EQUALS("AB *", typeOf("struct AB {int a; int b;}; AB ab; x=&ab;", "&"));
-        ASSERT_EQUALS("AB *", typeOf("struct AB {int a; int b;}; struct AB ab; x=&ab;", "&"));
-        ASSERT_EQUALS("A::BC *", typeOf("namespace A { struct BC { int b; int c; }; }; struct A::BC abc; x=&abc;", "&"));
-        ASSERT_EQUALS("A::BC *", typeOf("namespace A { struct BC { int b; int c; }; }; struct A::BC *abc; x=abc+1;", "+"));
-        ASSERT_EQUALS("signed int", typeOf("auto a(int& x, int& y) { return x + y; }", "+"));
-        ASSERT_EQUALS("signed int", typeOf("auto a(int& x) { return x << 1; }", "<<"));
-        ASSERT_EQUALS("signed int", typeOf("void a(int& x, int& y) { x = y; }", "=")); //Debatably this should be a signed int & but we'll stick with the current behavior for now
-        ASSERT_EQUALS("signed int", typeOf("auto a(int* y) { return *y; }", "*")); //Debatably this should be a signed int & but we'll stick with the current behavior for now
+        ASSERT_EQUALS("void *", typeOf("void *p; a = p + 1;\n", "+"));
+        ASSERT_EQUALS("signed int", typeOf("int x; a = x + 1;\n", "+"));
+        ASSERT_EQUALS("signed int", typeOf("int x; a = x | 1;\n", "|"));
+        ASSERT_EQUALS("float", typeOf("float x; a = x + 1;\n", "+"));
+        ASSERT_EQUALS("signed int", typeOf("signed x; a = x + 1;\n", "x +"));
+        ASSERT_EQUALS("unsigned int", typeOf("unsigned x; a = x + 1;\n", "x +"));
+        ASSERT_EQUALS("unsigned int", typeOf("unsigned int u1, u2; a = u1 + 1;\n",  "u1 +"));
+        ASSERT_EQUALS("unsigned int", typeOf("unsigned int u1, u2; a = u1 + 1U;\n", "u1 +"));
+        ASSERT_EQUALS("unsigned int", typeOf("unsigned int u1, u2; a = u1 + u2;\n", "u1 +"));
+        ASSERT_EQUALS("unsigned int", typeOf("unsigned int u1, u2; a = u1 * 2;\n",  "u1 *"));
+        ASSERT_EQUALS("unsigned int", typeOf("unsigned int u1, u2; a = u1 * u2;\n", "u1 *"));
+        ASSERT_EQUALS("signed int *", typeOf("int x; a = &x;\n", "&"));
+        ASSERT_EQUALS("signed int *", typeOf("int x; a = &x;\n", "&"));
+        ASSERT_EQUALS("long double", typeOf("long double x; dostuff(x,1);\n", "x ,"));
+        ASSERT_EQUALS("long double *", typeOf("long double x; dostuff(&x,1);\n", "& x ,"));
+        ASSERT_EQUALS("signed int", typeOf("struct X {int i;}; void f(struct X x) { x.i }\n", "."));
+        ASSERT_EQUALS("signed int *", typeOf("int *p; a = p++;\n", "++"));
+        ASSERT_EQUALS("signed int", typeOf("int x; a = x++;\n", "++"));
+        ASSERT_EQUALS("signed int *", typeOf("enum AB {A,B}; AB *ab; x=ab+2;\n", "+"));
+        ASSERT_EQUALS("signed int *", typeOf("enum AB {A,B}; enum AB *ab; x=ab+2;\n", "+"));
+        ASSERT_EQUALS("AB *", typeOf("struct AB {int a; int b;}; AB ab; x=&ab;\n", "&"));
+        ASSERT_EQUALS("AB *", typeOf("struct AB {int a; int b;}; struct AB ab; x=&ab;\n", "&"));
+        ASSERT_EQUALS("A::BC *", typeOf("namespace A { struct BC { int b; int c; }; }; struct A::BC abc; x=&abc;\n", "&"));
+        ASSERT_EQUALS("A::BC *", typeOf("namespace A { struct BC { int b; int c; }; }; struct A::BC *abc; x=abc+1;\n", "+"));
+        ASSERT_EQUALS("signed int", typeOf("auto a(int& x, int& y) { return x + y; }\n", "+"));
+        ASSERT_EQUALS("signed int", typeOf("auto a(int& x) { return x << 1; }\n", "<<"));
+        ASSERT_EQUALS("signed int", typeOf("void a(int& x, int& y) { x = y; }\n", "=")); //Debatably this should be a signed int & but we'll stick with the current behavior for now
+        ASSERT_EQUALS("signed int", typeOf("auto a(int* y) { return *y; }\n", "*")); //Debatably this should be a signed int & but we'll stick with the current behavior for now
 
         // Unary arithmetic/bit operators
-        ASSERT_EQUALS("signed int", typeOf("int x; a = -x;", "-"));
-        ASSERT_EQUALS("signed int", typeOf("int x; a = ~x;", "~"));
-        ASSERT_EQUALS("double", typeOf("double x; a = -x;", "-"));
+        ASSERT_EQUALS("signed int", typeOf("int x; a = -x;\n", "-"));
+        ASSERT_EQUALS("signed int", typeOf("int x; a = ~x;\n", "~"));
+        ASSERT_EQUALS("double", typeOf("double x; a = -x;\n", "-"));
 
         // Ternary operator
-        ASSERT_EQUALS("signed int", typeOf("int x; a = (b ? x : x);", "?"));
-        ASSERT_EQUALS("", typeOf("int x; a = (b ? x : y);", "?"));
-        ASSERT_EQUALS("double", typeOf("int x; double y; a = (b ? x : y);", "?"));
-        ASSERT_EQUALS("const char *", typeOf("int x; double y; a = (b ? \"a\" : \"b\");", "?"));
-        ASSERT_EQUALS("", typeOf("int x; double y; a = (b ? \"a\" : std::string(\"b\"));", "?"));
-        ASSERT_EQUALS("bool", typeOf("int x; a = (b ? false : true);", "?"));
+        ASSERT_EQUALS("signed int", typeOf("int x; a = (b ? x : x);\n", "?"));
+        ASSERT_EQUALS("", typeOf("int x; a = (b ? x : y);\n", "?"));
+        ASSERT_EQUALS("double", typeOf("int x; double y; a = (b ? x : y);\n", "?"));
+        ASSERT_EQUALS("const char *", typeOf("int x; double y; a = (b ? \"a\" : \"b\");\n", "?"));
+        ASSERT_EQUALS("", typeOf("int x; double y; a = (b ? \"a\" : std::string(\"b\"));\n", "?"));
+        ASSERT_EQUALS("bool", typeOf("int x; a = (b ? false : true);\n", "?"));
 
         // Boolean operators/literals
-        ASSERT_EQUALS("bool", typeOf("a > b;", ">"));
-        ASSERT_EQUALS("bool", typeOf(";!b;", "!"));
-        ASSERT_EQUALS("bool", typeOf("c = a && b;", "&&"));
-        ASSERT_EQUALS("bool", typeOf("a = false;", "false"));
-        ASSERT_EQUALS("bool", typeOf("a = true;", "true"));
+        ASSERT_EQUALS("bool", typeOf("a > b;\n", ">"));
+        ASSERT_EQUALS("bool", typeOf(";!b;\n", "!"));
+        ASSERT_EQUALS("bool", typeOf("c = a && b;\n", "&&"));
+        ASSERT_EQUALS("bool", typeOf("a = false;\n", "false"));
+        ASSERT_EQUALS("bool", typeOf("a = true;\n", "true"));
 
         // shift => result has same type as lhs
-        ASSERT_EQUALS("signed int", typeOf("int x; a = x << 1U;", "<<"));
-        ASSERT_EQUALS("signed int", typeOf("int x; a = x >> 1U;", ">>"));
-        ASSERT_EQUALS("",           typeOf("a = 12 >> x;", ">>", true)); // >> might be overloaded
-        ASSERT_EQUALS("signed int", typeOf("a = 12 >> x;", ">>", false));
-        ASSERT_EQUALS("",           typeOf("a = 12 << x;", "<<", true)); // << might be overloaded
-        ASSERT_EQUALS("signed int", typeOf("a = 12 << x;", "<<", false));
-        ASSERT_EQUALS("signed int", typeOf("a = true << 1U;", "<<"));
+        ASSERT_EQUALS("signed int", typeOf("int x; a = x << 1U;\n", "<<"));
+        ASSERT_EQUALS("signed int", typeOf("int x; a = x >> 1U;\n", ">>"));
+        ASSERT_EQUALS("",           typeOf("a = 12 >> x;\n", ">>", true)); // >> might be overloaded
+        ASSERT_EQUALS("signed int", typeOf("a = 12 >> x;\n", ">>", false));
+        ASSERT_EQUALS("",           typeOf("a = 12 << x;\n", "<<", true)); // << might be overloaded
+        ASSERT_EQUALS("signed int", typeOf("a = 12 << x;\n", "<<", false));
+        ASSERT_EQUALS("signed int", typeOf("a = true << 1U;\n", "<<"));
 
         // assignment => result has same type as lhs
-        ASSERT_EQUALS("unsigned short", typeOf("unsigned short x; x = 3;", "="));
+        ASSERT_EQUALS("unsigned short", typeOf("unsigned short x; x = 3;\n", "="));
 
         // array..
-        ASSERT_EQUALS("void * *", typeOf("void * x[10]; a = x + 0;", "+"));
-        ASSERT_EQUALS("signed int *", typeOf("int x[10]; a = x + 1;", "+"));
-        ASSERT_EQUALS("signed int",  typeOf("int x[10]; a = x[0] + 1;", "+"));
-        ASSERT_EQUALS("",            typeOf("a = x[\"hello\"];", "[", true));
-        ASSERT_EQUALS("const char",  typeOf("a = x[\"hello\"];", "[", false));
-        ASSERT_EQUALS("signed int *", typeOf("int x[10]; a = &x;", "&"));
-        ASSERT_EQUALS("signed int *", typeOf("int x[10]; a = &x[1];", "&"));
+        ASSERT_EQUALS("void * *", typeOf("void * x[10]; a = x + 0;\n", "+"));
+        ASSERT_EQUALS("signed int *", typeOf("int x[10]; a = x + 1;\n", "+"));
+        ASSERT_EQUALS("signed int",  typeOf("int x[10]; a = x[0] + 1;\n", "+"));
+        ASSERT_EQUALS("",            typeOf("a = x[\"hello\"];\n", "[", true));
+        ASSERT_EQUALS("const char",  typeOf("a = x[\"hello\"];\n", "[", false));
+        ASSERT_EQUALS("signed int *", typeOf("int x[10]; a = &x;\n", "&"));
+        ASSERT_EQUALS("signed int *", typeOf("int x[10]; a = &x[1];\n", "&"));
 
         // cast..
-        ASSERT_EQUALS("void *", typeOf("a = (void *)0;", "("));
-        ASSERT_EQUALS("char", typeOf("a = (char)32;", "("));
-        ASSERT_EQUALS("signed long", typeOf("a = (long)32;", "("));
-        ASSERT_EQUALS("signed long", typeOf("a = (long int)32;", "("));
-        ASSERT_EQUALS("signed long long", typeOf("a = (long long)32;", "("));
-        ASSERT_EQUALS("long double", typeOf("a = (long double)32;", "("));
-        ASSERT_EQUALS("char", typeOf("a = static_cast<char>(32);", "("));
-        ASSERT_EQUALS("", typeOf("a = (unsigned x)0;", "("));
-        ASSERT_EQUALS("unsigned int", typeOf("a = unsigned(123);", "("));
+        ASSERT_EQUALS("void *", typeOf("a = (void *)0;\n", "("));
+        ASSERT_EQUALS("char", typeOf("a = (char)32;\n", "("));
+        ASSERT_EQUALS("signed long", typeOf("a = (long)32;\n", "("));
+        ASSERT_EQUALS("signed long", typeOf("a = (long int)32;\n", "("));
+        ASSERT_EQUALS("signed long long", typeOf("a = (long long)32;\n", "("));
+        ASSERT_EQUALS("long double", typeOf("a = (long double)32;\n", "("));
+        ASSERT_EQUALS("char", typeOf("a = static_cast<char>(32);\n", "("));
+        ASSERT_EQUALS("", typeOf("a = (unsigned x)0;\n", "("));
+        ASSERT_EQUALS("unsigned int", typeOf("a = unsigned(123);\n", "("));
 
         // sizeof..
-        ASSERT_EQUALS("char", typeOf("sizeof(char);", "char"));
+        ASSERT_EQUALS("char", typeOf("sizeof(char);\n", "char"));
 
         // const..
-        ASSERT_EQUALS("const char *", typeOf("a = \"123\";", "\"123\""));
-        ASSERT_EQUALS("const signed int *", typeOf("const int *a; x = a + 1;", "a +"));
-        ASSERT_EQUALS("signed int * const", typeOf("int * const a; x = a + 1;", "+"));
-        ASSERT_EQUALS("const signed int *", typeOf("const int a[20]; x = a + 1;", "+"));
-        ASSERT_EQUALS("const signed int *", typeOf("const int x; a = &x;", "&"));
-        ASSERT_EQUALS("signed int", typeOf("int * const a; x = *a;", "*"));
-        ASSERT_EQUALS("const signed int", typeOf("const int * const a; x = *a;", "*"));
+        ASSERT_EQUALS("const char *", typeOf("a = \"123\";\n", "\"123\""));
+        ASSERT_EQUALS("const signed int *", typeOf("const int *a; x = a + 1;\n", "a +"));
+        ASSERT_EQUALS("signed int * const", typeOf("int * const a; x = a + 1;\n", "+"));
+        ASSERT_EQUALS("const signed int *", typeOf("const int a[20]; x = a + 1;\n", "+"));
+        ASSERT_EQUALS("const signed int *", typeOf("const int x; a = &x;\n", "&"));
+        ASSERT_EQUALS("signed int", typeOf("int * const a; x = *a;\n", "*"));
+        ASSERT_EQUALS("const signed int", typeOf("const int * const a; x = *a;\n", "*"));
 
         // function call..
-        ASSERT_EQUALS("signed int", typeOf("int a(int); a(5);", "( 5"));
-        ASSERT_EQUALS("signed int", typeOf("auto a(int) -> int; a(5);", "( 5"));
-        ASSERT_EQUALS("unsigned long", typeOf("sizeof(x);", "("));
-        ASSERT_EQUALS("signed int", typeOf("int (*a)(int); a(5);", "( 5"));
-        ASSERT_EQUALS("s", typeOf("struct s { s foo(); s(int, int); }; s s::foo() { return s(1, 2); } ", "( 1 , 2 )"));
+        ASSERT_EQUALS("signed int", typeOf("int a(int); a(5);\n", "( 5"));
+        ASSERT_EQUALS("signed int", typeOf("auto a(int) -> int; a(5);\n", "( 5"));
+        ASSERT_EQUALS("unsigned long", typeOf("sizeof(x);\n", "("));
+        ASSERT_EQUALS("signed int", typeOf("int (*a)(int); a(5);\n", "( 5"));
+        ASSERT_EQUALS("s", typeOf("struct s { s foo(); s(int, int); }; s s::foo() { return s(1, 2); } \n", "( 1 , 2 )"));
         // Some standard template functions.. TODO library configuration
-        ASSERT_EQUALS("signed int &&", typeOf("std::move(5);", "( 5 )"));
-        ASSERT_EQUALS("signed int", typeOf("using F = int(int*); F* f; f(ptr);", "( ptr")); // #9792
+        ASSERT_EQUALS("signed int &&", typeOf("std::move(5);\n", "( 5 )"));
+        ASSERT_EQUALS("signed int", typeOf("using F = int(int*); F* f; f(ptr);\n", "( ptr")); // #9792
 
         // calling constructor..
-        ASSERT_EQUALS("s", typeOf("struct s { s(int); }; s::s(int){} void foo() { throw s(1); } ", "( 1 )")); // #13100
+        ASSERT_EQUALS("s", typeOf("struct s { s(int); }; s::s(int){} void foo() { throw s(1); } \n", "( 1 )")); // #13100
 
         // struct member..
-        ASSERT_EQUALS("signed int", typeOf("struct AB { int a; int b; } ab; x = ab.a;", "."));
-        ASSERT_EQUALS("signed int", typeOf("struct AB { int a; int b; } *ab; x = ab[1].a;", "."));
+        ASSERT_EQUALS("signed int", typeOf("struct AB { int a; int b; } ab; x = ab.a;\n", "."));
+        ASSERT_EQUALS("signed int", typeOf("struct AB { int a; int b; } *ab; x = ab[1].a;\n", "."));
 
         // Overloaded operators
-        ASSERT_EQUALS("Fred &", typeOf("class Fred { Fred& operator<(int); }; void f() { Fred fred; x=fred<123; }", "<"));
+        ASSERT_EQUALS("Fred &", typeOf("class Fred { Fred& operator<(int); }; void f() { Fred fred; x=fred<123; }\n", "<"));
 
         // Static members
-        ASSERT_EQUALS("signed int", typeOf("struct AB { static int a; }; x = AB::a;", "::"));
+        ASSERT_EQUALS("signed int", typeOf("struct AB { static int a; }; x = AB::a;\n", "::"));
 
         // Pointer to unknown type
-        ASSERT_EQUALS("*", typeOf("Bar* b;", "b"));
+        ASSERT_EQUALS("*", typeOf("Bar* b;\n", "b"));
 
         // Enum
-        ASSERT_EQUALS("char", typeOf("enum E : char { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
-        ASSERT_EQUALS("signed char", typeOf("enum E : signed char { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
-        ASSERT_EQUALS("unsigned char", typeOf("enum E : unsigned char { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
-        ASSERT_EQUALS("signed short", typeOf("enum E : short { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
-        ASSERT_EQUALS("unsigned short", typeOf("enum E : unsigned short { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
-        ASSERT_EQUALS("signed int", typeOf("enum E : int { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
-        ASSERT_EQUALS("unsigned int", typeOf("enum E : unsigned int { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
-        ASSERT_EQUALS("signed long", typeOf("enum E : long { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
-        ASSERT_EQUALS("unsigned long", typeOf("enum E : unsigned long { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
-        ASSERT_EQUALS("signed long long", typeOf("enum E : long long { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
-        ASSERT_EQUALS("unsigned long long", typeOf("enum E : unsigned long long { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
+        ASSERT_EQUALS("char", typeOf("enum E : char { }; void foo() { E e[3]; bar(e[0]); }\n", "[ 0"));
+        ASSERT_EQUALS("signed char", typeOf("enum E : signed char { }; void foo() { E e[3]; bar(e[0]); }\n", "[ 0"));
+        ASSERT_EQUALS("unsigned char", typeOf("enum E : unsigned char { }; void foo() { E e[3]; bar(e[0]); }\n", "[ 0"));
+        ASSERT_EQUALS("signed short", typeOf("enum E : short { }; void foo() { E e[3]; bar(e[0]); }\n", "[ 0"));
+        ASSERT_EQUALS("unsigned short", typeOf("enum E : unsigned short { }; void foo() { E e[3]; bar(e[0]); }\n", "[ 0"));
+        ASSERT_EQUALS("signed int", typeOf("enum E : int { }; void foo() { E e[3]; bar(e[0]); }\n", "[ 0"));
+        ASSERT_EQUALS("unsigned int", typeOf("enum E : unsigned int { }; void foo() { E e[3]; bar(e[0]); }\n", "[ 0"));
+        ASSERT_EQUALS("signed long", typeOf("enum E : long { }; void foo() { E e[3]; bar(e[0]); }\n", "[ 0"));
+        ASSERT_EQUALS("unsigned long", typeOf("enum E : unsigned long { }; void foo() { E e[3]; bar(e[0]); }\n", "[ 0"));
+        ASSERT_EQUALS("signed long long", typeOf("enum E : long long { }; void foo() { E e[3]; bar(e[0]); }\n", "[ 0"));
+        ASSERT_EQUALS("unsigned long long", typeOf("enum E : unsigned long long { }; void foo() { E e[3]; bar(e[0]); }\n", "[ 0"));
 
 #define CHECK_LIBRARY_FUNCTION_RETURN_TYPE(type) do { \
         const char xmldata[] = "<?xml version=\"1.0\"?>\n" \
@@ -9904,7 +9904,7 @@ class TestSymbolDatabase : public TestFixture {
                                "</function>\n" \
                                "</def>";              \
         const Settings sF = settingsBuilder().libraryxml(xmldata).build(); \
-        ASSERT_EQUALS(#type, typeOf("void f() { auto x = g(); }", "x", true, &sF)); \
+        ASSERT_EQUALS(#type, typeOf("void f() { auto x = g(); }\n", "x", true, &sF)); \
 } while (false)
         // *INDENT-OFF*
         CHECK_LIBRARY_FUNCTION_RETURN_TYPE(bool);
@@ -9937,12 +9937,12 @@ class TestSymbolDatabase : public TestFixture {
             settings.platform.sizeof_short = 2;
             settings.platform.sizeof_int = 4;
 
-            ASSERT_EQUALS("unsigned char", typeOf("u8'a';", "u8'a'", true, &settings));
-            ASSERT_EQUALS("unsigned short", typeOf("u'a';", "u'a'", true, &settings));
-            ASSERT_EQUALS("unsigned int", typeOf("U'a';", "U'a'", true, &settings));
-            ASSERT_EQUALS("const unsigned char *", typeOf("u8\"a\";", "u8\"a\"", true, &settings));
-            ASSERT_EQUALS("const unsigned short *", typeOf("u\"a\";", "u\"a\"", true, &settings));
-            ASSERT_EQUALS("const unsigned int *", typeOf("U\"a\";", "U\"a\"", true, &settings));
+            ASSERT_EQUALS("unsigned char", typeOf("u8'a';\n", "u8'a'", true, &settings));
+            ASSERT_EQUALS("unsigned short", typeOf("u'a';\n", "u'a'", true, &settings));
+            ASSERT_EQUALS("unsigned int", typeOf("U'a';\n", "U'a'", true, &settings));
+            ASSERT_EQUALS("const unsigned char *", typeOf("u8\"a\";\n", "u8\"a\"", true, &settings));
+            ASSERT_EQUALS("const unsigned short *", typeOf("u\"a\";\n", "u\"a\"", true, &settings));
+            ASSERT_EQUALS("const unsigned int *", typeOf("U\"a\";\n", "U\"a\"", true, &settings));
         }
         {
             // PodType
@@ -9960,11 +9960,11 @@ class TestSymbolDatabase : public TestFixture {
             ValueType vt2;
             ASSERT_EQUALS(true, vt2.fromLibraryType("podtype2", settingsWin64));
             ASSERT_EQUALS(ValueType::Type::INT, vt2.type);
-            ASSERT_EQUALS("unsigned int *", typeOf(";void *data = new u32[10];", "new", true, &settingsWin64));
-            ASSERT_EQUALS("unsigned int *", typeOf(";void *data = new xyz::x[10];", "new", true, &settingsWin64));
-            ASSERT_EQUALS("unsigned int", typeOf("; x = (xyz::x)12;", "(", true, &settingsWin64));
-            ASSERT_EQUALS("unsigned int", typeOf(";u32(12);", "(", true, &settingsWin64));
-            ASSERT_EQUALS("unsigned int", typeOf("x = u32(y[i]);", "(", true, &settingsWin64));
+            ASSERT_EQUALS("unsigned int *", typeOf(";void *data = new u32[10];\n", "new", true, &settingsWin64));
+            ASSERT_EQUALS("unsigned int *", typeOf(";void *data = new xyz::x[10];\n", "new", true, &settingsWin64));
+            ASSERT_EQUALS("unsigned int", typeOf("; x = (xyz::x)12;\n", "(", true, &settingsWin64));
+            ASSERT_EQUALS("unsigned int", typeOf(";u32(12);\n", "(", true, &settingsWin64));
+            ASSERT_EQUALS("unsigned int", typeOf("x = u32(y[i]);\n", "(", true, &settingsWin64));
         }
         {
             // PlatformType
@@ -9999,9 +9999,9 @@ class TestSymbolDatabase : public TestFixture {
                                        "  <container id=\"C\" startPattern=\"C\"/>\n"
                                        "</def>";
             const Settings sC = settingsBuilder().libraryxml(xmldata).build();
-            ASSERT_EQUALS("container(C) *", typeOf("C*c=new C;","new",true,&sC));
-            ASSERT_EQUALS("container(C) *", typeOf("x=(C*)c;","(",true,&sC));
-            ASSERT_EQUALS("container(C)", typeOf("C c = C();","(",true,&sC));
+            ASSERT_EQUALS("container(C) *", typeOf("C*c=new C;\n","new",true,&sC));
+            ASSERT_EQUALS("container(C) *", typeOf("x=(C*)c;\n","(",true,&sC));
+            ASSERT_EQUALS("container(C)", typeOf("C c = C();\n","(",true,&sC));
         }
         {
             // Container (vector)
@@ -10021,64 +10021,64 @@ class TestSymbolDatabase : public TestFixture {
                                        "  </container>\n"
                                        "</def>";
             const Settings set = settingsBuilder().libraryxml(xmldata).build();
-            ASSERT_EQUALS("signed int", typeOf("Vector<int> v; v[0]=3;", "[", true, &set));
-            ASSERT_EQUALS("container(test :: string)", typeOf("{return test::string();}", "(", true, &set));
+            ASSERT_EQUALS("signed int", typeOf("Vector<int> v; v[0]=3;\n", "[", true, &set));
+            ASSERT_EQUALS("container(test :: string)", typeOf("{return test::string();}\n", "(", true, &set));
             ASSERT_EQUALS(
                 "container(test :: string)",
-                typeOf("void foo(Vector<test::string> v) { for (auto s: v) { x=s+s; } }", "s", true, &set));
+                typeOf("void foo(Vector<test::string> v) { for (auto s: v) { x=s+s; } }\n", "s", true, &set));
             ASSERT_EQUALS(
                 "container(test :: string)",
-                typeOf("void foo(Vector<test::string> v) { for (auto s: v) { x=s+s; } }", "+", true, &set));
+                typeOf("void foo(Vector<test::string> v) { for (auto s: v) { x=s+s; } }\n", "+", true, &set));
             ASSERT_EQUALS("container(test :: string) &",
-                          typeOf("Vector<test::string> v; x = v.front();", "(", true, &set));
+                          typeOf("Vector<test::string> v; x = v.front();\n", "(", true, &set));
             ASSERT_EQUALS("container(test :: string) *",
-                          typeOf("Vector<test::string> v; x = v.data();", "(", true, &set));
-            ASSERT_EQUALS("signed int &", typeOf("Vector<int> v; x = v.front();", "(", true, &set));
-            ASSERT_EQUALS("signed int *", typeOf("Vector<int> v; x = v.data();", "(", true, &set));
-            ASSERT_EQUALS("signed int * *", typeOf("Vector<int*> v; x = v.data();", "(", true, &set));
-            ASSERT_EQUALS("iterator(Vector <)", typeOf("Vector<int> v; x = v.begin();", "(", true, &set));
-            ASSERT_EQUALS("signed int &", typeOf("Vector<int> v; x = *v.begin();", "*", true, &set));
+                          typeOf("Vector<test::string> v; x = v.data();\n", "(", true, &set));
+            ASSERT_EQUALS("signed int &", typeOf("Vector<int> v; x = v.front();\n", "(", true, &set));
+            ASSERT_EQUALS("signed int *", typeOf("Vector<int> v; x = v.data();\n", "(", true, &set));
+            ASSERT_EQUALS("signed int * *", typeOf("Vector<int*> v; x = v.data();\n", "(", true, &set));
+            ASSERT_EQUALS("iterator(Vector <)", typeOf("Vector<int> v; x = v.begin();\n", "(", true, &set));
+            ASSERT_EQUALS("signed int &", typeOf("Vector<int> v; x = *v.begin();\n", "*", true, &set));
             ASSERT_EQUALS("container(test :: string)",
-                          typeOf("void foo(){test::string s; return \"x\"+s;}", "+", true, &set));
+                          typeOf("void foo(){test::string s; return \"x\"+s;}\n", "+", true, &set));
             ASSERT_EQUALS("container(test :: string)",
-                          typeOf("void foo(){test::string s; return s+\"x\";}", "+", true, &set));
+                          typeOf("void foo(){test::string s; return s+\"x\";}\n", "+", true, &set));
             ASSERT_EQUALS("container(test :: string)",
-                          typeOf("void foo(){test::string s; return 'x'+s;}", "+", true, &set));
+                          typeOf("void foo(){test::string s; return 'x'+s;}\n", "+", true, &set));
             ASSERT_EQUALS("container(test :: string)",
-                          typeOf("void foo(){test::string s; return s+'x';}", "+", true, &set));
+                          typeOf("void foo(){test::string s; return s+'x';}\n", "+", true, &set));
         }
 
         // new
-        ASSERT_EQUALS("C *", typeOf("class C {}; x = new C();", "new"));
+        ASSERT_EQUALS("C *", typeOf("class C {}; x = new C();\n", "new"));
 
         // auto variables
-        ASSERT_EQUALS("signed int", typeOf("; auto x = 3;", "x"));
-        ASSERT_EQUALS("signed int *", typeOf("; auto *p = (int *)0;", "p"));
-        ASSERT_EQUALS("const signed int *", typeOf("; auto *p = (const int *)0;", "p"));
-        ASSERT_EQUALS("const signed int *", typeOf("; auto *p = (constexpr int *)0;", "p"));
-        ASSERT_EQUALS("const signed int *", typeOf("; const auto *p = (int *)0;", "p"));
-        ASSERT_EQUALS("const signed int *", typeOf("; constexpr auto *p = (int *)0;", "p"));
-        ASSERT_EQUALS("const signed int *", typeOf("; const auto *p = (const int *)0;", "p"));
-        ASSERT_EQUALS("const signed int *", typeOf("; constexpr auto *p = (constexpr int *)0;", "p"));
-        ASSERT_EQUALS("const signed int *", typeOf("; const constexpr auto *p = (int *)0;", "p"));
-        ASSERT_EQUALS("signed int *", typeOf("; auto data = new int[100];", "data"));
-        ASSERT_EQUALS("signed int", typeOf("; auto data = new X::Y; int x=1000; x=x/5;", "/")); // #7970
-        ASSERT_EQUALS("signed int *", typeOf("; auto data = new (nothrow) int[100];", "data"));
-        ASSERT_EQUALS("signed int *", typeOf("; auto data = new (std::nothrow) int[100];", "data"));
-        ASSERT_EQUALS("const signed short", typeOf("short values[10]; void f() { for (const auto x : values); }", "x"));
-        ASSERT_EQUALS("const signed short &", typeOf("short values[10]; void f() { for (const auto& x : values); }", "x"));
-        ASSERT_EQUALS("signed short &", typeOf("short values[10]; void f() { for (auto& x : values); }", "x"));
-        ASSERT_EQUALS("signed int * &", typeOf("int* values[10]; void f() { for (auto& p : values); }", "p"));
-        ASSERT_EQUALS("signed int * const &", typeOf("int* values[10]; void f() { for (const auto& p : values); }", "p"));
-        ASSERT_EQUALS("const signed int *", typeOf("int* values[10]; void f() { for (const auto* p : values); }", "p"));
-        ASSERT_EQUALS("const signed int", typeOf("; const auto x = 3;", "x"));
-        ASSERT_EQUALS("const signed int", typeOf("; constexpr auto x = 3;", "x"));
-        ASSERT_EQUALS("const signed int", typeOf("; const constexpr auto x = 3;", "x"));
-        ASSERT_EQUALS("void * const", typeOf("typedef void* HWND; const HWND x = 0;", "x"));
+        ASSERT_EQUALS("signed int", typeOf("; auto x = 3;\n", "x"));
+        ASSERT_EQUALS("signed int *", typeOf("; auto *p = (int *)0;\n", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; auto *p = (const int *)0;\n", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; auto *p = (constexpr int *)0;\n", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; const auto *p = (int *)0;\n", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; constexpr auto *p = (int *)0;\n", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; const auto *p = (const int *)0;\n", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; constexpr auto *p = (constexpr int *)0;\n", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; const constexpr auto *p = (int *)0;\n", "p"));
+        ASSERT_EQUALS("signed int *", typeOf("; auto data = new int[100];\n", "data"));
+        ASSERT_EQUALS("signed int", typeOf("; auto data = new X::Y; int x=1000; x=x/5;\n", "/")); // #7970
+        ASSERT_EQUALS("signed int *", typeOf("; auto data = new (nothrow) int[100];\n", "data"));
+        ASSERT_EQUALS("signed int *", typeOf("; auto data = new (std::nothrow) int[100];\n", "data"));
+        ASSERT_EQUALS("const signed short", typeOf("short values[10]; void f() { for (const auto x : values); }\n", "x"));
+        ASSERT_EQUALS("const signed short &", typeOf("short values[10]; void f() { for (const auto& x : values); }\n", "x"));
+        ASSERT_EQUALS("signed short &", typeOf("short values[10]; void f() { for (auto& x : values); }\n", "x"));
+        ASSERT_EQUALS("signed int * &", typeOf("int* values[10]; void f() { for (auto& p : values); }\n", "p"));
+        ASSERT_EQUALS("signed int * const &", typeOf("int* values[10]; void f() { for (const auto& p : values); }\n", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("int* values[10]; void f() { for (const auto* p : values); }\n", "p"));
+        ASSERT_EQUALS("const signed int", typeOf("; const auto x = 3;\n", "x"));
+        ASSERT_EQUALS("const signed int", typeOf("; constexpr auto x = 3;\n", "x"));
+        ASSERT_EQUALS("const signed int", typeOf("; const constexpr auto x = 3;\n", "x"));
+        ASSERT_EQUALS("void * const", typeOf("typedef void* HWND; const HWND x = 0;\n", "x"));
 
         // Variable declaration
-        ASSERT_EQUALS("char *", typeOf("; char abc[] = \"abc\";", "["));
-        ASSERT_EQUALS("", typeOf("; int x[10] = { [3]=1 };", "[ 3 ]"));
+        ASSERT_EQUALS("char *", typeOf("; char abc[] = \"abc\";\n", "["));
+        ASSERT_EQUALS("", typeOf("; int x[10] = { [3]=1 };\n", "[ 3 ]"));
 
         // std::make_shared
         {
@@ -10088,7 +10088,7 @@ class TestSymbolDatabase : public TestFixture {
                                        "</def>";
             const Settings set = settingsBuilder().libraryxml(xmldata).build();
             ASSERT_EQUALS("smart-pointer(std::shared_ptr)",
-                          typeOf("class C {}; x = std::make_shared<C>();", "(", true, &set));
+                          typeOf("class C {}; x = std::make_shared<C>();\n", "(", true, &set));
         }
 
         // return
@@ -10099,7 +10099,7 @@ class TestSymbolDatabase : public TestFixture {
                                        "  <container id=\"C\" startPattern=\"C\"/>\n"
                                        "</def>";
             const Settings sC = settingsBuilder().libraryxml(xmldata).build();
-            ASSERT_EQUALS("container(C)", typeOf("C f(char *p) { char data[10]; return data; }", "return", true, &sC));
+            ASSERT_EQUALS("container(C)", typeOf("C f(char *p) { char data[10]; return data; }\n", "return", true, &sC));
         }
         // Smart pointer
         {
@@ -10109,9 +10109,9 @@ class TestSymbolDatabase : public TestFixture {
                                        "</def>";
             const Settings set = settingsBuilder().libraryxml(xmldata).build();
             ASSERT_EQUALS("smart-pointer(MyPtr)",
-                          typeOf("void f() { MyPtr<int> p; return p; }", "p ;", true, &set));
-            ASSERT_EQUALS("signed int", typeOf("void f() { MyPtr<int> p; return *p; }", "* p ;", true, &set));
-            ASSERT_EQUALS("smart-pointer(MyPtr)", typeOf("void f() {return MyPtr<int>();}", "(", true, &set));
+                          typeOf("void f() { MyPtr<int> p; return p; }\n", "p ;", true, &set));
+            ASSERT_EQUALS("signed int", typeOf("void f() { MyPtr<int> p; return *p; }\n", "* p ;", true, &set));
+            ASSERT_EQUALS("smart-pointer(MyPtr)", typeOf("void f() {return MyPtr<int>();}\n", "(", true, &set));
         }
     }
 
@@ -10126,7 +10126,7 @@ class TestSymbolDatabase : public TestFixture {
                       "\n"
                       "void f() {\n"
                       "    func(i, b, u, s, v, it, p);\n"
-                      "}");
+                      "}\n");
 
         const Token* tok = tokenizer.tokens();
 
@@ -10386,19 +10386,19 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void valueTypeThis() {
-        ASSERT_EQUALS("C *", typeOf("class C { C() { *this = 0; } };", "this"));
-        ASSERT_EQUALS("const C *", typeOf("class C { void foo() const; }; void C::foo() const { *this = 0; }", "this"));
+        ASSERT_EQUALS("C *", typeOf("class C { C() { *this = 0; } };\n", "this"));
+        ASSERT_EQUALS("const C *", typeOf("class C { void foo() const; }; void C::foo() const { *this = 0; }\n", "this"));
     }
 
     void valueTypeChar() {
         Settings s = settings2;
         s.platform.defaultSign = 's';
-        ASSERT_EQUALS("char", typeOf("char c; c = 'x';", "c =", true, &s));
-        ASSERT_EQUALS("char", typeOf("char buf[10]; buf[0] = 'x';", "[ 0 ]", true, &s));
+        ASSERT_EQUALS("char", typeOf("char c; c = 'x';\n", "c =", true, &s));
+        ASSERT_EQUALS("char", typeOf("char buf[10]; buf[0] = 'x';\n", "[ 0 ]", true, &s));
     }
 
     void valueTypeRValueReference() {
-        TODO_ASSERT_EQUALS("", "bool", typeOf("void f(std::string&& s = {})", "&&"));
+        TODO_ASSERT_EQUALS("", "bool", typeOf("void f(std::string&& s = {})\n", "&&"));
     }
 
     void variadic1() { // #7453
@@ -10409,7 +10409,7 @@ class TestSymbolDatabase : public TestFixture {
                           "{\n"
                           "   CBase* cp1 = create(\"AAAA\", 44, (char*)0);\n"
                           "   CBase* cp2 = create(ot, \"AAAA\", 44, (char*)0);\n"
-                          "}");
+                          "}\n");
 
             const Token *f = Token::findsimplematch(tokenizer.tokens(), "create ( \"AAAA\"");
             ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 1);
@@ -10423,7 +10423,7 @@ class TestSymbolDatabase : public TestFixture {
                           "{\n"
                           "   CBase* cp1 = create(\"AAAA\", 44, (char*)0);\n"
                           "   CBase* cp2 = create(ot, \"AAAA\", 44, (char*)0);\n"
-                          "}");
+                          "}\n");
 
             const Token *f = Token::findsimplematch(tokenizer.tokens(), "create ( \"AAAA\"");
             ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 2);
@@ -10440,7 +10440,7 @@ class TestSymbolDatabase : public TestFixture {
                           "{\n"
                           "   CBase* cp1 = create(\"AAAA\", 44, (char*)0);\n"
                           "   CBase* cp2 = create(L\"AAAA\", 44, (char*)0);\n"
-                          "}");
+                          "}\n");
 
             const Token *f = Token::findsimplematch(tokenizer.tokens(), "cp1 = create (");
             ASSERT_EQUALS(true, db && f && f->tokAt(2) && f->tokAt(2)->function() && f->tokAt(2)->function()->tokenDef->linenr() == 1);
@@ -10454,7 +10454,7 @@ class TestSymbolDatabase : public TestFixture {
                           "{\n"
                           "   CBase* cp1 = create(\"AAAA\", 44, (char*)0);\n"
                           "   CBase* cp2 = create(L\"AAAA\", 44, (char*)0);\n"
-                          "}");
+                          "}\n");
 
             const Token *f = Token::findsimplematch(tokenizer.tokens(), "cp1 = create (");
             ASSERT_EQUALS(true, db && f && f->tokAt(2) && f->tokAt(2)->function() && f->tokAt(2)->function()->tokenDef->linenr() == 2);
@@ -10471,7 +10471,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    long length;\n"
                           "    XYZ per;\n"
                           "    zdcalc(length, &per);\n"
-                          "}");
+                          "}\n");
 
             const Token *f = Token::findsimplematch(tokenizer.tokens(), "zdcalc ( length");
             ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 2);
@@ -10483,7 +10483,7 @@ class TestSymbolDatabase : public TestFixture {
                           "    long length;\n"
                           "    XYZ per;\n"
                           "    zdcalc(length, &per);\n"
-                          "}");
+                          "}\n");
 
             const Token *f = Token::findsimplematch(tokenizer.tokens(), "zdcalc ( length");
             ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 1);
@@ -10491,7 +10491,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void noReturnType() {
-        GET_SYMBOL_DB_C("func() { }");
+        GET_SYMBOL_DB_C("func() { }\n");
 
         ASSERT(db && db->functionScopes.size() == 1);
         ASSERT(db->functionScopes[0]->function != nullptr);
@@ -10500,7 +10500,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void auto1() {
-        GET_SYMBOL_DB("; auto x = \"abc\";");
+        GET_SYMBOL_DB("; auto x = \"abc\";\n");
         const Token *autotok = tokenizer.tokens()->next();
         ASSERT(autotok && autotok->isStandardType());
         const Variable *var = db ? db->getVariableFromVarId(1) : nullptr;
@@ -10515,7 +10515,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    auto c = new S[10];\n"
                       "    auto * d = new S[10];\n"
                       "    return a->i + b->i + c[0]->i + d[0]->i;\n"
-                      "}");
+                      "}\n");
         const Token *autotok = Token::findsimplematch(tokenizer.tokens(), "auto");
         ASSERT(db && autotok && autotok->valueType() && autotok->valueType()->pointer == 1 && autotok->valueType()->typeScope && autotok->valueType()->typeScope->definedType && autotok->valueType()->typeScope->definedType->name() == "S" && autotok->type() == nullptr);
 
@@ -10577,7 +10577,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    auto c = new E[10];\n"
                       "    auto * d = new E[10];\n"
                       "    return *a + *b + c[0] + d[0];\n"
-                      "}");
+                      "}\n");
         const Token *autotok = Token::findsimplematch(tokenizer.tokens(), "auto");
         ASSERT(db && autotok && autotok->valueType() && autotok->valueType()->pointer == 1 && autotok->valueType()->typeScope && autotok->valueType()->typeScope->definedType && autotok->valueType()->typeScope->definedType->name() == "E" && autotok->type() == nullptr);
 
@@ -10632,7 +10632,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    for (const auto * e : array)\n"
                       "        auto ei = e->i;\n"
                       "    return array[0].i;\n"
-                      "}");
+                      "}\n");
         const Token *autotok = Token::findsimplematch(tokenizer.tokens(), "auto a");
         ASSERT(db && autotok && autotok->valueType() && autotok->valueType()->pointer == 0 && autotok->valueType()->constness == 0 && autotok->valueType()->typeScope && autotok->valueType()->typeScope->definedType && autotok->valueType()->typeScope->definedType->name() == "S");
         ASSERT(db && autotok && autotok->type() && autotok->type()->name() == "S");
@@ -10723,7 +10723,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    for (const auto * e : vec)\n"
                       "        auto ei = e->i;\n"
                       "    return vec[0].i;\n"
-                      "}");
+                      "}\n");
         const Token *autotok = Token::findsimplematch(tokenizer.tokens(), "auto a");
         ASSERT(autotok && autotok->valueType() && autotok->valueType()->pointer == 0 && autotok->valueType()->constness == 0 && autotok->valueType()->typeScope && autotok->valueType()->typeScope->definedType && autotok->valueType()->typeScope->definedType->name() == "S");
         ASSERT(autotok && autotok->type() && autotok->type()->name() == "S");
@@ -10819,7 +10819,7 @@ class TestSymbolDatabase : public TestFixture {
                       "mBuffersForTF . clear ( ) ;\n"
                       "for ( const auto & cur : mIndexedBindings ) {}\n"
                       "return mBuffersForTF ;\n"
-                      "}");
+                      "}\n");
     }
 
     void auto7() {
@@ -10845,7 +10845,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    const auto * v10 = bar.getFoo2()[0].b;\n"
                       "    auto v11 = v1 + v2 + v3[0] + v4[0] + v5[0] + v6 + v7 + v8[0] + v9[0] + v10[0];\n"
                       "    return v11;\n"
-                      "}");
+                      "}\n");
         const Token *autotok = Token::findsimplematch(tokenizer.tokens(), "auto v1");
 
         // auto = int, v1 = int
@@ -11029,7 +11029,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("std::vector<int> vec;\n"
                       "void foo() {\n"
                       "    for (auto it = vec.begin(); it != vec.end(); ++it) { }\n"
-                      "}");
+                      "}\n");
         const Token *autotok = Token::findsimplematch(tokenizer.tokens(), "auto it");
 
         ASSERT(autotok);
@@ -11069,14 +11069,14 @@ class TestSymbolDatabase : public TestFixture {
                       "{\n"
                       "  for (auto& elem : secret_) {\n"
                       "  }\n"
-                      "}");
+                      "}\n");
     }
 
     void auto10() { // #8020
         GET_SYMBOL_DB("void f() {\n"
                       "    std::vector<int> ints(4);\n"
                       "    auto iter = ints.begin() + (ints.size() - 1);\n"
-                      "}");
+                      "}\n");
         const Token *autotok = Token::findsimplematch(tokenizer.tokens(), "auto iter");
 
         ASSERT(autotok);
@@ -11091,7 +11091,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("void f() {\n"
                       "  const auto v1 = 3;\n"
                       "  const auto *v2 = 0;\n"
-                      "}");
+                      "}\n");
 
         const Token *v1tok = Token::findsimplematch(tokenizer.tokens(), "v1");
         ASSERT(v1tok && v1tok->variable() && v1tok->variable()->isConst());
@@ -11104,7 +11104,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("void f(const std::string &x) {\n"
                       "  auto y = x;\n"
                       "  if (y.empty()) {}\n"
-                      "}");
+                      "}\n");
 
         const Token *tok;
 
@@ -11122,7 +11122,7 @@ class TestSymbolDatabase : public TestFixture {
                       "{\n"
                       "    auto *next = get();\n"
                       "    return next;\n"
-                      "}");
+                      "}\n");
 
         const Token *tok;
 
@@ -11138,7 +11138,7 @@ class TestSymbolDatabase : public TestFixture {
         GET_SYMBOL_DB("static void foo() {\n"
                       "    auto combo = widget->combo = new Combo{};\n"
                       "    combo->addItem();\n"
-                      "}");
+                      "}\n");
 
         const Token *tok;
 
@@ -11148,7 +11148,7 @@ class TestSymbolDatabase : public TestFixture {
 
     void auto15() {
         GET_SYMBOL_DB("auto var1{3};\n"
-                      "auto var2{4.0};");
+                      "auto var2{4.0};\n");
         ASSERT_EQUALS(3, db->variableList().size());
         const Variable *var1 = db->variableList()[1];
         ASSERT(var1->valueType());
@@ -11316,7 +11316,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    Fred(float x) : f(x) { }\n"
                       "    int i;\n"
                       "    float f;\n"
-                      "};");
+                      "};\n");
 
         ASSERT_EQUALS("", errout_str());
 
@@ -11340,7 +11340,7 @@ class TestSymbolDatabase : public TestFixture {
                       "  {   // return iterator for end of reversed nonmutable sequence\n"
                       "    return (rend());\n"
                       "  }\n"
-                      "};");
+                      "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -11619,7 +11619,7 @@ class TestSymbolDatabase : public TestFixture {
 
         {
             GET_SYMBOL_DB("typedef void ( *fp16 )( int16_t n );\n"
-                          "fp16 fp3 = ( fp16 ) 0x8000;");
+                          "fp16 fp3 = ( fp16 ) 0x8000;\n");
             const Token* tok = Token::findsimplematch(tokenizer.tokens(), "( void * ) 0x8000");
             ASSERT_EQUALS(tok->isCast(), true);
             ASSERT(tok->valueType());
@@ -11636,7 +11636,7 @@ class TestSymbolDatabase : public TestFixture {
                       "    friend bool operator==(const Foo&lhs, const Foo&rhs) {\n"
                       "        return lhs.x == rhs.x;\n"
                       "    }\n"
-                      "};");
+                      "};\n");
         std::ostringstream ostr;
         db->printXml(ostr);
         ASSERT(ostr.str().find(" isFriend=\"true\"") != std::string::npos);
@@ -11645,13 +11645,13 @@ class TestSymbolDatabase : public TestFixture {
     void smartPointerLookupCtor() { // #13719
         // do not crash in smartpointer lookup
         GET_SYMBOL_DB("struct S { int v; S(int i); };\n"
-                      "void f() { S(0).v; }");
+                      "void f() { S(0).v; }\n");
 
         ASSERT(db);
     }
 
     void stdintFunction() {
-        GET_SYMBOL_DB("a = UINT32_C(60);");
+        GET_SYMBOL_DB("a = UINT32_C(60);\n");
         const Token* tok = Token::findsimplematch(tokenizer.tokens(), "UINT32_C (");
         ASSERT(tok != nullptr);
         ASSERT_EQUALS(tok->next()->valueType()->sign, ValueType::Sign::UNSIGNED);
@@ -11659,7 +11659,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void userDefinedLiteral() {
-        GET_SYMBOL_DB("_ 1p;");
+        GET_SYMBOL_DB("_ 1p;\n");
         const Token *x = Token::findsimplematch(tokenizer.tokens(), "1p");
         ASSERT(x);
         ASSERT(!x->varId());
@@ -11667,7 +11667,7 @@ class TestSymbolDatabase : public TestFixture {
     }
 
     void dumpValueNegative() { // #14735
-        GET_SYMBOL_DB("void f(unsigned int x) { a = x; }");
+        GET_SYMBOL_DB("void f(unsigned int x) { a = x; }\n");
         const Token* x = Token::findsimplematch(tokenizer.tokens(), "x ;");
         ASSERT(x != nullptr);
         std::ostringstream out;
diff --git a/test/testthreadexecutor.cpp b/test/testthreadexecutor.cpp
index ddd65c316b2..c32fb360bec 100644
--- a/test/testthreadexecutor.cpp
+++ b/test/testthreadexecutor.cpp
@@ -169,7 +169,7 @@ class TestThreadExecutorBase : public TestFixture {
               "void f()\n"
               "{\n"
               "  (void)(*((int*)0));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(num_files, cppcheck::count_all_of(errout_str(), "(error) Null pointer dereference: (int*)0"));
     }
 
@@ -180,7 +180,7 @@ class TestThreadExecutorBase : public TestFixture {
               "void f()\n"
               "{\n"
               "  (void)(*((int*)0));\n"
-              "}", dinit(CheckOptions, $.showtime = Settings::ShowTime::SUMMARY));
+              "}\n", dinit(CheckOptions, $.showtime = Settings::ShowTime::SUMMARY));
         // we are not interested in the results - so just consume them
         ignore_errout();
     }
@@ -193,7 +193,7 @@ class TestThreadExecutorBase : public TestFixture {
               "void f()\n"
               "{\n"
               "  (void)(*((int*)0));\n"
-              "}", dinit(CheckOptions, $.plistOutput = plistOutput.c_str()));
+              "}\n", dinit(CheckOptions, $.plistOutput = plistOutput.c_str()));
         // we are not interested in the results - so just consume them
         ignore_errout();
     }
@@ -203,7 +203,7 @@ class TestThreadExecutorBase : public TestFixture {
               "int main()\n"
               "{\n"
               "  return 0;\n"
-              "}");
+              "}\n");
     }
 
     void no_errors_less_files() {
@@ -211,7 +211,7 @@ class TestThreadExecutorBase : public TestFixture {
               "int main()\n"
               "{\n"
               "  return 0;\n"
-              "}");
+              "}\n");
     }
 
     void no_errors_equal_amount_files() {
@@ -219,7 +219,7 @@ class TestThreadExecutorBase : public TestFixture {
               "int main()\n"
               "{\n"
               "  return 0;\n"
-              "}");
+              "}\n");
     }
 
     void one_error_less_files() {
@@ -227,7 +227,7 @@ class TestThreadExecutorBase : public TestFixture {
               "void f()\n"
               "{\n"
               "  (void)(*((int*)0));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[" + fprefix() + "_1.c:3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
     }
 
@@ -237,7 +237,7 @@ class TestThreadExecutorBase : public TestFixture {
               "void f()\n"
               "{\n"
               "  (void)(*((int*)0));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(num_files, cppcheck::count_all_of(errout_str(), "(error) Null pointer dereference: (int*)0"));
     }
 
@@ -247,7 +247,7 @@ class TestThreadExecutorBase : public TestFixture {
     void showtime_top5_file() {
         REDIRECT; // should not cause TSAN failures as the showtime logging is synchronized
         check(2, 2, 0,
-              "int main() {}",
+              "int main() {}\n",
               dinit(CheckOptions,
                     $.showtime = Settings::ShowTime::TOP5_FILE));
         const std::string output_s = GET_REDIRECT_OUTPUT;
@@ -258,7 +258,7 @@ class TestThreadExecutorBase : public TestFixture {
     void showtime_file() {
         REDIRECT; // should not cause TSAN failures as the showtime logging is synchronized
         check(2, 2, 0,
-              "int main() {}",
+              "int main() {}\n",
               dinit(CheckOptions,
                     $.showtime = Settings::ShowTime::FILE));
         const std::string output_s = GET_REDIRECT_OUTPUT;
@@ -268,7 +268,7 @@ class TestThreadExecutorBase : public TestFixture {
     void showtime_file_total() {
         REDIRECT; // should not cause TSAN failures as the showtime logging is synchronized
         check(2, 2, 0,
-              "int main() {}",
+              "int main() {}\n",
               dinit(CheckOptions,
                     $.showtime = Settings::ShowTime::FILE_TOTAL));
         const std::string output_s = GET_REDIRECT_OUTPUT;
@@ -285,7 +285,7 @@ class TestThreadExecutorBase : public TestFixture {
               "void f()\n"
               "{\n"
               "  (void)(*((int*)0));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
         settings = settingsOld;
     }
@@ -296,9 +296,9 @@ class TestThreadExecutorBase : public TestFixture {
                          "inline void f()\n"
                          "{\n"
                          "  (void)(*((int*)0));\n"
-                         "}");
+                         "}\n");
         check(2, 2, 2,
-              "#include \"" + inc_h.name() +"\"");
+              "#include \"" + inc_h.name() +"\"\n");
         // this is made unique by the executor
         ASSERT_EQUALS("[" + inc_h.name() + ":3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
     }
diff --git a/test/testtoken.cpp b/test/testtoken.cpp
index 92c111c810c..b72c7f60148 100644
--- a/test/testtoken.cpp
+++ b/test/testtoken.cpp
@@ -158,7 +158,7 @@ class TestToken : public TestFixture {
 #define MatchCheck(...) MatchCheck_(__FILE__, __LINE__, __VA_ARGS__)
     bool MatchCheck_(const char* file, int line, const std::string& code, const std::string& pattern) {
         SimpleTokenizer tokenizer(settingsDefault, *this);
-        const std::string code2 = ";" + code + ";";
+        const std::string code2 = ";" + code + ";\n";
         try {
             ASSERT_LOC(tokenizer.tokenize(code2), file, line);
         } catch (...) {}
@@ -248,7 +248,7 @@ class TestToken : public TestFixture {
 
     void multiCompare2() const { // #3294
         // Original pattern that failed: [[,(=<>+-*|&^] %num% [+-*/] %num% ]|,|)|;|=|%op%
-        const SimpleTokenList toks("a == 1");
+        const SimpleTokenList toks("a == 1\n");
         ASSERT_EQUALS(true, Token::Match(toks.front(), "a =|%op%"));
     }
 
@@ -257,28 +257,28 @@ class TestToken : public TestFixture {
         // Code snippet that failed: "return lv@86 |= rv@87 ;"
 
         // Note: Also test "reverse" alternative pattern, two different code paths to handle it
-        const SimpleTokenList toks("return a |= b ;");
+        const SimpleTokenList toks("return a |= b ;\n");
         ASSERT_EQUALS(false, Token::Match(toks.front(), "return %name% xyz|%or% %name% ;"));
         ASSERT_EQUALS(false, Token::Match(toks.front(), "return %name% %or%|xyz %name% ;"));
 
-        const SimpleTokenList toks2("return a | b ;");
+        const SimpleTokenList toks2("return a | b ;\n");
         ASSERT_EQUALS(true, Token::Match(toks2.front(), "return %name% xyz|%or% %name% ;"));
         ASSERT_EQUALS(true, Token::Match(toks2.front(), "return %name% %or%|xyz %name% ;"));
 
-        const SimpleTokenList toks3("return a || b ;");
+        const SimpleTokenList toks3("return a || b ;\n");
         ASSERT_EQUALS(false, Token::Match(toks3.front(), "return %name% xyz|%or% %name% ;"));
         ASSERT_EQUALS(false, Token::Match(toks3.front(), "return %name% %or%|xyz %name% ;"));
 
         ASSERT_EQUALS(true, Token::Match(toks3.front(), "return %name% xyz|%oror% %name% ;"));
         ASSERT_EQUALS(true, Token::Match(toks3.front(), "return %name% %oror%|xyz %name% ;"));
 
-        const SimpleTokenList toks4("a % b ;");
+        const SimpleTokenList toks4("a % b ;\n");
         ASSERT_EQUALS(true, Token::Match(toks4.front(), "%name% >>|<<|&|%or%|^|% %name% ;"));
         ASSERT_EQUALS(true, Token::Match(toks4.front(), "%name% %|>>|<<|&|%or%|^ %name% ;"));
         ASSERT_EQUALS(true, Token::Match(toks4.front(), "%name% >>|<<|&|%or%|%|^ %name% ;"));
 
         //%name%|%num% support
-        const SimpleTokenList num("100");
+        const SimpleTokenList num("100\n");
         ASSERT_EQUALS(true, Token::Match(num.front(), "%num%|%name%"));
         ASSERT_EQUALS(true, Token::Match(num.front(), "%name%|%num%"));
         ASSERT_EQUALS(true, Token::Match(num.front(), "%name%|%num%|%bool%"));
@@ -288,7 +288,7 @@ class TestToken : public TestFixture {
         ASSERT_EQUALS(false, Token::Match(num.front(), "%type%|%bool%|%char%"));
         ASSERT_EQUALS(true, Token::Match(num.front(), "%type%|%bool%|100"));
 
-        const SimpleTokenList numparen("( 100 )");
+        const SimpleTokenList numparen("( 100 )\n");
         ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| %num%|%name% )|"));
         ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| %name%|%num% )|"));
         ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| %name%|%num%|%bool% )|"));
@@ -306,7 +306,7 @@ class TestToken : public TestFixture {
 
     void multiCompare4() {
         SimpleTokenizer var(*this);
-        ASSERT(var.tokenize("std :: queue < int > foo ;"));
+        ASSERT(var.tokenize("std :: queue < int > foo ;\n"));
 
         ASSERT_EQUALS(Token::eBracket, var.tokens()->tokAt(3)->tokType());
         ASSERT_EQUALS(Token::eBracket, var.tokens()->tokAt(5)->tokType());
@@ -325,11 +325,11 @@ class TestToken : public TestFixture {
 
     void multiCompare6() const {
         {
-            const SimpleTokenList stl("x %= y;");
+            const SimpleTokenList stl("x %= y;\n");
             ASSERT_EQUALS(true, Token::Match(stl.front(), "%name% %= %name%"));
         }
         {
-            const SimpleTokenList stl("x += y;");
+            const SimpleTokenList stl("x += y;\n");
             ASSERT_EQUALS(false, Token::Match(stl.front(), "%name% %= %name%"));
         }
     }
@@ -598,40 +598,40 @@ class TestToken : public TestFixture {
 
     void nextArgument() {
         SimpleTokenizer example1(*this);
-        ASSERT(example1.tokenize("foo(1, 2, 3, 4);"));
+        ASSERT(example1.tokenize("foo(1, 2, 3, 4);\n"));
         ASSERT_EQUALS(true, Token::simpleMatch(example1.tokens()->tokAt(2)->nextArgument(), "2 , 3"));
         ASSERT_EQUALS(true, Token::simpleMatch(example1.tokens()->tokAt(4)->nextArgument(), "3 , 4"));
 
         SimpleTokenizer example2(*this);
-        ASSERT(example2.tokenize("foo();"));
+        ASSERT(example2.tokenize("foo();\n"));
         ASSERT_EQUALS(true, example2.tokens()->tokAt(2)->nextArgument() == nullptr);
 
         SimpleTokenizer example3(*this);
-        ASSERT(example3.tokenize("foo(bar(a, b), 2, 3);"));
+        ASSERT(example3.tokenize("foo(bar(a, b), 2, 3);\n"));
         ASSERT_EQUALS(true, Token::simpleMatch(example3.tokens()->tokAt(2)->nextArgument(), "2 , 3"));
 
         SimpleTokenizer example4(*this);
-        ASSERT(example4.tokenize("foo(x.i[1], \"\", 3);"));
+        ASSERT(example4.tokenize("foo(x.i[1], \"\", 3);\n"));
         ASSERT_EQUALS(true, Token::simpleMatch(example4.tokens()->tokAt(2)->nextArgument(), "\"\" , 3"));
     }
 
     void eraseTokens() const {
-        SimpleTokenList code("begin ; { this code will be removed } end", Standards::Language::C);
+        SimpleTokenList code("begin ; { this code will be removed } end\n", Standards::Language::C);
         Token::eraseTokens(code.front()->next(), code.front()->tokAt(9));
         ASSERT_EQUALS("begin ; end", code.front()->stringifyList(nullptr, false));
     }
 
 
     void matchAny() const {
-        const SimpleTokenList varBitOrVar("abc|def");
+        const SimpleTokenList varBitOrVar("abc|def\n");
         ASSERT_EQUALS(true, Token::Match(varBitOrVar.front(), "%name% %or% %name%"));
 
-        const SimpleTokenList varLogOrVar("abc||def");
+        const SimpleTokenList varLogOrVar("abc||def\n");
         ASSERT_EQUALS(true, Token::Match(varLogOrVar.front(), "%name% %oror% %name%"));
     }
 
     void matchSingleChar() const {
-        const SimpleTokenList singleChar("a");
+        const SimpleTokenList singleChar("a\n");
         ASSERT_EQUALS(true, Token::Match(singleChar.front(), "[a|bc]"));
         ASSERT_EQUALS(false, Token::Match(singleChar.front(), "[d|ef]"));
 
@@ -646,80 +646,80 @@ class TestToken : public TestFixture {
         ASSERT_EQUALS(true, Token::Match(empty_String.front(), "!!else"));
         ASSERT_EQUALS(false, Token::Match(empty_String.front(), "!!else something"));
 
-        const SimpleTokenList ifSemicolon("if ;");
+        const SimpleTokenList ifSemicolon("if ;\n");
         ASSERT_EQUALS(true, Token::Match(ifSemicolon.front(), "if ; !!else"));
 
-        const SimpleTokenList ifSemicolonSomething("if ; something");
+        const SimpleTokenList ifSemicolonSomething("if ; something\n");
         ASSERT_EQUALS(true, Token::Match(ifSemicolonSomething.front(), "if ; !!else"));
 
-        const SimpleTokenList justElse("else");
+        const SimpleTokenList justElse("else\n");
         ASSERT_EQUALS(false, Token::Match(justElse.front(), "!!else"));
 
-        const SimpleTokenList ifSemicolonElse("if ; else");
+        const SimpleTokenList ifSemicolonElse("if ; else\n");
         ASSERT_EQUALS(false, Token::Match(ifSemicolonElse.front(), "if ; !!else"));
     }
 
     void matchType() {
-        const SimpleTokenList type("abc");
+        const SimpleTokenList type("abc\n");
         ASSERT_EQUALS(true, Token::Match(type.front(), "%type%"));
 
         SimpleTokenizer isVar(*this);
-        ASSERT(isVar.tokenize("int a = 3 ;"));
+        ASSERT(isVar.tokenize("int a = 3 ;\n"));
         ASSERT_EQUALS(true, Token::Match(isVar.tokens(), "%type%"));
         ASSERT_EQUALS(true, Token::Match(isVar.tokens(), "%type% %name%"));
         ASSERT_EQUALS(false, Token::Match(isVar.tokens(), "%type% %type%"));
 
         // TODO: %type% should not match keywords other than fundamental types
-        const SimpleTokenList noType1_cpp("delete");
+        const SimpleTokenList noType1_cpp("delete\n");
         ASSERT_EQUALS(true, Token::Match(noType1_cpp.front(), "%type%"));
 
-        const SimpleTokenList noType1_c("delete", Standards::Language::C);
+        const SimpleTokenList noType1_c("delete\n", Standards::Language::C);
         ASSERT_EQUALS(true, Token::Match(noType1_c.front(), "%type%"));
 
-        const SimpleTokenList noType2("void delete");
+        const SimpleTokenList noType2("void delete\n");
         ASSERT_EQUALS(true, Token::Match(noType2.front(), "!!foo %type%"));
     }
 
     void matchChar() const {
-        const SimpleTokenList chr1("'a'");
+        const SimpleTokenList chr1("'a'\n");
         ASSERT_EQUALS(true, Token::Match(chr1.front(), "%char%"));
 
-        const SimpleTokenList chr2("'1'");
+        const SimpleTokenList chr2("'1'\n");
         ASSERT_EQUALS(true, Token::Match(chr2.front(), "%char%"));
 
-        const SimpleTokenList noChr("\"10\"");
+        const SimpleTokenList noChr("\"10\"\n");
         ASSERT_EQUALS(false, Token::Match(noChr.front(), "%char%"));
     }
 
     void matchCompOp() const {
-        const SimpleTokenList comp1("<=");
+        const SimpleTokenList comp1("<=\n");
         ASSERT_EQUALS(true, Token::Match(comp1.front(), "%comp%"));
 
-        const SimpleTokenList comp2(">");
+        const SimpleTokenList comp2(">\n");
         ASSERT_EQUALS(true, Token::Match(comp2.front(), "%comp%"));
 
-        const SimpleTokenList noComp("=");
+        const SimpleTokenList noComp("=\n");
         ASSERT_EQUALS(false, Token::Match(noComp.front(), "%comp%"));
     }
 
     void matchStr() const {
-        const SimpleTokenList noStr1("abc");
+        const SimpleTokenList noStr1("abc\n");
         ASSERT_EQUALS(false, Token::Match(noStr1.front(), "%str%"));
 
-        const SimpleTokenList noStr2("'a'");
+        const SimpleTokenList noStr2("'a'\n");
         ASSERT_EQUALS(false, Token::Match(noStr2.front(), "%str%"));
 
-        const SimpleTokenList str("\"abc\"");
+        const SimpleTokenList str("\"abc\"\n");
         ASSERT_EQUALS(true, Token::Match(str.front(), "%str%"));
 
         // Empty string
-        const SimpleTokenList emptyStr("\"\"");
+        const SimpleTokenList emptyStr("\"\"\n");
         ASSERT_EQUALS(true, Token::Match(emptyStr.front(), "%str%"));
     }
 
     void matchVarid() {
         SimpleTokenizer var(*this);
-        ASSERT(var.tokenize("int a ; int b ;"));
+        ASSERT(var.tokenize("int a ; int b ;\n"));
 
         // Varid == 0 should throw exception
         ASSERT_THROW_INTERNAL_EQUALS((void)Token::Match(var.tokens(), "%type% %varid% ; %type% %name%", 0),INTERNAL,"Internal error. Token::Match called with varid 0.");
@@ -736,89 +736,89 @@ class TestToken : public TestFixture {
     }
 
     void matchNumeric() const {
-        const SimpleTokenList nonNumeric("abc");
+        const SimpleTokenList nonNumeric("abc\n");
         ASSERT_EQUALS(false, Token::Match(nonNumeric.front(), "%num%"));
 
-        const SimpleTokenList msLiteral("5ms"); // #11438
+        const SimpleTokenList msLiteral("5ms\n"); // #11438
         ASSERT_EQUALS(false, Token::Match(msLiteral.front(), "%num%"));
 
-        const SimpleTokenList sLiteral("3s");
+        const SimpleTokenList sLiteral("3s\n");
         ASSERT_EQUALS(false, Token::Match(sLiteral.front(), "%num%"));
 
-        const SimpleTokenList octal("0123");
+        const SimpleTokenList octal("0123\n");
         ASSERT_EQUALS(true, Token::Match(octal.front(), "%num%"));
 
-        const SimpleTokenList decimal("4567");
+        const SimpleTokenList decimal("4567\n");
         ASSERT_EQUALS(true, Token::Match(decimal.front(), "%num%"));
 
-        const SimpleTokenList hexadecimal("0xDEADBEEF");
+        const SimpleTokenList hexadecimal("0xDEADBEEF\n");
         ASSERT_EQUALS(true, Token::Match(hexadecimal.front(), "%num%"));
 
-        const SimpleTokenList floatingPoint("0.0f");
+        const SimpleTokenList floatingPoint("0.0f\n");
         ASSERT_EQUALS(true, Token::Match(floatingPoint.front(), "%num%"));
 
-        const SimpleTokenList signedLong("0L");
+        const SimpleTokenList signedLong("0L\n");
         ASSERT_EQUALS(true, Token::Match(signedLong.front(), "%num%"));
 
-        const SimpleTokenList negativeSignedLong("-0L");
+        const SimpleTokenList negativeSignedLong("-0L\n");
         ASSERT_EQUALS(true, Token::Match(negativeSignedLong.front(), "- %num%"));
 
-        const SimpleTokenList positiveSignedLong("+0L");
+        const SimpleTokenList positiveSignedLong("+0L\n");
         ASSERT_EQUALS(true, Token::Match(positiveSignedLong.front(), "+ %num%"));
 
-        const SimpleTokenList unsignedInt("0U");
+        const SimpleTokenList unsignedInt("0U\n");
         ASSERT_EQUALS(true, Token::Match(unsignedInt.front(), "%num%"));
 
-        const SimpleTokenList unsignedLong("0UL");
+        const SimpleTokenList unsignedLong("0UL\n");
         ASSERT_EQUALS(true, Token::Match(unsignedLong.front(), "%num%"));
 
-        const SimpleTokenList unsignedLongLong("0ULL");
+        const SimpleTokenList unsignedLongLong("0ULL\n");
         ASSERT_EQUALS(true, Token::Match(unsignedLongLong.front(), "%num%"));
 
-        const SimpleTokenList positive("+666");
+        const SimpleTokenList positive("+666\n");
         ASSERT_EQUALS(true, Token::Match(positive.front(), "+ %num%"));
 
-        const SimpleTokenList negative("-42");
+        const SimpleTokenList negative("-42\n");
         ASSERT_EQUALS(true, Token::Match(negative.front(), "- %num%"));
 
-        const SimpleTokenList negativeNull("-.0");
+        const SimpleTokenList negativeNull("-.0\n");
         ASSERT_EQUALS(true, Token::Match(negativeNull.front(), "- %num%"));
 
-        const SimpleTokenList positiveNull("+.0");
+        const SimpleTokenList positiveNull("+.0\n");
         ASSERT_EQUALS(true, Token::Match(positiveNull.front(), "+ %num%"));
     }
 
 
     void matchBoolean() const {
-        const SimpleTokenList yes("YES");
+        const SimpleTokenList yes("YES\n");
         ASSERT_EQUALS(false, Token::Match(yes.front(), "%bool%"));
 
-        const SimpleTokenList positive("true");
+        const SimpleTokenList positive("true\n");
         ASSERT_EQUALS(true, Token::Match(positive.front(), "%bool%"));
 
-        const SimpleTokenList negative("false");
+        const SimpleTokenList negative("false\n");
         ASSERT_EQUALS(true, Token::Match(negative.front(), "%bool%"));
     }
 
     void matchOr() const {
-        const SimpleTokenList bitwiseOr(";|;");
+        const SimpleTokenList bitwiseOr(";|;\n");
         ASSERT_EQUALS(true,  Token::Match(bitwiseOr.front(), "; %or%"));
         ASSERT_EQUALS(true,  Token::Match(bitwiseOr.front(), "; %op%"));
         ASSERT_EQUALS(false, Token::Match(bitwiseOr.front(), "; %oror%"));
 
-        const SimpleTokenList bitwiseOrAssignment(";|=;");
+        const SimpleTokenList bitwiseOrAssignment(";|=;\n");
         ASSERT_EQUALS(false,  Token::Match(bitwiseOrAssignment.front(), "; %or%"));
         ASSERT_EQUALS(true,  Token::Match(bitwiseOrAssignment.front(), "; %op%"));
         ASSERT_EQUALS(false, Token::Match(bitwiseOrAssignment.front(), "; %oror%"));
 
-        const SimpleTokenList logicalOr(";||;");
+        const SimpleTokenList logicalOr(";||;\n");
         ASSERT_EQUALS(false, Token::Match(logicalOr.front(), "; %or%"));
         ASSERT_EQUALS(true,  Token::Match(logicalOr.front(), "; %op%"));
         ASSERT_EQUALS(true,  Token::Match(logicalOr.front(), "; %oror%"));
         ASSERT_EQUALS(true,  Token::Match(logicalOr.front(), "; &&|%oror%"));
         ASSERT_EQUALS(true,  Token::Match(logicalOr.front(), "; %oror%|&&"));
 
-        const SimpleTokenList logicalAnd(";&&;");
+        const SimpleTokenList logicalAnd(";&&;\n");
         ASSERT_EQUALS(true, Token::simpleMatch(logicalAnd.front(), "; &&"));
         ASSERT_EQUALS(true, Token::Match(logicalAnd.front(), "; &&|%oror%"));
         ASSERT_EQUALS(true, Token::Match(logicalAnd.front(), "; %oror%|&&"));
@@ -1144,7 +1144,7 @@ class TestToken : public TestFixture {
 
     void canFindMatchingBracketsNeedsOpen() {
         SimpleTokenizer var(*this);
-        ASSERT(var.tokenize("std::deque<std::set<int> > intsets;"));
+        ASSERT(var.tokenize("std::deque<std::set<int> > intsets;\n"));
 
         const Token* const t = var.tokens()->findClosingBracket();
         ASSERT(t == nullptr);
@@ -1152,7 +1152,7 @@ class TestToken : public TestFixture {
 
     void canFindMatchingBracketsInnerPair() {
         SimpleTokenizer var(*this);
-        ASSERT(var.tokenize("std::deque<std::set<int> > intsets;"));
+        ASSERT(var.tokenize("std::deque<std::set<int> > intsets;\n"));
 
         const Token * const t = var.tokens()->tokAt(7)->findClosingBracket();
         ASSERT_EQUALS(">", t->str());
@@ -1161,7 +1161,7 @@ class TestToken : public TestFixture {
 
     void canFindMatchingBracketsOuterPair() {
         SimpleTokenizer var(*this);
-        ASSERT(var.tokenize("std::deque<std::set<int> > intsets;"));
+        ASSERT(var.tokenize("std::deque<std::set<int> > intsets;\n"));
 
         const Token* const t = var.tokens()->tokAt(3)->findClosingBracket();
         ASSERT_EQUALS(">", t->str());
@@ -1170,7 +1170,7 @@ class TestToken : public TestFixture {
 
     void canFindMatchingBracketsWithTooManyClosing() {
         SimpleTokenizer var(*this);
-        ASSERT(var.tokenize("X< 1>2 > x1;"));
+        ASSERT(var.tokenize("X< 1>2 > x1;\n"));
 
         const Token* const t = var.tokens()->next()->findClosingBracket();
         ASSERT_EQUALS(">", t->str());
@@ -1179,7 +1179,7 @@ class TestToken : public TestFixture {
 
     void canFindMatchingBracketsWithTooManyOpening() {
         SimpleTokenizer var(*this);
-        ASSERT(var.tokenize("X < (2 < 1) > x1;"));
+        ASSERT(var.tokenize("X < (2 < 1) > x1;\n"));
 
         const Token* t = var.tokens()->next()->findClosingBracket();
         ASSERT(t != nullptr && t->str() == ">");
@@ -1190,7 +1190,7 @@ class TestToken : public TestFixture {
 
     void findClosingBracket() {
         SimpleTokenizer var(*this);
-        ASSERT(var.tokenize("template<typename X, typename...Y> struct S : public Fred<Wilma<Y...>> {}"));
+        ASSERT(var.tokenize("template<typename X, typename...Y> struct S : public Fred<Wilma<Y...>> {}\n"));
 
         const Token* const t = var.tokens()->next()->findClosingBracket();
         ASSERT(Token::simpleMatch(t, "> struct"));
@@ -1224,29 +1224,29 @@ class TestToken : public TestFixture {
 
     void expressionString() {
         SimpleTokenizer var1(*this);
-        ASSERT(var1.tokenize("void f() { *((unsigned long long *)x) = 0; }"));
+        ASSERT(var1.tokenize("void f() { *((unsigned long long *)x) = 0; }\n"));
         const Token *const tok1 = Token::findsimplematch(var1.tokens(), "*");
         ASSERT_EQUALS("*((unsigned long long*)x)", tok1->expressionString());
 
         SimpleTokenizer var2(*this);
-        ASSERT(var2.tokenize("typedef unsigned long long u64; void f() { *((u64 *)x) = 0; }"));
+        ASSERT(var2.tokenize("typedef unsigned long long u64; void f() { *((u64 *)x) = 0; }\n"));
         const Token *const tok2 = Token::findsimplematch(var2.tokens(), "*");
         ASSERT_EQUALS("*((unsigned long long*)x)", tok2->expressionString());
 
         SimpleTokenizer data3(*this);
-        ASSERT(data3.tokenize("void f() { return (t){1,2}; }"));
+        ASSERT(data3.tokenize("void f() { return (t){1,2}; }\n"));
         ASSERT_EQUALS("return(t){1,2}", data3.tokens()->tokAt(5)->expressionString());
 
         SimpleTokenizer data4(*this);
-        ASSERT(data4.tokenize("void f() { return L\"a\"; }"));
+        ASSERT(data4.tokenize("void f() { return L\"a\"; }\n"));
         ASSERT_EQUALS("returnL\"a\"", data4.tokens()->tokAt(5)->expressionString());
 
         SimpleTokenizer data5(*this);
-        ASSERT(data5.tokenize("void f() { return U\"a\"; }"));
+        ASSERT(data5.tokenize("void f() { return U\"a\"; }\n"));
         ASSERT_EQUALS("returnU\"a\"", data5.tokens()->tokAt(5)->expressionString());
 
         SimpleTokenizer data6(*this);
-        ASSERT(data6.tokenize("x = \"\\0\\x1\\x2\\x3\\x4\\x5\\x6\\x7\";"));
+        ASSERT(data6.tokenize("x = \"\\0\\x1\\x2\\x3\\x4\\x5\\x6\\x7\";\n"));
         ASSERT_EQUALS("x=\"\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\"", data6.tokens()->next()->expressionString());
     }
 
diff --git a/test/testtokenize.cpp b/test/testtokenize.cpp
index 600d457e944..e8dd4a32806 100644
--- a/test/testtokenize.cpp
+++ b/test/testtokenize.cpp
@@ -118,7 +118,7 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(simplifyAt);
 
         TEST_CASE(inlineasm);
-        TEST_CASE(simplifyAsm2);  // #4725 (writing asm() around "^{}")
+        TEST_CASE(simplifyAsm2);  // #4725 (writing asm() around "^{}\n")
 
         TEST_CASE(ifAddBraces1);
         TEST_CASE(ifAddBraces2);
@@ -605,11 +605,13 @@ class TestTokenizer : public TestFixture {
     void directiveDump(const char (&code)[size], const char filename[], const Settings& settings, std::ostream& ostr) {
         simplecpp::OutputList outputList;
         std::vector<std::string> files;
-        simplecpp::TokenList tokens1(code, files, filename, &outputList);
+        simplecpp::TokenList tokens1(code, files, filename, {}, &outputList);
         Preprocessor preprocessor(tokens1, settings, *this, Path::identify(tokens1.getFiles()[0], false));
         std::list<Directive> directives;
-        preprocessor.setLoadCallback([&](const simplecpp::FileData &data) {
-            Preprocessor::createDirectives(data.tokens, directives);
+        preprocessor.setLoadCallback([&](const simplecpp::FileData &data, bool loaded) {
+            if (loaded) {
+                Preprocessor::createDirectives(data.tokens, directives);
+            }
         });
         preprocessor.createDirectives(directives);
         ASSERT(preprocessor.loadFiles(files));
@@ -623,16 +625,18 @@ class TestTokenizer : public TestFixture {
     }
 
     void tokenize1() {
-        const char code[] = "void f ( )\n"
-                            "{ if ( p . y ( ) > yof ) { } }";
-        ASSERT_EQUALS(code, tokenizeAndStringify(code));
+        const char code[] = "void f()\n"
+                            "{ if (p.y() > yof) {} }\n";
+        const char expected[] = "void f ( )\n"
+                                "{ if ( p . y ( ) > yof ) { } }";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         ASSERT_EQUALS(
-            "[test.cpp:2:20]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable yof [valueFlowBailoutIncompleteVar]\n",
+            "[test.cpp:2:15]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable yof [valueFlowBailoutIncompleteVar]\n",
             errout_str());
     }
 
     void tokenize2() {
-        const char code[] = "{ sizeof a, sizeof b }";
+        const char code[] = "{ sizeof a, sizeof b }\n";
         ASSERT_EQUALS("{ sizeof ( a ) , sizeof ( b ) }", tokenizeAndStringify(code));
     }
 
@@ -641,7 +645,7 @@ class TestTokenizer : public TestFixture {
                             "{\n"
                             "public:\n"
                             "    const int i;\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("class foo\n"
                       "{\n"
                       "public:\n"
@@ -652,8 +656,8 @@ class TestTokenizer : public TestFixture {
 
     void tokenize5() {
         // Tokenize values
-        ASSERT_EQUALS("; + 1E3 ;", tokenizeAndStringify("; +1E3 ;"));
-        ASSERT_EQUALS("; 1E-2 ;", tokenizeAndStringify("; 1E-2 ;"));
+        ASSERT_EQUALS("; + 1E3 ;", tokenizeAndStringify("; +1E3 ;\n"));
+        ASSERT_EQUALS("; 1E-2 ;", tokenizeAndStringify("; 1E-2 ;\n"));
     }
 
     void tokenize7() {
@@ -682,13 +686,13 @@ class TestTokenizer : public TestFixture {
                             "typedef fp (*fpp)();\n"
                             "void f() {\n"
                             "    fpp x = (fpp)f();\n"
-                            "}";
+                            "}\n";
         (void)tokenizeAndStringify(code);
         ASSERT_EQUALS("", errout_str());
     }
 
     void tokenize11() {
-        ASSERT_EQUALS("X * sizeof ( Y ( ) ) ;", tokenizeAndStringify("X * sizeof(Y());"));
+        ASSERT_EQUALS("X * sizeof ( Y ( ) ) ;", tokenizeAndStringify("X * sizeof(Y());\n"));
     }
 
     // bailout if there is "@" - it is not handled well
@@ -702,44 +706,44 @@ class TestTokenizer : public TestFixture {
 
     // Ticket #2361: 0X10 => 16
     void tokenize14() {
-        ASSERT_EQUALS("; 0x10 ;", tokenizeAndStringify(";0x10;"));
-        ASSERT_EQUALS("; 0X10 ;", tokenizeAndStringify(";0X10;"));
-        ASSERT_EQUALS("; 0444 ;", tokenizeAndStringify(";0444;"));
+        ASSERT_EQUALS("; 0x10 ;", tokenizeAndStringify(";0x10;\n"));
+        ASSERT_EQUALS("; 0X10 ;", tokenizeAndStringify(";0X10;\n"));
+        ASSERT_EQUALS("; 0444 ;", tokenizeAndStringify(";0444;\n"));
     }
 
     // Ticket #8050
     void tokenizeHexWithSuffix() {
-        ASSERT_EQUALS("; 0xFFFFFF ;", tokenizeAndStringify(";0xFFFFFF;"));
-        ASSERT_EQUALS("; 0xFFFFFFu ;", tokenizeAndStringify(";0xFFFFFFu;"));
-        ASSERT_EQUALS("; 0xFFFFFFul ;", tokenizeAndStringify(";0xFFFFFFul;"));
+        ASSERT_EQUALS("; 0xFFFFFF ;", tokenizeAndStringify(";0xFFFFFF;\n"));
+        ASSERT_EQUALS("; 0xFFFFFFu ;", tokenizeAndStringify(";0xFFFFFFu;\n"));
+        ASSERT_EQUALS("; 0xFFFFFFul ;", tokenizeAndStringify(";0xFFFFFFul;\n"));
 
         // Number of digits decides about internal representation...
-        ASSERT_EQUALS("; 0xFFFFFFFF ;", tokenizeAndStringify(";0xFFFFFFFF;"));
-        ASSERT_EQUALS("; 0xFFFFFFFFu ;", tokenizeAndStringify(";0xFFFFFFFFu;"));
-        ASSERT_EQUALS("; 0xFFFFFFFFul ;", tokenizeAndStringify(";0xFFFFFFFFul;"));
+        ASSERT_EQUALS("; 0xFFFFFFFF ;", tokenizeAndStringify(";0xFFFFFFFF;\n"));
+        ASSERT_EQUALS("; 0xFFFFFFFFu ;", tokenizeAndStringify(";0xFFFFFFFFu;\n"));
+        ASSERT_EQUALS("; 0xFFFFFFFFul ;", tokenizeAndStringify(";0xFFFFFFFFul;\n"));
     }
 
     // Ticket #2429: 0.125
     void tokenize15() {
-        ASSERT_EQUALS("0.125 ;", tokenizeAndStringify(".125;"));
-        ASSERT_EQUALS("005.125 ;", tokenizeAndStringify("005.125;")); // Don't confuse with octal values
+        ASSERT_EQUALS("0.125 ;", tokenizeAndStringify(".125;\n"));
+        ASSERT_EQUALS("005.125 ;", tokenizeAndStringify("005.125;\n")); // Don't confuse with octal values
     }
 
     void tokenize17() { // #2759
-        ASSERT_EQUALS("class B : private :: A { } ;", tokenizeAndStringify("class B : private ::A { };"));
+        ASSERT_EQUALS("class B : private :: A { } ;", tokenizeAndStringify("class B : private ::A { };\n"));
     }
 
     void tokenize18() { // tokenize "(X&&Y)" into "( X && Y )" instead of "( X & & Y )"
-        ASSERT_EQUALS("( X && Y ) ;", tokenizeAndStringify("(X&&Y);"));
+        ASSERT_EQUALS("( X && Y ) ;", tokenizeAndStringify("(X&&Y);\n"));
     }
 
     void tokenize19() {
         // #3006 - added hasComplicatedSyntaxErrorsInTemplates to avoid segmentation fault
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("x < () <"), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("x < () <\n"), SYNTAX);
 
         // #3496 - make sure hasComplicatedSyntaxErrorsInTemplates works
         ASSERT_EQUALS("void a ( Fred * f ) { for ( ; n < f . x ( ) ; ) { } }",
-                      tokenizeAndStringify("void a(Fred* f) MACRO { for (;n < f->x();) {} }"));
+                      tokenizeAndStringify("void a(Fred* f) MACRO { for (;n < f->x();) {} }\n"));
 
         // #6216 - make sure hasComplicatedSyntaxErrorsInTemplates works
         ASSERT_EQUALS("C :: C ( )\n"
@@ -755,30 +759,30 @@ class TestTokenizer : public TestFixture {
                                            "    for (int dim = 0; dim < v.size(); ++dim) {\n"
                                            "        v[dim]->f();\n"
                                            "    }\n"
-                                           "};"));
+                                           "};\n"));
         ignore_errout(); // we do not care about the output
     }
 
     void tokenize21() { // tokenize 0x0E-7
-        ASSERT_EQUALS("0x0E - 7 ;", tokenizeAndStringify("0x0E-7;"));
+        ASSERT_EQUALS("0x0E - 7 ;", tokenizeAndStringify("0x0E-7;\n"));
     }
 
     void tokenize22() { // tokenize special marker $ from preprocessor
-        ASSERT_EQUALS("a$b", tokenizeAndStringify("a$b"));
-        ASSERT_EQUALS("a $b\nc", tokenizeAndStringify("a $b\nc"));
-        ASSERT_EQUALS("a = $0 ;", tokenizeAndStringify("a = $0;"));
-        ASSERT_EQUALS("a$ ++ ;", tokenizeAndStringify("a$++;"));
-        ASSERT_EQUALS("$if ( ! p )", tokenizeAndStringify("$if(!p)"));
+        ASSERT_EQUALS("a$b", tokenizeAndStringify("a$b\n"));
+        ASSERT_EQUALS("a $b\nc", tokenizeAndStringify("a $b\nc\n"));
+        ASSERT_EQUALS("a = $0 ;", tokenizeAndStringify("a = $0;\n"));
+        ASSERT_EQUALS("a$ ++ ;", tokenizeAndStringify("a$++;\n"));
+        ASSERT_EQUALS("$if ( ! p )", tokenizeAndStringify("$if(!p)\n"));
     }
 
-    // #4239 - segfault for "f ( struct { int typedef T x ; } ) { }"
+    // #4239 - segfault for "f ( struct { int typedef T x ; } ) { }\n"
     void tokenize25() {
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("f ( struct { int typedef T x ; } ) { }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("f ( struct { int typedef T x ; } ) { }\n"), SYNTAX);
     }
 
     // #4245 - segfault
     void tokenize26() {
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("class x { protected : template < int y = } ;"), SYNTAX); // Garbage code
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("class x { protected : template < int y = } ;\n"), SYNTAX); // Garbage code
     }
 
     void tokenize27() {
@@ -787,11 +791,11 @@ class TestTokenizer : public TestFixture {
                                    "~except_spec_d_good();\n"
                                    "};\n"
                                    "struct S { S(); };\n"
-                                   "S::S() __attribute((pure)) = default;"
+                                   "S::S() __attribute((pure)) = default;\n"
                                    );
 
         // original code: glibc-2.18/posix/bug-regex20.c
-        (void)tokenizeAndStringify("static unsigned int re_string_context_at (const re_string_t *input, int idx, int eflags) internal_function __attribute__ ((pure));");
+        (void)tokenizeAndStringify("static unsigned int re_string_context_at (const re_string_t *input, int idx, int eflags) internal_function __attribute__ ((pure));\n");
     }
 
     // #3503 - don't "simplify" SetFunction member function to a variable
@@ -801,21 +805,22 @@ class TestTokenizer : public TestFixture {
                       "} ;",
                       tokenizeAndStringify("struct TTestClass { TTestClass() { }\n"
                                            "    void SetFunction(Other(*m_f)()) { }\n"
-                                           "};"));
+                                           "};\n"));
 
         ASSERT_EQUALS("struct TTestClass { TTestClass ( ) { }\n"
                       "void SetFunction ( Other ( * m_f ) ( ) ) ;\n"
                       "} ;",
                       tokenizeAndStringify("struct TTestClass { TTestClass() { }\n"
                                            "    void SetFunction(Other(*m_f)());\n"
-                                           "};"));
+                                           "};\n"));
     }
 
     // #5884 - Avoid left shift of negative integer value.
     void tokenize32() {
         // Do not simplify negative integer left shifts.
-        const char code[] = "void f ( ) { int max_x ; max_x = -10000 << 16 ; }";
-        ASSERT_EQUALS(code, tokenizeAndStringify(code));
+        const char code[] = "void f () { int max_x; max_x = -10000 << 16; }\n";
+        const char expected[] = "void f ( ) { int max_x ; max_x = -10000 << 16 ; }";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     // #5780 Various crashes on valid template code in Tokenizer::setVarId()
@@ -834,7 +839,7 @@ class TestTokenizer : public TestFixture {
                                 "  int* mElements;\n"
                                 "};\n"
                                 "Container::Container() : mElements(nullptr) {}\n"
-                                "Container intContainer;";
+                                "Container intContainer;\n";
             const char exp[] = "1: struct Container {\n"
                                "2: Container ( ) ;\n"
                                "3: int * mElements@1 ;\n"
@@ -849,7 +854,7 @@ class TestTokenizer : public TestFixture {
                                 "  int* mElements;\n"
                                 "};\n"
                                 "template <class T> Container<T>::Container() : mElements(nullptr) {}\n"
-                                "Container<int> intContainer;";
+                                "Container<int> intContainer;\n";
             const char exp[] = "1: struct Container<int> ;\n"
                                "2:\n"
                                "|\n"
@@ -865,42 +870,45 @@ class TestTokenizer : public TestFixture {
     }
 
     void tokenize35() { // #8361
-        ASSERT_NO_THROW(tokenizeAndStringify("typedef int CRCWord; "
-                                             "template<typename T> ::CRCWord const Compute(T const t) { return 0; }"));
+        ASSERT_NO_THROW(tokenizeAndStringify("typedef int CRCWord;\n"
+                                             "template<typename T> ::CRCWord const Compute(T const t) { return 0; }\n"));
     }
 
     void tokenize36() { // #8436
-        const char code[] = "int foo ( int i ) { return i ? * new int { 5 } : int { i ? 0 : 1 } ; }";
-        ASSERT_EQUALS(code, tokenizeAndStringify(code));
+        const char code[] = "int foo (int i) { return i ? *new int {5} : int {i ? 0 : 1}; }\n";
+        const char expected[] = "int foo ( int i ) { return i ? * new int { 5 } : int { i ? 0 : 1 } ; }";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     void tokenize37() { // #8550
-        const char codeC[] = "class name { public: static void init ( ) {} } ; "
-                             "typedef class name N; "
-                             "void foo ( ) { return N :: init ( ) ; }";
-        const char expC[] = "class name { public: static void init ( ) { } } ; "
+        const char codeC[] = "class name { public: static void init ( ) {} } ;\n"
+                             "typedef class name N;\n"
+                             "void foo ( ) { return N :: init ( ) ; }\n";
+        const char expC[] = "class name { public: static void init ( ) { } } ;\n"
+                            "\n"
                             "void foo ( ) { return name :: init ( ) ; }";
         ASSERT_EQUALS(expC, tokenizeAndStringify(codeC));
-        const char codeS[] = "class name { public: static void init ( ) {} } ; "
-                             "typedef struct name N; "
-                             "void foo ( ) { return N :: init ( ) ; }";
-        const char expS[] = "class name { public: static void init ( ) { } } ; "
+        const char codeS[] = "class name { public: static void init ( ) {} } ;\n"
+                             "typedef struct name N;\n"
+                             "void foo ( ) { return N :: init ( ) ; }\n";
+        const char expS[] = "class name { public: static void init ( ) { } } ;\n"
+                            "\n"
                             "void foo ( ) { return name :: init ( ) ; }";
         ASSERT_EQUALS(expS, tokenizeAndStringify(codeS));
     }
 
     void tokenize38() { // #9569
-        const char code[] = "using Binary = std::vector<char>; enum Type { Binary };";
+        const char code[] = "using Binary = std::vector<char>; enum Type { Binary };\n";
         const char exp[]  = "enum Type { Binary } ;";
         ASSERT_EQUALS(exp, tokenizeAndStringify(code));
     }
 
     void tokenize39() { // #9771
-        const char code[] = "template <typename T> class Foo;"
-                            "template <typename T> bool operator!=(const Foo<T> &, const Foo<T> &);"
-                            "template <typename T> class Foo { friend bool operator!= <> (const Foo<T> &, const Foo<T> &); };";
-        const char exp[]  = "template < typename T > class Foo ; "
-                            "template < typename T > bool operator!= ( const Foo < T > & , const Foo < T > & ) ; "
+        const char code[] = "template <typename T> class Foo;\n"
+                            "template <typename T> bool operator!=(const Foo<T> &, const Foo<T> &);\n"
+                            "template <typename T> class Foo { friend bool operator!= <> (const Foo<T> &, const Foo<T> &); };\n";
+        const char exp[]  = "template < typename T > class Foo ;\n"
+                            "template < typename T > bool operator!= ( const Foo < T > & , const Foo < T > & ) ;\n"
                             "template < typename T > class Foo { friend bool operator!= < > ( const Foo < T > & , const Foo < T > & ) ; } ;";
         ASSERT_EQUALS(exp, tokenizeAndStringify(code));
     }
@@ -945,7 +953,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void tokenize43() {
-        const char code[] = "void f(int i) { do if (i &= 1) {} while (0); }";
+        const char code[] = "void f(int i) { do if (i &= 1) {} while (0); }\n";
         ASSERT_NO_THROW(tokenizeAndStringify(code));
         (void)errout_str();
     }
@@ -967,13 +975,13 @@ class TestTokenizer : public TestFixture {
 
     void validate() {
         // C++ code in C file
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify(";using namespace std;",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify(";std::map<int,int> m;",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify(";template<class T> class X { };",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("int X<Y>() {};",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(";using namespace std;\n",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(";std::map<int,int> m;\n",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(";template<class T> class X { };\n",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("int X<Y>() {};\n",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);
         {
             TokenList tokenlist{settings1, Standards::Language::C}; // headers are treated as C files
-            const char code[] = "void foo(int i) { reinterpret_cast<char>(i) };";
+            const char code[] = "void foo(int i) { reinterpret_cast<char>(i) };\n";
             tokenlist.appendFileIfNew("test.h");
             ASSERT(tokenlist.createTokensFromString(code));
             Tokenizer tokenizer(std::move(tokenlist), *this);
@@ -982,56 +990,56 @@ class TestTokenizer : public TestFixture {
     }
 
     void objectiveC() {
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f() { [foo bar]; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f() { [foo bar]; }\n"), SYNTAX);
     }
 
     void syntax_case_default() { // correct syntax
-        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case 0: z(); break;}}"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case 0: z(); break;}}\n"));
         ASSERT_EQUALS("", errout_str());
 
-        (void)tokenizeAndStringify("void f(int n) {switch (n) { case 0:; break;}}");
+        (void)tokenizeAndStringify("void f(int n) {switch (n) { case 0:; break;}}\n");
         ASSERT_EQUALS("", errout_str());
 
         // TODO: Do not throw AST validation exception
-        TODO_ASSERT_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case 0?1:2 : z(); break;}}"), InternalError);
+        TODO_ASSERT_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case 0?1:2 : z(); break;}}\n"), InternalError);
         //ASSERT_EQUALS("", errout_str());
 
         // TODO: Do not throw AST validation exception
-        TODO_ASSERT_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case 0?(1?3:4):2 : z(); break;}}"), InternalError);
+        TODO_ASSERT_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case 0?(1?3:4):2 : z(); break;}}\n"), InternalError);
         ASSERT_EQUALS("", errout_str());
 
         //allow GCC '({ %name%|%num%|%bool% ; })' statement expression extension
         // TODO: Do not throw AST validation exception
-        TODO_ASSERT_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case 0?({0;}):1: z(); break;}}"), InternalError);
+        TODO_ASSERT_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case 0?({0;}):1: z(); break;}}\n"), InternalError);
         ASSERT_EQUALS("", errout_str());
 
         //'b' can be or a macro or an undefined enum
-        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case b: z(); break;}}"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case b: z(); break;}}\n"));
         ASSERT_EQUALS("", errout_str());
 
         //valid, when there's this declaration: 'constexpr int g() { return 2; }'
-        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case g(): z(); break;}}"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case g(): z(); break;}}\n"));
         ASSERT_EQUALS("", errout_str());
 
         //valid, when there's also this declaration: 'constexpr int g[1] = {0};'
-        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case g[0]: z(); break;}}"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case g[0]: z(); break;}}\n"));
         ASSERT_EQUALS(
             "[test.cpp:1:34]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable g [valueFlowBailoutIncompleteVar]\n",
             errout_str());
 
         //valid, similar to above case
-        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case *g: z(); break;}}"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case *g: z(); break;}}\n"));
         ASSERT_EQUALS("", errout_str());
 
         //valid, when 'x' and 'y' are constexpr.
-        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case sqrt(x+y): z(); break;}}"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case sqrt(x+y): z(); break;}}\n"));
         ASSERT_EQUALS(
             "[test.cpp:1:39]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
             errout_str());
     }
 
     void removePragma() {
-        const char code[] = "_Pragma(\"abc\") int x;";
+        const char code[] = "_Pragma(\"abc\") int x;\n";
         const Settings s_c89 = settingsBuilder().c(Standards::C89).build();
         ASSERT_EQUALS("_Pragma ( \"abc\" ) int x ;", tokenizeAndStringify(code, s_c89, false));
         const Settings s_clatest;
@@ -1045,7 +1053,7 @@ class TestTokenizer : public TestFixture {
 
     void foreach () {
         // #3690,#5154
-        const char code[] ="void f() { for each ( char c in MyString ) { Console::Write(c); } }";
+        const char code[] ="void f() { for each ( char c in MyString ) { Console::Write(c); } }\n";
         ASSERT_EQUALS("void f ( ) { for ( char c : MyString ) { Console :: Write ( c ) ; } }", tokenizeAndStringify(code));
         ASSERT_EQUALS(
             "[test.cpp:1:33]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable MyString [valueFlowBailoutIncompleteVar]\n",
@@ -1053,39 +1061,40 @@ class TestTokenizer : public TestFixture {
     }
 
     void ifconstexpr() {
-        ASSERT_EQUALS("void f ( ) { if ( FOO ) { bar ( c ) ; } }", tokenizeAndStringify("void f() { if constexpr ( FOO ) { bar(c); } }"));
+        ASSERT_EQUALS("void f ( ) { if ( FOO ) { bar ( c ) ; } }", tokenizeAndStringify("void f() { if constexpr ( FOO ) { bar(c); } }\n"));
         ASSERT_EQUALS(
             "[test.cpp:1:27]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable FOO [valueFlowBailoutIncompleteVar]\n",
             filter_valueflow(errout_str()));
     }
 
     void combineOperators() {
-        ASSERT_EQUALS("; private: ;", tokenizeAndStringify(";private:;"));
-        ASSERT_EQUALS("; protected: ;", tokenizeAndStringify(";protected:;"));
-        ASSERT_EQUALS("; public: ;", tokenizeAndStringify(";public:;"));
-        ASSERT_EQUALS("; __published: ;", tokenizeAndStringify(";__published:;"));
-        ASSERT_EQUALS("a . public : ;", tokenizeAndStringify("a.public:;"));
-        ASSERT_EQUALS("void f ( x & = 2 ) ;", tokenizeAndStringify("void f(x &= 2);"));
-        ASSERT_EQUALS("const_cast < a * > ( & e )", tokenizeAndStringify("const_cast<a*>(&e)"));
+        ASSERT_EQUALS("; private: ;", tokenizeAndStringify(";private:;\n"));
+        ASSERT_EQUALS("; protected: ;", tokenizeAndStringify(";protected:;\n"));
+        ASSERT_EQUALS("; public: ;", tokenizeAndStringify(";public:;\n"));
+        ASSERT_EQUALS("; __published: ;", tokenizeAndStringify(";__published:;\n"));
+        ASSERT_EQUALS("a . public : ;", tokenizeAndStringify("a.public:;\n"));
+        ASSERT_EQUALS("void f ( x & = 2 ) ;", tokenizeAndStringify("void f(x &= 2);\n"));
+        ASSERT_EQUALS("const_cast < a * > ( & e )", tokenizeAndStringify("const_cast<a*>(&e)\n"));
     }
 
     void concatenateNegativeNumber() {
-        ASSERT_EQUALS("i = -12 ;", tokenizeAndStringify("i = -12;"));
-        ASSERT_EQUALS("1 - 2 ;", tokenizeAndStringify("1-2;"));
-        ASSERT_EQUALS("foo ( -1 ) - 2 ;", tokenizeAndStringify("foo(-1)-2;"));
-        ASSERT_EQUALS("int f ( ) { return -2 ; }", tokenizeAndStringify("int f(){return -2;}"));
-        ASSERT_EQUALS("int x [ 2 ] = { -2 , 1 }", tokenizeAndStringify("int x[2] = {-2,1}"));
+        ASSERT_EQUALS("i = -12 ;", tokenizeAndStringify("i = -12;\n"));
+        ASSERT_EQUALS("1 - 2 ;", tokenizeAndStringify("1-2;\n"));
+        ASSERT_EQUALS("foo ( -1 ) - 2 ;", tokenizeAndStringify("foo(-1)-2;\n"));
+        ASSERT_EQUALS("int f ( ) { return -2 ; }", tokenizeAndStringify("int f(){return -2;}\n"));
+        ASSERT_EQUALS("int x [ 2 ] = { -2 , 1 }", tokenizeAndStringify("int x[2] = {-2,1}\n"));
 
-        ASSERT_EQUALS("f ( 123 )", tokenizeAndStringify("f(+123)"));
+        ASSERT_EQUALS("f ( 123 )", tokenizeAndStringify("f(+123)\n"));
 
-        ASSERT_EQUALS("std :: extent_v < A > - 1 ;", tokenizeAndStringify("std::extent_v<A> - 1;")); // #11341
+        ASSERT_EQUALS("std :: extent_v < A > - 1 ;", tokenizeAndStringify("std::extent_v<A> - 1;\n")); // #11341
     }
 
 
 
     void longtok() {
-        const std::string filedata(10000, 'a');
-        ASSERT_EQUALS(filedata, tokenizeAndStringify(filedata));
+        const std::string code = std::string(10000, 'a') + '\n';
+        const std::string expected = std::string(10000, 'a');
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
 
@@ -1095,13 +1104,13 @@ class TestTokenizer : public TestFixture {
                       tokenizeAndStringify("; template <typename... a> uint8_t b(std::tuple<uint8_t> d) {\n"
                                            "  std::tuple<a...> c{std::move(d)};\n"
                                            "  return std::get<0>(c);\n"
-                                           "}", s));
+                                           "}\n", s));
         ASSERT_EQUALS("int g ( int ) ;",
                       tokenizeAndStringify("int g(int);\n"
                                            "template <class F, class... Ts> auto h(F f, Ts... xs) {\n"
                                            "    auto e = f(g(xs)...);\n"
                                            "    return e;\n"
-                                           "}", s));
+                                           "}\n", s));
     }
 
     void simplifyHeadersAndUnusedTemplates2() {
@@ -1111,7 +1120,7 @@ class TestTokenizer : public TestFixture {
                             "    void FooBar() {\n"
                             "        new ( (uBAR ? uBAR : sizeof(T))) T;\n"
                             "    }\n"
-                            "};";
+                            "};\n";
 
         {
             const Settings s = settingsBuilder().checkUnusedTemplates(false).build();
@@ -1130,100 +1139,104 @@ class TestTokenizer : public TestFixture {
     }
 
     void simplifyAt() {
-        ASSERT_EQUALS("int x ;", tokenizeAndStringify("int x@123;"));
-        ASSERT_EQUALS("bool x ;", tokenizeAndStringify("bool x@123:1;"));
+        ASSERT_EQUALS("int x ;", tokenizeAndStringify("int x@123;\n"));
+        ASSERT_EQUALS("bool x ;", tokenizeAndStringify("bool x@123:1;\n"));
         ASSERT_EQUALS("char PORTB ; bool PB3 ;", tokenizeAndStringify("char PORTB @ 0x10; bool PB3 @ PORTB:3;\n"));
-        ASSERT_EQUALS("int x ;", tokenizeAndStringify("int x @ (0x1000 + 18);"));
+        ASSERT_EQUALS("int x ;", tokenizeAndStringify("int x @ (0x1000 + 18);\n"));
 
-        ASSERT_EQUALS("int x [ 10 ] ;", tokenizeAndStringify("int x[10]@0x100;"));
+        ASSERT_EQUALS("int x [ 10 ] ;", tokenizeAndStringify("int x[10]@0x100;\n"));
 
-        ASSERT_EQUALS("void ( * f [ ] ) ( void ) ;", tokenizeAndStringify("void (*f[])(void)@0x100;")); // #13458
+        ASSERT_EQUALS("void ( * f [ ] ) ( void ) ;", tokenizeAndStringify("void (*f[])(void)@0x100;\n")); // #13458
 
-        ASSERT_EQUALS("interrupt@ f ( ) { }", tokenizeAndStringify("@interrupt f() {}"));
+        ASSERT_EQUALS("interrupt@ f ( ) { }", tokenizeAndStringify("@interrupt f() {}\n"));
 
-        ASSERT_EQUALS("const short MyVariable = 0xF0F0 ;", tokenizeAndStringify("const short MyVariable @ \"MYOWNSECTION\" = 0xF0F0; ")); // #12602
+        ASSERT_EQUALS("const short MyVariable = 0xF0F0 ;", tokenizeAndStringify("const short MyVariable @ \"MYOWNSECTION\" = 0xF0F0; \n")); // #12602
     }
 
     void inlineasm() {
-        ASSERT_EQUALS("asm ( \"mov ax , bx\" ) ;", tokenizeAndStringify("asm { mov ax,bx };"));
-        ASSERT_EQUALS("asm ( \"mov ax , bx\" ) ;", tokenizeAndStringify("_asm { mov ax,bx };"));
-        ASSERT_EQUALS("asm ( \"mov ax , bx\" ) ;", tokenizeAndStringify("_asm mov ax,bx"));
-        ASSERT_EQUALS("asm ( \"mov ax , bx\" ) ;", tokenizeAndStringify("__asm { mov ax,bx };"));
-        ASSERT_EQUALS("asm ( \"\"mov ax,bx\"\" ) ;", tokenizeAndStringify("__asm__ __volatile__ ( \"mov ax,bx\" );"));
-        ASSERT_EQUALS("asm ( \"_emit 12h\" ) ;", tokenizeAndStringify("__asm _emit 12h ;"));
-        ASSERT_EQUALS("asm ( \"mov a , b\" ) ;", tokenizeAndStringify("__asm mov a, b ;"));
-        ASSERT_EQUALS("asm ( \"\"fnstcw %0\" : \"= m\" ( old_cw )\" ) ;", tokenizeAndStringify("asm volatile (\"fnstcw %0\" : \"= m\" (old_cw));"));
-        ASSERT_EQUALS("asm ( \"\"fnstcw %0\" : \"= m\" ( old_cw )\" ) ;", tokenizeAndStringify(" __asm__ (\"fnstcw %0\" : \"= m\" (old_cw));"));
-        ASSERT_EQUALS("asm ( \"\"ddd\"\" ) ;", tokenizeAndStringify(" __asm __volatile__ (\"ddd\") ;"));
-        ASSERT_EQUALS("asm ( \"\"ddd\"\" ) ;", tokenizeAndStringify(" __asm __volatile (\"ddd\") ;"));
-        ASSERT_EQUALS("asm ( \"\"mov ax,bx\"\" ) ;", tokenizeAndStringify("__asm__ volatile ( \"mov ax,bx\" );"));
-        ASSERT_EQUALS("asm ( \"mov ax , bx\" ) ; int a ;", tokenizeAndStringify("asm { mov ax,bx } int a;"));
-        ASSERT_EQUALS("asm\n\n( \"mov ax , bx\" ) ;", tokenizeAndStringify("__asm\nmov ax,bx\n__endasm;"));
-        ASSERT_EQUALS("asm\n\n( \"push b ; for if\" ) ;", tokenizeAndStringify("__asm\npush b ; for if\n__endasm;"));
-        ASSERT_EQUALS("asm ( \"\"mov ax , bx\"\" ) ;", tokenizeAndStringify("asm volatile (\"mov ax , bx\");"));
-        ASSERT_EQUALS("asm ( \"\"mov ax , bx\"\" ) ;", tokenizeAndStringify("asm goto (\"mov ax , bx\");"));
-        ASSERT_EQUALS("asm ( \"\"mov ax , bx\"\" ) ;", tokenizeAndStringify("asm inline (\"mov ax , bx\");"));
+        ASSERT_EQUALS("asm ( \"mov ax , bx\" ) ;", tokenizeAndStringify("asm { mov ax,bx };\n"));
+        ASSERT_EQUALS("asm ( \"mov ax , bx\" ) ;", tokenizeAndStringify("_asm { mov ax,bx };\n"));
+        ASSERT_EQUALS("asm ( \"mov ax , bx\" ) ;", tokenizeAndStringify("_asm mov ax,bx\n"));
+        ASSERT_EQUALS("asm ( \"mov ax , bx\" ) ;", tokenizeAndStringify("__asm { mov ax,bx };\n"));
+        ASSERT_EQUALS("asm ( \"\"mov ax,bx\"\" ) ;", tokenizeAndStringify("__asm__ __volatile__ ( \"mov ax,bx\" );\n"));
+        ASSERT_EQUALS("asm ( \"_emit 12h\" ) ;", tokenizeAndStringify("__asm _emit 12h ;\n"));
+        ASSERT_EQUALS("asm ( \"mov a , b\" ) ;", tokenizeAndStringify("__asm mov a, b ;\n"));
+        ASSERT_EQUALS("asm ( \"\"fnstcw %0\" : \"= m\" ( old_cw )\" ) ;", tokenizeAndStringify("asm volatile (\"fnstcw %0\" : \"= m\" (old_cw));\n"));
+        ASSERT_EQUALS("asm ( \"\"fnstcw %0\" : \"= m\" ( old_cw )\" ) ;", tokenizeAndStringify(" __asm__ (\"fnstcw %0\" : \"= m\" (old_cw));\n"));
+        ASSERT_EQUALS("asm ( \"\"ddd\"\" ) ;", tokenizeAndStringify(" __asm __volatile__ (\"ddd\") ;\n"));
+        ASSERT_EQUALS("asm ( \"\"ddd\"\" ) ;", tokenizeAndStringify(" __asm __volatile (\"ddd\") ;\n"));
+        ASSERT_EQUALS("asm ( \"\"mov ax,bx\"\" ) ;", tokenizeAndStringify("__asm__ volatile ( \"mov ax,bx\" );\n"));
+        ASSERT_EQUALS("asm ( \"mov ax , bx\" ) ; int a ;", tokenizeAndStringify("asm { mov ax,bx } int a;\n"));
+        ASSERT_EQUALS("asm\n\n( \"mov ax , bx\" ) ;", tokenizeAndStringify("__asm\nmov ax,bx\n__endasm;\n"));
+        ASSERT_EQUALS("asm\n\n( \"push b ; for if\" ) ;", tokenizeAndStringify("__asm\npush b ; for if\n__endasm;\n"));
+        ASSERT_EQUALS("asm ( \"\"mov ax , bx\"\" ) ;", tokenizeAndStringify("asm volatile (\"mov ax , bx\");\n"));
+        ASSERT_EQUALS("asm ( \"\"mov ax , bx\"\" ) ;", tokenizeAndStringify("asm goto (\"mov ax , bx\");\n"));
+        ASSERT_EQUALS("asm ( \"\"mov ax , bx\"\" ) ;", tokenizeAndStringify("asm inline (\"mov ax , bx\");\n"));
 
         // 'asm ( ) ;' should be in the same line
-        ASSERT_EQUALS(";\n\nasm ( \"\"mov ax,bx\"\" ) ;", tokenizeAndStringify(";\n\n__asm__ volatile ( \"mov ax,bx\" );"));
+        ASSERT_EQUALS(";\n\nasm ( \"\"mov ax,bx\"\" ) ;", tokenizeAndStringify(";\n\n__asm__ volatile ( \"mov ax,bx\" );\n"));
 
-        ASSERT_EQUALS("void func1 ( ) ;", tokenizeAndStringify("void func1() __asm__(\"...\") __attribute__();"));
+        ASSERT_EQUALS("void func1 ( ) ;", tokenizeAndStringify("void func1() __asm__(\"...\") __attribute__();\n"));
 
         // #14250 - assembler function
-        const char code[] = "__asm void dostuff(uint32_t x) { "
-                            "%reg x "
-                            "  e_lis r7, (lf)@h "
-                            "%error "
-                            "}";
-        ASSERT_EQUALS("void dostuff ( uint32_t x ) { asm ( \"% reg x e_lis r7 , ( lf ) @ h % error\" ) ; }",
-                      tokenizeAndStringify(code));
+        const char code[] = "__asm void dostuff(uint32_t x) {\n"
+                            "%reg x\n"
+                            "  e_lis r7, (lf)@h\n"
+                            "%error\n"
+                            "}\n";
+        const char expected[] = "void dostuff ( uint32_t x ) {\n"
+                                "asm ( \"% reg x e_lis r7 , ( lf ) @ h % error\" ) ;\n"
+                                "\n"
+                                "\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     // #4725 - ^{}
     void simplifyAsm2() {
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { ^{} }"), SYNTAX, "syntax error");
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { x(^{}); }"), SYNTAX, "syntax error");
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { foo(A(), ^{ bar(); }); }"), SYNTAX, "syntax error");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { ^{} }\n"), SYNTAX, "syntax error");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { x(^{}); }\n"), SYNTAX, "syntax error");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { foo(A(), ^{ bar(); }); }\n"), SYNTAX, "syntax error");
         ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("int f0(Args args) {\n"
                                                           "    return ^{\n"
                                                           "        return sizeof...(Args);\n"
                                                           "    }() + ^ {\n"
                                                           "        return sizeof...(args);\n"
                                                           "    }();\n"
-                                                          "};"), SYNTAX, "syntax error");
+                                                          "};\n"), SYNTAX, "syntax error");
         ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("int(^block)(void) = ^{\n"
                                                           "    static int test = 0;\n"
                                                           "    return test;\n"
-                                                          "};"), SYNTAX, "syntax error");
+                                                          "};\n"), SYNTAX, "syntax error");
 
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("; return f(a[b=c],^{});"), SYNTAX, "syntax error: keyword 'return' is not allowed in global scope"); // #7185
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("; return f(a[b=c],^{});\n"), SYNTAX, "syntax error: keyword 'return' is not allowed in global scope"); // #7185
         ASSERT_EQUALS("{ return f ( asm ( \"^(void){somecode}\" ) ) ; }",
-                      tokenizeAndStringify("{ return f(^(void){somecode}); }"));
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify(";a?(b?(c,^{}):0):^{};"), SYNTAX, "syntax error");
-        ASSERT_EQUALS("template < typename T > "
-                      "CImg < T > operator| ( const char * const expression , const CImg < T > & img ) { "
-                      "return img | expression ; "
-                      "} "
-                      "template < typename T > "
-                      "CImg < T > operator^ ( const char * const expression , const CImg < T > & img ) { "
-                      "return img ^ expression ; "
-                      "} "
-                      "template < typename T > "
-                      "CImg < T > operator== ( const char * const expression , const CImg < T > & img ) { "
-                      "return img == expression ; "
+                      tokenizeAndStringify("{ return f(^(void){somecode}); }\n"));
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify(";a?(b?(c,^{}):0):^{};\n"), SYNTAX, "syntax error");
+        ASSERT_EQUALS("template < typename T >\n"
+                      "CImg < T > operator| ( const char * const expression , const CImg < T > & img ) {\n"
+                      "return img | expression ;\n"
+                      "}\n"
+                      "template < typename T >\n"
+                      "CImg < T > operator^ ( const char * const expression , const CImg < T > & img ) {\n"
+                      "return img ^ expression ;\n"
+                      "}\n"
+                      "template < typename T >\n"
+                      "CImg < T > operator== ( const char * const expression , const CImg < T > & img ) {\n"
+                      "return img == expression ;\n"
                       "}",
-                      tokenizeAndStringify("template < typename T >"
-                                           "inline CImg<T> operator|(const char *const expression, const CImg<T>& img) {"
-                                           "  return img | expression ;"
-                                           "}"
-                                           "template<typename T>"
-                                           "inline CImg<T> operator^(const char *const expression, const CImg<T>& img) {"
-                                           "  return img ^ expression;"
-                                           "}"
-                                           "template<typename T>"
-                                           "inline CImg<T> operator==(const char *const expression, const CImg<T>& img) {"
-                                           "  return img == expression;"
-                                           "}"));
+                      tokenizeAndStringify("template < typename T >\n"
+                                           "inline CImg<T> operator|(const char *const expression, const CImg<T>& img) {\n"
+                                           "  return img | expression ;\n"
+                                           "}\n"
+                                           "template<typename T>\n"
+                                           "inline CImg<T> operator^(const char *const expression, const CImg<T>& img) {\n"
+                                           "  return img ^ expression;\n"
+                                           "}\n"
+                                           "template<typename T>\n"
+                                           "inline CImg<T> operator==(const char *const expression, const CImg<T>& img) {\n"
+                                           "  return img == expression;\n"
+                                           "}\n"));
     }
 
     void ifAddBraces1() {
@@ -1330,34 +1343,34 @@ class TestTokenizer : public TestFixture {
     void ifAddBraces9() {
         // ticket #990
         const char code[] =
-            "void f() {"
-            "    for (int k=0; k<VectorSize; k++)"
-            "        LOG_OUT(ID_Vector[k])"
-            "}";
+            "void f() {\n"
+            "    for (int k=0; k<VectorSize; k++)\n"
+            "        LOG_OUT(ID_Vector[k])\n"
+            "}\n";
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code), UNKNOWN_MACRO);
     }
 
     void ifAddBraces11() {
-        const char code[] = "{ if (x) if (y) ; else ; }";
+        const char code[] = "{ if (x) if (y) ; else ; }\n";
         const char expected[] = "{ if ( x ) { if ( y ) { ; } else { ; } } }";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     void ifAddBraces12() {
         // ticket #1424
-        const char code[] = "{ if (x) do { } while(x); }";
+        const char code[] = "{ if (x) do { } while(x); }\n";
         const char expected[] = "{ if ( x ) { do { } while ( x ) ; } }";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     void ifAddBraces13() {
         // ticket #1809
-        const char code[] = "{ if (x) if (y) { } else { } else { } }";
+        const char code[] = "{ if (x) if (y) { } else { } else { } }\n";
         const char expected[] = "{ if ( x ) { if ( y ) { } else { } } else { } }";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
 
         // ticket #1809
-        const char code2[] = "{ if (x) while (y) { } else { } }";
+        const char code2[] = "{ if (x) while (y) { } else { } }\n";
         const char expected2[] = "{ if ( x ) { while ( y ) { } } else { } }";
         ASSERT_EQUALS(expected2, tokenizeAndStringify(code2));
     }
@@ -1365,19 +1378,21 @@ class TestTokenizer : public TestFixture {
     void ifAddBraces15() {
         // ticket #2616 - unknown macro before if
         // TODO: Remove "A" or change it to ";A;". Then cleanup Tokenizer::ifAddBraces().
-        ASSERT_EQUALS("{ A if ( x ) { y ( ) ; } }", tokenizeAndStringify("{A if(x)y();}"));
+        ASSERT_EQUALS("{ A if ( x ) { y ( ) ; } }", tokenizeAndStringify("{A if(x)y();}\n"));
     }
 
     void ifAddBraces16() {
         // ticket #2873 - the fix is not needed anymore.
         {
-            const char code[] = "void f() { "
-                                "(void) ( { if(*p) (*p) = x(); } ) "
-                                "}";
-            ASSERT_EQUALS("void f ( ) { ( void ) ( { if ( * p ) { ( * p ) = x ( ) ; } } ) }",
-                          tokenizeAndStringify(code));
+            const char code[] = "void f() {\n"
+                                "(void) ( { if(*p) (*p) = x(); } )\n"
+                                "}\n";
+            const char expected[] = "void f ( ) {\n"
+                                    "( void ) ( { if ( * p ) { ( * p ) = x ( ) ; } } )\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
             ASSERT_EQUALS(
-                "[test.cpp:1:27]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
+                "[test.cpp:2:16]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
                 filter_valueflow(errout_str()));
         }
     }
@@ -1407,10 +1422,10 @@ class TestTokenizer : public TestFixture {
     void ifAddBraces18() {
         // ticket #3424 - if if { } else else
         ASSERT_EQUALS("{ if ( x ) { if ( y ) { } else { ; } } else { ; } }",
-                      tokenizeAndStringify("{ if(x) if(y){}else;else;}"));
+                      tokenizeAndStringify("{ if(x) if(y){}else;else;}\n"));
 
         ASSERT_EQUALS("{ if ( x ) { if ( y ) { if ( z ) { } else { ; } } else { ; } } else { ; } }",
-                      tokenizeAndStringify("{ if(x) if(y) if(z){}else;else;else;}"));
+                      tokenizeAndStringify("{ if(x) if(y) if(z){}else;else;else;}\n"));
     }
 
     void ifAddBraces19() {
@@ -1439,7 +1454,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void ifAddBraces20() { // #5012 - syntax error 'else }'
-        const char code[] = "void f() { if(x) {} else }";
+        const char code[] = "void f() { if(x) {} else }\n";
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code), SYNTAX);
     }
 
@@ -1452,7 +1467,7 @@ class TestTokenizer : public TestFixture {
                       tokenizeAndStringify("int f(int x) {\n"
                                            "  if (x)\n"
                                            "  l1: l2: return x;\n"
-                                           "}"));
+                                           "}\n"));
         ASSERT_EQUALS("", filter_valueflow(errout_str()));
 
         // Labels before {
@@ -1463,7 +1478,7 @@ class TestTokenizer : public TestFixture {
                       tokenizeAndStringify("int f(int x) {\n"
                                            "  if (x)\n"
                                            "  l1: l2: { return x; }\n"
-                                           "}"));
+                                           "}\n"));
         ASSERT_EQUALS("", filter_valueflow(errout_str()));
 
         // Labels before try/catch
@@ -1478,7 +1493,7 @@ class TestTokenizer : public TestFixture {
                                            "  l1: l2:\n"
                                            "    try { throw 1; }\n"
                                            "    catch(...) { return x; }\n"
-                                           "}"));
+                                           "}\n"));
         ASSERT_EQUALS("", filter_valueflow(errout_str()));
     }
 
@@ -1491,7 +1506,7 @@ class TestTokenizer : public TestFixture {
                       tokenizeAndStringify("int f(int x) {\n"
                                            "  switch (x)\n"
                                            "  l1: case 0: l2: case (1): return x;\n"
-                                           "}"));
+                                           "}\n"));
 
         // Labels before {
         ASSERT_EQUALS("int f ( int x ) {\n"
@@ -1501,7 +1516,7 @@ class TestTokenizer : public TestFixture {
                       tokenizeAndStringify("int f(int x) {\n"
                                            "  switch (x)\n"
                                            "  l1: case 0: l2: case (1): { return x; }\n"
-                                           "}"));
+                                           "}\n"));
 
         // Labels before try/catch
         ASSERT_EQUALS("int f ( int x ) {\n"
@@ -1515,11 +1530,11 @@ class TestTokenizer : public TestFixture {
                                            "  l1: case 0: l2: case (1):\n"
                                            "    try { throw 1; }\n"
                                            "    catch(...) { return x; }\n"
-                                           "}"));
+                                           "}\n"));
     }
 
     void whileAddBraces() {
-        const char code[] = "{while(a);}";
+        const char code[] = "{while(a);}\n";
         ASSERT_EQUALS("{ while ( a ) { ; } }", tokenizeAndStringify(code));
     }
 
@@ -1532,7 +1547,7 @@ class TestTokenizer : public TestFixture {
                       tokenizeAndStringify("void f(int x) {\n"
                                            "  while (x)\n"
                                            "  l1: l2: --x;\n"
-                                           "}"));
+                                           "}\n"));
         ASSERT_EQUALS("", filter_valueflow(errout_str()));
 
         // Labels before {
@@ -1543,7 +1558,7 @@ class TestTokenizer : public TestFixture {
                       tokenizeAndStringify("void f(int x) {\n"
                                            "  while (x)\n"
                                            "  l1: l2: { -- x; }\n"
-                                           "}"));
+                                           "}\n"));
         ASSERT_EQUALS("", filter_valueflow(errout_str()));
 
         // Labels before try/catch
@@ -1558,12 +1573,12 @@ class TestTokenizer : public TestFixture {
                                            "  l1: l2:\n"
                                            "    try { throw 1; }\n"
                                            "    catch(...) { --x; }\n"
-                                           "}"));
+                                           "}\n"));
         ASSERT_EQUALS("", filter_valueflow(errout_str()));
     }
 
     void whileAddBracesDump() {
-        const char code[] = "void f(){while(a);}";
+        const char code[] = "void f(){while(a);}\n";
         SimpleTokenizer tokenizer(settingsDefault, *this, false);
         ASSERT(tokenizer.tokenize(code));
         ASSERT(Token::simpleMatch(tokenizer.tokens(), "void f ( ) { while ( a ) { ; } }"));
@@ -1575,7 +1590,7 @@ class TestTokenizer : public TestFixture {
 
     void doWhileAddBraces() {
         {
-            const char code[] = "{do ; while (0);}";
+            const char code[] = "{do ; while (0);}\n";
             const char result[] = "{ do { ; } while ( 0 ) ; }";
 
             ASSERT_EQUALS(result, tokenizeAndStringify(code));
@@ -1583,13 +1598,13 @@ class TestTokenizer : public TestFixture {
         }
 
         {
-            const char code[] = "{ UNKNOWN_MACRO ( do ) ; while ( a -- ) ; }";
+            const char code[] = "{ UNKNOWN_MACRO ( do ) ; while ( a -- ) ; }\n";
             ASSERT_THROW_INTERNAL(tokenizeAndStringify(code), SYNTAX);
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "{ UNKNOWN_MACRO ( do , foo ) ; while ( a -- ) ; }";
+            const char code[] = "{ UNKNOWN_MACRO ( do , foo ) ; while ( a -- ) ; }\n";
             ASSERT_THROW_INTERNAL(tokenizeAndStringify(code), SYNTAX);
             ASSERT_EQUALS("", errout_str());
         }
@@ -1636,7 +1651,7 @@ class TestTokenizer : public TestFixture {
             // #8148 - while inside the do-while body
             const char code[] = "void foo() {\n"
                                 "    do { while (x) f(); } while (y);\n"
-                                "}";
+                                "}\n";
             const char result[] = "void foo ( ) {\n"
                                   "do { while ( x ) { f ( ) ; } } while ( y ) ;\n"
                                   "}";
@@ -1658,7 +1673,7 @@ class TestTokenizer : public TestFixture {
                                            "  do\n"
                                            "  l1: l2: --x;\n"
                                            "  while (x);\n"
-                                           "}"));
+                                           "}\n"));
 
         // Labels before {
         ASSERT_EQUALS("void f ( int x ) {\n"
@@ -1670,7 +1685,7 @@ class TestTokenizer : public TestFixture {
                                            "  do\n"
                                            "  l1: l2: { -- x; }\n"
                                            "  while (x);\n"
-                                           "}"));
+                                           "}\n"));
 
         // Labels before try/catch
         ASSERT_EQUALS("void f ( int x ) {\n"
@@ -1686,7 +1701,7 @@ class TestTokenizer : public TestFixture {
                                            "    try { throw 1; }\n"
                                            "    catch(...) { --x; }\n"
                                            "  while (x);\n"
-                                           "}"));
+                                           "}\n"));
     }
 
     void forAddBraces1() {
@@ -1695,7 +1710,7 @@ class TestTokenizer : public TestFixture {
                                 "     for(;;)\n"
                                 "         if (a) { }\n"
                                 "         else { }\n"
-                                "}";
+                                "}\n";
             const char expected[] = "void f ( ) {\n"
                                     "for ( ; ; ) {\n"
                                     "if ( a ) { }\n"
@@ -1713,7 +1728,7 @@ class TestTokenizer : public TestFixture {
                                 "         if (a) { }\n"
                                 "         else if (b) { }\n"
                                 "         else { }\n"
-                                "}";
+                                "}\n";
             const char expected[] = "void f ( ) {\n"
                                     "for ( ; ; ) {\n"
                                     "if ( a ) { }\n"
@@ -1730,7 +1745,7 @@ class TestTokenizer : public TestFixture {
     void forAddBraces2() { // #5088
         const char code[] = "void f() {\n"
                             "    for(;;) try { } catch (...) { }\n"
-                            "}";
+                            "}\n";
         const char expected[] = "void f ( ) {\n"
                                 "for ( ; ; ) { try { } catch ( ... ) { } }\n"
                                 "}";
@@ -1746,7 +1761,7 @@ class TestTokenizer : public TestFixture {
                       tokenizeAndStringify("void f(int x) {\n"
                                            "  for ( ; x; )\n"
                                            "  l1: l2: --x;\n"
-                                           "}"));
+                                           "}\n"));
 
         // Labels before {
         ASSERT_EQUALS("void f ( int x ) {\n"
@@ -1756,7 +1771,7 @@ class TestTokenizer : public TestFixture {
                       tokenizeAndStringify("void f(int x) {\n"
                                            "  for ( ; x; )\n"
                                            "  l1: l2: { -- x; }\n"
-                                           "}"));
+                                           "}\n"));
 
         // Labels before try/catch
         ASSERT_EQUALS("void f ( int x ) {\n"
@@ -1770,14 +1785,14 @@ class TestTokenizer : public TestFixture {
                                            "  l1: l2:\n"
                                            "    try { throw 1; }\n"
                                            "    catch(...) { --x; }\n"
-                                           "}"));
+                                           "}\n"));
     }
 
 
     void simplifyExternC() {
         const char expected[] = "int foo ( ) ;";
         {
-            const char code[] = "extern \"C\" int foo();";
+            const char code[] = "extern \"C\" int foo();\n";
             // tokenize..
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
@@ -1786,7 +1801,7 @@ class TestTokenizer : public TestFixture {
             ASSERT(tokenizer.tokens()->next()->isExternC());
         }
         {
-            const char code[] = "extern \"C\" { int foo(); }";
+            const char code[] = "extern \"C\" { int foo(); }\n";
             // tokenize..
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
@@ -1795,7 +1810,7 @@ class TestTokenizer : public TestFixture {
             ASSERT(tokenizer.tokens()->next()->isExternC());
         }
         {
-            const char code[] = "extern \"C++\" int foo();";
+            const char code[] = "extern \"C++\" int foo();\n";
             // tokenize..
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
@@ -1804,7 +1819,7 @@ class TestTokenizer : public TestFixture {
             ASSERT(!tokenizer.tokens()->next()->isExternC());
         }
         {
-            const char code[] = "extern \"C++\" { int foo(); }";
+            const char code[] = "extern \"C++\" { int foo(); }\n";
             // tokenize..
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
@@ -1816,41 +1831,49 @@ class TestTokenizer : public TestFixture {
 
     void simplifyFunctionParameters() {
         {
-            const char code[] = "char a [ ABC ( DEF ) ] ;";
-            ASSERT_EQUALS(code, tokenizeAndStringify(code));
+            const char code[] = "char a [ ABC ( DEF ) ] ;\n";
+            const char expected[] = "char a [ ABC ( DEF ) ] ;";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "module ( a , a , sizeof ( a ) , 0444 ) ;";
+            const char code[] = "module ( a , a , sizeof ( a ) , 0444 ) ;\n";
             ASSERT_EQUALS("module ( a , a , sizeof ( a ) , 0444 ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
-        ASSERT_EQUALS("void f ( int x ) { }", tokenizeAndStringify("void f(x) int x; { }"));
+        ASSERT_EQUALS("void f ( int x ) { }", tokenizeAndStringify("void f(x) int x; { }\n"));
         ASSERT_EQUALS("", errout_str());
-        ASSERT_EQUALS("void f ( int x , char y ) { }", tokenizeAndStringify("void f(x,y) int x; char y; { }"));
+        ASSERT_EQUALS("void f ( int x , char y ) { }", tokenizeAndStringify("void f(x,y) int x; char y; { }\n"));
         ASSERT_EQUALS("", errout_str());
-        ASSERT_EQUALS("int main ( int argc , char * argv [ ] ) { }", tokenizeAndStringify("int main(argc,argv) int argc; char *argv[]; { }"));
+        ASSERT_EQUALS("int main ( int argc , char * argv [ ] ) { }", tokenizeAndStringify("int main(argc,argv) int argc; char *argv[]; { }\n"));
         ASSERT_EQUALS("", errout_str());
-        ASSERT_EQUALS("int f ( int p , int w , float d ) { }", tokenizeAndStringify("int f(p,w,d) float d; { }"));
+        ASSERT_EQUALS("int f ( int p , int w , float d ) { }", tokenizeAndStringify("int f(p,w,d) float d; { }\n"));
         ASSERT_EQUALS("", errout_str());
 
         // #1067 - Not simplified. Feel free to fix so it is simplified correctly but this syntax is obsolescent.
-        ASSERT_EQUALS("int ( * d ( a , b , c ) ) ( ) int a ; int b ; int c ; { }", tokenizeAndStringify("int (*d(a,b,c))()int a,b,c; { }"));
+        ASSERT_EQUALS("int ( * d ( a , b , c ) ) ( ) int a ; int b ; int c ; { }", tokenizeAndStringify("int (*d(a,b,c))()int a,b,c; { }\n"));
         ASSERT_EQUALS("", errout_str());
 
         {
             // This is not a function but the pattern is similar..
-            const char code[] = "void foo()"
-                                "{"
-                                "    if (x)"
-                                "        int x;"
-                                "    { }"
-                                "}";
-            ASSERT_EQUALS("void foo ( ) { if ( x ) { int x ; } { } }", tokenizeAndStringify(code));
+            const char code[] = "void foo()\n"
+                                "{\n"
+                                "    if (x)\n"
+                                "        int x;\n"
+                                "    { }\n"
+                                "}\n";
+
+            const char expected[] = "void foo ( )\n"
+                                    "{\n"
+                                    "if ( x ) {\n"
+                                    "int x ; }\n"
+                                    "{ }\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
             ASSERT_EQUALS(
-                "[test.cpp:1:20]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
+                "[test.cpp:3:9]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
                 filter_valueflow(errout_str()));
         }
     }
@@ -1868,36 +1891,52 @@ class TestTokenizer : public TestFixture {
     }
 
     void simplifyFunctionParameters2() { // #4430
-        const char code[] = "class Item { "
-                            "int i ; "
-                            "public: "
-                            "Item ( int i ) ; "
-                            "} ; "
-                            "Item :: Item ( int i ) : i ( i ) { }";
-        ASSERT_EQUALS(code, tokenizeAndStringify(code));
+        const char code[] = "class Item {\n"
+                            "    int i;\n"
+                            "public:\n"
+                            "    Item (int i);\n"
+                            "};\n"
+                            "Item::Item(int i) : i(i) { }\n";
+        const char expected[] = "class Item {\n"
+                                "int i ;\n"
+                                "public:\n"
+                                "Item ( int i ) ;\n"
+                                "} ;\n"
+                                "Item :: Item ( int i ) : i ( i ) { }";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     void simplifyFunctionParameters3() { // #4436
-        const char code[] = "class Item { "
-                            "int i ; "
-                            "int j ; "
-                            "public: "
-                            "Item ( int i , int j ) ; "
-                            "} ; "
-                            "Item :: Item ( int i , int j ) : i ( i ) , j ( j ) { }";
-        ASSERT_EQUALS(code, tokenizeAndStringify(code));
+        const char code[] = "class Item {\n"
+                            "    int i;\n"
+                            "    int j;\n"
+                            "public:\n"
+                            "    Item(int i, int j);\n"
+                            "};\n"
+                            "Item :: Item (int i, int j) : i(i), j(j) {}\n";
+        const char expected[] = "class Item {\n"
+                                "int i ;\n"
+                                "int j ;\n"
+                                "public:\n"
+                                "Item ( int i , int j ) ;\n"
+                                "} ;\n"
+                                "Item :: Item ( int i , int j ) : i ( i ) , j ( j ) { }";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     void simplifyFunctionParameters4() { // #9421
-        const char code[] = "int foo :: bar ( int , int ) const ;";
-        ASSERT_EQUALS(code, tokenizeAndStringify(code));
+        const char code[] = "int foo::bar(int, int) const;\n";
+        const char expected[] = "int foo :: bar ( int , int ) const ;";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     void simplifyFunctionParametersMultiTemplate() {
-        const char code[] = "template < typename T1 > template < typename T2 > "
-                            "void A < T1 > :: foo ( T2 ) { }";
-        ASSERT_EQUALS(code, tokenizeAndStringify(code));
-        ASSERT_EQUALS("[test.cpp:1:68]: (debug) Executable scope 'foo' with unknown function. [symbolDatabaseWarning]\n", errout_str());
+        const char code[] = "template<typename T1> template<typename T2>\n"
+                            "void A<T1>::foo(T2) {}\n";
+        const char expected[] = "template < typename T1 > template < typename T2 >\n"
+                                "void A < T1 > :: foo ( T2 ) { }";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS("[test.cpp:2:13]: (debug) Executable scope 'foo' with unknown function. [symbolDatabaseWarning]\n", errout_str());
     }
 
     void simplifyFunctionParametersErrors() {
@@ -1913,7 +1952,7 @@ class TestTokenizer : public TestFixture {
                                                    "{}\n"), SYNTAX);
 
         ASSERT_NO_THROW(tokenizeAndStringify("void foo(int, int)\n"
-                                             "{}"));
+                                             "{}\n"));
         ASSERT_EQUALS("", errout_str());
 
         // #3848 - Don't hang
@@ -1923,7 +1962,7 @@ class TestTokenizer : public TestFixture {
                                    "void CreateSdrOLEFromStorage() {\n"
                                    "    comphelper::EmbeddedObjectContainer aCnt( xDestStorage );\n"
                                    "    { }\n"
-                                   "}");
+                                   "}\n");
         ignore_errout();
     }
 
@@ -1935,7 +1974,7 @@ class TestTokenizer : public TestFixture {
                       tokenizeAndStringify("void foo() try {\n"
                                            "} catch (int) {\n"
                                            "} catch (char) {\n"
-                                           "}"));
+                                           "}\n"));
 
         ASSERT_EQUALS("void foo ( ) { try {\n"
                       "struct S {\n"
@@ -1954,7 +1993,7 @@ class TestTokenizer : public TestFixture {
                                            "    }\n"
                                            "  };\n"
                                            "} catch (long) {\n"
-                                           "}"));
+                                           "}\n"));
 
         ASSERT_EQUALS("struct S { void func ( ) const ; } ;\n"
                       "void S :: func ( ) const {\n"
@@ -1968,77 +2007,104 @@ class TestTokenizer : public TestFixture {
 
     // Simplify "((..))" into "(..)"
     void removeParentheses1() {
-        const char code[] = "void foo()"
-                            "{"
-                            "    free(((void*)p));"
-                            "}";
-
-        ASSERT_EQUALS("void foo ( ) { free ( ( void * ) p ) ; }", tokenizeAndStringify(code));
+        const char code[] = "void foo()\n"
+                            "{\n"
+                            "    free(((void*)p));\n"
+                            "}\n";
+        const char expected[] = "void foo ( )\n"
+                                "{\n"
+                                "free ( ( void * ) p ) ;\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         ASSERT_EQUALS(
-            "[test.cpp:1:29]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
+            "[test.cpp:3:18]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
             errout_str());
     }
 
     void removeParentheses3() {
         {
-            const char code[] = "void foo()"
-                                "{"
-                                "    if (( true )==(true)){}"
-                                "}";
-            ASSERT_EQUALS("void foo ( ) { if ( true == true ) { } }", tokenizeAndStringify(code));
+            const char code[] = "void foo()\n"
+                                "{\n"
+                                "    if (( true )==(true)){}\n"
+                                "}\n";
+            const char expected[] = "void foo ( )\n"
+                                    "{\n"
+                                    "if ( true == true ) { }\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
 
         {
-            const char code[] = "void foo()"
-                                "{"
-                                "    if (( 2 )==(2)){}"
-                                "}";
-            ASSERT_EQUALS("void foo ( ) { if ( 2 == 2 ) { } }", tokenizeAndStringify(code));
+            const char code[] = "void foo()\n"
+                                "{\n"
+                                "    if (( 2 )==(2)){}\n"
+                                "}\n";
+            const char expected[] = "void foo ( )\n"
+                                    "{\n"
+                                    "if ( 2 == 2 ) { }\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
 
         {
-            const char code[] = "void foo()"
-                                "{"
-                                "    if( g(10)){}"
-                                "}";
-            ASSERT_EQUALS("void foo ( ) { if ( g ( 10 ) ) { } }", tokenizeAndStringify(code));
+            const char code[] = "void foo()\n"
+                                "{\n"
+                                "    if( g(10)){}\n"
+                                "}\n";
+            const char expected[] = "void foo ( )\n"
+                                    "{\n"
+                                    "if ( g ( 10 ) ) { }\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
     }
 
     // Simplify "( function (..))" into "function (..)"
     void removeParentheses4() {
-        const char code[] = "void foo()"
-                            "{"
-                            "    (free(p));"
-                            "}";
-        ASSERT_EQUALS("void foo ( ) { free ( p ) ; }", tokenizeAndStringify(code));
+        const char code[] = "void foo()\n"
+                            "{\n"
+                            "    (free(p));\n"
+                            "}\n";
+        const char expected[] = "void foo ( )\n"
+                                "{\n"
+                                "free ( p ) ;\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         ASSERT_EQUALS(
-            "[test.cpp:1:22]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
+            "[test.cpp:3:11]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
             errout_str());
     }
 
     void removeParentheses5() {
         // Simplify "( delete x )" into "delete x"
         {
-            const char code[] = "void foo()"
-                                "{"
-                                "    (delete p);"
-                                "}";
-            ASSERT_EQUALS("void foo ( ) { delete p ; }", tokenizeAndStringify(code));
+            const char code[] = "void foo()\n"
+                                "{\n"
+                                "    (delete p);\n"
+                                "}\n";
+            const char expected[] = "void foo ( )\n"
+                                    "{\n"
+                                    "delete p ;\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
             ASSERT_EQUALS(
-                "[test.cpp:1:24]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
+                "[test.cpp:3:13]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
                 errout_str());
         }
 
         // Simplify "( delete [] x )" into "delete [] x"
         {
-            const char code[] = "void foo()"
-                                "{"
-                                "    (delete [] p);"
-                                "}";
-            ASSERT_EQUALS("void foo ( ) { delete [ ] p ; }", tokenizeAndStringify(code));
+            const char code[] = "void foo()\n"
+                                "{\n"
+                                "    (delete [] p);\n"
+                                "}\n";
+            const char expected[] = "void foo ( )\n"
+                                    "{\n"
+                                    "delete [ ] p ;\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
             ASSERT_EQUALS(
-                "[test.cpp:1:27]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
+                "[test.cpp:3:16]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
                 errout_str());
         }
     }
@@ -2046,18 +2112,18 @@ class TestTokenizer : public TestFixture {
     // "!(abc.a)" => "!abc.a"
     void removeParentheses6() {
         {
-            const char code[] = "(!(abc.a));";
+            const char code[] = "(!(abc.a));\n";
             ASSERT_EQUALS("( ! abc . a ) ;", tokenizeAndStringify(code));
         }
         //handle more complex member selections
         {
-            const char code[] = "(!(a.b.c.d));";
+            const char code[] = "(!(a.b.c.d));\n";
             ASSERT_EQUALS("( ! a . b . c . d ) ;", tokenizeAndStringify(code));
         }
     }
 
     void removeParentheses7() {
-        const char code[] = ";char *p; (delete(p), (p)=0);";
+        const char code[] = ";char *p; (delete(p), (p)=0);\n";
         ASSERT_EQUALS("; char * p ; delete ( p ) , p = 0 ;", tokenizeAndStringify(code));
     }
 
@@ -2075,77 +2141,77 @@ class TestTokenizer : public TestFixture {
     }
 
     void removeParentheses9() {
-        ASSERT_EQUALS("void delete ( double num ) ;", tokenizeAndStringify("void delete(double num);"));
+        ASSERT_EQUALS("void delete ( double num ) ;", tokenizeAndStringify("void delete(double num);\n"));
     }
 
     void removeParentheses10() {
-        ASSERT_EQUALS("p = buf + 8 ;", tokenizeAndStringify("p = (buf + 8);"));
+        ASSERT_EQUALS("p = buf + 8 ;", tokenizeAndStringify("p = (buf + 8);\n"));
     }
 
     void removeParentheses11() {
         // #2502
-        ASSERT_EQUALS("{ } x ( ) ;", tokenizeAndStringify("{}(x());"));
+        ASSERT_EQUALS("{ } x ( ) ;", tokenizeAndStringify("{}(x());\n"));
     }
 
     void removeParentheses12() {
         // #2760
-        ASSERT_EQUALS(", x = 0 ;", tokenizeAndStringify(",(x)=0;"));
+        ASSERT_EQUALS(", x = 0 ;", tokenizeAndStringify(",(x)=0;\n"));
     }
 
     void removeParentheses13() {
-        ASSERT_EQUALS("; f ( a + b , c ) ;", tokenizeAndStringify(";f((a+b),c);"));
-        ASSERT_EQUALS("; x = y [ a + b ] ;", tokenizeAndStringify(";x=y[(a+b)];"));
+        ASSERT_EQUALS("; f ( a + b , c ) ;", tokenizeAndStringify(";f((a+b),c);\n"));
+        ASSERT_EQUALS("; x = y [ a + b ] ;", tokenizeAndStringify(";x=y[(a+b)];\n"));
     }
 
     void removeParentheses14() {
-        ASSERT_EQUALS("{ if ( ( i & 1 ) == 0 ) { ; } }", tokenizeAndStringify("{ if ( (i & 1) == 0 ); }"));
+        ASSERT_EQUALS("{ if ( ( i & 1 ) == 0 ) { ; } }", tokenizeAndStringify("{ if ( (i & 1) == 0 ); }\n"));
     }
 
     void removeParentheses15() {
-        ASSERT_EQUALS("a = b ? c : 123 ;", tokenizeAndStringify("a = b ? c : (123);"));
-        ASSERT_EQUALS("a = b ? c : ( 123 + 456 ) ;", tokenizeAndStringify("a = b ? c : ((123)+(456));"));
-        ASSERT_EQUALS("a = b ? ( 123 ) : c ;", tokenizeAndStringify("a = b ? (123) : c;"));
+        ASSERT_EQUALS("a = b ? c : 123 ;", tokenizeAndStringify("a = b ? c : (123);\n"));
+        ASSERT_EQUALS("a = b ? c : ( 123 + 456 ) ;", tokenizeAndStringify("a = b ? c : ((123)+(456));\n"));
+        ASSERT_EQUALS("a = b ? ( 123 ) : c ;", tokenizeAndStringify("a = b ? (123) : c;\n"));
 
         // #4316
-        ASSERT_EQUALS("a = b ? c : ( d = 1 , 0 ) ;", tokenizeAndStringify("a = b ? c : (d=1,0);"));
+        ASSERT_EQUALS("a = b ? c : ( d = 1 , 0 ) ;", tokenizeAndStringify("a = b ? c : (d=1,0);\n"));
     }
 
     void removeParentheses16() { // *(x.y)=
         // #4423
-        ASSERT_EQUALS("; * x = 0 ;", tokenizeAndStringify(";*(x)=0;"));
-        ASSERT_EQUALS("; * x . y = 0 ;", tokenizeAndStringify(";*(x.y)=0;"));
+        ASSERT_EQUALS("; * x = 0 ;", tokenizeAndStringify(";*(x)=0;\n"));
+        ASSERT_EQUALS("; * x . y = 0 ;", tokenizeAndStringify(";*(x.y)=0;\n"));
     }
 
     void removeParentheses17() { // a ? b : (c > 0 ? d : e)
-        ASSERT_EQUALS("a ? b : ( c > 0 ? d : e ) ;", tokenizeAndStringify("a?b:(c>0?d:e);"));
+        ASSERT_EQUALS("a ? b : ( c > 0 ? d : e ) ;", tokenizeAndStringify("a?b:(c>0?d:e);\n"));
     }
 
     void removeParentheses18() {
-        ASSERT_EQUALS("float ( * a ) [ 2 ] ;", tokenizeAndStringify("float(*a)[2];"));
+        ASSERT_EQUALS("float ( * a ) [ 2 ] ;", tokenizeAndStringify("float(*a)[2];\n"));
     }
 
     void removeParentheses19() {
-        ASSERT_EQUALS("( ( ( typeof ( X ) ) * ) 0 ) ;", tokenizeAndStringify("(((typeof(X))*)0);"));
+        ASSERT_EQUALS("( ( ( typeof ( X ) ) * ) 0 ) ;", tokenizeAndStringify("(((typeof(X))*)0);\n"));
     }
 
     void removeParentheses20() {
-        ASSERT_EQUALS("a < b < int > > ( 2 ) ;", tokenizeAndStringify("a<b<int>>(2);"));
+        ASSERT_EQUALS("a < b < int > > ( 2 ) ;", tokenizeAndStringify("a<b<int>>(2);\n"));
     }
 
     void removeParentheses21() {
-        ASSERT_EQUALS("a = ( int ) - b ;", tokenizeAndStringify("a = ((int)-b);"));
+        ASSERT_EQUALS("a = ( int ) - b ;", tokenizeAndStringify("a = ((int)-b);\n"));
     }
 
     void removeParentheses22() {
-        static char code[] = "struct S { "
-                             "char *(a); "
-                             "char &(b); "
-                             "const static char *(c); "
-                             "} ;";
-        static const char exp[] = "struct S { "
-                                  "char * a ; "
-                                  "char & b ; "
-                                  "static const char * c ; "
+        static char code[] = "struct S {\n"
+                             "    char *(a);\n"
+                             "    char &(b);\n"
+                             "    const static char *(c);\n"
+                             "};\n";
+        static const char exp[] = "struct S {\n"
+                                  "char * a ;\n"
+                                  "char & b ;\n"
+                                  "static const char * c ;\n"
                                   "} ;";
         ASSERT_EQUALS(exp, tokenizeAndStringify(code));
     }
@@ -2153,48 +2219,48 @@ class TestTokenizer : public TestFixture {
     void removeParentheses23() { // Ticket #6103
         // Reported case
         {
-            static char code[] = "; * * p f ( ) int = { new int ( * [ 2 ] ) ; void }";
+            static char code[] = "; * * p f ( ) int = { new int ( * [ 2 ] ) ; void }\n";
             static const char exp[] = "; * * p f ( ) int = { new int ( * [ 2 ] ) ; void }";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code));
         }
         // Various valid cases
         {
-            static char code[] = "int * f [ 1 ] = { new ( int ) } ;";
+            static char code[] = "int * f [ 1 ] = { new ( int ) } ;\n";
             static const char exp[] = "int * f [ 1 ] = { new int } ;";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code));
         }
         {
-            static char code[] = "int * * f [ 1 ] = { new ( int ) [ 1 ] } ;";
+            static char code[] = "int * * f [ 1 ] = { new ( int ) [ 1 ] } ;\n";
             static const char exp[] = "int * * f [ 1 ] = { new int [ 1 ] } ;";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code));
         }
         {
-            static char code[] = "list < int > * f [ 1 ] = { new ( list < int > ) } ;";
+            static char code[] = "list < int > * f [ 1 ] = { new ( list < int > ) } ;\n";
             static const char exp[] = "list < int > * f [ 1 ] = { new list < int > } ;";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code));
         }
         // don't remove parentheses in operator new overload
         {
-            static char code[] = "void *operator new(__SIZE_TYPE__, int);";
+            static char code[] = "void *operator new(__SIZE_TYPE__, int);\n";
             static const char exp[] = "void * operatornew ( __SIZE_TYPE__ , int ) ;";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code));
         }
     }
 
     void removeParentheses24() { // Ticket #7040
-        static char code[] = "std::hash<decltype(t._data)>()(t._data);";
+        static char code[] = "std::hash<decltype(t._data)>()(t._data);\n";
         static const char exp[] = "std :: hash < decltype ( t . _data ) > ( ) ( t . _data ) ;";
         ASSERT_EQUALS(exp, tokenizeAndStringify(code));
     }
 
     void removeParentheses25() { // daca@home - a=(b,c)
-        static char code[] = "a=(b,c);";
+        static char code[] = "a=(b,c);\n";
         static const char exp[] = "a = ( b , c ) ;";
         ASSERT_EQUALS(exp, tokenizeAndStringify(code));
     }
 
     void removeParentheses26() { // Ticket #8875 a[0](0)
-        static char code[] = "a[0](0);";
+        static char code[] = "a[0](0);\n";
         static const char exp[] = "a [ 0 ] ( 0 ) ;";
         ASSERT_EQUALS(exp, tokenizeAndStringify(code));
     }
@@ -2214,7 +2280,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void removeParentheses28() { // Ticket #12164
-        static char code[] = "temp1 = (value > 100U) ? (value+100U) : (value-50U);";
+        static char code[] = "temp1 = (value > 100U) ? (value+100U) : (value-50U);\n";
         static const char exp[] = "temp1 = ( value > 100U ) ? ( value + 100U ) : ( value - 50U ) ;";
         ASSERT_EQUALS(exp, tokenizeAndStringify(code));
     }
@@ -2223,7 +2289,7 @@ class TestTokenizer : public TestFixture {
         static char code[] = "double foo(void)\n"
                              "{\n"
                              "return (modf)(12.3, NULL);\n"
-                             "}";
+                             "}\n";
         static const char exp[] = "double foo ( )\n"
                                   "{\n"
                                   "return modf ( 12.3 , NULL ) ;\n"
@@ -2251,7 +2317,7 @@ class TestTokenizer : public TestFixture {
                             "    double c = 4.2e+10;\n"
                             "    double d = 4.2e-10;\n"
                             "    int e = 4+2;\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("void f ( ) {\n"
                       "double a ; a = 4.2 ;\n"
                       "float b ; b = 4.2f ;\n"
@@ -2262,14 +2328,14 @@ class TestTokenizer : public TestFixture {
     }
 
     void tokenize_strings() {
-        const char code[] =   "void f() {\n"
+        const char code[] = "void f() {\n"
                             "const char *a =\n"
                             "{\n"
                             "\"hello \"\n"
                             "\"more \"\n"
                             "\"world\"\n"
                             "};\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("void f ( ) {\n"
                       "const char * a ; a =\n"
                       "{\n"
@@ -2281,32 +2347,32 @@ class TestTokenizer : public TestFixture {
     }
 
     void simplifyStructDecl() {
-        const char code[] = "const struct A { int a; int b; } a;";
+        const char code[] = "const struct A { int a; int b; } a;\n";
         ASSERT_EQUALS("struct A { int a ; int b ; } ; const struct A a ;", tokenizeAndStringify(code));
 
         // #9519
-        const char code2[] = "enum A {} (a);";
+        const char code2[] = "enum A {} (a);\n";
         const char expected2[] = "enum A { } ; enum A a ;";
         ASSERT_EQUALS(expected2, tokenizeAndStringify(code2));
 
         // #11052
-        const char code3[] = "struct a { int b; } static e[1];";
+        const char code3[] = "struct a { int b; } static e[1];\n";
         const char expected3[] = "struct a { int b ; } ; struct a static e [ 1 ] ;";
         ASSERT_EQUALS(expected3, tokenizeAndStringify(code3));
 
         // #11013 - Do not remove unnamed struct in union
-        const char code4[] = "union U { struct { int a; int b; }; int ab[2]; };";
+        const char code4[] = "union U { struct { int a; int b; }; int ab[2]; };\n";
         const char expected4[] = "union U { struct { int a ; int b ; } ; int ab [ 2 ] ; } ;";
         ASSERT_EQUALS(expected4, tokenizeAndStringify(code4));
 
         // #14836: FP syntaxError for anonymous struct in for loop
-        const char code5[] = "void f(void) { for (struct { int a; } it = {0}; it.a < 10; it.a++) {} }";
+        const char code5[] = "void f(void) { for (struct { int a; } it = {0}; it.a < 10; it.a++) {} }\n";
         const char expected5[] = "void f ( ) { struct Anonymous0 { int a ; } ; for ( struct Anonymous0 it = { 0 } ; it . a < 10 ; it . a ++ ) { } }";
         ASSERT_EQUALS(expected5, tokenizeAndStringify(code5));
     }
 
     void vardecl1() {
-        const char code[] = "unsigned int a, b;";
+        const char code[] = "unsigned int a, b;\n";
 
         const std::string actual(tokenizeAndStringify(code));
 
@@ -2314,7 +2380,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void vardecl2() {
-        const char code[] = "void foo(a,b) unsigned int a, b; { }";
+        const char code[] = "void foo(a,b) unsigned int a, b; { }\n";
 
         const std::string actual(tokenizeAndStringify(code));
 
@@ -2322,7 +2388,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void vardecl3() {
-        const char code[] = "void f() { char * p = foo<10,char>(); }";
+        const char code[] = "void f() { char * p = foo<10,char>(); }\n";
         const std::string actual(tokenizeAndStringify(code));
         ASSERT_EQUALS("void f ( ) { char * p ; p = foo < 10 , char > ( ) ; }", actual);
     }
@@ -2330,23 +2396,23 @@ class TestTokenizer : public TestFixture {
     void vardecl4() {
         // ticket #346
 
-        const char code1[] = "void *p = NULL;";
+        const char code1[] = "void *p = NULL;\n";
         const char res1[]  = "void * p ; p = NULL ;";
         ASSERT_EQUALS(res1, tokenizeAndStringify(code1));
 
-        const char code2[] = "const void *p = NULL;";
+        const char code2[] = "const void *p = NULL;\n";
         const char res2[]  = "const void * p ; p = NULL ;";
         ASSERT_EQUALS(res2, tokenizeAndStringify(code2));
 
-        const char code3[] = "void * const p = NULL;";
+        const char code3[] = "void * const p = NULL;\n";
         const char res3[]  = "void * const p ; p = NULL ;";
         ASSERT_EQUALS(res3, tokenizeAndStringify(code3));
 
-        const char code4[] = "const void * const p = NULL;";
+        const char code4[] = "const void * const p = NULL;\n";
         const char res4[]  = "const void * const p ; p = NULL ;";
         ASSERT_EQUALS(res4, tokenizeAndStringify(code4));
 
-        const char code5[] = "const void * volatile p = NULL;";
+        const char code5[] = "const void * volatile p = NULL;\n";
         const char res5[]  = "const void * volatile p ; p = NULL ;";
         ASSERT_EQUALS(res5, tokenizeAndStringify(code5));
     }
@@ -2356,7 +2422,7 @@ class TestTokenizer : public TestFixture {
                       "int addI ; addI = frontPoint == 2 || frontPoint == 1 ? ( i = 0 , 1 ) : ( i = nX - 2 , -1 ) ;\n"
                       "}", tokenizeAndStringify("void foo(int nX) {\n"
                                                 "    int addI = frontPoint == 2 || frontPoint == 1 ? i = 0, 1 : (i = nX - 2, -1);\n"
-                                                "}"));
+                                                "}\n"));
         ASSERT_EQUALS(
             "[test.cpp:2:16]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable frontPoint [valueFlowBailoutIncompleteVar]\n",
             errout_str());
@@ -2365,48 +2431,48 @@ class TestTokenizer : public TestFixture {
     void vardecl_stl_1() {
         // ticket #520
 
-        const char code1[] = "std::vector<std::string>a, b;";
+        const char code1[] = "std::vector<std::string>a, b;\n";
         const char res1[]  = "std :: vector < std :: string > a ; std :: vector < std :: string > b ;";
         ASSERT_EQUALS(res1, tokenizeAndStringify(code1));
 
-        const char code2[] = "std::vector<std::string>::const_iterator it, cit;";
+        const char code2[] = "std::vector<std::string>::const_iterator it, cit;\n";
         const char res2[]  = "std :: vector < std :: string > :: const_iterator it ; std :: vector < std :: string > :: const_iterator cit ;";
         ASSERT_EQUALS(res2, tokenizeAndStringify(code2));
 
-        const char code3[] = "std::vector<std::pair<std::string, std::string > > *c, d;";
+        const char code3[] = "std::vector<std::pair<std::string, std::string > > *c, d;\n";
         const char res3[]  = "std :: vector < std :: pair < std :: string , std :: string > > * c ; std :: vector < std :: pair < std :: string , std :: string > > d ;";
         ASSERT_EQUALS(res3, tokenizeAndStringify(code3));
     }
 
     void vardecl_stl_2() {
-        const char code1[] = "{ std::string x = \"abc\"; }";
+        const char code1[] = "{ std::string x = \"abc\"; }\n";
         ASSERT_EQUALS("{ std :: string x ; x = \"abc\" ; }", tokenizeAndStringify(code1));
 
-        const char code2[] = "{ std::vector<int> x = y; }";
+        const char code2[] = "{ std::vector<int> x = y; }\n";
         ASSERT_EQUALS("{ std :: vector < int > x ; x = y ; }", tokenizeAndStringify(code2));
     }
 
     void vardecl_stl_3()
     {
-        const char code1[] = "{ std::string const x = \"abc\"; }";
+        const char code1[] = "{ std::string const x = \"abc\"; }\n";
         ASSERT_EQUALS("{ const std :: string x = \"abc\" ; }", tokenizeAndStringify(code1));
 
-        const char code2[] = "{ std::vector<int> const x = y; }";
+        const char code2[] = "{ std::vector<int> const x = y; }\n";
         ASSERT_EQUALS("{ const std :: vector < int > x = y ; }", tokenizeAndStringify(code2));
     }
 
     void vardecl_template_1() {
         // ticket #1046
-        const char code1[] = "b<(1<<24),10,24> u, v;";
+        const char code1[] = "b<(1<<24),10,24> u, v;\n";
         const char res1[]  = "b < 16777216 , 10 , 24 > u ; b < 16777216 , 10 , 24 > v ;";
         ASSERT_EQUALS(res1, tokenizeAndStringify(code1));
         // ticket #3571 (segmentation fault)
-        (void)tokenizeAndStringify("template <int i = (3>4) > class X4 {};");
+        (void)tokenizeAndStringify("template <int i = (3>4) > class X4 {};\n");
     }
 
     void vardecl_template_2() {
         // ticket #3650
-        const char code[] = "const string str = x<8,int>();";
+        const char code[] = "const string str = x<8,int>();\n";
         const char expected[]  = "const string str = x < 8 , int > ( ) ;";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
@@ -2415,7 +2481,7 @@ class TestTokenizer : public TestFixture {
         const char code[] = "template <class T>\n" // #14909
                             "void f(T x) {\n"
                             "    const auto y = h<T, x.size()>;\n"
-                            "}";
+                            "}\n";
         const char expected[]  = "template < class T >\n"
                                  "void f ( T x ) {\n"
                                  "const auto y = h < T , x . size ( ) > ;\n"
@@ -2426,8 +2492,8 @@ class TestTokenizer : public TestFixture {
 
     void vardecl_union() {
         // ticket #1976
-        const char code1[] = "class Fred { public: union { int a ; int b ; } ; } ;";
-        ASSERT_EQUALS(code1, tokenizeAndStringify(code1));
+        const char code1[] = "class Fred { public: union { int a ; int b ; } ; } ;\n";
+        ASSERT_EQUALS("class Fred { public: union { int a ; int b ; } ; } ;", tokenizeAndStringify(code1));
 
         // ticket #2039
         const char code2[] = "void f() {\n"
@@ -2435,34 +2501,34 @@ class TestTokenizer : public TestFixture {
                              "         int x;\n"
                              "         long y;\n"
                              "     };\n"
-                             "}";
+                             "}\n";
         ASSERT_EQUALS("void f ( ) {\nunion {\nint x ;\nlong y ;\n} ;\n}", tokenizeAndStringify(code2));
 
         // ticket #3927
-        const char code3[] = "union xy *p = NULL;";
+        const char code3[] = "union xy *p = NULL;\n";
         ASSERT_EQUALS("union xy * p ; p = NULL ;", tokenizeAndStringify(code3));
     }
 
     void vardecl_par() {
         // ticket #2743 - set links if variable type contains parentheses
-        const char code[] = "Fred<int(*)()> fred1=a, fred2=b;";
+        const char code[] = "Fred<int(*)()> fred1=a, fred2=b;\n";
         ASSERT_EQUALS("Fred < int ( * ) ( ) > fred1 ; fred1 = a ; Fred < int ( * ) ( ) > fred2 ; fred2 = b ;", tokenizeAndStringify(code));
     }
 
     void vardecl_par2() {
         // ticket #3912 - set correct links
-        const char code[] = "function<void (shared_ptr<MyClass>)> v;";
+        const char code[] = "function<void (shared_ptr<MyClass>)> v;\n";
         ASSERT_EQUALS("function < void ( shared_ptr < MyClass > ) > v ;", tokenizeAndStringify(code));
     }
 
     void vardecl_par3() {
         // ticket #6556- Fred x1(a), x2(b);
-        const char code[] = "Fred x1(a), x2(b);";
+        const char code[] = "Fred x1(a), x2(b);\n";
         ASSERT_EQUALS("Fred x1 ( a ) ; Fred x2 ( b ) ;", tokenizeAndStringify(code));
     }
 
     void vardecl_class_ref() {
-        const char code[] = "class A { B &b1,&b2; };";
+        const char code[] = "class A { B &b1,&b2; };\n";
         ASSERT_EQUALS("class A { B & b1 ; B & b2 ; } ;", tokenizeAndStringify(code));
     }
 
@@ -2470,59 +2536,60 @@ class TestTokenizer : public TestFixture {
         {
             // don't simplify declarations of static variables
             // "static int i = 0;" is not the same as "static int i; i = 0;"
-            const char code[] = "static int i = 0 ;";
-            ASSERT_EQUALS(code, tokenizeAndStringify(code));
+            const char code[] = "static int i = 0 ;\n";
+            ASSERT_EQUALS("static int i = 0 ;", tokenizeAndStringify(code));
         }
 
         {
-            const char code[] = "static int a, b;";
+            const char code[] = "static int a, b;\n";
             ASSERT_EQUALS("static int a ; static int b ;", tokenizeAndStringify(code));
         }
 
         {
-            const char code[] = "static unsigned int a, b;";
+            const char code[] = "static unsigned int a, b;\n";
             ASSERT_EQUALS("static unsigned int a ; static unsigned int b ;", tokenizeAndStringify(code));
         }
 
         {
-            const char code[] = "static int a=1, b=1;";
+            const char code[] = "static int a=1, b=1;\n";
             ASSERT_EQUALS("static int a = 1 ; static int b = 1 ;", tokenizeAndStringify(code));
         }
 
         {
-            const char code[] = "static int *a, *b;";
+            const char code[] = "static int *a, *b;\n";
             ASSERT_EQUALS("static int * a ; static int * b ;", tokenizeAndStringify(code));
         }
 
         {
-            const char code[] = "static unsigned int *a=0, *b=0;";
+            const char code[] = "static unsigned int *a=0, *b=0;\n";
             ASSERT_EQUALS("static unsigned int * a = 0 ; static unsigned int * b = 0 ;", tokenizeAndStringify(code));
         }
 
         {
             // Ticket #4450
-            const char code[] = "static int large_eeprom_type = (13 | (5)), "
-                                "default_flash_type = 42;";
-            ASSERT_EQUALS("static int large_eeprom_type = 13 | 5 ; static int default_flash_type = 42 ;",
+            const char code[] = "static int large_eeprom_type = (13 | (5)),\n"
+                                "default_flash_type = 42;\n";
+            ASSERT_EQUALS("static int large_eeprom_type = 13 | 5 ; static int\n"
+                          "default_flash_type = 42 ;",
                           tokenizeAndStringify(code));
         }
 
         {
             // Ticket #5121
-            const char code[] = "unsigned int x;"
-                                "static const unsigned int A = 1, B = A, C = 0, D = (A), E = 0;"
-                                "void f() {"
-                                "  unsigned int *foo = &x;"
-                                "}";
-            ASSERT_EQUALS("unsigned int x ; "
+            const char code[] = "unsigned int x;\n"
+                                "static const unsigned int A = 1, B = A, C = 0, D = (A), E = 0;\n"
+                                "void f() {\n"
+                                "  unsigned int *foo = &x;\n"
+                                "}\n";
+            ASSERT_EQUALS("unsigned int x ;\n"
                           "static const unsigned int A = 1 ; "
                           "static const unsigned int B = A ; "
                           "static const unsigned int C = 0 ; "
                           "static const unsigned int D = A ; "
-                          "static const unsigned int E = 0 ; "
-                          "void f ( ) { "
+                          "static const unsigned int E = 0 ;\n"
+                          "void f ( ) {\n"
                           "unsigned int * foo ; "
-                          "foo = & x ; "
+                          "foo = & x ;\n"
                           "}",
                           tokenizeAndStringify(code));
         }
@@ -2532,7 +2599,7 @@ class TestTokenizer : public TestFixture {
             const char code[] = "class Machine {\n"
                                 "  static int const STACK_ORDER = 10, STACK_MAX = 1 << STACK_ORDER,"
                                 "                   STACK_GUARD = 2;\n"
-                                "};";
+                                "};\n";
             ASSERT_EQUALS("class Machine {\n"
                           "static const int STACK_ORDER = 10 ; static const int STACK_MAX = 1 << STACK_ORDER ; "
                           "static const int STACK_GUARD = 2 ;\n"
@@ -2557,7 +2624,7 @@ class TestTokenizer : public TestFixture {
     void vardecl6() {
         // ticket #565
 
-        const char code1[] = "int z = x >> 16;";
+        const char code1[] = "int z = x >> 16;\n";
         const char res1[]  = "int z ; z = x >> 16 ;";
         ASSERT_EQUALS(res1, tokenizeAndStringify(code1));
     }
@@ -2568,7 +2635,7 @@ class TestTokenizer : public TestFixture {
                             "    for (int c = 0; c < 0; ++c) {}\n"
                             "    int t;\n"
                             "    D(3 > t, \"T\");\n"
-                            "}";
+                            "}\n";
         const char res[] = "void f ( ) {\n"
                            "for ( int c = 0 ; c < 0 ; ++ c ) { }\n"
                            "int t ;\n"
@@ -2580,38 +2647,38 @@ class TestTokenizer : public TestFixture {
 
     void vardecl8() {
         // ticket #696
-        const char code[] = "char a[10]={'\\0'}, b[10]={'\\0'};";
+        const char code[] = "char a[10]={'\\0'}, b[10]={'\\0'};\n";
         const char res[]  = "char a [ 10 ] = { '\\0' } ; char b [ 10 ] = { '\\0' } ;";
         ASSERT_EQUALS(res, tokenizeAndStringify(code));
     }
 
     void vardecl9() {
-        const char code[] = "char a[2] = {'A', '\\0'}, b[2] = {'B', '\\0'};";
+        const char code[] = "char a[2] = {'A', '\\0'}, b[2] = {'B', '\\0'};\n";
         const char res[]  = "char a [ 2 ] = { 'A' , '\\0' } ; char b [ 2 ] = { 'B' , '\\0' } ;";
         ASSERT_EQUALS(res, tokenizeAndStringify(code));
     }
 
     void vardecl10() {
         // ticket #732
-        const char code[] = "char a [ 2 ] = { '-' } ; memset ( a , '-' , sizeof ( a ) ) ;";
-        ASSERT_EQUALS(code, tokenizeAndStringify(code));
+        const char code[] = "char a[2] = {'-'}; memset(a, '-', sizeof(a));\n";
+        ASSERT_EQUALS("char a [ 2 ] = { '-' } ; memset ( a , '-' , sizeof ( a ) ) ;", tokenizeAndStringify(code));
     }
 
     void vardecl11() {
         // ticket #1684
-        const char code[] = "char a[5][8], b[5][8];";
+        const char code[] = "char a[5][8], b[5][8];\n";
         ASSERT_EQUALS("char a [ 5 ] [ 8 ] ; char b [ 5 ] [ 8 ] ;", tokenizeAndStringify(code));
     }
 
     void vardecl12() {
-        const char code[] = "struct A { public: B a, b, c, d; };";
+        const char code[] = "struct A { public: B a, b, c, d; };\n";
         ASSERT_EQUALS("struct A { public: B a ; B b ; B c ; B d ; } ;", tokenizeAndStringify(code));
     }
 
     void vardecl13() {
         const char code[] = "void f() {\n"
                             "    int a = (x < y) ? 1 : 0;\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("void f ( ) {\nint a ; a = ( x < y ) ? 1 : 0 ;\n}", tokenizeAndStringify(code));
         ASSERT_EQUALS(
             "[test.cpp:2:14]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
@@ -2785,11 +2852,11 @@ class TestTokenizer : public TestFixture {
     }
 
     void vardecl22() {  // #4211 - segmentation fault
-        (void)tokenizeAndStringify("A<B<C<int>> >* p = 0;");
+        (void)tokenizeAndStringify("A<B<C<int>> >* p = 0;\n");
     }
 
     void vardecl23() {  // #4276 - segmentation fault
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("class a { protected : template < class int x = 1 ; public : int f ( ) ; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("class a { protected : template < class int x = 1 ; public : int f ( ) ; }\n"), SYNTAX);
     }
 
     void vardecl24() {  // #4187 - variable declaration within lambda function
@@ -2798,7 +2865,7 @@ class TestTokenizer : public TestFixture {
                              "    {\n"
                              "        int temp = 0;\n"
                              "    });\n"
-                             "}";
+                             "}\n";
 
         const char expected1[] = "void f ( ) {\n"
                                  "std :: for_each ( ints . begin ( ) , ints . end ( ) , [ ] ( int val )\n"
@@ -2811,7 +2878,7 @@ class TestTokenizer : public TestFixture {
 
         const char code2[] = "void f(int j) {\n"
                              "    g( [](){int temp = 0;} , j );\n"
-                             "}";
+                             "}\n";
 
         const char expected2[] = "void f ( int j ) {\n"
                                  "g ( [ ] ( ) { int temp ; temp = 0 ; } , j ) ;\n"
@@ -2824,12 +2891,12 @@ class TestTokenizer : public TestFixture {
         (void)tokenizeAndStringify("void A::func(P g) const {}\n"
                                    "void A::a() {\n"
                                    "   b = new d(  [this]( const P & p) -> double { return this->func(p);}  );\n"
-                                   "}");
+                                   "}\n");
         ignore_errout();
     }
 
     void vardecl26() { // #5907
-        const char code[] = "extern int *new, obj, player;";
+        const char code[] = "extern int *new, obj, player;\n";
         const char expected[] = "extern int * new ; extern int obj ; extern int player ;";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
@@ -2842,7 +2909,7 @@ class TestTokenizer : public TestFixture {
                             "  if (foo(c))\n"
                             "    return 0;\n"
                             "  return 0;\n"
-                            "}";
+                            "}\n";
         (void)tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false));
     }
 
@@ -2850,7 +2917,7 @@ class TestTokenizer : public TestFixture {
         const char code[] = "unsigned short f(void) {\n"
                             "    unsigned short const int x = 1;\n"
                             "    return x;\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("unsigned short f ( ) {\n"
                       "const unsigned short x ; x = 1 ;\n"
                       "return x ;\n"
@@ -2860,7 +2927,7 @@ class TestTokenizer : public TestFixture {
 
     void vardecl29() { // #9282
         {
-            const char code[] = "double f1() noexcept, f2(double) noexcept;";
+            const char code[] = "double f1() noexcept, f2(double) noexcept;\n";
             ASSERT_EQUALS("double f1 ( ) noexcept ( true ) ; double f2 ( double ) noexcept ( true ) ;",
                           tokenizeAndStringify(code));
         }
@@ -2877,7 +2944,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void vardecl30() {
-        const char code[] = "struct D {} const d;";
+        const char code[] = "struct D {} const d;\n";
         ASSERT_EQUALS("struct D { } ; struct D const d ;",
                       tokenizeAndStringify(code));
         ASSERT_EQUALS("struct D { } ; struct D const d ;",
@@ -2886,33 +2953,33 @@ class TestTokenizer : public TestFixture {
 
     void vardecl31() {
         {
-            const char code[] = "void foo() { int (*fptr)() = 0; }";
+            const char code[] = "void foo() { int (*fptr)() = 0; }\n";
             ASSERT_EQUALS("void foo ( ) { int ( * fptr ) ( ) ; fptr = 0 ; }", tokenizeAndStringify(code));
         }
 
         {
-            const char code[] = "void foo() { int (*fptr)(int) = 0; }";
+            const char code[] = "void foo() { int (*fptr)(int) = 0; }\n";
             ASSERT_EQUALS("void foo ( ) { int ( * fptr ) ( int ) ; fptr = 0 ; }", tokenizeAndStringify(code));
         }
     }
 
     void vardecl32() {
         {
-            const char code[] = "static enum { E } f() { return E; }";
+            const char code[] = "static enum { E } f() { return E; }\n";
             ASSERT_EQUALS("enum Anonymous0 { E } ; static enum Anonymous0 f ( ) { return E ; }", tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
     }
 
     void vardecl33() {
         {
-            const char code[] = "static enum { E } *f() { return NULL; }";
+            const char code[] = "static enum { E } *f() { return NULL; }\n";
             ASSERT_EQUALS("enum Anonymous0 { E } ; static enum Anonymous0 * f ( ) { return NULL ; }", tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
     }
 
     void vardecl34() {
         {
-            const char code[] = "static enum { E } const *f() { return NULL; }";
+            const char code[] = "static enum { E } const *f() { return NULL; }\n";
             ASSERT_EQUALS("enum Anonymous0 { E } ; static enum Anonymous0 const * f ( ) { return NULL ; }", tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
     }
@@ -2933,7 +3000,7 @@ class TestTokenizer : public TestFixture {
             const char code[] = "auto f() -> ::std::vector<int> {\n"
                                 "    int i = 0;\n"
                                 "    return { i };\n"
-                                "}";
+                                "}\n";
             ASSERT_EQUALS("auto f ( ) . :: std :: vector < int > {\n"
                           "int i ; i = 0 ;\n"
                           "return { i } ;\n"
@@ -2965,11 +3032,11 @@ class TestTokenizer : public TestFixture {
 
     void simplifyKeyword() {
         {
-            const char code[] = "void f (int a [ static 5] );";
+            const char code[] = "void f (int a [ static 5] );\n";
             ASSERT_EQUALS("void f ( int a [ 5 ] ) ;", tokenizeAndStringify(code));
         }
         {
-            const char in4[] = "struct B final : A { void foo(); };";
+            const char in4[] = "struct B final : A { void foo(); };\n";
             const char out4[] = "struct B : A { void foo ( ) ; } ;";
             ASSERT_EQUALS(out4, tokenizeAndStringify(in4));
 
@@ -2996,25 +3063,25 @@ class TestTokenizer : public TestFixture {
         }
         {
             // Ticket #8679
-            const char code[] = "thread_local void *thread_local_var; "
-                                "__thread void *thread_local_var_2;";
-            ASSERT_EQUALS("static void * thread_local_var ; "
+            const char code[] = "thread_local void *thread_local_var;\n"
+                                "__thread void *thread_local_var_2;\n";
+            ASSERT_EQUALS("static void * thread_local_var ;\n"
                           "void * thread_local_var_2 ;", tokenizeAndStringify(code));
         }
 
-        ASSERT_EQUALS("class Fred { } ;", tokenizeAndStringify("class DLLEXPORT Fred final { };"));
+        ASSERT_EQUALS("class Fred { } ;", tokenizeAndStringify("class DLLEXPORT Fred final { };\n"));
     }
 
     void implicitIntConst() {
-        ASSERT_EQUALS("const int x ;", tokenizeAndStringify("const x;", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("const int * x ;", tokenizeAndStringify("const *x;", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("const int * f ( ) ;", tokenizeAndStringify("const *f();", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("const int x ;", tokenizeAndStringify("const x;\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("const int * x ;", tokenizeAndStringify("const *x;\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("const int * f ( ) ;", tokenizeAndStringify("const *f();\n", dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void implicitIntExtern() {
-        ASSERT_EQUALS("extern int x ;", tokenizeAndStringify("extern x;", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("extern int * x ;", tokenizeAndStringify("extern *x;", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("const int * f ( ) ;", tokenizeAndStringify("const *f();", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("extern int x ;", tokenizeAndStringify("extern x;\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("extern int * x ;", tokenizeAndStringify("extern *x;\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("const int * f ( ) ;", tokenizeAndStringify("const *f();\n", dinit(TokenizeOptions, $.cpp = false)));
     }
 
     /**
@@ -3022,29 +3089,31 @@ class TestTokenizer : public TestFixture {
      */
     void implicitIntSigned1() {
         {
-            const char code1[] = "void foo ( signed int , float ) ;";
-            ASSERT_EQUALS(code1, tokenizeAndStringify(code1));
+            const char code1[] = "void foo(signed int, float);\n";
+            const char code2[] = "void foo ( signed int , float ) ;";
+            ASSERT_EQUALS(code2, tokenizeAndStringify(code1));
         }
 
         {
-            const char code1[] = "signed i ;";
+            const char code1[] = "signed i ;\n";
             const char code2[] = "signed int i ;";
             ASSERT_EQUALS(code2, tokenizeAndStringify(code1));
         }
 
         {
-            const char code1[] = "signed int i ;";
-            ASSERT_EQUALS(code1, tokenizeAndStringify(code1));
+            const char code1[] = "signed int i ;\n";
+            const char code2[] = "signed int i ;";
+            ASSERT_EQUALS(code2, tokenizeAndStringify(code1));
         }
 
         {
-            const char code1[] = "int signed i ;";
+            const char code1[] = "int signed i ;\n";
             const char code2[] = "signed int i ;";
             ASSERT_EQUALS(code2, tokenizeAndStringify(code1));
         }
 
         {
-            const char code1[] = "void f() { for (signed i=0; i<10; i++) {} }";
+            const char code1[] = "void f() { for (signed i=0; i<10; i++) {} }\n";
             const char code2[] = "void f ( ) { for ( signed int i = 0 ; i < 10 ; i ++ ) { } }";
             ASSERT_EQUALS(code2, tokenizeAndStringify(code1));
         }
@@ -3057,40 +3126,41 @@ class TestTokenizer : public TestFixture {
     void implicitIntUnsigned1() {
         // No changes..
         {
-            const char code[] = "void foo ( unsigned int , float ) ;";
-            ASSERT_EQUALS(code, tokenizeAndStringify(code));
+            const char code1[] = "void foo(unsigned int, float);\n";
+            const char code2[] = "void foo ( unsigned int , float ) ;";
+            ASSERT_EQUALS(code2, tokenizeAndStringify(code1));
         }
 
         // insert "int" after "unsigned"..
         {
-            const char code1[] = "unsigned i ;";
+            const char code1[] = "unsigned i ;\n";
             const char code2[] = "unsigned int i ;";
             ASSERT_EQUALS(code2, tokenizeAndStringify(code1));
         }
 
         {
-            const char code1[] = "int unsigned i ;";
+            const char code1[] = "int unsigned i ;\n";
             const char code2[] = "unsigned int i ;";
             ASSERT_EQUALS(code2, tokenizeAndStringify(code1));
         }
 
         // insert "int" after "unsigned"..
         {
-            const char code1[] = "void f() { for (unsigned i=0; i<10; i++) {} }";
+            const char code1[] = "void f() { for (unsigned i=0; i<10; i++) {} }\n";
             const char code2[] = "void f ( ) { for ( unsigned int i = 0 ; i < 10 ; i ++ ) { } }";
             ASSERT_EQUALS(code2, tokenizeAndStringify(code1));
         }
 
         // "extern unsigned x;" => "extern int x;"
         {
-            const char code1[] = "; extern unsigned x;";
+            const char code1[] = "; extern unsigned x;\n";
             const char code2[] = "; extern unsigned int x ;";
             ASSERT_EQUALS(code2, tokenizeAndStringify(code1));
         }
     }
 
     void implicitIntUnsigned2() {
-        const char code[] = "i = (unsigned)j;";
+        const char code[] = "i = (unsigned)j;\n";
         const char expected[] = "i = ( unsigned int ) j ;";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
@@ -3098,13 +3168,13 @@ class TestTokenizer : public TestFixture {
     // simplify "unsigned" when using templates..
     void implicitIntUnsigned3() {
         {
-            const char code[] = "; foo<unsigned>();";
+            const char code[] = "; foo<unsigned>();\n";
             const char expected[] = "; foo < unsigned int > ( ) ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
 
         {
-            const char code[] = "; foo<unsigned int>();";
+            const char code[] = "; foo<unsigned int>();\n";
             const char expected[] = "; foo < unsigned int > ( ) ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
@@ -3113,160 +3183,160 @@ class TestTokenizer : public TestFixture {
     void simplifyStdType() { // #4947, #4950, #4951
         // unsigned long long
         {
-            const char code[] = "long long unsigned int x;";
+            const char code[] = "long long unsigned int x;\n";
             const char expected[] = "unsigned long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "long long int unsigned x;";
+            const char code[] = "long long int unsigned x;\n";
             const char expected[] = "unsigned long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "unsigned long long int x;";
+            const char code[] = "unsigned long long int x;\n";
             const char expected[] = "unsigned long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "unsigned int long long x;";
+            const char code[] = "unsigned int long long x;\n";
             const char expected[] = "unsigned long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "int unsigned long long x;";
+            const char code[] = "int unsigned long long x;\n";
             const char expected[] = "unsigned long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "int long long unsigned x;";
+            const char code[] = "int long long unsigned x;\n";
             const char expected[] = "unsigned long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         // signed long long
         {
-            const char code[] = "long long signed int x;";
+            const char code[] = "long long signed int x;\n";
             const char expected[] = "signed long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "long long int signed x;";
+            const char code[] = "long long int signed x;\n";
             const char expected[] = "signed long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "signed long long int x;";
+            const char code[] = "signed long long int x;\n";
             const char expected[] = "signed long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "signed int long long x;";
+            const char code[] = "signed int long long x;\n";
             const char expected[] = "signed long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "int signed long long x;";
+            const char code[] = "int signed long long x;\n";
             const char expected[] = "signed long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "int long long signed x;";
+            const char code[] = "int long long signed x;\n";
             const char expected[] = "signed long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         // unsigned short
         {
-            const char code[] = "short unsigned int x;";
+            const char code[] = "short unsigned int x;\n";
             const char expected[] = "unsigned short x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "short int unsigned x;";
+            const char code[] = "short int unsigned x;\n";
             const char expected[] = "unsigned short x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "unsigned short int x;";
+            const char code[] = "unsigned short int x;\n";
             const char expected[] = "unsigned short x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "unsigned int short x;";
+            const char code[] = "unsigned int short x;\n";
             const char expected[] = "unsigned short x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "int unsigned short x;";
+            const char code[] = "int unsigned short x;\n";
             const char expected[] = "unsigned short x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "int short unsigned x;";
+            const char code[] = "int short unsigned x;\n";
             const char expected[] = "unsigned short x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         // signed short
         {
-            const char code[] = "short signed int x;";
+            const char code[] = "short signed int x;\n";
             const char expected[] = "signed short x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "short int signed x;";
+            const char code[] = "short int signed x;\n";
             const char expected[] = "signed short x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "signed short int x;";
+            const char code[] = "signed short int x;\n";
             const char expected[] = "signed short x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "signed int short x;";
+            const char code[] = "signed int short x;\n";
             const char expected[] = "signed short x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "int signed short x;";
+            const char code[] = "int signed short x;\n";
             const char expected[] = "signed short x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "int short signed x;";
+            const char code[] = "int short signed x;\n";
             const char expected[] = "signed short x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "unsigned static short const int i;";
+            const char code[] = "unsigned static short const int i;\n";
             const char expected[] = "static const unsigned short i ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "float complex x;";
+            const char code[] = "float complex x;\n";
             const char expected[] = "float complex x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
         {
-            const char code[] = "float complex x;";
+            const char code[] = "float complex x;\n";
             const char expected[] = "_Complex float x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
         {
-            const char code[] = "complex float x;";
+            const char code[] = "complex float x;\n";
             const char expected[] = "_Complex float x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
         {
-            const char code[] = "complex long double x;";
+            const char code[] = "complex long double x;\n";
             const char expected[] = "_Complex long double x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
         {
-            const char code[] = "long double complex x;";
+            const char code[] = "long double complex x;\n";
             const char expected[] = "_Complex long double x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
         {
-            const char code[] = "double complex;";
+            const char code[] = "double complex;\n";
             const char expected[] = "double complex ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
@@ -3276,7 +3346,7 @@ class TestTokenizer : public TestFixture {
         {
             const char code[] = "class A{\n"
                                 " void f() {}\n"
-                                "};";
+                                "};\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3299,7 +3369,7 @@ class TestTokenizer : public TestFixture {
             const char code[] = "void f(){\n"
                                 " char a[10];\n"
                                 " char *b ; b = new char[a[0]];\n"
-                                "};";
+                                "};\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3321,7 +3391,7 @@ class TestTokenizer : public TestFixture {
         {
             const char code[] = "void f(){\n"
                                 " foo(g());\n"
-                                "};";
+                                "};\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3339,7 +3409,7 @@ class TestTokenizer : public TestFixture {
         {
             const char code[] = "bool foo(C<z> a, bar<int, x<float>>& f, int b) {\n"
                                 "    return(a<b && b>f);\n"
-                                "}";
+                                "}\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3365,7 +3435,7 @@ class TestTokenizer : public TestFixture {
         {
             const char code[] = "void foo() {\n"
                                 "    return static_cast<bar>(a);\n"
-                                "}";
+                                "}\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3380,7 +3450,7 @@ class TestTokenizer : public TestFixture {
         {
             const char code[] = "void foo() {\n"
                                 "    nvwa<(x > y)> ERROR_nnn;\n"
-                                "}";
+                                "}\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3394,7 +3464,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // #4860
-            const char code[] = "class A : public B<int> {};";
+            const char code[] = "class A : public B<int> {};\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3408,7 +3478,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // #4860
-            const char code[] = "Bar<Typelist< int, Typelist< int, Typelist< int, FooNullType>>>>::set(1, 2, 3);";
+            const char code[] = "Bar<Typelist< int, Typelist< int, Typelist< int, FooNullType>>>>::set(1, 2, 3);\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3423,7 +3493,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // #5627
-            const char code[] = "new Foo<Bar>[10];";
+            const char code[] = "new Foo<Bar>[10];\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3437,7 +3507,7 @@ class TestTokenizer : public TestFixture {
         }
         {
             // #6242
-            const char code[] = "func = integral_<uchar, int, double>;";
+            const char code[] = "func = integral_<uchar, int, double>;\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3450,7 +3520,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // if (a < b || c > d) { }
-            const char code[] = "{ if (a < b || c > d); }";
+            const char code[] = "{ if (a < b || c > d); }\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3460,7 +3530,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // bool f = a < b || c > d
-            const char code[] = "bool f = a < b || c > d;";
+            const char code[] = "bool f = a < b || c > d;\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3470,7 +3540,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // template
-            const char code[] = "a < b || c > d;";
+            const char code[] = "a < b || c > d;\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3480,7 +3550,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // if (a < ... > d) { }
-            const char code[] = "{ if (a < b || c == 3 || d > e); }";
+            const char code[] = "{ if (a < b || c == 3 || d > e); }\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3490,7 +3560,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // template
-            const char code[] = "a<b==3 || c> d;";
+            const char code[] = "a<b==3 || c> d;\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3499,7 +3569,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // template
-            const char code[] = "a<b || c==4> d;";
+            const char code[] = "a<b || c==4> d;\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3507,7 +3577,7 @@ class TestTokenizer : public TestFixture {
         }
 
         {
-            const char code[] = "template < f = b || c > struct S;";
+            const char code[] = "template < f = b || c > struct S;\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3516,7 +3586,7 @@ class TestTokenizer : public TestFixture {
         }
 
         {
-            const char code[] = "struct A : B<c&&d> {};";
+            const char code[] = "struct A : B<c&&d> {};\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3525,7 +3595,7 @@ class TestTokenizer : public TestFixture {
         }
 
         {
-            const char code[] = "Data<T&&>;";
+            const char code[] = "Data<T&&>;\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3535,7 +3605,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // #6601
-            const char code[] = "template<class R> struct FuncType<R(&)()> : FuncType<R()> { };";
+            const char code[] = "template<class R> struct FuncType<R(&)()> : FuncType<R()> { };\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
@@ -3553,7 +3623,7 @@ class TestTokenizer : public TestFixture {
     void createLinks2() {
         {
             // #7158
-            const char code[] = "enum { value = boost::mpl::at_c<B, C> };";
+            const char code[] = "enum { value = boost::mpl::at_c<B, C> };\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok = Token::findsimplematch(tokenizer.tokens(), "<");
@@ -3587,7 +3657,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // #8006
-            const char code[] = "C<int> && a = b;";
+            const char code[] = "C<int> && a = b;\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok1 = tokenizer.tokens()->next();
@@ -3598,7 +3668,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // #8115
-            const char code[] = "void Test(C<int> && c);";
+            const char code[] = "void Test(C<int> && c);\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), "<");
@@ -3609,7 +3679,7 @@ class TestTokenizer : public TestFixture {
         {
             // #8654
             const char code[] = "template<int N> struct A {}; "
-                                "template<int... Ns> struct foo : A<Ns>... {};";
+                                "template<int... Ns> struct foo : A<Ns>... {};\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *A = Token::findsimplematch(tokenizer.tokens(), "A <");
@@ -3617,8 +3687,8 @@ class TestTokenizer : public TestFixture {
         }
         {
             // #8851
-            const char code[] = "template<typename std::enable_if<!(std::value1) && std::value2>::type>"
-                                "void basic_json() {}";
+            const char code[] = "template<typename std::enable_if<!(std::value1) && std::value2>::type>\n"
+                                "void basic_json() {}\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             ASSERT_EQUALS(true, Token::simpleMatch(tokenizer.tokens()->linkAt(1), "> void"));
@@ -3626,7 +3696,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // #9094 - template usage or comparison?
-            const char code[] = "a = f(x%x<--a==x>x);";
+            const char code[] = "a = f(x%x<--a==x>x);\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             ASSERT(nullptr == Token::findsimplematch(tokenizer.tokens(), "<")->link());
@@ -3636,7 +3706,7 @@ class TestTokenizer : public TestFixture {
             // #11319
             const char code[] = "using std::same_as;\n"
                                 "template<same_as<int> T>\n"
-                                "void f();";
+                                "void f();\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), "template <");
@@ -3647,7 +3717,7 @@ class TestTokenizer : public TestFixture {
 
         {
             // #9131 - template usage or comparison?
-            const char code[] = "using std::list; list<t *> l;";
+            const char code[] = "using std::list; list<t *> l;\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             ASSERT(nullptr != Token::findsimplematch(tokenizer.tokens(), "<")->link());
@@ -3658,7 +3728,7 @@ class TestTokenizer : public TestFixture {
                                 "void foo()\n"
                                 "{\n"
                                 "    for (set<ParticleSource*>::iterator i = sources.begin(); i != sources.end(); ++i) {}\n"
-                                "}";
+                                "}\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             ASSERT(nullptr != Token::findsimplematch(tokenizer.tokens(), "<")->link());
@@ -3964,102 +4034,102 @@ class TestTokenizer : public TestFixture {
 
     void simplifyConst() {
         ASSERT_EQUALS("void foo ( ) { const int x ; }",
-                      tokenizeAndStringify("void foo(){ int const x;}"));
+                      tokenizeAndStringify("void foo(){ int const x;}\n"));
 
         ASSERT_EQUALS("void foo ( ) { { } const long x ; }",
-                      tokenizeAndStringify("void foo(){ {} long const x;}"));
+                      tokenizeAndStringify("void foo(){ {} long const x;}\n"));
 
         ASSERT_EQUALS("void foo ( int b , const unsigned int x ) { }",
-                      tokenizeAndStringify("void foo(int b,unsigned const x){}"));
+                      tokenizeAndStringify("void foo(int b,unsigned const x){}\n"));
 
         ASSERT_EQUALS("void foo ( ) { bar ( ) ; const char x ; }",
-                      tokenizeAndStringify("void foo(){ bar(); char const x;}"));
+                      tokenizeAndStringify("void foo(){ bar(); char const x;}\n"));
 
         ASSERT_EQUALS("void foo ( const char x ) { }",
-                      tokenizeAndStringify("void foo(char const x){}"));
+                      tokenizeAndStringify("void foo(char const x){}\n"));
 
         ASSERT_EQUALS("void foo ( int b , const char x ) { }",
-                      tokenizeAndStringify("void foo(int b,char const x){}"));
+                      tokenizeAndStringify("void foo(int b,char const x){}\n"));
 
         ASSERT_EQUALS("void foo ( ) { int * const x ; }",
-                      tokenizeAndStringify("void foo(){ int * const x;}"));
+                      tokenizeAndStringify("void foo(){ int * const x;}\n"));
 
-        ASSERT_EQUALS("const int foo ( ) ;", tokenizeAndStringify("int const foo ();"));
+        ASSERT_EQUALS("const int foo ( ) ;", tokenizeAndStringify("int const foo ();\n"));
 
-        ASSERT_EQUALS("const int x ;", tokenizeAndStringify("int const x;"));
-        ASSERT_EQUALS("const unsigned int x ;", tokenizeAndStringify("unsigned const x;"));
-        ASSERT_EQUALS("const struct X x ;", tokenizeAndStringify("struct X const x;"));
+        ASSERT_EQUALS("const int x ;", tokenizeAndStringify("int const x;\n"));
+        ASSERT_EQUALS("const unsigned int x ;", tokenizeAndStringify("unsigned const x;\n"));
+        ASSERT_EQUALS("const struct X x ;", tokenizeAndStringify("struct X const x;\n"));
     }
 
     void switchCase() {
         ASSERT_EQUALS("void foo ( int i ) { switch ( i ) { case -1 : ; break ; } }",
-                      tokenizeAndStringify("void foo (int i) { switch(i) { case -1: break; } }"));
+                      tokenizeAndStringify("void foo (int i) { switch(i) { case -1: break; } }\n"));
         //ticket #3227
         ASSERT_EQUALS("void foo ( int n ) { switch ( n ) { label : ; case 1 : ; label1 : ; label2 : ; break ; } }",
-                      tokenizeAndStringify("void foo(int n){ switch (n){ label: case 1: label1: label2: break; }}"));
+                      tokenizeAndStringify("void foo(int n){ switch (n){ label: case 1: label1: label2: break; }}\n"));
         //ticket #8345
         ASSERT_EQUALS("void foo ( ) { switch ( 0 ) { case 0 : ; default : ; } }",
-                      tokenizeAndStringify("void foo () { switch(0) case 0 : default : ; }"));
+                      tokenizeAndStringify("void foo () { switch(0) case 0 : default : ; }\n"));
         //ticket #8477
         ASSERT_EQUALS("void foo ( ) { enum Anonymous0 : int { Six = 6 } ; return Six ; }",
-                      tokenizeAndStringify("void foo () { enum : int { Six = 6 } ; return Six ; }"));
+                      tokenizeAndStringify("void foo () { enum : int { Six = 6 } ; return Six ; }\n"));
         // ticket #8281
-        ASSERT_NO_THROW(tokenizeAndStringify("void lzma_decode(int i) { "
-                                             "  bool state; "
-                                             "  switch (i) "
-                                             "  while (true) { "
-                                             "     state=false; "
-                                             "   case 1: "
-                                             "      ; "
-                                             "  }"
-                                             "}"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void lzma_decode(int i) {\n"
+                                             "  bool state;\n"
+                                             "  switch (i)\n"
+                                             "  while (true) {\n"
+                                             "     state=false;\n"
+                                             "   case 1:\n"
+                                             "      ;\n"
+                                             "  }\n"
+                                             "}\n"));
         // ticket #8417
-        ASSERT_NO_THROW(tokenizeAndStringify("void printOwnedAttributes(int mode) { "
-                                             "  switch(mode) case 0: { break; } "
-                                             "}"));
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void printOwnedAttributes(int mode) { "
-                                                   "  switch(mode) case 0: { break; } case 1: ; "
-                                                   "}"),
+        ASSERT_NO_THROW(tokenizeAndStringify("void printOwnedAttributes(int mode) {\n"
+                                             "  switch(mode) case 0: { break; }\n"
+                                             "}\n"));
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void printOwnedAttributes(int mode) {\n"
+                                                   "  switch(mode) case 0: { break; } case 1: ;\n"
+                                                   "}\n"),
                               SYNTAX);
     }
 
     void simplifyPointerToStandardType() {
         // Pointer to standard type
         ASSERT_EQUALS("char buf [ 100 ] ; readlink ( path , buf , 99 ) ;",
-                      tokenizeAndStringify("char buf[100] ; readlink(path, &buf[0], 99);",
+                      tokenizeAndStringify("char buf[100] ; readlink(path, &buf[0], 99);\n",
                                            dinit(TokenizeOptions, $.cpp = false)));
         ASSERT_EQUALS("", errout_str());
 
         ASSERT_EQUALS("void foo ( char * c ) { if ( 1 == ( 1 & c [ 0 ] ) ) { } }",
-                      tokenizeAndStringify("void foo(char *c) { if (1==(1 & c[0])) {} }",
+                      tokenizeAndStringify("void foo(char *c) { if (1==(1 & c[0])) {} }\n",
                                            dinit(TokenizeOptions, $.cpp = false)));
         ASSERT_EQUALS("", filter_valueflow(errout_str()));
 
         // Simplification of unknown type - C only
         ASSERT_EQUALS("foo data [ 100 ] ; something ( foo ) ;",
-                      tokenizeAndStringify("foo data[100]; something(&foo[0]);", dinit(TokenizeOptions, $.cpp = false)));
+                      tokenizeAndStringify("foo data[100]; something(&foo[0]);\n", dinit(TokenizeOptions, $.cpp = false)));
         ASSERT_EQUALS("", errout_str());
 
         // C++: No pointer simplification
         ASSERT_EQUALS("foo data [ 100 ] ; something ( & foo [ 0 ] ) ;",
-                      tokenizeAndStringify("foo data[100]; something(&foo[0]);"));
+                      tokenizeAndStringify("foo data[100]; something(&foo[0]);\n"));
         ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyFunctionPointers1() {
-        ASSERT_EQUALS("void ( * f ) ( ) ;", tokenizeAndStringify("void (*f)();"));
-        ASSERT_EQUALS("void * ( * f ) ( ) ;", tokenizeAndStringify("void *(*f)();"));
-        ASSERT_EQUALS("unsigned int ( * f ) ( ) ;", tokenizeAndStringify("unsigned int (*f)();"));
-        ASSERT_EQUALS("unsigned int * ( * f ) ( ) ;", tokenizeAndStringify("unsigned int * (*f)();"));
-        ASSERT_EQUALS("void ( * f [ 2 ] ) ( ) ;", tokenizeAndStringify("void (*f[2])();"));
-        ASSERT_EQUALS("void ( * f [ 2 ] ) ( void ) ;", tokenizeAndStringify("typedef void func_t(void); func_t *f[2];")); // #10581
+        ASSERT_EQUALS("void ( * f ) ( ) ;", tokenizeAndStringify("void (*f)();\n"));
+        ASSERT_EQUALS("void * ( * f ) ( ) ;", tokenizeAndStringify("void *(*f)();\n"));
+        ASSERT_EQUALS("unsigned int ( * f ) ( ) ;", tokenizeAndStringify("unsigned int (*f)();\n"));
+        ASSERT_EQUALS("unsigned int * ( * f ) ( ) ;", tokenizeAndStringify("unsigned int * (*f)();\n"));
+        ASSERT_EQUALS("void ( * f [ 2 ] ) ( ) ;", tokenizeAndStringify("void (*f[2])();\n"));
+        ASSERT_EQUALS("void ( * f [ 2 ] ) ( void ) ;", tokenizeAndStringify("typedef void func_t(void); func_t *f[2];\n")); // #10581
     }
 
     void simplifyFunctionPointers2() {
         const char code[] = "typedef void (* PF)();"
                             "void f1 ( ) { }"
                             "PF pf = &f1;"
-                            "PF pfs[] = { &f1, &f1 };";
+                            "PF pfs[] = { &f1, &f1 };\n";
         const char expected[] = "void f1 ( ) { } "
                                 "void ( * pf ) ( ) ; pf = & f1 ; "
                                 "void ( * pfs [ ] ) ( ) = { & f1 , & f1 } ;";
@@ -4070,7 +4140,7 @@ class TestTokenizer : public TestFixture {
         // Related with ticket #2873
         const char code[] = "void f() {\n"
                             "(void)(xy(*p)(0));"
-                            "\n}";
+                            "\n}\n";
         const char expected[] = "void f ( ) {\n"
                                 "( void ) ( xy ( * p ) ( 0 ) ) ;\n"
                                 "}";
@@ -4085,7 +4155,7 @@ class TestTokenizer : public TestFixture {
                             "{\n"
                             "    typedef void (*FP)();\n"
                             "    virtual FP getFP();\n"
-                            "};";
+                            "};\n";
         const char expected[] = "1: struct S\n"
                                 "2: {\n"
                                 "3:\n"
@@ -4095,67 +4165,67 @@ class TestTokenizer : public TestFixture {
     }
 
     void simplifyFunctionPointers5() {
-        const char code[] = ";void (*fp[])(int a) = {0,0,0};";
+        const char code[] = ";void (*fp[])(int a) = {0,0,0};\n";
         const char expected[] = "1: ; void ( * fp@1 [ ] ) ( int ) = { 0 , 0 , 0 } ;\n"; // TODO: Array dimension
         ASSERT_EQUALS(expected, tokenizeDebugListing(code));
     }
 
     void simplifyFunctionPointers6() {
-        const char code1[] = "void (*fp(void))(int) {}";
+        const char code1[] = "void (*fp(void))(int) {}\n";
         const char expected1[] = "1: void * fp ( ) { }\n";
         ASSERT_EQUALS(expected1, tokenizeDebugListing(code1));
 
-        const char code2[] = "std::string (*fp(void))(int);";
+        const char code2[] = "std::string (*fp(void))(int);\n";
         const char expected2[] = "1: std :: string * fp ( ) ;\n";
         ASSERT_EQUALS(expected2, tokenizeDebugListing(code2));
     }
 
     void simplifyFunctionPointers7() {
-        const char code1[] = "void (X::*y)();";
+        const char code1[] = "void (X::*y)();\n";
         const char expected1[] = "1: void ( * y@1 ) ( ) ;\n";
         ASSERT_EQUALS(expected1, tokenizeDebugListing(code1));
     }
 
     void simplifyFunctionPointers8() {
-        const char code1[] = "int (*f)() throw(int);";
+        const char code1[] = "int (*f)() throw(int);\n";
         const char expected1[] = "1: int ( * f@1 ) ( ) ;\n";
         ASSERT_EQUALS(expected1, tokenizeDebugListing(code1));
     }
 
     void simplifyFunctionPointers9() { // function call with function pointer
-        const char code1[] = "int f() { (*f)(); }";
+        const char code1[] = "int f() { (*f)(); }\n";
         const char expected1[] = "1: int f ( ) { ( * f ) ( ) ; }\n";
         ASSERT_EQUALS(expected1, tokenizeDebugListing(code1));
 
-        const char code2[] = "int f() { return (*f)(); }";
+        const char code2[] = "int f() { return (*f)(); }\n";
         const char expected2[] = "1: int f ( ) { return ( * f ) ( ) ; }\n";
         ASSERT_EQUALS(expected2, tokenizeDebugListing(code2));
 
-        const char code3[] = "int f() { throw (*f)(); }";
+        const char code3[] = "int f() { throw (*f)(); }\n";
         const char expected3[] = "1: int f ( ) { throw ( * f ) ( ) ; }\n";
         ASSERT_EQUALS(expected3, tokenizeDebugListing(code3));
     }
 
     void removedeclspec() {
-        ASSERT_EQUALS("a b", tokenizeAndStringify("a __declspec ( dllexport ) b"));
-        ASSERT_EQUALS("a b", tokenizeAndStringify("a _declspec ( dllexport ) b"));
-        ASSERT_EQUALS("int a ;", tokenizeAndStringify("__declspec(thread) __declspec(align(32)) int a;"));
-        ASSERT_EQUALS("int i ;", tokenizeAndStringify("__declspec(allocate(\"mycode\")) int i;"));
-        ASSERT_EQUALS("struct IUnknown ;", tokenizeAndStringify("struct __declspec(uuid(\"00000000-0000-0000-c000-000000000046\")) IUnknown;"));
-        ASSERT_EQUALS("__property int x [ ] ;", tokenizeAndStringify("__declspec(property(get=GetX, put=PutX)) int x[];"));
+        ASSERT_EQUALS("a b", tokenizeAndStringify("a __declspec ( dllexport ) b\n"));
+        ASSERT_EQUALS("a b", tokenizeAndStringify("a _declspec ( dllexport ) b\n"));
+        ASSERT_EQUALS("int a ;", tokenizeAndStringify("__declspec(thread) __declspec(align(32)) int a;\n"));
+        ASSERT_EQUALS("int i ;", tokenizeAndStringify("__declspec(allocate(\"mycode\")) int i;\n"));
+        ASSERT_EQUALS("struct IUnknown ;", tokenizeAndStringify("struct __declspec(uuid(\"00000000-0000-0000-c000-000000000046\")) IUnknown;\n"));
+        ASSERT_EQUALS("__property int x [ ] ;", tokenizeAndStringify("__declspec(property(get=GetX, put=PutX)) int x[];\n"));
     }
 
     void removeattribute() {
-        ASSERT_EQUALS("short array [ 3 ] ;", tokenizeAndStringify("short array[3] __attribute__ ((aligned));"));
-        ASSERT_EQUALS("int x [ 2 ] ;", tokenizeAndStringify("int x[2] __attribute__ ((packed));"));
-        ASSERT_EQUALS("int vecint ;", tokenizeAndStringify("int __attribute__((mode(SI))) __attribute__((vector_size (16))) vecint;"));
+        ASSERT_EQUALS("short array [ 3 ] ;", tokenizeAndStringify("short array[3] __attribute__ ((aligned));\n"));
+        ASSERT_EQUALS("int x [ 2 ] ;", tokenizeAndStringify("int x[2] __attribute__ ((packed));\n"));
+        ASSERT_EQUALS("int vecint ;", tokenizeAndStringify("int __attribute__((mode(SI))) __attribute__((vector_size (16))) vecint;\n"));
 
         // alternate spelling #5328
-        ASSERT_EQUALS("short array [ 3 ] ;", tokenizeAndStringify("short array[3] __attribute ((aligned));"));
-        ASSERT_EQUALS("int x [ 2 ] ;", tokenizeAndStringify("int x[2] __attribute ((packed));"));
-        ASSERT_EQUALS("int vecint ;", tokenizeAndStringify("int __attribute((mode(SI))) __attribute((vector_size (16))) vecint;"));
+        ASSERT_EQUALS("short array [ 3 ] ;", tokenizeAndStringify("short array[3] __attribute ((aligned));\n"));
+        ASSERT_EQUALS("int x [ 2 ] ;", tokenizeAndStringify("int x[2] __attribute ((packed));\n"));
+        ASSERT_EQUALS("int vecint ;", tokenizeAndStringify("int __attribute((mode(SI))) __attribute((vector_size (16))) vecint;\n"));
 
-        ASSERT_EQUALS("struct Payload_IR_config { uint8_t tap [ 16 ] ; } ;", tokenizeAndStringify("struct __attribute__((packed, gcc_struct)) Payload_IR_config { uint8_t tap[16]; };"));
+        ASSERT_EQUALS("struct Payload_IR_config { uint8_t tap [ 16 ] ; } ;", tokenizeAndStringify("struct __attribute__((packed, gcc_struct)) Payload_IR_config { uint8_t tap[16]; };\n"));
     }
 
     void functionAttributeBefore1() {
@@ -4164,7 +4234,7 @@ class TestTokenizer : public TestFixture {
                             "void __attribute__((nothrow)) __attribute__((pure)) __attribute__((const)) func3();\n"
                             "void __attribute__((__nothrow__)) __attribute__((__pure__)) __attribute__((__const__)) func4();\n"
                             "void __attribute__((noreturn)) func5();\n"
-                            "void __attribute__((__visibility__(\"default\"))) func6();";
+                            "void __attribute__((__visibility__(\"default\"))) func6();\n";
         const char expected[] = "void func1 ( ) ; void func2 ( ) ; void func3 ( ) ; void func4 ( ) ; void func5 ( ) ; void func6 ( ) ;";
 
         // tokenize..
@@ -4190,7 +4260,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void functionAttributeBefore2() {
-        const char code[] = "extern vas_f *VAS_Fail __attribute__((__noreturn__));";
+        const char code[] = "extern vas_f *VAS_Fail __attribute__((__noreturn__));\n";
         const char expected[] = "extern vas_f * VAS_Fail ;";
 
         // tokenize..
@@ -4203,7 +4273,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void functionAttributeBefore3() { // #10978
-        const char code[] = "void __attribute__((__noreturn__)) (*func_notret)(void);";
+        const char code[] = "void __attribute__((__noreturn__)) (*func_notret)(void);\n";
         const char expected[] = "void ( * func_notret ) ( void ) ;";
 
         // tokenize..
@@ -4216,7 +4286,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void functionAttributeBefore4() {
-        const char code[] = "__attribute__((const)) int& foo();";
+        const char code[] = "__attribute__((const)) int& foo();\n";
         const char expected[] = "int & foo ( ) ;";
 
         // tokenize..
@@ -4248,8 +4318,8 @@ class TestTokenizer : public TestFixture {
         const char code[] = "void func1() __attribute__((pure)) __attribute__((nothrow)) __attribute__((const));\n"
                             "void func2() __attribute__((__pure__)) __attribute__((__nothrow__)) __attribute__((__const__));\n"
                             "void func3() __attribute__((nothrow)) __attribute__((pure)) __attribute__((const));\n"
-                            "void func4() __attribute__((__nothrow__)) __attribute__((__pure__)) __attribute__((__const__));"
-                            "void func5() __attribute__((noreturn));";
+                            "void func4() __attribute__((__nothrow__)) __attribute__((__pure__)) __attribute__((__const__));\n"
+                            "void func5() __attribute__((noreturn));\n";
         const char expected[] = "void func1 ( ) ; void func2 ( ) ; void func3 ( ) ; void func4 ( ) ; void func5 ( ) ;";
 
         // tokenize..
@@ -4276,7 +4346,7 @@ class TestTokenizer : public TestFixture {
         const char code[] = "class foo {\n"
                             "public:\n"
                             "    bool operator==(const foo &) __attribute__((__pure__));\n"
-                            "};";
+                            "};\n";
         const char expected[] = "class foo { public: bool operator== ( const foo & ) ; } ;";
 
         // tokenize..
@@ -4298,7 +4368,7 @@ class TestTokenizer : public TestFixture {
                             "void __attribute__((noreturn,format(printf,1,2))) func5();\n"
                             "void __attribute__((__nothrow__)) __attribute__((__pure__,__const__)) func6();\n"
                             "void __attribute__((__nothrow__,__pure__)) __attribute__((__const__)) func7();\n"
-                            "void __attribute__((noreturn)) __attribute__(()) __attribute__((nothrow,pure,const)) func8();";
+                            "void __attribute__((noreturn)) __attribute__(()) __attribute__((nothrow,pure,const)) func8();\n";
         const char expected[] = "void func1 ( ) ; void func2 ( ) ; void func3 ( ) ; void func4 ( ) ; void func5 ( ) ; "
                                 "void func6 ( ) ; void func7 ( ) ; void func8 ( ) ;";
 
@@ -4336,7 +4406,7 @@ class TestTokenizer : public TestFixture {
                             "void func5() __attribute__((noreturn,format(printf,1,2)));\n"
                             "void func6() __attribute__((__nothrow__)) __attribute__((__pure__,__const__));\n"
                             "void func7() __attribute__((__nothrow__,__pure__)) __attribute__((__const__));\n"
-                            "void func8() __attribute__((noreturn)) __attribute__(()) __attribute__((nothrow,pure,const));";
+                            "void func8() __attribute__((noreturn)) __attribute__(()) __attribute__((nothrow,pure,const));\n";
         const char expected[] = "void func1 ( ) ; void func2 ( ) ; void func3 ( ) ; void func4 ( ) ; void func5 ( ) ; "
                                 "void func6 ( ) ; void func7 ( ) ; void func8 ( ) ;";
 
@@ -4386,7 +4456,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void cppMaybeUnusedBefore() {
-        const char code[] = "[[maybe_unused]] int var {};";
+        const char code[] = "[[maybe_unused]] int var {};\n";
         const char expected[] = "int var { } ;";
 
         SimpleTokenizer tokenizer(settingsDefault, *this);
@@ -4399,7 +4469,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void cppMaybeUnusedAfter1() {
-        const char code[] = "int var [[maybe_unused]] {};";
+        const char code[] = "int var [[maybe_unused]] {};\n";
         const char expected[] = "int var { } ;";
 
         SimpleTokenizer tokenizer(settingsDefault, *this);
@@ -4412,7 +4482,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void cppMaybeUnusedAfter2() {
-        const char code[] = "std::string var [[maybe_unused]];";
+        const char code[] = "std::string var [[maybe_unused]];\n";
         const char expected[] = "std :: string var ;";
 
         SimpleTokenizer tokenizer(settingsDefault, *this);
@@ -4425,7 +4495,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void cppMaybeUnusedAfter3() {
-        const char code[] = "void foo(int x [[maybe_unused]]) {}";
+        const char code[] = "void foo(int x [[maybe_unused]]) {}\n";
         const char expected[] = "void foo ( int x ) { }";
 
         SimpleTokenizer tokenizer(settingsDefault, *this);
@@ -4438,7 +4508,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void cppMaybeUnusedStructuredBinding() {
-        const char code[] = "[[maybe_unused]] auto [var1, var2] = f();";
+        const char code[] = "[[maybe_unused]] auto [var1, var2] = f();\n";
         const char expected[] = "auto [ var1 , var2 ] = f ( ) ;";
 
         SimpleTokenizer tokenizer(settingsDefault, *this);
@@ -4453,7 +4523,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void attributeAlignasBefore() {
-        const char code[] = "alignas(long) unsigned char buffer[sizeof(long)];";
+        const char code[] = "alignas(long) unsigned char buffer[sizeof(long)];\n";
         const char expected[] = "char buffer [ sizeof ( long ) ] ;";
         SimpleTokenizer tokenizer(settingsDefault, *this);
         ASSERT(tokenizer.tokenize(code));
@@ -4468,7 +4538,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void attributeAlignasAfter() {
-        const char code[] = "unsigned char buffer[sizeof(long)] alignas(long);";
+        const char code[] = "unsigned char buffer[sizeof(long)] alignas(long);\n";
         const char expected[] = "char buffer [ sizeof ( long ) ] ;";
         SimpleTokenizer tokenizer(settingsDefault, *this);
         ASSERT(tokenizer.tokenize(code));
@@ -4483,7 +4553,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void simplifyAlignedStorage() {
-        const char code[] = "std::aligned_storage<sizeof(long), alignof(long)>::type buffer;";
+        const char code[] = "std::aligned_storage<sizeof(long), alignof(long)>::type buffer;\n";
         const char expected[] = "std :: aligned_storage < sizeof ( long ) , alignof ( long ) > :: type buffer ;";
 
         SimpleTokenizer tokenizer(settings2, *this);
@@ -4499,7 +4569,7 @@ class TestTokenizer : public TestFixture {
 
     void splitTemplateRightAngleBrackets() {
         {
-            const char code[] = "; z = x < 0 ? x >> y : x >> y;";
+            const char code[] = "; z = x < 0 ? x >> y : x >> y;\n";
             ASSERT_EQUALS("; z = x < 0 ? x >> y : x >> y ;", tokenizeAndStringify(code));
         }
         {
@@ -4513,7 +4583,7 @@ class TestTokenizer : public TestFixture {
                                 "         FFABS ( sprite_offset [ 1 ] [ i ] ) >= INT_MAX >> shift_c ||\n"
                                 "         FFABS ( sprite_delta [ 0 ] [ i ] ) >= INT_MAX >> shift_y ||\n"
                                 "         FFABS ( sprite_delta [ 1 ] [ i ] ) >= INT_MAX >> shift_y ) ;\n"
-                                "}";
+                                "}\n";
             ASSERT_EQUALS(std::string::npos, tokenizeAndStringify(code).find("> >"));
             ASSERT_EQUALS(
                 "[test.cpp:2:24]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable sprite_shift [valueFlowBailoutIncompleteVar]\n",
@@ -4531,15 +4601,15 @@ class TestTokenizer : public TestFixture {
 
     void cpp03template1() {
         {
-            const char code[] = "template<typename> struct extent {};";
+            const char code[] = "template<typename> struct extent {};\n";
             ASSERT_EQUALS("template < typename > struct extent { } ;", tokenizeAndStringify(code));
         }
         {
-            const char code[] = "template<typename> struct extent;";
+            const char code[] = "template<typename> struct extent;\n";
             ASSERT_EQUALS("template < typename > struct extent ;", tokenizeAndStringify(code));
         }
         {
-            const char code[] = "template<typename, unsigned = 0> struct extent;";
+            const char code[] = "template<typename, unsigned = 0> struct extent;\n";
             ASSERT_EQUALS("template < typename , unsigned int = 0 > struct extent ;", tokenizeAndStringify(code));
         }
     }
@@ -4588,262 +4658,262 @@ class TestTokenizer : public TestFixture {
         ASSERT_NO_THROW(tokenizeAndStringify("class A; "
                                              "template <class T> class Disposer; "
                                              "template <typename T, class D = Disposer<T>> class Shim {}; "
-                                             "class B : public Shim<A> {};"));
+                                             "class B : public Shim<A> {};\n"));
         // #6354 (segmentation fault)
-        (void)tokenizeAndStringify("template <class ELFT> class ELFObjectImage {}; "
-                                   "ObjectImage *createObjectImage() { "
-                                   "  return new ELFObjectImage<ELFType<little>>(Obj); "
-                                   "} "
-                                   "void resolveX86_64Relocation() { "
-                                   "  reinterpret_cast<int>(0); "
-                                   "}");
+        (void)tokenizeAndStringify("template <class ELFT> class ELFObjectImage {};\n"
+                                   "ObjectImage *createObjectImage() {\n"
+                                   "  return new ELFObjectImage<ELFType<little>>(Obj);\n"
+                                   "}\n"
+                                   "void resolveX86_64Relocation() {\n"
+                                   "  reinterpret_cast<int>(0);\n"
+                                   "}\n");
         // #6414
-        ASSERT_NO_THROW(tokenizeAndStringify("template<typename value_type, typename function_type> "
-                                             "value_type Base(const value_type x, const value_type dx, function_type func, int type_deriv) { "
-                                             "   return 0.0; "
-                                             "}; "
-                                             "namespace { "
-                                             "  template<class DC> class C { "
-                                             "    void Fun(int G, const double x); "
-                                             "  }; "
-                                             "  template<class DC> void C<DC>::Fun(int G, const double x) {"
-                                             "    Base<double, CDFFunctor<DC>>(2, 2, f, 0); "
-                                             "  }; "
-                                             "  template<class DC> class C2 {}; "
-                                             "}"));
+        ASSERT_NO_THROW(tokenizeAndStringify("template<typename value_type, typename function_type>\n"
+                                             "value_type Base(const value_type x, const value_type dx, function_type func, int type_deriv) {\n"
+                                             "   return 0.0;\n"
+                                             "};\n"
+                                             "namespace {\n"
+                                             "  template<class DC> class C {\n"
+                                             "    void Fun(int G, const double x);\n"
+                                             "  };\n"
+                                             "  template<class DC> void C<DC>::Fun(int G, const double x) {\n"
+                                             "    Base<double, CDFFunctor<DC>>(2, 2, f, 0);\n"
+                                             "  };\n"
+                                             "  template<class DC> class C2 {};\n"
+                                             "}\n"));
 
         ignore_errout();
     }
 
     void cpp0xtemplate5() { // #9154
         {
-            const char code[] = "struct s<x<u...>>;";
+            const char code[] = "struct s<x<u...>>;\n";
             ASSERT_EQUALS("struct s < x < u ... > > ;",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "template <class f> using c = e<i<q<f,r>,b...>>;";
+            const char code[] = "template <class f> using c = e<i<q<f,r>,b...>>;\n";
             ASSERT_EQUALS("template < class f > using c = e < i < q < f , r > , b ... > > ;",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "struct s<x<u...>> { };";
+            const char code[] = "struct s<x<u...>> { };\n";
             ASSERT_EQUALS("struct s < x < u ... > > { } ;",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "struct q : s<x<u...>> { };";
+            const char code[] = "struct q : s<x<u...>> { };\n";
             ASSERT_EQUALS("struct q : s < x < u ... > > { } ;",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "struct q : private s<x<u...>> { };";
+            const char code[] = "struct q : private s<x<u...>> { };\n";
             ASSERT_EQUALS("struct q : private s < x < u ... > > { } ;",
                           tokenizeAndStringify(code));
         }
     }
 
     void cpp14template() { // Ticket #6708
-        (void)tokenizeAndStringify("template <typename T> "
-                                   "decltype(auto) forward(T& t) { return 0; }");
-        ASSERT_EQUALS("[test.cpp:1:32]: (debug) auto token with no type. [autoNoType]\n", errout_str());
+        (void)tokenizeAndStringify("template <typename T>\n"
+                                   "decltype(auto) forward(T& t) { return 0; }\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (debug) auto token with no type. [autoNoType]\n", errout_str());
     }
 
     void arraySize() {
-        ASSERT_EQUALS("; int a [ 3 ] = { 1 , 2 , 3 } ;", tokenizeAndStringify(";int a[]={1,2,3};"));
-        ASSERT_EQUALS("; int a [ 3 ] = { 1 , 2 , 3 } ;", tokenizeAndStringify(";int a[]={1,2,3,};"));
-        ASSERT_EQUALS("; foo a [ 3 ] = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;", tokenizeAndStringify(";foo a[]={{1,2},{3,4},{5,6}};"));
-        ASSERT_EQUALS("; int a [ 1 ] = { foo < bar1 , bar2 > ( 123 , 4 ) } ;", tokenizeAndStringify(";int a[]={foo<bar1,bar2>(123,4)};"));
-        ASSERT_EQUALS("; int a [ 2 ] = { b > c ? 1 : 2 , 3 } ;", tokenizeAndStringify(";int a[]={ b>c?1:2,3};"));
-        ASSERT_EQUALS("int main ( ) { int a [ 2 ] = { b < c ? 1 : 2 , 3 } }", tokenizeAndStringify("int main(){int a[]={b<c?1:2,3}}"));
+        ASSERT_EQUALS("; int a [ 3 ] = { 1 , 2 , 3 } ;", tokenizeAndStringify(";int a[]={1,2,3};\n"));
+        ASSERT_EQUALS("; int a [ 3 ] = { 1 , 2 , 3 } ;", tokenizeAndStringify(";int a[]={1,2,3,};\n"));
+        ASSERT_EQUALS("; foo a [ 3 ] = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;", tokenizeAndStringify(";foo a[]={{1,2},{3,4},{5,6}};\n"));
+        ASSERT_EQUALS("; int a [ 1 ] = { foo < bar1 , bar2 > ( 123 , 4 ) } ;", tokenizeAndStringify(";int a[]={foo<bar1,bar2>(123,4)};\n"));
+        ASSERT_EQUALS("; int a [ 2 ] = { b > c ? 1 : 2 , 3 } ;", tokenizeAndStringify(";int a[]={ b>c?1:2,3};\n"));
+        ASSERT_EQUALS("int main ( ) { int a [ 2 ] = { b < c ? 1 : 2 , 3 } }", tokenizeAndStringify("int main(){int a[]={b<c?1:2,3}}\n"));
         ASSERT_EQUALS(
             "[test.cpp:1:21]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable b [valueFlowBailoutIncompleteVar]\n",
             errout_str());
-        ASSERT_EQUALS("; int a [ 3 ] = { ABC , 2 , 3 } ;", tokenizeAndStringify(";int a[]={ABC,2,3};"));
-        ASSERT_EQUALS("; int a [ 3 ] = { [ 2 ] = 5 } ;", tokenizeAndStringify(";int a[]={ [2] = 5 };"));
-        ASSERT_EQUALS("; int a [ 5 ] = { 1 , 2 , [ 2 ] = 5 , 3 , 4 } ;", tokenizeAndStringify(";int a[]={ 1, 2, [2] = 5, 3, 4 };"));
-        ASSERT_EQUALS("; int a [ ] = { 1 , 2 , [ x ] = 5 , 3 , 4 } ;", tokenizeAndStringify(";int a[]={ 1, 2, [x] = 5, 3, 4 };"));
-        ASSERT_EQUALS("; const char c [ 4 ] = \"abc\" ;", tokenizeAndStringify(";const char c[] = { \"abc\" };"));
+        ASSERT_EQUALS("; int a [ 3 ] = { ABC , 2 , 3 } ;", tokenizeAndStringify(";int a[]={ABC,2,3};\n"));
+        ASSERT_EQUALS("; int a [ 3 ] = { [ 2 ] = 5 } ;", tokenizeAndStringify(";int a[]={ [2] = 5 };\n"));
+        ASSERT_EQUALS("; int a [ 5 ] = { 1 , 2 , [ 2 ] = 5 , 3 , 4 } ;", tokenizeAndStringify(";int a[]={ 1, 2, [2] = 5, 3, 4 };\n"));
+        ASSERT_EQUALS("; int a [ ] = { 1 , 2 , [ x ] = 5 , 3 , 4 } ;", tokenizeAndStringify(";int a[]={ 1, 2, [x] = 5, 3, 4 };\n"));
+        ASSERT_EQUALS("; const char c [ 4 ] = \"abc\" ;", tokenizeAndStringify(";const char c[] = { \"abc\" };\n"));
     }
 
     void arraySizeAfterValueFlow() {
-        const char code[] = "enum {X=10}; int a[] = {[X]=1};";
+        const char code[] = "enum {X=10}; int a[] = {[X]=1};\n";
         ASSERT_EQUALS("enum Anonymous0 { X = 10 } ; int a [ 11 ] = { [ X ] = 1 } ;", tokenizeAndStringify(code));
     }
 
     void labels() {
-        ASSERT_EQUALS("void f ( ) { ab : ; a = 0 ; }", tokenizeAndStringify("void f() { ab: a=0; }"));
+        ASSERT_EQUALS("void f ( ) { ab : ; a = 0 ; }", tokenizeAndStringify("void f() { ab: a=0; }\n"));
         //ticket #3176
-        ASSERT_EQUALS("void f ( ) { ab : ; ( * func ) ( ) ; }", tokenizeAndStringify("void f() { ab: (*func)(); }"));
+        ASSERT_EQUALS("void f ( ) { ab : ; ( * func ) ( ) ; }", tokenizeAndStringify("void f() { ab: (*func)(); }\n"));
         //with '*' operator
-        ASSERT_EQUALS("void f ( ) { ab : ; * b = 0 ; }", tokenizeAndStringify("void f() { ab: *b=0; }"));
-        ASSERT_EQUALS("void f ( ) { ab : ; * * b = 0 ; }", tokenizeAndStringify("void f() { ab: **b=0; }"));
+        ASSERT_EQUALS("void f ( ) { ab : ; * b = 0 ; }", tokenizeAndStringify("void f() { ab: *b=0; }\n"));
+        ASSERT_EQUALS("void f ( ) { ab : ; * * b = 0 ; }", tokenizeAndStringify("void f() { ab: **b=0; }\n"));
         //with '&' operator
-        ASSERT_EQUALS("void f ( ) { ab : ; & b = 0 ; }", tokenizeAndStringify("void f() { ab: &b=0; }"));
-        ASSERT_EQUALS("void f ( ) { ab : ; & ( b . x ) = 0 ; }", tokenizeAndStringify("void f() { ab: &(b->x)=0; }"));
+        ASSERT_EQUALS("void f ( ) { ab : ; & b = 0 ; }", tokenizeAndStringify("void f() { ab: &b=0; }\n"));
+        ASSERT_EQUALS("void f ( ) { ab : ; & ( b . x ) = 0 ; }", tokenizeAndStringify("void f() { ab: &(b->x)=0; }\n"));
         //with '(' parentheses
-        ASSERT_EQUALS("void f ( ) { ab : ; * ( * b ) . x = 0 ; }", tokenizeAndStringify("void f() { ab: *(* b)->x=0; }"));
-        ASSERT_EQUALS("void f ( ) { ab : ; ( * * b ) . x = 0 ; }", tokenizeAndStringify("void f() { ab: (** b).x=0; }"));
-        ASSERT_EQUALS("void f ( ) { ab : ; & ( * b . x ) = 0 ; }", tokenizeAndStringify("void f() { ab: &(*b.x)=0; }"));
+        ASSERT_EQUALS("void f ( ) { ab : ; * ( * b ) . x = 0 ; }", tokenizeAndStringify("void f() { ab: *(* b)->x=0; }\n"));
+        ASSERT_EQUALS("void f ( ) { ab : ; ( * * b ) . x = 0 ; }", tokenizeAndStringify("void f() { ab: (** b).x=0; }\n"));
+        ASSERT_EQUALS("void f ( ) { ab : ; & ( * b . x ) = 0 ; }", tokenizeAndStringify("void f() { ab: &(*b.x)=0; }\n"));
         //with '{' parentheses
-        ASSERT_EQUALS("void f ( ) { ab : ; { b = 0 ; } }", tokenizeAndStringify("void f() { ab: {b=0;} }"));
-        ASSERT_EQUALS("void f ( ) { ab : ; { * b = 0 ; } }", tokenizeAndStringify("void f() { ab: { *b=0;} }"));
-        ASSERT_EQUALS("void f ( ) { ab : ; { & b = 0 ; } }", tokenizeAndStringify("void f() { ab: { &b=0;} }"));
-        ASSERT_EQUALS("void f ( ) { ab : ; { & ( * b . x ) = 0 ; } }", tokenizeAndStringify("void f() { ab: {&(*b.x)=0;} }"));
+        ASSERT_EQUALS("void f ( ) { ab : ; { b = 0 ; } }", tokenizeAndStringify("void f() { ab: {b=0;} }\n"));
+        ASSERT_EQUALS("void f ( ) { ab : ; { * b = 0 ; } }", tokenizeAndStringify("void f() { ab: { *b=0;} }\n"));
+        ASSERT_EQUALS("void f ( ) { ab : ; { & b = 0 ; } }", tokenizeAndStringify("void f() { ab: { &b=0;} }\n"));
+        ASSERT_EQUALS("void f ( ) { ab : ; { & ( * b . x ) = 0 ; } }", tokenizeAndStringify("void f() { ab: {&(*b.x)=0;} }\n"));
         //with unhandled MACRO() code
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f() { MACRO(ab: b=0;, foo)}"), UNKNOWN_MACRO);
-        ASSERT_EQUALS("void f ( ) { MACRO ( bar , ab : { & ( * b . x ) = 0 ; } ) }", tokenizeAndStringify("void f() { MACRO(bar, ab: {&(*b.x)=0;})}"));
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f() { MACRO(ab: b=0;, foo)}\n"), UNKNOWN_MACRO);
+        ASSERT_EQUALS("void f ( ) { MACRO ( bar , ab : { & ( * b . x ) = 0 ; } ) }", tokenizeAndStringify("void f() { MACRO(bar, ab: {&(*b.x)=0;})}\n"));
 
         ignore_errout();
     }
 
     void simplifyInitVar() {
         {
-            const char code[] = "int i ; int p(0);";
+            const char code[] = "int i ; int p(0);\n";
             ASSERT_EQUALS("int i ; int p ( 0 ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "int i; int *p(0);";
+            const char code[] = "int i; int *p(0);\n";
             ASSERT_EQUALS("int i ; int * p ( 0 ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "int p(0);";
+            const char code[] = "int p(0);\n";
             ASSERT_EQUALS("int p ( 0 ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "int *p(0);";
+            const char code[] = "int *p(0);\n";
             ASSERT_EQUALS("int * p ( 0 ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "int i ; int p(i);";
+            const char code[] = "int i ; int p(i);\n";
             ASSERT_EQUALS("int i ; int p ( i ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "int i; int *p(&i);";
+            const char code[] = "int i; int *p(&i);\n";
             ASSERT_EQUALS("int i ; int * p ( & i ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "int i; void *p(&i);";
+            const char code[] = "int i; void *p(&i);\n";
             ASSERT_EQUALS("int i ; void * p ( & i ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "struct S { }; struct S s; struct S *p(&s);";
+            const char code[] = "struct S { }; struct S s; struct S *p(&s);\n";
             ASSERT_EQUALS("struct S { } ; struct S s ; struct S * p ( & s ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "struct S { }; S s; S *p(&s);";
+            const char code[] = "struct S { }; S s; S *p(&s);\n";
             ASSERT_EQUALS("struct S { } ; S s ; S * p ( & s ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "union S { int i; float f; }; union S s; union S *p(&s);";
+            const char code[] = "union S { int i; float f; }; union S s; union S *p(&s);\n";
             ASSERT_EQUALS("union S { int i ; float f ; } ; union S s ; union S * p ( & s ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "union S { int i; float f; }; S s; S *p(&s);";
+            const char code[] = "union S { int i; float f; }; S s; S *p(&s);\n";
             ASSERT_EQUALS("union S { int i ; float f ; } ; S s ; S * p ( & s ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "class C { }; class C c; class C *p(&c);";
+            const char code[] = "class C { }; class C c; class C *p(&c);\n";
             ASSERT_EQUALS("class C { } ; class C c ; class C * p ( & c ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "class C { }; C c; C *p(&c);";
+            const char code[] = "class C { }; C c; C *p(&c);\n";
             ASSERT_EQUALS("class C { } ; C c ; C * p ( & c ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "struct S { }; struct S s; struct S s1(s);";
+            const char code[] = "struct S { }; struct S s; struct S s1(s);\n";
             ASSERT_EQUALS("struct S { } ; struct S s ; struct S s1 ( s ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "struct S { }; S s; S s1(s);";
+            const char code[] = "struct S { }; S s; S s1(s);\n";
             ASSERT_EQUALS("struct S { } ; S s ; S s1 ( s ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "struct S { }; struct S s; struct S s1(&s);";
+            const char code[] = "struct S { }; struct S s; struct S s1(&s);\n";
             ASSERT_EQUALS("struct S { } ; struct S s ; struct S s1 ( & s ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "struct S { }; S s; S s1(&s);";
+            const char code[] = "struct S { }; S s; S s1(&s);\n";
             ASSERT_EQUALS("struct S { } ; S s ; S s1 ( & s ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "class S { int function(); };";
+            const char code[] = "class S { int function(); };\n";
             ASSERT_EQUALS("class S { int function ( ) ; } ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "class S { int function(void); };";
+            const char code[] = "class S { int function(void); };\n";
             ASSERT_EQUALS("class S { int function ( ) ; } ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "class S { int function(int); };";
+            const char code[] = "class S { int function(int); };\n";
             ASSERT_EQUALS("class S { int function ( int ) ; } ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "int function(void);";
+            const char code[] = "int function(void);\n";
             ASSERT_EQUALS("int function ( ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "int function(int);";
+            const char code[] = "int function(int);\n";
             ASSERT_EQUALS("int function ( int ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "extern int function(void);";
+            const char code[] = "extern int function(void);\n";
             ASSERT_EQUALS("extern int function ( ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "int function1(void); int function2(void);";
+            const char code[] = "int function1(void); int function2(void);\n";
             ASSERT_EQUALS("int function1 ( ) ; int function2 ( ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "int function(A);";
+            const char code[] = "int function(A);\n";
             // We can't tell if this a function prototype or a variable without knowing
             // what A is. Since A is undefined, just leave it alone.
             ASSERT_EQUALS("int function ( A ) ;", tokenizeAndStringify(code));
@@ -4851,38 +4921,38 @@ class TestTokenizer : public TestFixture {
         }
 
         {
-            const char code[] = "int i; int function(A);";
+            const char code[] = "int i; int function(A);\n";
             ASSERT_EQUALS("int i ; int function ( A ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "class A { } ; int foo(A);";
+            const char code[] = "class A { } ; int foo(A);\n";
             ASSERT_EQUALS("class A { } ; int foo ( A ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "class A { } ; A a; int foo(a);";
+            const char code[] = "class A { } ; A a; int foo(a);\n";
             ASSERT_EQUALS("class A { } ; A a ; int foo ( a ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "int x(f());";
+            const char code[] = "int x(f());\n";
             ASSERT_EQUALS("int x ( f ( ) ) ;", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "{ return doSomething(X), 0; }";
+            const char code[] = "{ return doSomething(X), 0; }\n";
             ASSERT_EQUALS("{ return doSomething ( X ) , 0 ; }", tokenizeAndStringify(code));
             ASSERT_EQUALS("", errout_str());
         }
 
         {
             // 13893
-            const char code[] = "namespace test { bool foo; }";
+            const char code[] = "namespace test { bool foo; }\n";
             SimpleTokenizer tokenizer(settingsDefault, *this);
             ASSERT(tokenizer.tokenize(code));
             ASSERT(!tokenizer.tokens()->tokAt(2)->isInitBracket());
@@ -4893,7 +4963,7 @@ class TestTokenizer : public TestFixture {
         // ticket #5131 - unsigned
         const char code[] = "void f() {\n"
                             "    unsigned int a(0),b(0);\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("void f ( ) {\n"
                       "unsigned int a ( 0 ) ; unsigned int b ( 0 ) ;\n"
                       "}", tokenizeAndStringify(code));
@@ -4902,7 +4972,7 @@ class TestTokenizer : public TestFixture {
     void simplifyInitVar3() {
         const char code[] = "void f() {\n"
                             "    int *a(0),b(0);\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("void f ( ) {\n"
                       "int * a ( 0 ) ; int b ( 0 ) ;\n"
                       "}", tokenizeAndStringify(code));
@@ -4911,203 +4981,203 @@ class TestTokenizer : public TestFixture {
     void simplifyInitVar4() {
         const char code[] = "void f() {\n"
                             "    uint32_t x{0};\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("void f ( ) {\n"
                       "uint32_t x { 0 } ;\n"
                       "}", tokenizeAndStringify(code));
     }
 
     void simplifyInitVar5() { // #14218
-        const char code[] = "int c[1]{}, b;";
+        const char code[] = "int c[1]{}, b;\n";
         ASSERT_EQUALS("int c [ 1 ] { } ; int b ;", tokenizeAndStringify(code));
     }
 
     void bitfields1() {
-        const char code1[] = "struct A { bool x : 1; };";
+        const char code1[] = "struct A { bool x : 1; };\n";
         ASSERT_EQUALS("struct A { bool x ; } ;", tokenizeAndStringify(code1));
 
-        const char code2[] = "struct A { char x : 3; };";
+        const char code2[] = "struct A { char x : 3; };\n";
         ASSERT_EQUALS("struct A { char x ; } ;", tokenizeAndStringify(code2));
 
-        const char code3[] = "struct A { short x : 3; };";
+        const char code3[] = "struct A { short x : 3; };\n";
         ASSERT_EQUALS("struct A { short x ; } ;", tokenizeAndStringify(code3));
 
-        const char code4[] = "struct A { int x : 3; };";
+        const char code4[] = "struct A { int x : 3; };\n";
         ASSERT_EQUALS("struct A { int x ; } ;", tokenizeAndStringify(code4));
 
-        const char code5[] = "struct A { long x : 3; };";
+        const char code5[] = "struct A { long x : 3; };\n";
         ASSERT_EQUALS("struct A { long x ; } ;", tokenizeAndStringify(code5));
 
-        const char code6[] = "struct A { __int8 x : 3; };";
+        const char code6[] = "struct A { __int8 x : 3; };\n";
         ASSERT_EQUALS("struct A { char x ; } ;", tokenizeAndStringify(code6, settings_win32a));
 
-        const char code7[] = "struct A { __int16 x : 3; };";
+        const char code7[] = "struct A { __int16 x : 3; };\n";
         ASSERT_EQUALS("struct A { short x ; } ;", tokenizeAndStringify(code7,settings_win32a));
 
-        const char code8[] = "struct A { __int32 x : 3; };";
+        const char code8[] = "struct A { __int32 x : 3; };\n";
         ASSERT_EQUALS("struct A { int x ; } ;", tokenizeAndStringify(code8, settings_win32a));
 
-        const char code9[] = "struct A { __int64 x : 3; };";
+        const char code9[] = "struct A { __int64 x : 3; };\n";
         ASSERT_EQUALS("struct A { long long x ; } ;", tokenizeAndStringify(code9, settings_win32a));
 
-        const char code10[] = "struct A { unsigned char x : 3; };";
+        const char code10[] = "struct A { unsigned char x : 3; };\n";
         ASSERT_EQUALS("struct A { unsigned char x ; } ;", tokenizeAndStringify(code10));
 
-        const char code11[] = "struct A { unsigned short x : 3; };";
+        const char code11[] = "struct A { unsigned short x : 3; };\n";
         ASSERT_EQUALS("struct A { unsigned short x ; } ;", tokenizeAndStringify(code11));
 
-        const char code12[] = "struct A { unsigned int x : 3; };";
+        const char code12[] = "struct A { unsigned int x : 3; };\n";
         ASSERT_EQUALS("struct A { unsigned int x ; } ;", tokenizeAndStringify(code12));
 
-        const char code13[] = "struct A { unsigned long x : 3; };";
+        const char code13[] = "struct A { unsigned long x : 3; };\n";
         ASSERT_EQUALS("struct A { unsigned long x ; } ;", tokenizeAndStringify(code13));
 
-        const char code14[] = "struct A { unsigned __int8 x : 3; };";
+        const char code14[] = "struct A { unsigned __int8 x : 3; };\n";
         ASSERT_EQUALS("struct A { unsigned char x ; } ;", tokenizeAndStringify(code14, settings_win32a));
 
-        const char code15[] = "struct A { unsigned __int16 x : 3; };";
+        const char code15[] = "struct A { unsigned __int16 x : 3; };\n";
         ASSERT_EQUALS("struct A { unsigned short x ; } ;", tokenizeAndStringify(code15, settings_win32a));
 
-        const char code16[] = "struct A { unsigned __int32 x : 3; };";
+        const char code16[] = "struct A { unsigned __int32 x : 3; };\n";
         ASSERT_EQUALS("struct A { unsigned int x ; } ;", tokenizeAndStringify(code16, settings_win32a));
 
-        const char code17[] = "struct A { unsigned __int64 x : 3; };";
+        const char code17[] = "struct A { unsigned __int64 x : 3; };\n";
         ASSERT_EQUALS("struct A { unsigned long long x ; } ;", tokenizeAndStringify(code17, settings_win32a));
 
-        const char code18[] = "struct A { signed char x : 3; };";
+        const char code18[] = "struct A { signed char x : 3; };\n";
         ASSERT_EQUALS("struct A { signed char x ; } ;", tokenizeAndStringify(code18));
 
-        const char code19[] = "struct A { signed short x : 3; };";
+        const char code19[] = "struct A { signed short x : 3; };\n";
         ASSERT_EQUALS("struct A { signed short x ; } ;", tokenizeAndStringify(code19));
 
-        const char code20[] = "struct A { signed int x : 3; };";
+        const char code20[] = "struct A { signed int x : 3; };\n";
         ASSERT_EQUALS("struct A { signed int x ; } ;", tokenizeAndStringify(code20));
 
-        const char code21[] = "struct A { signed long x : 3; };";
+        const char code21[] = "struct A { signed long x : 3; };\n";
         ASSERT_EQUALS("struct A { signed long x ; } ;", tokenizeAndStringify(code21, settings_windows));
 
-        const char code22[] = "struct A { signed __int8 x : 3; };";
+        const char code22[] = "struct A { signed __int8 x : 3; };\n";
         ASSERT_EQUALS("struct A { signed char x ; } ;", tokenizeAndStringify(code22, settings_win32a));
 
-        const char code23[] = "struct A { signed __int16 x : 3; };";
+        const char code23[] = "struct A { signed __int16 x : 3; };\n";
         ASSERT_EQUALS("struct A { signed short x ; } ;", tokenizeAndStringify(code23, settings_win32a));
 
-        const char code24[] = "struct A { signed __int32 x : 3; };";
+        const char code24[] = "struct A { signed __int32 x : 3; };\n";
         ASSERT_EQUALS("struct A { signed int x ; } ;", tokenizeAndStringify(code24, settings_win32a));
 
-        const char code25[] = "struct A { signed __int64 x : 3; };";
+        const char code25[] = "struct A { signed __int64 x : 3; };\n";
         ASSERT_EQUALS("struct A { signed long long x ; } ;", tokenizeAndStringify(code25, settings_win32a));
     }
 
     void bitfields2() {
-        const char code1[] = "struct A { public: int x : 3; };";
+        const char code1[] = "struct A { public: int x : 3; };\n";
         ASSERT_EQUALS("struct A { public: int x ; } ;", tokenizeAndStringify(code1));
 
-        const char code2[] = "struct A { public: unsigned long x : 3; };";
+        const char code2[] = "struct A { public: unsigned long x : 3; };\n";
         ASSERT_EQUALS("struct A { public: unsigned long x ; } ;", tokenizeAndStringify(code2));
 
-        const char code3[] = "struct A { protected: int x : 3; };";
+        const char code3[] = "struct A { protected: int x : 3; };\n";
         ASSERT_EQUALS("struct A { protected: int x ; } ;", tokenizeAndStringify(code3));
 
-        const char code4[] = "struct A { protected: unsigned long x : 3; };";
+        const char code4[] = "struct A { protected: unsigned long x : 3; };\n";
         ASSERT_EQUALS("struct A { protected: unsigned long x ; } ;", tokenizeAndStringify(code4));
 
-        const char code5[] = "struct A { private: int x : 3; };";
+        const char code5[] = "struct A { private: int x : 3; };\n";
         ASSERT_EQUALS("struct A { private: int x ; } ;", tokenizeAndStringify(code5));
 
-        const char code6[] = "struct A { private: unsigned long x : 3; };";
+        const char code6[] = "struct A { private: unsigned long x : 3; };\n";
         ASSERT_EQUALS("struct A { private: unsigned long x ; } ;", tokenizeAndStringify(code6));
     }
 
     void bitfields3() {
-        const char code1[] = "struct A { const int x : 3; };";
+        const char code1[] = "struct A { const int x : 3; };\n";
         ASSERT_EQUALS("struct A { const int x ; } ;", tokenizeAndStringify(code1));
 
-        const char code2[] = "struct A { const unsigned long x : 3; };";
+        const char code2[] = "struct A { const unsigned long x : 3; };\n";
         ASSERT_EQUALS("struct A { const unsigned long x ; } ;", tokenizeAndStringify(code2));
 
-        const char code3[] = "struct A { public: const int x : 3; };";
+        const char code3[] = "struct A { public: const int x : 3; };\n";
         ASSERT_EQUALS("struct A { public: const int x ; } ;", tokenizeAndStringify(code3));
 
-        const char code4[] = "struct A { public: const unsigned long x : 3; };";
+        const char code4[] = "struct A { public: const unsigned long x : 3; };\n";
         ASSERT_EQUALS("struct A { public: const unsigned long x ; } ;", tokenizeAndStringify(code4));
     }
 
     void bitfields4() { // ticket #1956
-        const char code1[] = "struct A { CHAR x : 3; };";
+        const char code1[] = "struct A { CHAR x : 3; };\n";
         ASSERT_EQUALS("struct A { CHAR x ; } ;", tokenizeAndStringify(code1));
 
-        const char code2[] = "struct A { UCHAR x : 3; };";
+        const char code2[] = "struct A { UCHAR x : 3; };\n";
         ASSERT_EQUALS("struct A { UCHAR x ; } ;", tokenizeAndStringify(code2));
 
-        const char code3[] = "struct A { BYTE x : 3; };";
+        const char code3[] = "struct A { BYTE x : 3; };\n";
         ASSERT_EQUALS("struct A { BYTE x ; } ;", tokenizeAndStringify(code3));
 
-        const char code4[] = "struct A { WORD x : 3; };";
+        const char code4[] = "struct A { WORD x : 3; };\n";
         ASSERT_EQUALS("struct A { WORD x ; } ;", tokenizeAndStringify(code4));
 
-        const char code5[] = "struct A { DWORD x : 3; };";
+        const char code5[] = "struct A { DWORD x : 3; };\n";
         ASSERT_EQUALS("struct A { DWORD x ; } ;", tokenizeAndStringify(code5));
 
-        const char code6[] = "struct A { LONG x : 3; };";
+        const char code6[] = "struct A { LONG x : 3; };\n";
         ASSERT_EQUALS("struct A { LONG x ; } ;", tokenizeAndStringify(code6));
 
-        const char code7[] = "struct A { UINT8 x : 3; };";
+        const char code7[] = "struct A { UINT8 x : 3; };\n";
         ASSERT_EQUALS("struct A { UINT8 x ; } ;", tokenizeAndStringify(code7));
 
-        const char code8[] = "struct A { UINT16 x : 3; };";
+        const char code8[] = "struct A { UINT16 x : 3; };\n";
         ASSERT_EQUALS("struct A { UINT16 x ; } ;", tokenizeAndStringify(code8));
 
-        const char code9[] = "struct A { UINT32 x : 3; };";
+        const char code9[] = "struct A { UINT32 x : 3; };\n";
         ASSERT_EQUALS("struct A { UINT32 x ; } ;", tokenizeAndStringify(code9));
 
-        const char code10[] = "struct A { UINT64 x : 3; };";
+        const char code10[] = "struct A { UINT64 x : 3; };\n";
         ASSERT_EQUALS("struct A { UINT64 x ; } ;", tokenizeAndStringify(code10));
     }
 
     void bitfields5() { // ticket #1956
-        const char code1[] = "struct RGB { unsigned int r : 3, g : 3, b : 2; };";
+        const char code1[] = "struct RGB { unsigned int r : 3, g : 3, b : 2; };\n";
         ASSERT_EQUALS("struct RGB { unsigned int r ; unsigned int g ; unsigned int b ; } ;", tokenizeAndStringify(code1));
 
-        const char code2[] = "struct A { int a : 3; int : 3; int c : 3; };";
+        const char code2[] = "struct A { int a : 3; int : 3; int c : 3; };\n";
         ASSERT_EQUALS("struct A { int a ; int anonymous@0 ; int c ; } ;", tokenizeAndStringify(code2));
 
-        const char code3[] = "struct A { virtual void f() {} int f1 : 1; };";
+        const char code3[] = "struct A { virtual void f() {} int f1 : 1; };\n";
         ASSERT_EQUALS("struct A { virtual void f ( ) { } int f1 ; } ;", tokenizeAndStringify(code3));
     }
 
     void bitfields6() { // ticket #2595
-        const char code1[] = "struct A { bool b : true; };";
+        const char code1[] = "struct A { bool b : true; };\n";
         ASSERT_EQUALS("struct A { bool b ; } ;", tokenizeAndStringify(code1));
 
-        const char code2[] = "struct A { bool b : true, c : true; };";
+        const char code2[] = "struct A { bool b : true, c : true; };\n";
         ASSERT_EQUALS("struct A { bool b ; bool c ; } ;", tokenizeAndStringify(code2));
 
-        const char code3[] = "struct A { bool : true; };";
+        const char code3[] = "struct A { bool : true; };\n";
         ASSERT_EQUALS("struct A { bool anonymous@0 ; } ;", tokenizeAndStringify(code3));
     }
 
     void bitfields7() { // ticket #1987
-        const char code[] = "typedef struct Descriptor {"
-                            "    unsigned element_size: 8* sizeof( unsigned );"
-                            "} Descriptor;";
-        const char expected[] = "struct Descriptor { "
-                                "unsigned int element_size ; "
+        const char code[] = "typedef struct Descriptor {\n"
+                            "    unsigned element_size: 8* sizeof( unsigned );\n"
+                            "} Descriptor;\n";
+        const char expected[] = "struct Descriptor {\n"
+                                "unsigned int element_size ;\n"
                                 "} ;";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         ASSERT_EQUALS("", errout_str());
     }
 
     void bitfields8() {
-        const char code[] = "struct A;"
-                            "class B : virtual public C"
-                            "{"
-                            "    int f();"
-                            "};";
-        const char expected[] = "struct A ; "
-                                "class B : virtual public C "
-                                "{ "
-                                "int f ( ) ; "
+        const char code[] = "struct A;\n"
+                            "class B : virtual public C\n"
+                            "{\n"
+                            "    int f();\n"
+                            "};\n";
+        const char expected[] = "struct A ;\n"
+                                "class B : virtual public C\n"
+                                "{\n"
+                                "int f ( ) ;\n"
                                 "} ;";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         ASSERT_EQUALS("", errout_str());
@@ -5120,17 +5190,21 @@ class TestTokenizer : public TestFixture {
                             "    {\n"
                             "        ;\n"
                             "    }\n"
-                            "};";
+                            "};\n";
         (void)tokenizeAndStringify(code);
         ASSERT_EQUALS("", errout_str());
     }
 
     void bitfields10() { // ticket #2737
-        const char code[] = "{}"
-                            "MACRO "
-                            "default: { }"
-                            ";";
-        ASSERT_EQUALS("{ } MACRO default : { } ;", tokenizeAndStringify(code));
+        const char code[] = "{}\n"
+                            "MACRO\n"
+                            "default: { }\n"
+                            ";\n";
+        const char expected[] = "{ }\n"
+                                "MACRO\n"
+                                "default : { }\n"
+                                ";";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     void bitfields12() { // ticket #3485 (segmentation fault)
@@ -5148,13 +5222,13 @@ class TestTokenizer : public TestFixture {
                       "} ;",
                       tokenizeAndStringify("struct AB {\n"
                                            "  enum Foo {A,B} : 4;\n"
-                                           "};"));
+                                           "};\n"));
         ASSERT_EQUALS("struct AB {\n"
                       "enum Foo { A , B } ; enum Foo foo ;\n"
                       "} ;",
                       tokenizeAndStringify("struct AB {\n"
                                            "  enum Foo {A,B} foo : 4;\n"
-                                           "};"));
+                                           "};\n"));
 
         ASSERT_EQUALS("struct S {\n" // #14324
                       "enum E : int { E0 , E1 } ; enum E e ;\n"
@@ -5172,7 +5246,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void bitfields16() {
-        const char code[] = "struct A { unsigned int x : 1; };";
+        const char code[] = "struct A { unsigned int x : 1; };\n";
 
         SimpleTokenizer tokenizer(settingsDefault, *this);
         ASSERT(tokenizer.tokenize(code));
@@ -5207,23 +5281,23 @@ class TestTokenizer : public TestFixture {
     }
 
     void bitfields18() {
-        const char code[] = "struct S { unsigned int a : 100000; };";
+        const char code[] = "struct S { unsigned int a : 100000; };\n";
         (void) tokenizeAndStringify(code);
         ASSERT_EQUALS("[test.cpp:1:29]: (warning) Bit-field size exceeds max number of bits 32767 [tooLargeBitField]\n", errout_str());
     }
 
     void bitfields19() {
-        const char code[] = "struct S { volatile std::uint32_t a : 10; };";
+        const char code[] = "struct S { volatile std::uint32_t a : 10; };\n";
         ASSERT_EQUALS("struct S { volatile std :: uint32_t a ; } ;", tokenizeAndStringify(code));
     }
 
     void bitfields20() {
-        const char code[] = "struct S { volatile ::uint32_t a : 10; };";
+        const char code[] = "struct S { volatile ::uint32_t a : 10; };\n";
         ASSERT_EQUALS("struct S { volatile :: uint32_t a ; } ;", tokenizeAndStringify(code));
     }
 
     void bitfields21() {
-        const char code[] = "struct S { uint32_t a : 1, b : 1; };";
+        const char code[] = "struct S { uint32_t a : 1, b : 1; };\n";
         SimpleTokenizer tokenizer(settingsDefault, *this);
         ASSERT(tokenizer.tokenize(code));
         const Token *a = Token::findsimplematch(tokenizer.tokens(), "a");
@@ -5236,68 +5310,68 @@ class TestTokenizer : public TestFixture {
         const char *expected;
 
         {
-            const char code[] = "map<foo, bar> m;"; // namespace std is not used
+            const char code[] = "map<foo, bar> m;\n"; // namespace std is not used
             ASSERT_EQUALS("map < foo , bar > m ;", tokenizeAndStringify(code));
         }
 
         {
             const char code[] = "using namespace std;\n"
-                                "map<foo, bar> m;";
+                                "map<foo, bar> m;\n";
             ASSERT_EQUALS("std :: map < foo , bar > m ;", tokenizeAndStringify(code));
         }
 
         {
             const char code[] = "using namespace std;\n"
-                                "string s;";
+                                "string s;\n";
             ASSERT_EQUALS("std :: string s ;", tokenizeAndStringify(code));
         }
 
         {
             const char code[] = "using namespace std;\n"
-                                "void foo() {swap(a, b); }";
+                                "void foo() {swap(a, b); }\n";
             ASSERT_EQUALS("void foo ( ) { std :: swap ( a , b ) ; }", tokenizeAndStringify(code));
         }
 
         {
             const char code[] = "using namespace std;\n"
-                                "void search() {}";
+                                "void search() {}\n";
             ASSERT_EQUALS("void search ( ) { }", tokenizeAndStringify(code));
         }
 
         {
             const char code[] = "using namespace std;\n"
                                 "void search();\n"
-                                "void dostuff() { search(); }";
+                                "void dostuff() { search(); }\n";
             ASSERT_EQUALS("void search ( ) ;\nvoid dostuff ( ) { search ( ) ; }", tokenizeAndStringify(code));
         }
 
         {
             const char code[] = "using namespace std;\n"
-                                "void foo() {map(a, b); }"; // That's obviously not std::map<>
+                                "void foo() {map(a, b); }\n"; // That's obviously not std::map<>
             ASSERT_EQUALS("void foo ( ) { map ( a , b ) ; }", tokenizeAndStringify(code));
         }
 
         {
             const char code[] = "using namespace std;\n"
-                                "string<wchar_t> s;"; // That's obviously not std::string
+                                "string<wchar_t> s;\n"; // That's obviously not std::string
             TODO_ASSERT_EQUALS("string < wchar_t > s ;", "std :: string < wchar_t > s ;", tokenizeAndStringify(code));
         }
 
         {
             const char code[] = "using namespace std;\n"
-                                "swap s;"; // That's obviously not std::swap
+                                "swap s;\n"; // That's obviously not std::swap
             ASSERT_EQUALS("swap s ;", tokenizeAndStringify(code));
         }
 
         {
             const char code[] = "using namespace std;\n"
-                                "std::string s;";
+                                "std::string s;\n";
             ASSERT_EQUALS("std :: string s ;", tokenizeAndStringify(code));
         }
 
         { // #4042 (Do not add 'std ::' to variables)
             const char code[] = "using namespace std;\n"
-                                "const char * string = \"Hi\";";
+                                "const char * string = \"Hi\";\n";
             ASSERT_EQUALS("const char * string ; string = \"Hi\" ;", tokenizeAndStringify(code));
         }
 
@@ -5306,11 +5380,11 @@ class TestTokenizer : public TestFixture {
                                 "string f(const char * string) {\n"
                                 "    cout << string << endl;\n"
                                 "    return string;\n"
-                                "}";
+                                "}\n";
             expected = "std :: string f ( const char * string ) {\n"
                        "std :: cout << string << std :: endl ;\n"
                        "return string ;\n"
-                       "}";
+                       "}\n";
             TODO_ASSERT_EQUALS(expected,
                                "std :: string f ( const char * string ) {\n"
                                "cout << string << endl ;\n"
@@ -5327,7 +5401,7 @@ class TestTokenizer : public TestFixture {
                                 "void f() {\n"
                                 "  try { }\n"
                                 "  catch(std::exception &exception) { }\n"
-                                "}";
+                                "}\n";
             expected = "void f ( ) {\n"
                        "try { }\n"
                        "catch ( std :: exception & exception ) { }\n"
@@ -5341,7 +5415,7 @@ class TestTokenizer : public TestFixture {
                                 "    void search() {}\n"
                                 "    void search() const {}\n"
                                 "    void search() THROW_MACRO {}\n"
-                                "};";
+                                "};\n";
             expected = "class C {\n"
                        "void search ( ) { }\n"
                        "void search ( ) const { }\n"
@@ -5353,38 +5427,38 @@ class TestTokenizer : public TestFixture {
         // Ticket #8091
         ASSERT_EQUALS("enum Anonymous0 { string } ;",
                       tokenizeAndStringify("using namespace std; "
-                                           "enum { string };"));
+                                           "enum { string };\n"));
         ASSERT_EQUALS("enum Type { string } ;",
                       tokenizeAndStringify("using namespace std; "
-                                           "enum Type { string } ;"));
+                                           "enum Type { string } ;\n"));
         ASSERT_EQUALS("enum class Type { string } ;",
                       tokenizeAndStringify("using namespace std; "
-                                           "enum class Type { string } ;"));
+                                           "enum class Type { string } ;\n"));
         ASSERT_EQUALS("enum struct Type { string } ;",
                       tokenizeAndStringify("using namespace std; "
-                                           "enum struct Type { string } ;"));
+                                           "enum struct Type { string } ;\n"));
         ASSERT_EQUALS("enum struct Type : int { f = 0 , string } ;",
                       tokenizeAndStringify("using namespace std; "
-                                           "enum struct Type : int { f = 0 , string } ;"));
+                                           "enum struct Type : int { f = 0 , string } ;\n"));
         ASSERT_EQUALS("enum Type { a , b } ; void foo ( enum Type , std :: string ) { }",
                       tokenizeAndStringify("using namespace std; "
-                                           "enum Type { a , b } ; void foo ( enum Type , string) {}"));
+                                           "enum Type { a , b } ; void foo ( enum Type , string) {}\n"));
         ASSERT_EQUALS("struct T { } ; enum struct Type : int { f = 0 , string } ;",
                       tokenizeAndStringify("using namespace std; "
                                            "struct T { typedef int type; } ; "
-                                           "enum struct Type : T :: type { f = 0 , string } ;"));
+                                           "enum struct Type : T :: type { f = 0 , string } ;\n"));
         // Handle garbage enum code "well"
         ASSERT_EQUALS("enum E : int ; void foo ( ) { std :: string s ; }",
-                      tokenizeAndStringify("using namespace std; enum E : int ; void foo ( ) { string s ; }"));
+                      tokenizeAndStringify("using namespace std; enum E : int ; void foo ( ) { string s ; }\n"));
 
-        ASSERT_NO_THROW(tokenizeAndStringify("NS_BEGIN(IMAGEIO_2D_DICOM) using namespace std; NS_END")); // #11045
+        ASSERT_NO_THROW(tokenizeAndStringify("NS_BEGIN(IMAGEIO_2D_DICOM) using namespace std; NS_END\n")); // #11045
 
         {
             const char code[] = "using namespace std;\n"
                                 "void f(const unique_ptr<int>& p) {\n"
                                 "    if (!p)\n"
                                 "        throw runtime_error(\"abc\");\n"
-                                "}";
+                                "}\n";
             expected = "void f ( const std :: unique_ptr < int > & p ) {\n"
                        "if ( ! p ) {\n"
                        "throw std :: runtime_error ( \"abc\" ) ; }\n"
@@ -5425,61 +5499,61 @@ class TestTokenizer : public TestFixture {
     }
 
     void microsoftMemory() {
-        const char code1a[] = "void foo() { int a[10], b[10]; CopyMemory(a, b, sizeof(a)); }";
+        const char code1a[] = "void foo() { int a[10], b[10]; CopyMemory(a, b, sizeof(a)); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memcpy ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code1a,settings2_win32a));
 
-        const char code1b[] = "void foo() { int a[10], b[10]; RtlCopyMemory(a, b, sizeof(a)); }";
+        const char code1b[] = "void foo() { int a[10], b[10]; RtlCopyMemory(a, b, sizeof(a)); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memcpy ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code1b,settings2_win32a));
 
-        const char code1c[] = "void foo() { int a[10], b[10]; RtlCopyBytes(a, b, sizeof(a)); }";
+        const char code1c[] = "void foo() { int a[10], b[10]; RtlCopyBytes(a, b, sizeof(a)); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memcpy ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code1c,settings2_win32a));
 
-        const char code2a[] = "void foo() { int a[10]; FillMemory(a, sizeof(a), 255); }";
+        const char code2a[] = "void foo() { int a[10]; FillMemory(a, sizeof(a), 255); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 255 , sizeof ( a ) ) ; }", tokenizeAndStringify(code2a,settings2_win32a));
-        const char code2b[] = "void foo() { int a[10]; RtlFillMemory(a, sizeof(a), 255); }";
+        const char code2b[] = "void foo() { int a[10]; RtlFillMemory(a, sizeof(a), 255); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 255 , sizeof ( a ) ) ; }", tokenizeAndStringify(code2b,settings2_win32a));
-        const char code2c[] = "void foo() { int a[10]; RtlFillBytes(a, sizeof(a), 255); }";
+        const char code2c[] = "void foo() { int a[10]; RtlFillBytes(a, sizeof(a), 255); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 255 , sizeof ( a ) ) ; }", tokenizeAndStringify(code2c,settings2_win32a));
 
-        const char code3a[] = "void foo() { int a[10], b[10]; MoveMemory(a, b, sizeof(a)); }";
+        const char code3a[] = "void foo() { int a[10], b[10]; MoveMemory(a, b, sizeof(a)); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memmove ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code3a,settings2_win32a));
-        const char code3b[] = "void foo() { int a[10], b[10]; RtlMoveMemory(a, b, sizeof(a)); }";
+        const char code3b[] = "void foo() { int a[10], b[10]; RtlMoveMemory(a, b, sizeof(a)); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memmove ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code3b,settings2_win32a));
 
-        const char code4a[] = "void foo() { int a[10]; ZeroMemory(a, sizeof(a)); }";
+        const char code4a[] = "void foo() { int a[10]; ZeroMemory(a, sizeof(a)); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 0 , sizeof ( a ) ) ; }", tokenizeAndStringify(code4a,settings2_win32a));
-        const char code4b[] = "void foo() { int a[10]; RtlZeroMemory(a, sizeof(a)); }";
+        const char code4b[] = "void foo() { int a[10]; RtlZeroMemory(a, sizeof(a)); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 0 , sizeof ( a ) ) ; }", tokenizeAndStringify(code4b,settings2_win32a));
-        const char code4c[] = "void foo() { int a[10]; RtlZeroBytes(a, sizeof(a)); }";
+        const char code4c[] = "void foo() { int a[10]; RtlZeroBytes(a, sizeof(a)); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 0 , sizeof ( a ) ) ; }", tokenizeAndStringify(code4c,settings2_win32a));
-        const char code4d[] = "void foo() { int a[10]; RtlSecureZeroMemory(a, sizeof(a)); }";
+        const char code4d[] = "void foo() { int a[10]; RtlSecureZeroMemory(a, sizeof(a)); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 0 , sizeof ( a ) ) ; }", tokenizeAndStringify(code4d,settings2_win32a));
 
-        const char code5[] = "void foo() { int a[10], b[10]; RtlCompareMemory(a, b, sizeof(a)); }";
+        const char code5[] = "void foo() { int a[10], b[10]; RtlCompareMemory(a, b, sizeof(a)); }\n";
         ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memcmp ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code5,settings2_win32a));
 
-        const char code6[] = "void foo() { ZeroMemory(f(1, g(a, b)), h(i, j(0, 1))); }";
+        const char code6[] = "void foo() { ZeroMemory(f(1, g(a, b)), h(i, j(0, 1))); }\n";
         ASSERT_EQUALS("void foo ( ) { memset ( f ( 1 , g ( a , b ) ) , 0 , h ( i , j ( 0 , 1 ) ) ) ; }", tokenizeAndStringify(code6,settings2_win32a));
 
-        const char code7[] = "void foo() { FillMemory(f(1, g(a, b)), h(i, j(0, 1)), 255); }";
+        const char code7[] = "void foo() { FillMemory(f(1, g(a, b)), h(i, j(0, 1)), 255); }\n";
         ASSERT_EQUALS("void foo ( ) { memset ( f ( 1 , g ( a , b ) ) , 255 , h ( i , j ( 0 , 1 ) ) ) ; }", tokenizeAndStringify(code7,settings2_win32a));
     }
 
     void microsoftString() {
-        const char code1a[] = "void foo() { _tprintf (_T(\"test\") _T(\"1\")); }";
+        const char code1a[] = "void foo() { _tprintf (_T(\"test\") _T(\"1\")); }\n";
         ASSERT_EQUALS("void foo ( ) { printf ( \"test1\" ) ; }", tokenizeAndStringify(code1a, settings2_win32a));
-        const char code1b[] = "void foo() { _tprintf (_TEXT(\"test\") _TEXT(\"2\")); }";
+        const char code1b[] = "void foo() { _tprintf (_TEXT(\"test\") _TEXT(\"2\")); }\n";
         ASSERT_EQUALS("void foo ( ) { printf ( \"test2\" ) ; }", tokenizeAndStringify(code1b, settings2_win32a));
-        const char code1c[] = "void foo() { _tprintf (TEXT(\"test\") TEXT(\"3\")); }";
+        const char code1c[] = "void foo() { _tprintf (TEXT(\"test\") TEXT(\"3\")); }\n";
         ASSERT_EQUALS("void foo ( ) { printf ( \"test3\" ) ; }", tokenizeAndStringify(code1c, settings2_win32a));
 
-        const char code2a[] = "void foo() { _tprintf (_T(\"test\") _T(\"1\")); }";
+        const char code2a[] = "void foo() { _tprintf (_T(\"test\") _T(\"1\")); }\n";
         ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test1\" ) ; }", tokenizeAndStringify(code2a, settings2_win32w));
         ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test1\" ) ; }", tokenizeAndStringify(code2a, settings2_win64));
-        const char code2b[] = "void foo() { _tprintf (_TEXT(\"test\") _TEXT(\"2\")); }";
+        const char code2b[] = "void foo() { _tprintf (_TEXT(\"test\") _TEXT(\"2\")); }\n";
         ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test2\" ) ; }", tokenizeAndStringify(code2b, settings2_win32w));
         ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test2\" ) ; }", tokenizeAndStringify(code2b, settings2_win64));
-        const char code2c[] = "void foo() { _tprintf (TEXT(\"test\") TEXT(\"3\")); }";
+        const char code2c[] = "void foo() { _tprintf (TEXT(\"test\") TEXT(\"3\")); }\n";
         ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test3\" ) ; }", tokenizeAndStringify(code2c, settings2_win32w));
         ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test3\" ) ; }", tokenizeAndStringify(code2c, settings2_win64));
     }
@@ -5487,69 +5561,69 @@ class TestTokenizer : public TestFixture {
     void borland() {
         // __closure
         ASSERT_EQUALS("int ( * a ) ( ) ;",  // TODO VarId
-                      tokenizeAndStringify("int (__closure *a)();", settings2_win32a));
+                      tokenizeAndStringify("int (__closure *a)();\n", settings2_win32a));
 
         // __property
         ASSERT_EQUALS("class Fred { ; __property ; } ;",
-                      tokenizeAndStringify("class Fred { __property int x = { } };", settings2_win32a));
+                      tokenizeAndStringify("class Fred { __property int x = { } };\n", settings2_win32a));
     }
 
     void simplifySQL() {
         // Oracle PRO*C extensions for inline SQL. Just replace the SQL with "asm()" to fix wrong error messages
         // ticket: #1959
-        ASSERT_EQUALS("asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL SELECT A FROM B\"\" ) ;", tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL SELECT A FROM B;"));
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL"), SYNTAX);
+        ASSERT_EQUALS("asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL SELECT A FROM B\"\" ) ;", tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL SELECT A FROM B;\n"));
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL\n"), SYNTAX);
 
         ASSERT_EQUALS("asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL EXECUTE BEGIN Proc1 ( A ) ; END ; END - __CPPCHECK_EMBEDDED_SQL_EXEC__\"\" ) ; asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT\"\" ) ;",
-                      tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL EXECUTE BEGIN Proc1(A); END; END-__CPPCHECK_EMBEDDED_SQL_EXEC__; __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT;"));
+                      tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL EXECUTE BEGIN Proc1(A); END; END-__CPPCHECK_EMBEDDED_SQL_EXEC__; __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT;\n"));
         ASSERT_EQUALS("asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL UPDATE A SET B = C\"\" ) ; asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT\"\" ) ;",
-                      tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL UPDATE A SET B = C; __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT;"));
+                      tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL UPDATE A SET B = C; __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT;\n"));
         ASSERT_EQUALS("asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT\"\" ) ; asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL EXECUTE BEGIN Proc1 ( A ) ; END ; END - __CPPCHECK_EMBEDDED_SQL_EXEC__\"\" ) ;",
-                      tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT; __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL EXECUTE BEGIN Proc1(A); END; END-__CPPCHECK_EMBEDDED_SQL_EXEC__;"));
+                      tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT; __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL EXECUTE BEGIN Proc1(A); END; END-__CPPCHECK_EMBEDDED_SQL_EXEC__;\n"));
 
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("int f(){ __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL } int a;"), SYNTAX);
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL int f(){"), SYNTAX);
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL END-__CPPCHECK_EMBEDDED_SQL_EXEC__ int a;"), SYNTAX);
-        ASSERT_NO_THROW(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL UPDATE A SET B = :&b->b1, C = :c::c1;"));
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("int f(){ __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL } int a;\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL int f(){\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL END-__CPPCHECK_EMBEDDED_SQL_EXEC__ int a;\n"), SYNTAX);
+        ASSERT_NO_THROW(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL UPDATE A SET B = :&b->b1, C = :c::c1;\n"));
     }
 
     void simplifyCAlternativeTokens() {
-        ASSERT_EQUALS("void or ( ) ;", tokenizeAndStringify("void or(void);", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( a && b ) { ; } }", tokenizeAndStringify("void f() { if (a and b); }", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( a && b ) { ; } }", tokenizeAndStringify("void f() { if (a and b); }"));
-        ASSERT_EQUALS("void f ( ) { if ( a || b ) { ; } }", tokenizeAndStringify("void f() { if (a or b); }", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( a || b ) { ; } }", tokenizeAndStringify("void f() { if (a or b); }"));
-        ASSERT_EQUALS("void f ( ) { if ( a & b ) { ; } }", tokenizeAndStringify("void f() { if (a bitand b); }", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( a & b ) { ; } }", tokenizeAndStringify("void f() { if (a bitand b); }"));
-        ASSERT_EQUALS("void f ( ) { if ( a | b ) { ; } }", tokenizeAndStringify("void f() { if (a bitor b); }", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( a | b ) { ; } }", tokenizeAndStringify("void f() { if (a bitor b); }"));
-        ASSERT_EQUALS("void f ( ) { if ( a ^ b ) { ; } }", tokenizeAndStringify("void f() { if (a xor b); }", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( a ^ b ) { ; } }", tokenizeAndStringify("void f() { if (a xor b); }"));
-        ASSERT_EQUALS("void f ( ) { if ( ~ b ) { ; } }", tokenizeAndStringify("void f() { if (compl b); }", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( ~ b ) { ; } }", tokenizeAndStringify("void f() { if (compl b); }"));
-        ASSERT_EQUALS("void f ( ) { if ( ! b ) { ; } }", tokenizeAndStringify("void f() { if (not b); }", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( ! b ) { ; } }", tokenizeAndStringify("void f() { if (not b); }"));
-        ASSERT_EQUALS("void f ( ) const { if ( ! b ) { ; } }", tokenizeAndStringify("void f() const { if (not b); }"));
-        ASSERT_EQUALS("void f ( ) { if ( a != b ) { ; } }", tokenizeAndStringify("void f() { if (a not_eq b); }", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( a != b ) { ; } }", tokenizeAndStringify("void f() { if (a not_eq b); }"));
+        ASSERT_EQUALS("void or ( ) ;", tokenizeAndStringify("void or(void);\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a && b ) { ; } }", tokenizeAndStringify("void f() { if (a and b); }\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a && b ) { ; } }", tokenizeAndStringify("void f() { if (a and b); }\n"));
+        ASSERT_EQUALS("void f ( ) { if ( a || b ) { ; } }", tokenizeAndStringify("void f() { if (a or b); }\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a || b ) { ; } }", tokenizeAndStringify("void f() { if (a or b); }\n"));
+        ASSERT_EQUALS("void f ( ) { if ( a & b ) { ; } }", tokenizeAndStringify("void f() { if (a bitand b); }\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a & b ) { ; } }", tokenizeAndStringify("void f() { if (a bitand b); }\n"));
+        ASSERT_EQUALS("void f ( ) { if ( a | b ) { ; } }", tokenizeAndStringify("void f() { if (a bitor b); }\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a | b ) { ; } }", tokenizeAndStringify("void f() { if (a bitor b); }\n"));
+        ASSERT_EQUALS("void f ( ) { if ( a ^ b ) { ; } }", tokenizeAndStringify("void f() { if (a xor b); }\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a ^ b ) { ; } }", tokenizeAndStringify("void f() { if (a xor b); }\n"));
+        ASSERT_EQUALS("void f ( ) { if ( ~ b ) { ; } }", tokenizeAndStringify("void f() { if (compl b); }\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( ~ b ) { ; } }", tokenizeAndStringify("void f() { if (compl b); }\n"));
+        ASSERT_EQUALS("void f ( ) { if ( ! b ) { ; } }", tokenizeAndStringify("void f() { if (not b); }\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( ! b ) { ; } }", tokenizeAndStringify("void f() { if (not b); }\n"));
+        ASSERT_EQUALS("void f ( ) const { if ( ! b ) { ; } }", tokenizeAndStringify("void f() const { if (not b); }\n"));
+        ASSERT_EQUALS("void f ( ) { if ( a != b ) { ; } }", tokenizeAndStringify("void f() { if (a not_eq b); }\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a != b ) { ; } }", tokenizeAndStringify("void f() { if (a not_eq b); }\n"));
         // #6201
-        ASSERT_EQUALS("void f ( ) { if ( ! c || ! memcmp ( a , b , s ) ) { ; } }", tokenizeAndStringify("void f() { if (!c or !memcmp(a, b, s)); }", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( ! c || ! memcmp ( a , b , s ) ) { ; } }", tokenizeAndStringify("void f() { if (!c or !memcmp(a, b, s)); }"));
+        ASSERT_EQUALS("void f ( ) { if ( ! c || ! memcmp ( a , b , s ) ) { ; } }", tokenizeAndStringify("void f() { if (!c or !memcmp(a, b, s)); }\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( ! c || ! memcmp ( a , b , s ) ) { ; } }", tokenizeAndStringify("void f() { if (!c or !memcmp(a, b, s)); }\n"));
         // #6029
-        ASSERT_EQUALS("void f ( ) { if ( ! b ) { } }", tokenizeAndStringify("void f() { if (not b){} }", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( ! b ) { } }", tokenizeAndStringify("void f() { if (not b){} }"));
+        ASSERT_EQUALS("void f ( ) { if ( ! b ) { } }", tokenizeAndStringify("void f() { if (not b){} }\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( ! b ) { } }", tokenizeAndStringify("void f() { if (not b){} }\n"));
         // #6207
-        ASSERT_EQUALS("void f ( ) { if ( not = x ) { } }", tokenizeAndStringify("void f() { if (not=x){} }", dinit(TokenizeOptions, $.cpp = false)));
-        ASSERT_EQUALS("void f ( ) { if ( not = x ) { } }", tokenizeAndStringify("void f() { if (not=x){} }"));
+        ASSERT_EQUALS("void f ( ) { if ( not = x ) { } }", tokenizeAndStringify("void f() { if (not=x){} }\n", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( not = x ) { } }", tokenizeAndStringify("void f() { if (not=x){} }\n"));
         // #8029
-        ASSERT_EQUALS("void f ( struct S * s ) { x = s . and + 1 ; }", tokenizeAndStringify("void f(struct S *s) { x = s->and + 1; }", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( struct S * s ) { x = s . and + 1 ; }", tokenizeAndStringify("void f(struct S *s) { x = s->and + 1; }\n", dinit(TokenizeOptions, $.cpp = false)));
         // #8745
-        ASSERT_EQUALS("void f ( ) { if ( x ) { or = 0 ; } }", tokenizeAndStringify("void f() { if (x) or = 0; }"));
+        ASSERT_EQUALS("void f ( ) { if ( x ) { or = 0 ; } }", tokenizeAndStringify("void f() { if (x) or = 0; }\n"));
         // #9324
         ASSERT_EQUALS("void f ( const char * str ) { while ( * str == '!' || * str == '[' ) { } }",
-                      tokenizeAndStringify("void f(const char *str) { while (*str=='!' or *str=='['){} }"));
+                      tokenizeAndStringify("void f(const char *str) { while (*str=='!' or *str=='['){} }\n"));
         // #9920
-        ASSERT_EQUALS("result = ch != s . end ( ) && * ch == ':' ;", tokenizeAndStringify("result = ch != s.end() and *ch == ':';", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("result = ch != s . end ( ) && * ch == ':' ;", tokenizeAndStringify("result = ch != s.end() and *ch == ':';\n", dinit(TokenizeOptions, $.cpp = false)));
 
         // #8975
         ASSERT_EQUALS("void foo ( ) {\n"
@@ -5560,15 +5634,15 @@ class TestTokenizer : public TestFixture {
                           "void foo() {\n"
                           "  char *or;\n"
                           "  while ((*or != 0) && (*or != '|')) or++;\n"
-                          "}", dinit(TokenizeOptions, $.cpp = false)));
+                          "}\n", dinit(TokenizeOptions, $.cpp = false)));
         // #10013
-        ASSERT_EQUALS("void f ( ) { x = ! 123 ; }", tokenizeAndStringify("void f() { x = not 123; }"));
+        ASSERT_EQUALS("void f ( ) { x = ! 123 ; }", tokenizeAndStringify("void f() { x = not 123; }\n"));
 
         { // #12476
             const char code[] = "struct S { int a, b; };"
                                 "void f(struct S* compl) {"
                                 "    compl->a = compl->b;"
-                                "}";
+                                "}\n";
             const char exp[] = "struct S { int a ; int b ; } ; void f ( struct S * compl ) { compl . a = compl . b ; }";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
@@ -5576,13 +5650,13 @@ class TestTokenizer : public TestFixture {
         { // not used as parameter name in C
             const char code[] = "static void foo(int not, int test) {"
                                 "    test = not;"
-                                "}";
+                                "}\n";
             const char exp[] = "static void foo ( int not , int test ) { test = not ; }";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
 
         { // binary alt token as last parameter in C
-            const char code[] = "void f(int or) { if (or) {} }";
+            const char code[] = "void f(int or) { if (or) {} }\n";
             const char exp[] = "void f ( int or ) { if ( or ) { } }";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
@@ -5592,41 +5666,41 @@ class TestTokenizer : public TestFixture {
     }
 
     void simplifyCompoundStatements() {
-        ASSERT_EQUALS("; x = 123 ;", tokenizeAndStringify(";x=({123;});"));
-        ASSERT_EQUALS("; x = y ;", tokenizeAndStringify(";x=({y;});"));
+        ASSERT_EQUALS("; x = 123 ;", tokenizeAndStringify(";x=({123;});\n"));
+        ASSERT_EQUALS("; x = y ;", tokenizeAndStringify(";x=({y;});\n"));
         // #13419: Do not simplify compound statements in for loop
         ASSERT_EQUALS("void foo ( int x ) { for ( ; ( { { } ; x < 1 ; } ) ; ) { ; } }",
-                      tokenizeAndStringify("void foo(int x) { for (;({ {}; x<1; });); }"));
+                      tokenizeAndStringify("void foo(int x) { for (;({ {}; x<1; });); }\n"));
     }
 
     void simplifyOperatorName1() {
         // make sure C code doesn't get changed
-        const char code[] = "void operator () {}"
-                            "int main()"
-                            "{"
-                            "    operator();"
-                            "}";
-
-        const char result[] = "void operator ( ) { } "
-                              "int main ( ) "
-                              "{ "
-                              "operator ( ) ; "
+        const char code[] = "void operator () {}\n"
+                            "int main()\n"
+                            "{\n"
+                            "    operator();\n"
+                            "}\n";
+
+        const char result[] = "void operator ( ) { }\n"
+                              "int main ( )\n"
+                              "{\n"
+                              "operator ( ) ;\n"
                               "}";
 
         ASSERT_EQUALS(result, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void simplifyOperatorName2() {
-        const char code[] = "class Fred"
-                            "{"
-                            "    Fred(const Fred & f) { operator = (f); }"
-                            "    operator = ();"
-                            "}";
-
-        const char result[] = "class Fred "
-                              "{ "
-                              "Fred ( const Fred & f ) { operator= ( f ) ; } "
-                              "operator= ( ) ; "
+        const char code[] = "class Fred\n"
+                            "{\n"
+                            "    Fred(const Fred & f) { operator = (f); }\n"
+                            "    operator = ();\n"
+                            "}\n";
+
+        const char result[] = "class Fred\n"
+                              "{\n"
+                              "Fred ( const Fred & f ) { operator= ( f ) ; }\n"
+                              "operator= ( ) ;\n"
                               "}";
 
         ASSERT_EQUALS(result, tokenizeAndStringify(code));
@@ -5634,165 +5708,174 @@ class TestTokenizer : public TestFixture {
 
     void simplifyOperatorName3() {
         // #2615
-        const char code[] = "void f() {"
-                            "static_cast<ScToken*>(xResult.operator->())->GetMatrix();"
-                            "}";
-        const char result[] = "void f ( ) { static_cast < ScToken * > ( xResult . operator-> ( ) ) . GetMatrix ( ) ; }";
+        const char code[] = "void f() {\n"
+                            "static_cast<ScToken*>(xResult.operator->())->GetMatrix();\n"
+                            "}\n";
+        const char result[] = "void f ( ) {\n"
+                              "static_cast < ScToken * > ( xResult . operator-> ( ) ) . GetMatrix ( ) ;\n"
+                              "}";
         ASSERT_EQUALS(result, tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName4() {
-        const char code[] = "void operator==() { }";
+        const char code[] = "void operator==() { }\n";
         const char result[] = "void operator== ( ) { }";
         ASSERT_EQUALS(result, tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName5() {
-        const char code1[] = "std::istream & operator >> (std::istream & s, Fred &f);";
+        const char code1[] = "std::istream & operator >> (std::istream & s, Fred &f);\n";
         const char result1[] = "std :: istream & operator>> ( std :: istream & s , Fred & f ) ;";
         ASSERT_EQUALS(result1, tokenizeAndStringify(code1));
 
-        const char code2[] = "std::ostream & operator << (std::ostream & s, const Fred &f);";
+        const char code2[] = "std::ostream & operator << (std::ostream & s, const Fred &f);\n";
         const char result2[] = "std :: ostream & operator<< ( std :: ostream & s , const Fred & f ) ;";
         ASSERT_EQUALS(result2, tokenizeAndStringify(code2));
     }
 
     void simplifyOperatorName6() { // ticket #3195
-        const char code1[] = "value_type * operator ++ (int);";
+        const char code1[] = "value_type * operator ++ (int);\n";
         const char result1[] = "value_type * operator++ ( int ) ;";
         ASSERT_EQUALS(result1, tokenizeAndStringify(code1));
 
-        const char code2[] = "value_type * operator -- (int);";
+        const char code2[] = "value_type * operator -- (int);\n";
         const char result2[] = "value_type * operator-- ( int ) ;";
         ASSERT_EQUALS(result2, tokenizeAndStringify(code2));
     }
 
     void simplifyOperatorName7() { // ticket #4619
-        const char code1[] = "value_type * operator += (int);";
+        const char code1[] = "value_type * operator += (int);\n";
         const char result1[] = "value_type * operator+= ( int ) ;";
         ASSERT_EQUALS(result1, tokenizeAndStringify(code1));
     }
 
     void simplifyOperatorName8() { // ticket #5706
-        const char code1[] = "value_type * operator += (int) noexcept ;";
+        const char code1[] = "value_type * operator += (int) noexcept ;\n";
         const char result1[] = "value_type * operator+= ( int ) noexcept ( true ) ;";
         ASSERT_EQUALS(result1, tokenizeAndStringify(code1));
 
-        const char code2[] = "value_type * operator += (int) noexcept ( true ) ;";
+        const char code2[] = "value_type * operator += (int) noexcept ( true ) ;\n";
         const char result2[] = "value_type * operator+= ( int ) noexcept ( true ) ;";
         ASSERT_EQUALS(result2, tokenizeAndStringify(code2));
 
-        const char code3[] = "value_type * operator += (int) throw ( ) ;";
+        const char code3[] = "value_type * operator += (int) throw ( ) ;\n";
         const char result3[] = "value_type * operator+= ( int ) throw ( ) ;";
         ASSERT_EQUALS(result3, tokenizeAndStringify(code3));
 
-        const char code4[] = "value_type * operator += (int) const noexcept ;";
+        const char code4[] = "value_type * operator += (int) const noexcept ;\n";
         const char result4[] = "value_type * operator+= ( int ) const noexcept ( true ) ;";
         ASSERT_EQUALS(result4, tokenizeAndStringify(code4));
 
-        const char code5[] = "value_type * operator += (int) const noexcept ( true ) ;";
+        const char code5[] = "value_type * operator += (int) const noexcept ( true ) ;\n";
         const char result5[] = "value_type * operator+= ( int ) const noexcept ( true ) ;";
         ASSERT_EQUALS(result5, tokenizeAndStringify(code5));
 
-        const char code6[] = "value_type * operator += (int) const throw ( ) ;";
+        const char code6[] = "value_type * operator += (int) const throw ( ) ;\n";
         const char result6[] = "value_type * operator+= ( int ) const throw ( ) ;";
         ASSERT_EQUALS(result6, tokenizeAndStringify(code6));
 
-        const char code7[] = "value_type * operator += (int) const noexcept ( false ) ;";
+        const char code7[] = "value_type * operator += (int) const noexcept ( false ) ;\n";
         const char result7[] = "value_type * operator+= ( int ) const noexcept ( false ) ;";
         ASSERT_EQUALS(result7, tokenizeAndStringify(code7));
 
     }
 
     void simplifyOperatorName9() { // Ticket #5709
-        const char code[] = "struct R { R operator, ( R b ) ; } ;";
-        ASSERT_EQUALS(code, tokenizeAndStringify(code));
+        const char code[] = "struct R { R operator,(R b); };\n";
+        const char expected[] = "struct R { R operator, ( R b ) ; } ;";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName10() { // #8746
-        const char code1[] = "using a::operator=;";
+        const char code1[] = "using a::operator=;\n";
         ASSERT_EQUALS("using a :: operator= ;", tokenizeAndStringify(code1));
 
-        const char code2[] = "{ return &Fred::operator!=; }";
+        const char code2[] = "{ return &Fred::operator!=; }\n";
         ASSERT_EQUALS("{ return & Fred :: operator!= ; }", tokenizeAndStringify(code2));
     }
 
     void simplifyOperatorName11() { // #8889
-        const char code[] = "auto operator = (const Fred & other) -> Fred & ;";
+        const char code[] = "auto operator = (const Fred & other) -> Fred & ;\n";
         ASSERT_EQUALS("auto operator= ( const Fred & other ) . Fred & ;", tokenizeAndStringify(code));
         ASSERT_EQUALS("[test.cpp:1:1]: (debug) auto token with no type. [autoNoType]\n", errout_str());
 
-        const char code1[] = "auto operator = (const Fred & other) -> Fred & { }";
+        const char code1[] = "auto operator = (const Fred & other) -> Fred & { }\n";
         ASSERT_EQUALS("auto operator= ( const Fred & other ) . Fred & { }", tokenizeAndStringify(code1));
         ASSERT_EQUALS("[test.cpp:1:1]: (debug) auto token with no type. [autoNoType]\n", errout_str());
 
-        const char code2[] = "template <typename T> void g(S<&T::operator+ >) {}";
+        const char code2[] = "template <typename T> void g(S<&T::operator+ >) {}\n";
         ASSERT_EQUALS("template < typename T > void g ( S < & T :: operator+ > ) { }", tokenizeAndStringify(code2));
         ASSERT_EQUALS("", errout_str());
 
-        const char code3[] = "template <typename T> void g(S<&T::operator int>) {}";
+        const char code3[] = "template <typename T> void g(S<&T::operator int>) {}\n";
         ASSERT_EQUALS("template < typename T > void g ( S < & T :: operatorint > ) { }", tokenizeAndStringify(code3));
         ASSERT_EQUALS("", errout_str());
 
-        const char code4[] = "template <typename T> void g(S<&T::template operator- <double> >) {}";
+        const char code4[] = "template <typename T> void g(S<&T::template operator- <double> >) {}\n";
         ASSERT_EQUALS("template < typename T > void g ( S < & T :: operator- < double > > ) { }", tokenizeAndStringify(code4));
         ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyOperatorName12() { // #9110
-        const char code[] = "namespace a {"
-                            "template <typename b> void operator+(b);"
-                            "}"
-                            "using a::operator+;";
-        ASSERT_EQUALS("namespace a { "
-                      "template < typename b > void operator+ ( b ) ; "
-                      "} "
+        const char code[] = "namespace a {\n"
+                            "template <typename b> void operator+(b);\n"
+                            "}\n"
+                            "using a::operator+;\n";
+        ASSERT_EQUALS("namespace a {\n"
+                      "template < typename b > void operator+ ( b ) ;\n"
+                      "}\n"
                       "using a :: operator+ ;",
                       tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName13() { // user defined literal
-        const char code[] = "unsigned long operator\"\"_numch(const char *ch, unsigned long size);";
+        const char code[] = "unsigned long operator\"\"_numch(const char *ch, unsigned long size);\n";
         ASSERT_EQUALS("unsigned long operator\"\"_numch ( const char * ch , unsigned long size ) ;",
                       tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName14() { // std::complex operator "" if
         {
-            const char code[] = "constexpr std::complex<float> operator\"\"if(long double __num);";
+            const char code[] = "constexpr std::complex<float> operator\"\"if(long double __num);\n";
             ASSERT_EQUALS("constexpr std :: complex < float > operator\"\"if ( long double __num ) ;",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "constexpr std::complex<float> operator\"\"if(long double __num) { }";
+            const char code[] = "constexpr std::complex<float> operator\"\"if(long double __num) { }\n";
             ASSERT_EQUALS("constexpr std :: complex < float > operator\"\"if ( long double __num ) { }",
                           tokenizeAndStringify(code));
         }
     }
 
     void simplifyOperatorName15() { // ticket #9468 syntaxError
-        const char code[] = "template <typename> struct a;"
-                            "template <typename> struct b {"
-                            "  typedef char c;"
-                            "  operator c();"
-                            "};"
-                            "template <> struct a<char> : b<char> { using b::operator char; };";
-        ASSERT_EQUALS("struct a<char> ; template < typename > struct a ; "
-                      "struct b<char> ; "
-                      "struct a<char> : b<char> { using b :: operatorchar ; } ; struct b<char> { "
-                      "operatorchar ( ) ; "
+        const char code[] = "template <typename> struct a;\n"
+                            "template <typename> struct b {\n"
+                            "  typedef char c;\n"
+                            "  operator c();\n"
+                            "};\n"
+                            "template <> struct a<char> : b<char> { using b::operator char; };\n";
+        ASSERT_EQUALS("struct a<char> ;\n"
+                      "template < typename > struct a ;\n"
+                      "struct b<char> ;\n"
+                      "\n"
+                      "\n"
+                      "\n"
+                      "struct a<char> : b<char> { using b :: operatorchar ; } ;\n"
+                      "struct b<char> {\n"
+                      "\n"
+                      "operatorchar ( ) ;\n"
                       "} ;",
                       tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName16() { // ticket #9472
         {
-            const char code[] = "class I : public A { iterator& operator++() override; };";
+            const char code[] = "class I : public A { iterator& operator++() override; };\n";
             ASSERT_EQUALS("class I : public A { iterator & operator++ ( ) override ; } ;",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "class I : public A { iterator& operator++() override { } };";
+            const char code[] = "class I : public A { iterator& operator++() override { } };\n";
             ASSERT_EQUALS("class I : public A { iterator & operator++ ( ) override { } } ;",
                           tokenizeAndStringify(code));
         }
@@ -5800,32 +5883,32 @@ class TestTokenizer : public TestFixture {
 
     void simplifyOperatorName17() {
         {
-            const char code[] = "template <class a> void b(a c, a d) { c.operator>() == d; }";
+            const char code[] = "template <class a> void b(a c, a d) { c.operator>() == d; }\n";
             ASSERT_EQUALS("template < class a > void b ( a c , a d ) { c . operator> ( ) == d ; }",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "template <class a> void b(a c, a d) { c.operator>() == (d + 1); }";
+            const char code[] = "template <class a> void b(a c, a d) { c.operator>() == (d + 1); }\n";
             ASSERT_EQUALS("template < class a > void b ( a c , a d ) { c . operator> ( ) == ( d + 1 ) ; }",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "template <class a> void b(a c, a d) { c.operator<() == d; }";
+            const char code[] = "template <class a> void b(a c, a d) { c.operator<() == d; }\n";
             ASSERT_EQUALS("template < class a > void b ( a c , a d ) { c . operator< ( ) == d ; }",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "template <class a> void b(a c, a d) { c.operator>() == (d + 1); }";
+            const char code[] = "template <class a> void b(a c, a d) { c.operator>() == (d + 1); }\n";
             ASSERT_EQUALS("template < class a > void b ( a c , a d ) { c . operator> ( ) == ( d + 1 ) ; }",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "template <class a> void b(a c, a d) { c.operator++() == d; }";
+            const char code[] = "template <class a> void b(a c, a d) { c.operator++() == d; }\n";
             ASSERT_EQUALS("template < class a > void b ( a c , a d ) { c . operator++ ( ) == d ; }",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "template <class a> void b(a c, a d) { c.operator++() == (d + 1); }";
+            const char code[] = "template <class a> void b(a c, a d) { c.operator++() == (d + 1); }\n";
             ASSERT_EQUALS("template < class a > void b ( a c , a d ) { c . operator++ ( ) == ( d + 1 ) ; }",
                           tokenizeAndStringify(code));
         }
@@ -5833,102 +5916,102 @@ class TestTokenizer : public TestFixture {
 
     void simplifyOperatorName18() { // global namespace
         {
-            const char code[] = "struct Fred { operator std::string() const { return std::string(\"Fred\"); } };";
+            const char code[] = "struct Fred { operator std::string() const { return std::string(\"Fred\"); } };\n";
             ASSERT_EQUALS("struct Fred { operatorstd::string ( ) const { return std :: string ( \"Fred\" ) ; } } ;",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "struct Fred { operator ::std::string() const { return ::std::string(\"Fred\"); } };";
+            const char code[] = "struct Fred { operator ::std::string() const { return ::std::string(\"Fred\"); } };\n";
             ASSERT_EQUALS("struct Fred { operator::std::string ( ) const { return :: std :: string ( \"Fred\" ) ; } } ;",
                           tokenizeAndStringify(code));
         }
     }
 
     void simplifyOperatorName19() {
-        const char code[] = "struct v {};"
-                            "enum E { e };"
-                            "struct s {"
-                            "  operator struct v() { return v(); };"
-                            "  operator enum E() { return e; }"
-                            "};"
-                            "void f() {"
-                            "  (void)&s::operator struct v;"
-                            "  (void)&s::operator enum E;"
-                            "}";
-        ASSERT_EQUALS("struct v { } ; "
-                      "enum E { e } ; "
-                      "struct s { "
-                      "operatorstructv ( ) { return v ( ) ; } ; "
-                      "operatorenumE ( ) { return e ; } "
-                      "} ; "
-                      "void f ( ) { "
-                      "( void ) & s :: operatorstructv ; "
-                      "( void ) & s :: operatorenumE ; "
+        const char code[] = "struct v {};\n"
+                            "enum E { e };\n"
+                            "struct s {\n"
+                            "  operator struct v() { return v(); };\n"
+                            "  operator enum E() { return e; }\n"
+                            "};\n"
+                            "void f() {\n"
+                            "  (void)&s::operator struct v;\n"
+                            "  (void)&s::operator enum E;\n"
+                            "}\n";
+        ASSERT_EQUALS("struct v { } ;\n"
+                      "enum E { e } ;\n"
+                      "struct s {\n"
+                      "operatorstructv ( ) { return v ( ) ; } ;\n"
+                      "operatorenumE ( ) { return e ; }\n"
+                      "} ;\n"
+                      "void f ( ) {\n"
+                      "( void ) & s :: operatorstructv ;\n"
+                      "( void ) & s :: operatorenumE ;\n"
                       "}",
                       tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName20() {
-        const char code[] = "void operator \"\" _a(const char *);"
-                            "namespace N {"
-                            "  using ::operator \"\" _a;"
-                            "  void operator \"\" _b(const char *);"
-                            "}";
-        ASSERT_EQUALS("void operator\"\"_a ( const char * ) ; "
-                      "namespace N { "
-                      "using :: operator\"\"_a ; "
-                      "void operator\"\"_b ( const char * ) ; "
+        const char code[] = "void operator \"\" _a(const char *);\n"
+                            "namespace N {\n"
+                            "  using ::operator \"\" _a;\n"
+                            "  void operator \"\" _b(const char *);\n"
+                            "}\n";
+        ASSERT_EQUALS("void operator\"\"_a ( const char * ) ;\n"
+                      "namespace N {\n"
+                      "using :: operator\"\"_a ;\n"
+                      "void operator\"\"_b ( const char * ) ;\n"
                       "}",
                       tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName21() {
-        const char code[] = "template<char...> void operator \"\" _h() {}"
-                            "template<> void operator \"\" _h<'a', 'b', 'c'>() {}"
-                            "template void operator \"\" _h<'a', 'b', 'c', 'd'>();";
-        ASSERT_EQUALS("void operator\"\"_h<'a','b','c'> ( ) ; "
-                      "void operator\"\"_h<'a','b','c','d'> ( ) ; "
-                      "void operator\"\"_h<'a','b','c'> ( ) { } "
+        const char code[] = "template<char...> void operator \"\" _h() {}\n"
+                            "template<> void operator \"\" _h<'a', 'b', 'c'>() {}\n"
+                            "template void operator \"\" _h<'a', 'b', 'c', 'd'>();\n";
+        ASSERT_EQUALS("void operator\"\"_h<'a','b','c'> ( ) ;\n"
+                      "void operator\"\"_h<'a','b','c','d'> ( ) ;\n"
+                      "void operator\"\"_h<'a','b','c'> ( ) { }\n"
                       "void operator\"\"_h<'a','b','c','d'> ( ) { }",
                       tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName22() {
-        const char code[] = "static RSLRelOp convertOperator(const Software::ComparisonOperator& op) {"
-                            "  if (op == &Software::operator==) return RSLEqual;"
-                            "return RSLNotEqual;"
-                            "}";
-        ASSERT_EQUALS("static RSLRelOp convertOperator ( const Software :: ComparisonOperator & op ) { "
-                      "if ( op == & Software :: operator== ) { return RSLEqual ; } "
-                      "return RSLNotEqual ; "
+        const char code[] = "static RSLRelOp convertOperator(const Software::ComparisonOperator& op) {\n"
+                            "  if (op == &Software::operator==) return RSLEqual;\n"
+                            "return RSLNotEqual;\n"
+                            "}\n";
+        ASSERT_EQUALS("static RSLRelOp convertOperator ( const Software :: ComparisonOperator & op ) {\n"
+                      "if ( op == & Software :: operator== ) { return RSLEqual ; }\n"
+                      "return RSLNotEqual ;\n"
                       "}",
                       tokenizeAndStringify(code));
         ASSERT_EQUALS(
-            "[test.cpp:1:116]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable RSLEqual [valueFlowBailoutIncompleteVar]\n",
+            "[test.cpp:2:43]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable RSLEqual [valueFlowBailoutIncompleteVar]\n",
             filter_valueflow(errout_str()));
     }
 
     void simplifyOperatorName23() {
         {
-            const char code[] = "double *vtkMatrix3x3::operator[](const unsigned int i) {"
-                                "  VTK_LEGACY_BODY(vtkMatrix3x3::operator[], \"VTK 7.0\");"
-                                "  return &(this->Element[i][0]);"
-                                "}";
-            ASSERT_EQUALS("double * vtkMatrix3x3 :: operator[] ( const unsigned int i ) { "
-                          "VTK_LEGACY_BODY ( vtkMatrix3x3 :: operator[] , \"VTK 7.0\" ) ; "
-                          "return & ( this . Element [ i ] [ 0 ] ) ; "
+            const char code[] = "double *vtkMatrix3x3::operator[](const unsigned int i) {\n"
+                                "  VTK_LEGACY_BODY(vtkMatrix3x3::operator[], \"VTK 7.0\");\n"
+                                "  return &(this->Element[i][0]);\n"
+                                "}\n";
+            ASSERT_EQUALS("double * vtkMatrix3x3 :: operator[] ( const unsigned int i ) {\n"
+                          "VTK_LEGACY_BODY ( vtkMatrix3x3 :: operator[] , \"VTK 7.0\" ) ;\n"
+                          "return & ( this . Element [ i ] [ 0 ] ) ;\n"
                           "}",
                           tokenizeAndStringify(code));
             ignore_errout();
         }
         {
-            const char code[] = "double *vtkMatrix3x3::operator,(const unsigned int i) {"
-                                "  VTK_LEGACY_BODY(vtkMatrix3x3::operator,, \"VTK 7.0\");"
-                                "  return &(this->Element[i][0]);"
-                                "}";
-            ASSERT_EQUALS("double * vtkMatrix3x3 :: operator, ( const unsigned int i ) { "
-                          "VTK_LEGACY_BODY ( vtkMatrix3x3 :: operator, , \"VTK 7.0\" ) ; "
-                          "return & ( this . Element [ i ] [ 0 ] ) ; "
+            const char code[] = "double *vtkMatrix3x3::operator,(const unsigned int i) {\n"
+                                "  VTK_LEGACY_BODY(vtkMatrix3x3::operator,, \"VTK 7.0\");\n"
+                                "  return &(this->Element[i][0]);\n"
+                                "}\n";
+            ASSERT_EQUALS("double * vtkMatrix3x3 :: operator, ( const unsigned int i ) {\n"
+                          "VTK_LEGACY_BODY ( vtkMatrix3x3 :: operator, , \"VTK 7.0\" ) ;\n"
+                          "return & ( this . Element [ i ] [ 0 ] ) ;\n"
                           "}",
                           tokenizeAndStringify(code));
             ignore_errout();
@@ -5937,35 +6020,37 @@ class TestTokenizer : public TestFixture {
 
     void simplifyOperatorName24() {
         {
-            const char code[] = "void foo() { int i = a.operator++() ? a.operator--() : 0; }";
+            const char code[] = "void foo() { int i = a.operator++() ? a.operator--() : 0; }\n";
             ASSERT_EQUALS("void foo ( ) { int i ; i = a . operator++ ( ) ? a . operator-- ( ) : 0 ; }",
                           tokenizeAndStringify(code));
         }
         {
-            const char code[] = "void foo() { int i = a.operator++(0) ? a.operator--(0) : 0; }";
+            const char code[] = "void foo() { int i = a.operator++(0) ? a.operator--(0) : 0; }\n";
             ASSERT_EQUALS("void foo ( ) { int i ; i = a . operator++ ( 0 ) ? a . operator-- ( 0 ) : 0 ; }",
                           tokenizeAndStringify(code));
         }
     }
 
     void simplifyOperatorName25() {
-        const char code[] = "bool negative(const Number &num) { return num.operator std::string()[0] == '-'; }";
+        const char code[] = "bool negative(const Number &num) { return num.operator std::string()[0] == '-'; }\n";
         ASSERT_EQUALS("bool negative ( const Number & num ) { return num . operatorstd::string ( ) [ 0 ] == '-' ; }",
                       tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName26() {
-        const char code[] = "void foo() {"
-                            "    x = y.operator *().z[123];"
-                            "}";
-        ASSERT_EQUALS("void foo ( ) { x = y . operator* ( ) . z [ 123 ] ; }",
+        const char code[] = "void foo() {\n"
+                            "    x = y.operator *().z[123];\n"
+                            "}\n";
+        ASSERT_EQUALS("void foo ( ) {\n"
+                      "x = y . operator* ( ) . z [ 123 ] ;\n"
+                      "}",
                       tokenizeAndStringify(code));
         ignore_errout();
     }
 
     void simplifyOperatorName27() {
         const char code[] = "int operator \"\" i (const char *, int);\n"
-                            "x = \"abc\"i;";
+                            "x = \"abc\"i;\n";
         ASSERT_EQUALS("int operator\"\"i ( const char * , int ) ;\n"
                       "x = operator\"\"i ( \"abc\" , 3 ) ;",
                       tokenizeAndStringify(code));
@@ -5973,7 +6058,7 @@ class TestTokenizer : public TestFixture {
 
     void simplifyOperatorName28() {
         const char code[] = "template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };\n"
-                            "int main() { }";
+                            "int main() { }\n";
         ASSERT_EQUALS("template < class ... Ts > struct overloaded : Ts ... { using Ts :: operator ( ) ... ; } ;\n"
                       "int main ( ) { }",
                       tokenizeAndStringify(code));
@@ -5982,7 +6067,7 @@ class TestTokenizer : public TestFixture {
 
     void simplifyOperatorName29() {
         const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
-        ASSERT_EQUALS("auto operator<=> ( ) ;", tokenizeAndStringify("auto operator<=>();", settings));
+        ASSERT_EQUALS("auto operator<=> ( ) ;", tokenizeAndStringify("auto operator<=>();\n", settings));
     }
 
     void simplifyOperatorName30() { // #14151
@@ -6005,7 +6090,7 @@ class TestTokenizer : public TestFixture {
                             "    typedef T A[3];\n"
                             "    operator A& () { return x_; }\n"
                             "    A x_;\n"
-                            "};";
+                            "};\n";
         ASSERT_EQUALS("template < typename T >\nstruct B {\n\nT ( & operatorT ( ) ) [ 3 ] { return x_ ; }\nT x_ [ 3 ] ;\n} ;", tokenizeAndStringify(code));
         ASSERT_EQUALS("", errout_str());
     }
@@ -6027,7 +6112,7 @@ class TestTokenizer : public TestFixture {
                             "\n"
                             "void foo(S x) {\n"
                             "    x(123);\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("struct S { void operator() ( int ) ; } ;\n"
                       "\n"
                       "void foo ( S x ) {\n"
@@ -6055,7 +6140,7 @@ class TestTokenizer : public TestFixture {
                             "    Func max;\n"
                             "    double y = 0;\n"
                             "    foo(0, max(y));\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("struct Func { double operator() ( double x ) const ; } ;\n"
                       "void foo ( double , double ) ;\n"
                       "void test ( ) {\n"
@@ -6067,40 +6152,40 @@ class TestTokenizer : public TestFixture {
     }
 
     void simplifyNullArray() {
-        ASSERT_EQUALS("* ( foo . bar [ 5 ] ) = x ;", tokenizeAndStringify("0[foo.bar[5]] = x;"));
+        ASSERT_EQUALS("* ( foo . bar [ 5 ] ) = x ;", tokenizeAndStringify("0[foo.bar[5]] = x;\n"));
     }
 
     void removeMacrosInGlobalScope() {
         // remove some unhandled macros in the global scope.
-        ASSERT_EQUALS("void f ( ) { }", tokenizeAndStringify("void f() NOTHROW { }"));
-        ASSERT_EQUALS("struct Foo { } ;", tokenizeAndStringify("struct __declspec(dllexport) Foo {};"));
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("ABA() namespace { int a ; }"), UNKNOWN_MACRO);
+        ASSERT_EQUALS("void f ( ) { }", tokenizeAndStringify("void f() NOTHROW { }\n"));
+        ASSERT_EQUALS("struct Foo { } ;", tokenizeAndStringify("struct __declspec(dllexport) Foo {};\n"));
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("ABA() namespace { int a ; }\n"), UNKNOWN_MACRO);
 
         // #3750
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("; AB(foo*) foo::foo() { }"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("; AB(foo*) foo::foo() { }\n"), UNKNOWN_MACRO);
 
         // #4834 - syntax error
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("A(B) foo() {}"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("A(B) foo() {}\n"), UNKNOWN_MACRO);
 
         // #3855
         ASSERT_EQUALS("; class foo { }",
-                      tokenizeAndStringify("; AB class foo { }"));
+                      tokenizeAndStringify("; AB class foo { }\n"));
         ASSERT_EQUALS("; CONST struct ABC abc ;",
-                      tokenizeAndStringify("; CONST struct ABC abc ;"));
+                      tokenizeAndStringify("; CONST struct ABC abc ;\n"));
 
         ASSERT_NO_THROW(tokenizeAndStringify("class A {\n"
                                              "  UNKNOWN_MACRO(A)\n" // <- this macro is ignored
                                              "private:\n"
                                              "  int x;\n"
-                                             "};"));
+                                             "};\n"));
 
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("MACRO(test) void test() { }"), UNKNOWN_MACRO); // #7931
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("MACRO(test) void test() { }\n"), UNKNOWN_MACRO); // #7931
 
         ASSERT_THROW_INTERNAL(tokenizeAndStringify("BEGIN_MESSAGE_MAP(CSetProgsAdvDlg, CResizableStandAloneDialog)\n"
                                                    "    ON_BN_CLICKED(IDC_ADDTOOL, OnBnClickedAddtool)\n"
                                                    "END_MESSAGE_MAP()\n"
                                                    "\n"
-                                                   "BOOL CSetProgsAdvDlg::OnInitDialog() {}"),
+                                                   "BOOL CSetProgsAdvDlg::OnInitDialog() {}\n"),
                               UNKNOWN_MACRO);
 
         ASSERT_EQUALS("struct S {\n"
@@ -6115,176 +6200,176 @@ class TestTokenizer : public TestFixture {
 
     void addSemicolonAfterUnknownMacro() {
         // #6975
-        ASSERT_EQUALS("void f ( ) { MACRO ( ) ; try { } }", tokenizeAndStringify("void f() { MACRO() try {} }"));
+        ASSERT_EQUALS("void f ( ) { MACRO ( ) ; try { } }", tokenizeAndStringify("void f() { MACRO() try {} }\n"));
         // #9376
-        ASSERT_EQUALS("MACRO ( ) ; using namespace foo ;", tokenizeAndStringify("MACRO() using namespace foo;"));
+        ASSERT_EQUALS("MACRO ( ) ; using namespace foo ;", tokenizeAndStringify("MACRO() using namespace foo;\n"));
     }
 
     void multipleAssignment() {
-        ASSERT_EQUALS("a = b = 0 ;", tokenizeAndStringify("a=b=0;"));
+        ASSERT_EQUALS("a = b = 0 ;", tokenizeAndStringify("a=b=0;\n"));
     }
 
     void platformWin() {
-        const char code[] = "BOOL f;"
-                            "BOOLEAN g;"
-                            "BYTE h;"
-                            "CHAR i;"
-                            "DWORD j;"
-                            "FLOAT k;"
-                            "INT l;"
-                            "INT32 m;"
-                            "INT64 n;"
-                            "LONG o;"
-                            "SHORT p;"
-                            "UCHAR q;"
-                            "UINT r;"
-                            "ULONG s;"
-                            "USHORT t;"
-                            "WORD u;"
-                            "VOID *v;"
-                            "LPBOOL w;"
-                            "PBOOL x;"
-                            "LPBYTE y;"
-                            "PBOOLEAN z;"
-                            "PBYTE A;"
-                            "LPCSTR B;"
-                            "PCSTR C;"
-                            "LPCVOID D;"
-                            "LPDWORD E;"
-                            "LPINT F;"
-                            "PINT G;"
-                            "LPLONG H;"
-                            "PLONG I;"
-                            "LPSTR J;"
-                            "PSTR K;"
-                            "PCHAR L;"
-                            "LPVOID M;"
-                            "PVOID N;"
-                            "BOOL _bool;"
-                            "HFILE hfile;"
-                            "LONG32 long32;"
-                            "LCID lcid;"
-                            "LCTYPE lctype;"
-                            "LGRPID lgrpid;"
-                            "LONG64 long64;"
-                            "PUCHAR puchar;"
-                            "LPCOLORREF lpcolorref;"
-                            "PDWORD pdword;"
-                            "PULONG pulong;"
-                            "SERVICE_STATUS_HANDLE service_status_hanlde;"
-                            "SC_LOCK sc_lock;"
-                            "SC_HANDLE sc_handle;"
-                            "HACCEL haccel;"
-                            "HCONV hconv;"
-                            "HCONVLIST hconvlist;"
-                            "HDDEDATA hddedata;"
-                            "HDESK hdesk;"
-                            "HDROP hdrop;"
-                            "HDWP hdwp;"
-                            "HENHMETAFILE henhmetafile;"
-                            "HHOOK hhook;"
-                            "HKL hkl;"
-                            "HMONITOR hmonitor;"
-                            "HSZ hsz;"
-                            "HWINSTA hwinsta;"
-                            "PWCHAR pwchar;"
-                            "PUSHORT pushort;"
-                            "LANGID langid;"
-                            "DWORD64 dword64;"
-                            "ULONG64 ulong64;"
-                            "LPWSTR lpcwstr;"
-                            "LPCWSTR lpcwstr;"
-                            "LPHANDLE lpHandle;"
-                            "PCWSTR pcwStr;"
-                            "PDWORDLONG pdWordLong;"
-                            "PDWORD_PTR pdWordPtr;"
-                            "PDWORD32 pdWord32;"
-                            "PDWORD64 pdWord64;"
-                            "LONGLONG ll;"
-                            "USN usn;"
-                            "PULONG64 puLong64;"
-                            "PULONG32 puLong32;"
-                            "PFLOAT ptrToFloat;";
-
-        const char expected[] = "int f ; "
-                                "unsigned char g ; "
-                                "unsigned char h ; "
-                                "char i ; "
-                                "unsigned long j ; "
-                                "float k ; "
-                                "int l ; "
-                                "int m ; "
-                                "long long n ; "
-                                "long o ; "
-                                "short p ; "
-                                "unsigned char q ; "
-                                "unsigned int r ; "
-                                "unsigned long s ; "
-                                "unsigned short t ; "
-                                "unsigned short u ; "
-                                "void * v ; "
-                                "int * w ; "
-                                "int * x ; "
-                                "unsigned char * y ; "
-                                "unsigned char * z ; "
-                                "unsigned char * A ; "
-                                "const char * B ; "
-                                "const char * C ; "
-                                "const void * D ; "
-                                "unsigned long * E ; "
-                                "int * F ; "
-                                "int * G ; "
-                                "long * H ; "
-                                "long * I ; "
-                                "char * J ; "
-                                "char * K ; "
-                                "char * L ; "
-                                "void * M ; "
-                                "void * N ; "
-                                "int _bool ; "
-                                "int hfile ; "
-                                "int long32 ; "
-                                "unsigned long lcid ; "
-                                "unsigned long lctype ; "
-                                "unsigned long lgrpid ; "
-                                "long long long64 ; "
-                                "unsigned char * puchar ; "
-                                "unsigned long * lpcolorref ; "
-                                "unsigned long * pdword ; "
-                                "unsigned long * pulong ; "
-                                "void * service_status_hanlde ; "
-                                "void * sc_lock ; "
-                                "void * sc_handle ; "
-                                "void * haccel ; "
-                                "void * hconv ; "
-                                "void * hconvlist ; "
-                                "void * hddedata ; "
-                                "void * hdesk ; "
-                                "void * hdrop ; "
-                                "void * hdwp ; "
-                                "void * henhmetafile ; "
-                                "void * hhook ; "
-                                "void * hkl ; "
-                                "void * hmonitor ; "
-                                "void * hsz ; "
-                                "void * hwinsta ; "
-                                "wchar_t * pwchar ; "
-                                "unsigned short * pushort ; "
-                                "unsigned short langid ; "
-                                "unsigned long long dword64 ; "
-                                "unsigned long long ulong64 ; "
-                                "wchar_t * lpcwstr ; "
-                                "const wchar_t * lpcwstr ; "
-                                "void * lpHandle ; "
-                                "const wchar_t * pcwStr ; "
-                                "long * pdWordLong ; "
-                                "long * pdWordPtr ; "
-                                "unsigned int * pdWord32 ; "
-                                "unsigned long * pdWord64 ; "
-                                "long long ll ; "
-                                "long long usn ; "
-                                "unsigned long long * puLong64 ; "
-                                "unsigned int * puLong32 ; "
+        const char code[] = "BOOL f;\n"
+                            "BOOLEAN g;\n"
+                            "BYTE h;\n"
+                            "CHAR i;\n"
+                            "DWORD j;\n"
+                            "FLOAT k;\n"
+                            "INT l;\n"
+                            "INT32 m;\n"
+                            "INT64 n;\n"
+                            "LONG o;\n"
+                            "SHORT p;\n"
+                            "UCHAR q;\n"
+                            "UINT r;\n"
+                            "ULONG s;\n"
+                            "USHORT t;\n"
+                            "WORD u;\n"
+                            "VOID *v;\n"
+                            "LPBOOL w;\n"
+                            "PBOOL x;\n"
+                            "LPBYTE y;\n"
+                            "PBOOLEAN z;\n"
+                            "PBYTE A;\n"
+                            "LPCSTR B;\n"
+                            "PCSTR C;\n"
+                            "LPCVOID D;\n"
+                            "LPDWORD E;\n"
+                            "LPINT F;\n"
+                            "PINT G;\n"
+                            "LPLONG H;\n"
+                            "PLONG I;\n"
+                            "LPSTR J;\n"
+                            "PSTR K;\n"
+                            "PCHAR L;\n"
+                            "LPVOID M;\n"
+                            "PVOID N;\n"
+                            "BOOL _bool;\n"
+                            "HFILE hfile;\n"
+                            "LONG32 long32;\n"
+                            "LCID lcid;\n"
+                            "LCTYPE lctype;\n"
+                            "LGRPID lgrpid;\n"
+                            "LONG64 long64;\n"
+                            "PUCHAR puchar;\n"
+                            "LPCOLORREF lpcolorref;\n"
+                            "PDWORD pdword;\n"
+                            "PULONG pulong;\n"
+                            "SERVICE_STATUS_HANDLE service_status_hanlde;\n"
+                            "SC_LOCK sc_lock;\n"
+                            "SC_HANDLE sc_handle;\n"
+                            "HACCEL haccel;\n"
+                            "HCONV hconv;\n"
+                            "HCONVLIST hconvlist;\n"
+                            "HDDEDATA hddedata;\n"
+                            "HDESK hdesk;\n"
+                            "HDROP hdrop;\n"
+                            "HDWP hdwp;\n"
+                            "HENHMETAFILE henhmetafile;\n"
+                            "HHOOK hhook;\n"
+                            "HKL hkl;\n"
+                            "HMONITOR hmonitor;\n"
+                            "HSZ hsz;\n"
+                            "HWINSTA hwinsta;\n"
+                            "PWCHAR pwchar;\n"
+                            "PUSHORT pushort;\n"
+                            "LANGID langid;\n"
+                            "DWORD64 dword64;\n"
+                            "ULONG64 ulong64;\n"
+                            "LPWSTR lpcwstr;\n"
+                            "LPCWSTR lpcwstr;\n"
+                            "LPHANDLE lpHandle;\n"
+                            "PCWSTR pcwStr;\n"
+                            "PDWORDLONG pdWordLong;\n"
+                            "PDWORD_PTR pdWordPtr;\n"
+                            "PDWORD32 pdWord32;\n"
+                            "PDWORD64 pdWord64;\n"
+                            "LONGLONG ll;\n"
+                            "USN usn;\n"
+                            "PULONG64 puLong64;\n"
+                            "PULONG32 puLong32;\n"
+                            "PFLOAT ptrToFloat;\n";
+
+        const char expected[] = "int f ;\n"
+                                "unsigned char g ;\n"
+                                "unsigned char h ;\n"
+                                "char i ;\n"
+                                "unsigned long j ;\n"
+                                "float k ;\n"
+                                "int l ;\n"
+                                "int m ;\n"
+                                "long long n ;\n"
+                                "long o ;\n"
+                                "short p ;\n"
+                                "unsigned char q ;\n"
+                                "unsigned int r ;\n"
+                                "unsigned long s ;\n"
+                                "unsigned short t ;\n"
+                                "unsigned short u ;\n"
+                                "void * v ;\n"
+                                "int * w ;\n"
+                                "int * x ;\n"
+                                "unsigned char * y ;\n"
+                                "unsigned char * z ;\n"
+                                "unsigned char * A ;\n"
+                                "const char * B ;\n"
+                                "const char * C ;\n"
+                                "const void * D ;\n"
+                                "unsigned long * E ;\n"
+                                "int * F ;\n"
+                                "int * G ;\n"
+                                "long * H ;\n"
+                                "long * I ;\n"
+                                "char * J ;\n"
+                                "char * K ;\n"
+                                "char * L ;\n"
+                                "void * M ;\n"
+                                "void * N ;\n"
+                                "int _bool ;\n"
+                                "int hfile ;\n"
+                                "int long32 ;\n"
+                                "unsigned long lcid ;\n"
+                                "unsigned long lctype ;\n"
+                                "unsigned long lgrpid ;\n"
+                                "long long long64 ;\n"
+                                "unsigned char * puchar ;\n"
+                                "unsigned long * lpcolorref ;\n"
+                                "unsigned long * pdword ;\n"
+                                "unsigned long * pulong ;\n"
+                                "void * service_status_hanlde ;\n"
+                                "void * sc_lock ;\n"
+                                "void * sc_handle ;\n"
+                                "void * haccel ;\n"
+                                "void * hconv ;\n"
+                                "void * hconvlist ;\n"
+                                "void * hddedata ;\n"
+                                "void * hdesk ;\n"
+                                "void * hdrop ;\n"
+                                "void * hdwp ;\n"
+                                "void * henhmetafile ;\n"
+                                "void * hhook ;\n"
+                                "void * hkl ;\n"
+                                "void * hmonitor ;\n"
+                                "void * hsz ;\n"
+                                "void * hwinsta ;\n"
+                                "wchar_t * pwchar ;\n"
+                                "unsigned short * pushort ;\n"
+                                "unsigned short langid ;\n"
+                                "unsigned long long dword64 ;\n"
+                                "unsigned long long ulong64 ;\n"
+                                "wchar_t * lpcwstr ;\n"
+                                "const wchar_t * lpcwstr ;\n"
+                                "void * lpHandle ;\n"
+                                "const wchar_t * pcwStr ;\n"
+                                "long * pdWordLong ;\n"
+                                "long * pdWordPtr ;\n"
+                                "unsigned int * pdWord32 ;\n"
+                                "unsigned long * pdWord64 ;\n"
+                                "long long ll ;\n"
+                                "long long usn ;\n"
+                                "unsigned long long * puLong64 ;\n"
+                                "unsigned int * puLong32 ;\n"
                                 "float * ptrToFloat ;";
 
         // These types should be defined the same on all Windows platforms
@@ -6295,121 +6380,121 @@ class TestTokenizer : public TestFixture {
     }
 
     void platformWin32A() {
-        const char code[] = "wchar_t wc;"
-                            "TCHAR c;"
-                            "PTSTR ptstr;"
-                            "LPTSTR lptstr;"
-                            "PCTSTR pctstr;"
-                            "LPCTSTR lpctstr;"
-                            "void foo() {"
-                            "    TCHAR tc = _T(\'c\'); "
-                            "    TCHAR src[10] = _T(\"123456789\");"
-                            "    TCHAR dst[10];"
-                            "    _tcscpy(dst, src);"
-                            "    dst[0] = 0;"
-                            "    _tcscat(dst, src);"
-                            "    LPTSTR d = _tcsdup(src);"
-                            "    _tprintf(_T(\"Hello world!\"));"
-                            "    _stprintf(dst, _T(\"Hello!\"));"
-                            "    _sntprintf(dst, sizeof(dst) / sizeof(TCHAR), _T(\"Hello world!\"));"
-                            "    _tscanf(_T(\"%s\"), dst);"
-                            "    _stscanf(dst, _T(\"%s\"), dst);"
-                            "}"
-                            "TBYTE tbyte;";
-        const char expected[] = "wchar_t wc ; "
-                                "char c ; "
-                                "char * ptstr ; "
-                                "char * lptstr ; "
-                                "const char * pctstr ; "
-                                "const char * lpctstr ; "
-                                "void foo ( ) { "
-                                "char tc ; tc = \'c\' ; "
-                                "char src [ 10 ] = \"123456789\" ; "
-                                "char dst [ 10 ] ; "
-                                "strcpy ( dst , src ) ; "
-                                "dst [ 0 ] = 0 ; "
-                                "strcat ( dst , src ) ; "
-                                "char * d ; d = strdup ( src ) ; "
-                                "printf ( \"Hello world!\" ) ; "
-                                "sprintf ( dst , \"Hello!\" ) ; "
-                                "_snprintf ( dst , sizeof ( dst ) / sizeof ( char ) , \"Hello world!\" ) ; "
-                                "scanf ( \"%s\" , dst ) ; "
-                                "sscanf ( dst , \"%s\" , dst ) ; "
-                                "} "
+        const char code[] = "wchar_t wc;\n"
+                            "TCHAR c;\n"
+                            "PTSTR ptstr;\n"
+                            "LPTSTR lptstr;\n"
+                            "PCTSTR pctstr;\n"
+                            "LPCTSTR lpctstr;\n"
+                            "void foo() {\n"
+                            "    TCHAR tc = _T(\'c\');\n"
+                            "    TCHAR src[10] = _T(\"123456789\");\n"
+                            "    TCHAR dst[10];\n"
+                            "    _tcscpy(dst, src);\n"
+                            "    dst[0] = 0;\n"
+                            "    _tcscat(dst, src);\n"
+                            "    LPTSTR d = _tcsdup(src);\n"
+                            "    _tprintf(_T(\"Hello world!\"));\n"
+                            "    _stprintf(dst, _T(\"Hello!\"));\n"
+                            "    _sntprintf(dst, sizeof(dst) / sizeof(TCHAR), _T(\"Hello world!\"));\n"
+                            "    _tscanf(_T(\"%s\"), dst);\n"
+                            "    _stscanf(dst, _T(\"%s\"), dst);\n"
+                            "}\n"
+                            "TBYTE tbyte;\n";
+        const char expected[] = "wchar_t wc ;\n"
+                                "char c ;\n"
+                                "char * ptstr ;\n"
+                                "char * lptstr ;\n"
+                                "const char * pctstr ;\n"
+                                "const char * lpctstr ;\n"
+                                "void foo ( ) {\n"
+                                "char tc ; tc = \'c\' ;\n"
+                                "char src [ 10 ] = \"123456789\" ;\n"
+                                "char dst [ 10 ] ;\n"
+                                "strcpy ( dst , src ) ;\n"
+                                "dst [ 0 ] = 0 ;\n"
+                                "strcat ( dst , src ) ;\n"
+                                "char * d ; d = strdup ( src ) ;\n"
+                                "printf ( \"Hello world!\" ) ;\n"
+                                "sprintf ( dst , \"Hello!\" ) ;\n"
+                                "_snprintf ( dst , sizeof ( dst ) / sizeof ( char ) , \"Hello world!\" ) ;\n"
+                                "scanf ( \"%s\" , dst ) ;\n"
+                                "sscanf ( dst , \"%s\" , dst ) ;\n"
+                                "}\n"
                                 "unsigned char tbyte ;";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code, settings_win32a));
 
         const char code2[] = "LPCTSTR f(void* p) { return LPCTSTR(p); }\n" // #11430
-                             "LPCTSTR g() { return LPCTSTR{}; }";
+                             "LPCTSTR g() { return LPCTSTR{}; }\n";
         const char expected2[] = "const char * f ( void * p ) { return ( const char * ) ( p ) ; }\n"
                                  "const char * g ( ) { return ( const char * ) ( 0 ) ; }";
         ASSERT_EQUALS(expected2, tokenizeAndStringify(code2, settings_win32a));
     }
 
     void platformWin32W() {
-        const char code[] = "wchar_t wc;"
-                            "TCHAR c;"
-                            "PTSTR ptstr;"
-                            "LPTSTR lptstr;"
-                            "PCTSTR pctstr;"
-                            "LPCTSTR lpctstr;"
-                            "TBYTE tbyte;"
-                            "void foo() {"
-                            "    TCHAR tc = _T(\'c\');"
-                            "    TCHAR src[10] = _T(\"123456789\");"
-                            "    TCHAR dst[10];"
-                            "    _tcscpy(dst, src);"
-                            "    dst[0] = 0;"
-                            "    _tcscat(dst, src);"
-                            "    LPTSTR d = _tcsdup(src);"
-                            "    _tprintf(_T(\"Hello world!\"));"
-                            "    _stprintf(dst, _T(\"Hello!\"));"
-                            "    _sntprintf(dst, sizeof(dst) / sizeof(TCHAR), _T(\"Hello world!\"));"
-                            "    _tscanf(_T(\"%s\"), dst);"
-                            "    _stscanf(dst, _T(\"%s\"), dst);"
-                            "}";
-        const char expected[] = "wchar_t wc ; "
-                                "wchar_t c ; "
-                                "wchar_t * ptstr ; "
-                                "wchar_t * lptstr ; "
-                                "const wchar_t * pctstr ; "
-                                "const wchar_t * lpctstr ; "
-                                "unsigned wchar_t tbyte ; "
-                                "void foo ( ) { "
-                                "wchar_t tc ; tc = L\'c\' ; "
-                                "wchar_t src [ 10 ] = L\"123456789\" ; "
-                                "wchar_t dst [ 10 ] ; "
-                                "wcscpy ( dst , src ) ; "
-                                "dst [ 0 ] = 0 ; "
-                                "wcscat ( dst , src ) ; "
-                                "wchar_t * d ; d = wcsdup ( src ) ; "
-                                "wprintf ( L\"Hello world!\" ) ; "
-                                "swprintf ( dst , L\"Hello!\" ) ; "
-                                "_snwprintf ( dst , sizeof ( dst ) / sizeof ( wchar_t ) , L\"Hello world!\" ) ; "
-                                "wscanf ( L\"%s\" , dst ) ; "
-                                "swscanf ( dst , L\"%s\" , dst ) ; "
+        const char code[] = "wchar_t wc;\n"
+                            "TCHAR c;\n"
+                            "PTSTR ptstr;\n"
+                            "LPTSTR lptstr;\n"
+                            "PCTSTR pctstr;\n"
+                            "LPCTSTR lpctstr;\n"
+                            "TBYTE tbyte;\n"
+                            "void foo() {\n"
+                            "    TCHAR tc = _T(\'c\');\n"
+                            "    TCHAR src[10] = _T(\"123456789\");\n"
+                            "    TCHAR dst[10];\n"
+                            "    _tcscpy(dst, src);\n"
+                            "    dst[0] = 0;\n"
+                            "    _tcscat(dst, src);\n"
+                            "    LPTSTR d = _tcsdup(src);\n"
+                            "    _tprintf(_T(\"Hello world!\"));\n"
+                            "    _stprintf(dst, _T(\"Hello!\"));\n"
+                            "    _sntprintf(dst, sizeof(dst) / sizeof(TCHAR), _T(\"Hello world!\"));\n"
+                            "    _tscanf(_T(\"%s\"), dst);\n"
+                            "    _stscanf(dst, _T(\"%s\"), dst);\n"
+                            "}\n";
+        const char expected[] = "wchar_t wc ;\n"
+                                "wchar_t c ;\n"
+                                "wchar_t * ptstr ;\n"
+                                "wchar_t * lptstr ;\n"
+                                "const wchar_t * pctstr ;\n"
+                                "const wchar_t * lpctstr ;\n"
+                                "unsigned wchar_t tbyte ;\n"
+                                "void foo ( ) {\n"
+                                "wchar_t tc ; tc = L\'c\' ;\n"
+                                "wchar_t src [ 10 ] = L\"123456789\" ;\n"
+                                "wchar_t dst [ 10 ] ;\n"
+                                "wcscpy ( dst , src ) ;\n"
+                                "dst [ 0 ] = 0 ;\n"
+                                "wcscat ( dst , src ) ;\n"
+                                "wchar_t * d ; d = wcsdup ( src ) ;\n"
+                                "wprintf ( L\"Hello world!\" ) ;\n"
+                                "swprintf ( dst , L\"Hello!\" ) ;\n"
+                                "_snwprintf ( dst , sizeof ( dst ) / sizeof ( wchar_t ) , L\"Hello world!\" ) ;\n"
+                                "wscanf ( L\"%s\" , dst ) ;\n"
+                                "swscanf ( dst , L\"%s\" , dst ) ;\n"
                                 "}";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code, settings_win32w));
     }
 
     void platformWin32AStringCat() { //#5150
-        const char code[] = "TCHAR text[] = _T(\"123\") _T(\"456\") _T(\"789\");";
+        const char code[] = "TCHAR text[] = _T(\"123\") _T(\"456\") _T(\"789\");\n";
         const char expected[] = "char text [ 10 ] = \"123456789\" ;";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code, settings_win32a));
     }
 
     void platformWin32WStringCat() { //#5150
-        const char code[] = "TCHAR text[] = _T(\"123\") _T(\"456\") _T(\"789\");";
+        const char code[] = "TCHAR text[] = _T(\"123\") _T(\"456\") _T(\"789\");\n";
         const char expected[] = "wchar_t text [ 10 ] = L\"123456789\" ;";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code, settings_win32w));
     }
 
     void platformWinWithNamespace() {
-        const char code1[] = "UINT32 a; ::UINT32 b; foo::UINT32 c;";
+        const char code1[] = "UINT32 a; ::UINT32 b; foo::UINT32 c;\n";
         const char expected1[] = "unsigned int a ; unsigned int b ; foo :: UINT32 c ;";
         ASSERT_EQUALS(expected1, tokenizeAndStringify(code1, settings_win32a));
 
-        const char code2[] = "LPCVOID a; ::LPCVOID b; foo::LPCVOID c;";
+        const char code2[] = "LPCVOID a; ::LPCVOID b; foo::LPCVOID c;\n";
         const char expected2[] = "const void * a ; const void * b ; foo :: LPCVOID c ;";
         ASSERT_EQUALS(expected2, tokenizeAndStringify(code2, settings_win32w));
     }
@@ -6431,7 +6516,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void simplifyStaticConst() {
-        const char code1[]     = "class foo { public: bool const static c ; }";
+        const char code1[]     = "class foo { public: bool const static c ; }\n";
         const char expected1[] = "class foo { public: static const bool c ; }";
         ASSERT_EQUALS(expected1, tokenizeAndStringify(code1));
 
@@ -6458,7 +6543,7 @@ class TestTokenizer : public TestFixture {
             "int long long signed static const i18;\n"
             "return i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9 + i10 + i11 + i12\n"
             "+ i13 + i14 + i15 + i16 + i17 + i18;\n"
-            "}";
+            "}\n";
         const char expected2[] =
             "long long f ( )\n"
             "{\n"
@@ -6485,115 +6570,115 @@ class TestTokenizer : public TestFixture {
             "}";
         ASSERT_EQUALS(expected2, tokenizeAndStringify(code2));
 
-        const char code3[] = "const unsigned long extern int i;";
+        const char code3[] = "const unsigned long extern int i;\n";
         const char expected3[] = "extern const unsigned long i ;";
         ASSERT_EQUALS(expected3, tokenizeAndStringify(code3));
     }
 
     void simplifyCPPAttribute() {
         ASSERT_EQUALS("int f ( ) ;",
-                      tokenizeAndStringify("[[deprecated]] int f();"));
+                      tokenizeAndStringify("[[deprecated]] int f();\n"));
 
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("[[deprecated]] int f();", dinit(TokenizeOptions, $.cpp = false)), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("[[deprecated]] int f();\n", dinit(TokenizeOptions, $.cpp = false)), SYNTAX);
 
         ASSERT_EQUALS("template < class T > int f ( ) { }",
-                      tokenizeAndStringify("template <class T> [[noreturn]] int f(){}"));
+                      tokenizeAndStringify("template <class T> [[noreturn]] int f(){}\n"));
 
         ASSERT_EQUALS("int f ( int i ) ;",
-                      tokenizeAndStringify("[[maybe_unused]] int f([[maybe_unused]] int i);"));
+                      tokenizeAndStringify("[[maybe_unused]] int f([[maybe_unused]] int i);\n"));
 
         ASSERT_EQUALS("struct a ;",
-                      tokenizeAndStringify("struct [[]] a;"));
+                      tokenizeAndStringify("struct [[]] a;\n"));
 
         ASSERT_EQUALS("struct a ;",
-                      tokenizeAndStringify("struct [[,]] a;"));
+                      tokenizeAndStringify("struct [[,]] a;\n"));
 
         ASSERT_EQUALS("struct a ;",
-                      tokenizeAndStringify("struct [[deprecated,]] a;"));
+                      tokenizeAndStringify("struct [[deprecated,]] a;\n"));
 
         ASSERT_EQUALS("struct a ;",
-                      tokenizeAndStringify("struct [[,,]] a;"));
+                      tokenizeAndStringify("struct [[,,]] a;\n"));
 
         ASSERT_EQUALS("struct a ;",
-                      tokenizeAndStringify("struct [[deprecated,,]] a;"));
+                      tokenizeAndStringify("struct [[deprecated,,]] a;\n"));
 
         ASSERT_EQUALS("struct a ;",
-                      tokenizeAndStringify("struct [[deprecated,maybe_unused,]] a;"));
+                      tokenizeAndStringify("struct [[deprecated,maybe_unused,]] a;\n"));
 
         ASSERT_EQUALS("struct a ;",
-                      tokenizeAndStringify("struct [[,,,]] a;"));
+                      tokenizeAndStringify("struct [[,,,]] a;\n"));
 
         ASSERT_EQUALS("struct a ;",
-                      tokenizeAndStringify("struct alignas(int) a;"));
+                      tokenizeAndStringify("struct alignas(int) a;\n"));
 
         ASSERT_EQUALS("struct a ;",
-                      tokenizeAndStringify("struct alignas ( alignof ( float ) ) a;"));
+                      tokenizeAndStringify("struct alignas ( alignof ( float ) ) a;\n"));
 
         ASSERT_EQUALS("char a [ 256 ] ;",
-                      tokenizeAndStringify("alignas(256) char a[256];"));
+                      tokenizeAndStringify("alignas(256) char a[256];\n"));
 
         ASSERT_EQUALS("struct a ;",
-                      tokenizeAndStringify("struct alignas(float) [[deprecated(reason)]] a;"));
+                      tokenizeAndStringify("struct alignas(float) [[deprecated(reason)]] a;\n"));
 
         ASSERT_EQUALS("struct a ;",
-                      tokenizeAndStringify("struct [[deprecated,maybe_unused]] alignas(double) [[trivial_abi]] a;"));
+                      tokenizeAndStringify("struct [[deprecated,maybe_unused]] alignas(double) [[trivial_abi]] a;\n"));
 
         ASSERT_EQUALS("void func5 ( const char * , ... ) ;",
-                      tokenizeAndStringify("[[noreturn]] void func5(const char*, ...);"));
+                      tokenizeAndStringify("[[noreturn]] void func5(const char*, ...);\n"));
 
         ASSERT_EQUALS("void func5 ( const char * , ... ) ;",
-                      tokenizeAndStringify("[[noreturn]] [[gnu::format(printf, 1, 2)]] void func5(const char*, ...);"));
+                      tokenizeAndStringify("[[noreturn]] [[gnu::format(printf, 1, 2)]] void func5(const char*, ...);\n"));
 
         ASSERT_EQUALS("void func5 ( const char * , ... ) ;",
-                      tokenizeAndStringify("[[gnu::format(printf, 1, 2)]] [[noreturn]] void func5(const char*, ...);"));
+                      tokenizeAndStringify("[[gnu::format(printf, 1, 2)]] [[noreturn]] void func5(const char*, ...);\n"));
 
         ASSERT_EQUALS("int func1 ( ) ;",
-                      tokenizeAndStringify("[[nodiscard]] int func1();"));
+                      tokenizeAndStringify("[[nodiscard]] int func1();\n"));
 
         ASSERT_EQUALS("int func1 ( ) ;",
-                      tokenizeAndStringify("[[nodiscard]] [[clang::optnone]] int func1();"));
+                      tokenizeAndStringify("[[nodiscard]] [[clang::optnone]] int func1();\n"));
 
         ASSERT_EQUALS("int func1 ( ) ;",
-                      tokenizeAndStringify("[[clang::optnone]] [[nodiscard]] int func1();"));
+                      tokenizeAndStringify("[[clang::optnone]] [[nodiscard]] int func1();\n"));
 
         const Settings s = settingsBuilder(settings1).c(Standards::C23).build();
         ASSERT_EQUALS("void f ( int i ) { exit ( i ) ; }",
-                      tokenizeAndStringify("[[noreturn]] void f(int i) { exit(i); }", s, false));
+                      tokenizeAndStringify("[[noreturn]] void f(int i) { exit(i); }\n", s, false));
     }
 
     void simplifyCaseRange() {
-        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case 1 : case 2 : case 3 : case 4 : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case 1 ... 4: } }"));
-        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case 4 ... 1 : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case 4 ... 1: } }"));
-        (void)tokenizeAndStringify("void f(int x) { switch(x) { case 1 ... 1000000: } }"); // Do not run out of memory
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case 1 : case 2 : case 3 : case 4 : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case 1 ... 4: } }\n"));
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case 4 ... 1 : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case 4 ... 1: } }\n"));
+        (void)tokenizeAndStringify("void f(int x) { switch(x) { case 1 ... 1000000: } }\n"); // Do not run out of memory
 
-        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case 'a' : case 98 : case 'c' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case 'a' ... 'c': } }"));
-        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case 'c' ... 'a' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case 'c' ... 'a': } }"));
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case 'a' : case 98 : case 'c' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case 'a' ... 'c': } }\n"));
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case 'c' ... 'a' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case 'c' ... 'a': } }\n"));
 
-        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case '[' : case 92 : case ']' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case '[' ... ']': } }"));
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case '[' : case 92 : case ']' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case '[' ... ']': } }\n"));
 
-        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case '&' : case 39 : case '(' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case '&' ... '(': } }"));
-        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case '\\x61' : case 98 : case '\\x63' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case '\\x61' ... '\\x63': } }"));
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case '&' : case 39 : case '(' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case '&' ... '(': } }\n"));
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case '\\x61' : case 98 : case '\\x63' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case '\\x61' ... '\\x63': } }\n"));
     }
 
     void simplifyEmptyNamespaces() {
-        ASSERT_EQUALS(";", tokenizeAndStringify("namespace { }"));
-        ASSERT_EQUALS(";", tokenizeAndStringify("namespace foo { }"));
-        ASSERT_EQUALS(";", tokenizeAndStringify("namespace foo { namespace { } }"));
-        ASSERT_EQUALS(";", tokenizeAndStringify("namespace { namespace { } }")); // Ticket #9512
-        ASSERT_EQUALS(";", tokenizeAndStringify("namespace foo { namespace bar { } }"));
+        ASSERT_EQUALS(";", tokenizeAndStringify("namespace { }\n"));
+        ASSERT_EQUALS(";", tokenizeAndStringify("namespace foo { }\n"));
+        ASSERT_EQUALS(";", tokenizeAndStringify("namespace foo { namespace { } }\n"));
+        ASSERT_EQUALS(";", tokenizeAndStringify("namespace { namespace { } }\n")); // Ticket #9512
+        ASSERT_EQUALS(";", tokenizeAndStringify("namespace foo { namespace bar { } }\n"));
     }
 
     void prepareTernaryOpForAST() {
-        ASSERT_EQUALS("a ? b : c ;", tokenizeAndStringify("a ? b : c;"));
+        ASSERT_EQUALS("a ? b : c ;", tokenizeAndStringify("a ? b : c;\n"));
 
-        ASSERT_EQUALS("a ? ( b , c ) : d ;", tokenizeAndStringify("a ? b , c : d;"));
-        ASSERT_EQUALS("a ? ( b , c ) : d ;", tokenizeAndStringify("a ? (b , c) : d;"));
+        ASSERT_EQUALS("a ? ( b , c ) : d ;", tokenizeAndStringify("a ? b , c : d;\n"));
+        ASSERT_EQUALS("a ? ( b , c ) : d ;", tokenizeAndStringify("a ? (b , c) : d;\n"));
 
-        ASSERT_EQUALS("a ? ( 1 ? ( a , b ) : 3 ) : d ;", tokenizeAndStringify("a ? 1 ? a, b : 3 : d;"));
+        ASSERT_EQUALS("a ? ( 1 ? ( a , b ) : 3 ) : d ;", tokenizeAndStringify("a ? 1 ? a, b : 3 : d;\n"));
 
-        ASSERT_EQUALS("a ? ( std :: map < int , int > ( ) ) : 0 ;", tokenizeAndStringify("typedef std::map<int,int> mymap; a ? mymap() : 0;"));
+        ASSERT_EQUALS("a ? ( std :: map < int , int > ( ) ) : 0 ;", tokenizeAndStringify("typedef std::map<int,int> mymap; a ? mymap() : 0;\n"));
 
-        ASSERT_EQUALS("a ? ( b < c ) : d > e", tokenizeAndStringify("a ? b < c : d > e"));
+        ASSERT_EQUALS("a ? ( b < c ) : d > e", tokenizeAndStringify("a ? b < c : d > e\n"));
     }
 
     enum class AstStyle : std :: uint8_t {
@@ -6663,135 +6748,135 @@ class TestTokenizer : public TestFixture {
     }
 
     void astexpr() { // simple expressions with arithmetical ops
-        ASSERT_EQUALS("12+3+", testAst("1+2+3"));
-        ASSERT_EQUALS("12*3+", testAst("1*2+3"));
-        ASSERT_EQUALS("123*+", testAst("1+2*3"));
-        ASSERT_EQUALS("12*34*+", testAst("1*2+3*4"));
-        ASSERT_EQUALS("12*34*5*+", testAst("1*2+3*4*5"));
-        ASSERT_EQUALS("0(r.&", testAst("(&((typeof(x))0).r);"));
-        ASSERT_EQUALS("0(r.&", testAst("&((typeof(x))0).r;"));
-        ASSERT_EQUALS("0f1(||", testAst("; 0 || f(1);"));
+        ASSERT_EQUALS("12+3+", testAst("1+2+3\n"));
+        ASSERT_EQUALS("12*3+", testAst("1*2+3\n"));
+        ASSERT_EQUALS("123*+", testAst("1+2*3\n"));
+        ASSERT_EQUALS("12*34*+", testAst("1*2+3*4\n"));
+        ASSERT_EQUALS("12*34*5*+", testAst("1*2+3*4*5\n"));
+        ASSERT_EQUALS("0(r.&", testAst("(&((typeof(x))0).r);\n"));
+        ASSERT_EQUALS("0(r.&", testAst("&((typeof(x))0).r;\n"));
+        ASSERT_EQUALS("0f1(||", testAst("; 0 || f(1);\n"));
 
         // Various tests of precedence
-        ASSERT_EQUALS("ab::c+", testAst("a::b+c"));
-        ASSERT_EQUALS("abc+=", testAst("a=b+c"));
-        ASSERT_EQUALS("abc=,", testAst("a,b=c"));
-        ASSERT_EQUALS("a-1+", testAst("-a+1"));
-        ASSERT_EQUALS("ab++-c-", testAst("a-b++-c"));
-        ASSERT_EQUALS("ab<=>", testAst("a<=>b"));
+        ASSERT_EQUALS("ab::c+", testAst("a::b+c\n"));
+        ASSERT_EQUALS("abc+=", testAst("a=b+c\n"));
+        ASSERT_EQUALS("abc=,", testAst("a,b=c\n"));
+        ASSERT_EQUALS("a-1+", testAst("-a+1\n"));
+        ASSERT_EQUALS("ab++-c-", testAst("a-b++-c\n"));
+        ASSERT_EQUALS("ab<=>", testAst("a<=>b\n"));
 
         // sizeof
-        ASSERT_EQUALS("ab.sizeof", testAst("sizeof a.b"));
+        ASSERT_EQUALS("ab.sizeof", testAst("sizeof a.b\n"));
 
         // assignment operators
-        ASSERT_EQUALS("ab>>=", testAst("a>>=b;"));
-        ASSERT_EQUALS("ab<<=", testAst("a<<=b;"));
-        ASSERT_EQUALS("ab+=",  testAst("a+=b;"));
-        ASSERT_EQUALS("ab-=",  testAst("a-=b;"));
-        ASSERT_EQUALS("ab*=",  testAst("a*=b;"));
-        ASSERT_EQUALS("ab/=",  testAst("a/=b;"));
-        ASSERT_EQUALS("ab%=",  testAst("a%=b;"));
-        ASSERT_EQUALS("ab&=",  testAst("a&=b;"));
-        ASSERT_EQUALS("ab|=",  testAst("a|=b;"));
-        ASSERT_EQUALS("ab^=",  testAst("a^=b;"));
-
-        ASSERT_EQUALS("ab*c*.(+return", testAst("return a + ((*b).*c)();"));
+        ASSERT_EQUALS("ab>>=", testAst("a>>=b;\n"));
+        ASSERT_EQUALS("ab<<=", testAst("a<<=b;\n"));
+        ASSERT_EQUALS("ab+=",  testAst("a+=b;\n"));
+        ASSERT_EQUALS("ab-=",  testAst("a-=b;\n"));
+        ASSERT_EQUALS("ab*=",  testAst("a*=b;\n"));
+        ASSERT_EQUALS("ab/=",  testAst("a/=b;\n"));
+        ASSERT_EQUALS("ab%=",  testAst("a%=b;\n"));
+        ASSERT_EQUALS("ab&=",  testAst("a&=b;\n"));
+        ASSERT_EQUALS("ab|=",  testAst("a|=b;\n"));
+        ASSERT_EQUALS("ab^=",  testAst("a^=b;\n"));
+
+        ASSERT_EQUALS("ab*c*.(+return", testAst("return a + ((*b).*c)();\n"));
 
         // assignments are executed from right to left
-        ASSERT_EQUALS("abc==", testAst("a=b=c;"));
+        ASSERT_EQUALS("abc==", testAst("a=b=c;\n"));
 
         // ternary operator
-        ASSERT_EQUALS("ab0=c1=:?", testAst("a?b=0:c=1;"));
-        ASSERT_EQUALS("fabc,d:?=e,", testAst("f = a ? b, c : d, e;"));
-        ASSERT_EQUALS("fabc,de,:?=", testAst("f = (a ? (b, c) : (d, e));"));
-        ASSERT_EQUALS("fabc,de,:?=", testAst("f = (a ? b, c : (d, e));"));
-        ASSERT_EQUALS("ab35,4:?foo(:?return", testAst("return (a ? b ? (3,5) : 4 : foo());"));
-        ASSERT_EQUALS("check(result_type00,{invalid:?return", testAst("return check() ? result_type {0, 0} : invalid;"));
-        ASSERT_EQUALS("x01:?return", testAst("return x ? 0 : 1;"));
-        ASSERT_EQUALS("x00throw:?return", testAst("return x ? 0 : throw 0;")); // #9768
-        ASSERT_EQUALS("val0<1throwval:?return", testAst("return val < 0 ? throw 1 : val;")); // #8526
-        ASSERT_EQUALS("ix0<00throw:?=", testAst("int i = x < 0 ? 0 : throw 0;"));
-        ASSERT_EQUALS("pa[pb[<1-pa[pb[>:?return", testAst("return p[a] < p[b] ? -1 : p[a] > p[b];"));
-
-        ASSERT_EQUALS("a\"\"=", testAst("a=\"\""));
-        ASSERT_EQUALS("a\'\'=", testAst("a=\'\'"));
-        ASSERT_EQUALS("'X''a'>", testAst("('X' > 'a')"));
-        ASSERT_EQUALS("L'X'L'a'>", testAst("(L'X' > L'a')"));
-        ASSERT_EQUALS("u'X'u'a'>", testAst("(u'X' > u'a')"));
-        ASSERT_EQUALS("U'X'U'a'>", testAst("(U'X' > U'a')"));
-        ASSERT_EQUALS("u8'X'u8'a'>", testAst("(u8'X' > u8'a')"));
-
-        ASSERT_EQUALS("a0>bc/d:?", testAst("(a>0) ? (b/(c)) : d;"));
-        ASSERT_EQUALS("abc/+d+", testAst("a + (b/(c)) + d;"));
-        ASSERT_EQUALS("x1024x/0:?", testAst("void f() { x ? 1024 / x : 0; }"));
-
-        ASSERT_EQUALS("absizeofd(ef.+(=", testAst("a = b(sizeof(c d) + e.f)"));
-
-        ASSERT_EQUALS("a*b***", testAst("*a * **b;")); // Correctly distinguish between unary and binary operator*
+        ASSERT_EQUALS("ab0=c1=:?", testAst("a?b=0:c=1;\n"));
+        ASSERT_EQUALS("fabc,d:?=e,", testAst("f = a ? b, c : d, e;\n"));
+        ASSERT_EQUALS("fabc,de,:?=", testAst("f = (a ? (b, c) : (d, e));\n"));
+        ASSERT_EQUALS("fabc,de,:?=", testAst("f = (a ? b, c : (d, e));\n"));
+        ASSERT_EQUALS("ab35,4:?foo(:?return", testAst("return (a ? b ? (3,5) : 4 : foo());\n"));
+        ASSERT_EQUALS("check(result_type00,{invalid:?return", testAst("return check() ? result_type {0, 0} : invalid;\n"));
+        ASSERT_EQUALS("x01:?return", testAst("return x ? 0 : 1;\n"));
+        ASSERT_EQUALS("x00throw:?return", testAst("return x ? 0 : throw 0;\n")); // #9768
+        ASSERT_EQUALS("val0<1throwval:?return", testAst("return val < 0 ? throw 1 : val;\n")); // #8526
+        ASSERT_EQUALS("ix0<00throw:?=", testAst("int i = x < 0 ? 0 : throw 0;\n"));
+        ASSERT_EQUALS("pa[pb[<1-pa[pb[>:?return", testAst("return p[a] < p[b] ? -1 : p[a] > p[b];\n"));
+
+        ASSERT_EQUALS("a\"\"=", testAst("a=\"\"\n"));
+        ASSERT_EQUALS("a\'\'=", testAst("a=\'\'\n"));
+        ASSERT_EQUALS("'X''a'>", testAst("('X' > 'a')\n"));
+        ASSERT_EQUALS("L'X'L'a'>", testAst("(L'X' > L'a')\n"));
+        ASSERT_EQUALS("u'X'u'a'>", testAst("(u'X' > u'a')\n"));
+        ASSERT_EQUALS("U'X'U'a'>", testAst("(U'X' > U'a')\n"));
+        ASSERT_EQUALS("u8'X'u8'a'>", testAst("(u8'X' > u8'a')\n"));
+
+        ASSERT_EQUALS("a0>bc/d:?", testAst("(a>0) ? (b/(c)) : d;\n"));
+        ASSERT_EQUALS("abc/+d+", testAst("a + (b/(c)) + d;\n"));
+        ASSERT_EQUALS("x1024x/0:?", testAst("void f() { x ? 1024 / x : 0; }\n"));
+
+        ASSERT_EQUALS("absizeofd(ef.+(=", testAst("a = b(sizeof(c d) + e.f)\n"));
+
+        ASSERT_EQUALS("a*b***", testAst("*a * **b;\n")); // Correctly distinguish between unary and binary operator*
 
         // strings
-        ASSERT_EQUALS("f\"A\"1,(",testAst("f(\"A\" B, 1);"));
-        ASSERT_EQUALS("fA1,(",testAst("f(A \"B\", 1);"));
+        ASSERT_EQUALS("f\"A\"1,(",testAst("f(\"A\" B, 1);\n"));
+        ASSERT_EQUALS("fA1,(",testAst("f(A \"B\", 1);\n"));
 
         // C++ : type()
-        ASSERT_EQUALS("fint(0,(", testAst("f(int(),0);"));
-        ASSERT_EQUALS("f(0,(", testAst("f(int *(),0);"));  // typedef int* X; f(X(),0);
-        ASSERT_EQUALS("f((0,(", testAst("f((intp)int *(),0);"));
-        ASSERT_EQUALS("zx1(&y2(&|=", testAst("z = (x & (unsigned)1) | (y & (unsigned)2);")); // not type()
+        ASSERT_EQUALS("fint(0,(", testAst("f(int(),0);\n"));
+        ASSERT_EQUALS("f(0,(", testAst("f(int *(),0);\n"));  // typedef int* X; f(X(),0);
+        ASSERT_EQUALS("f((0,(", testAst("f((intp)int *(),0);\n"));
+        ASSERT_EQUALS("zx1(&y2(&|=", testAst("z = (x & (unsigned)1) | (y & (unsigned)2);\n")); // not type()
 
         // for
-        ASSERT_EQUALS("for;;(", testAst("for(;;)"));
-        ASSERT_EQUALS("fora0=a8<a++;;(", testAst("for(a=0;a<8;a++)"));
-        ASSERT_EQUALS("fori1=current0=,iNUM<=i++;;(", testAst("for(i = (1), current = 0; i <= (NUM); ++i)"));
-        ASSERT_EQUALS("foreachxy,((", testAst("for(each(x,y)){}"));  // it's not well-defined what this ast should be
-        ASSERT_EQUALS("forvar1(;;(", testAst("for(int var(1);;)"));
-        ASSERT_EQUALS("forab:(", testAst("for (int a : b);"));
-        ASSERT_EQUALS("forvarb:(", testAst("for (int *var : b);"));
-        ASSERT_EQUALS("forvard:(", testAst("for (a<b> var : d);"));
-        ASSERT_EQUALS("forvare:(", testAst("for (a::b<c> var : e);"));
-        ASSERT_EQUALS("forx*0=yz;;(", testAst("for(*x=0;y;z)"));
-        ASSERT_EQUALS("forx0=y(8<z;;(", testAst("for (x=0;(int)y<8;z);"));
-        ASSERT_EQUALS("forab,c:(", testAst("for (auto [a,b]: c);"));
-        ASSERT_EQUALS("fora*++;;(", testAst("for (++(*a);;);"));
-        ASSERT_EQUALS("foryz:(", testAst("for (decltype(x) *y : z);"));
-        ASSERT_EQUALS("for(tmpNULL!=tmptmpnext.=;;( tmpa=", testAst("for ( ({ tmp = a; }) ; tmp != NULL; tmp = tmp->next ) {}"));
-        ASSERT_EQUALS("forx0=x;;(", testAst("for (int x=0; x;);"));
-        ASSERT_EQUALS("forae*bc.({:(", testAst("for (a *e : {b->c()});"));
-        ASSERT_EQUALS("fori0=iasize.(<i++;;( asize.(", testAst("for (decltype(a.size()) i = 0; i < a.size(); ++i);"));
-        ASSERT_EQUALS("foria:( asize.(", testAst("for(decltype(a.size()) i:a);"));
-        ASSERT_EQUALS("forec0{([,(:( fb.return", testAst("for (auto e : c(0, [](auto f) { return f->b; }));")); // #10802
-        ASSERT_EQUALS("forvar1{;;(", testAst("for(int var{1};;)")); // #12867
-        ASSERT_EQUALS("forxg{([(:( si.return", testAst("for (auto [x] : g([](S s) { return s.i; })) {}")); // #11861
+        ASSERT_EQUALS("for;;(", testAst("for(;;)\n"));
+        ASSERT_EQUALS("fora0=a8<a++;;(", testAst("for(a=0;a<8;a++)\n"));
+        ASSERT_EQUALS("fori1=current0=,iNUM<=i++;;(", testAst("for(i = (1), current = 0; i <= (NUM); ++i)\n"));
+        ASSERT_EQUALS("foreachxy,((", testAst("for(each(x,y)){}\n"));  // it's not well-defined what this ast should be
+        ASSERT_EQUALS("forvar1(;;(", testAst("for(int var(1);;)\n"));
+        ASSERT_EQUALS("forab:(", testAst("for (int a : b);\n"));
+        ASSERT_EQUALS("forvarb:(", testAst("for (int *var : b);\n"));
+        ASSERT_EQUALS("forvard:(", testAst("for (a<b> var : d);\n"));
+        ASSERT_EQUALS("forvare:(", testAst("for (a::b<c> var : e);\n"));
+        ASSERT_EQUALS("forx*0=yz;;(", testAst("for(*x=0;y;z)\n"));
+        ASSERT_EQUALS("forx0=y(8<z;;(", testAst("for (x=0;(int)y<8;z);\n"));
+        ASSERT_EQUALS("forab,c:(", testAst("for (auto [a,b]: c);\n"));
+        ASSERT_EQUALS("fora*++;;(", testAst("for (++(*a);;);\n"));
+        ASSERT_EQUALS("foryz:(", testAst("for (decltype(x) *y : z);\n"));
+        ASSERT_EQUALS("for(tmpNULL!=tmptmpnext.=;;( tmpa=", testAst("for ( ({ tmp = a; }) ; tmp != NULL; tmp = tmp->next ) {}\n"));
+        ASSERT_EQUALS("forx0=x;;(", testAst("for (int x=0; x;);\n"));
+        ASSERT_EQUALS("forae*bc.({:(", testAst("for (a *e : {b->c()});\n"));
+        ASSERT_EQUALS("fori0=iasize.(<i++;;( asize.(", testAst("for (decltype(a.size()) i = 0; i < a.size(); ++i);\n"));
+        ASSERT_EQUALS("foria:( asize.(", testAst("for(decltype(a.size()) i:a);\n"));
+        ASSERT_EQUALS("forec0{([,(:( fb.return", testAst("for (auto e : c(0, [](auto f) { return f->b; }));\n")); // #10802
+        ASSERT_EQUALS("forvar1{;;(", testAst("for(int var{1};;)\n")); // #12867
+        ASSERT_EQUALS("forxg{([(:( si.return", testAst("for (auto [x] : g([](S s) { return s.i; })) {}\n")); // #11861
 
         // for with initializer (c++20)
-        ASSERT_EQUALS("forab=ca:;(", testAst("for(a=b;int c:a)"));
+        ASSERT_EQUALS("forab=ca:;(", testAst("for(a=b;int c:a)\n"));
 
         // problems with multiple expressions
-        ASSERT_EQUALS("ax( whilex(", testAst("a(x) while (x)"));
-        ASSERT_EQUALS("ifx( i0= whilei(", testAst("if (x) { ({ int i = 0; while(i); }) };"));
-        ASSERT_EQUALS("ifx( BUG_ON{!( i0= whilei(", testAst("if (x) { BUG_ON(!({int i=0; while(i);})); }"));
-        ASSERT_EQUALS("v0= while{0!=( v0= while{0!=( v0=", testAst("({ v = 0; }); while (({ v = 0; }) != 0); while (({ v = 0; }) != 0);"));
+        ASSERT_EQUALS("ax( whilex(", testAst("a(x) while (x)\n"));
+        ASSERT_EQUALS("ifx( i0= whilei(", testAst("if (x) { ({ int i = 0; while(i); }) };\n"));
+        ASSERT_EQUALS("ifx( BUG_ON{!( i0= whilei(", testAst("if (x) { BUG_ON(!({int i=0; while(i);})); }\n"));
+        ASSERT_EQUALS("v0= while{0!=( v0= while{0!=( v0=", testAst("({ v = 0; }); while (({ v = 0; }) != 0); while (({ v = 0; }) != 0);\n"));
 
 
-        ASSERT_EQUALS("abc.1:?1+bd.1:?+=", testAst("a =(b.c ? : 1) + 1 + (b.d ? : 1);"));
+        ASSERT_EQUALS("abc.1:?1+bd.1:?+=", testAst("a =(b.c ? : 1) + 1 + (b.d ? : 1);\n"));
 
-        ASSERT_EQUALS("catch...(", testAst("try {} catch (...) {}"));
+        ASSERT_EQUALS("catch...(", testAst("try {} catch (...) {}\n"));
 
-        ASSERT_EQUALS("", testAst("void Foo(Bar&);"));
-        ASSERT_EQUALS("", testAst("void Foo(Bar&&);"));
+        ASSERT_EQUALS("", testAst("void Foo(Bar&);\n"));
+        ASSERT_EQUALS("", testAst("void Foo(Bar&&);\n"));
 
-        ASSERT_EQUALS("Barb&", testAst("void Foo(Bar& b);"));
-        ASSERT_EQUALS("Barb&&", testAst("void Foo(Bar&& b);"));
+        ASSERT_EQUALS("Barb&", testAst("void Foo(Bar& b);\n"));
+        ASSERT_EQUALS("Barb&&", testAst("void Foo(Bar&& b);\n"));
 
-        ASSERT_EQUALS("DerivedDerived::(", testAst("Derived::~Derived() {}"));
+        ASSERT_EQUALS("DerivedDerived::(", testAst("Derived::~Derived() {}\n"));
 
-        ASSERT_EQUALS("ifCA_FarReadfilenew(,sizeofobjtype(,(!(", testAst("if (!CA_FarRead(file, (void far *)new, sizeof(objtype)))")); // #5910 - don't hang if C code is parsed as C++
+        ASSERT_EQUALS("ifCA_FarReadfilenew(,sizeofobjtype(,(!(", testAst("if (!CA_FarRead(file, (void far *)new, sizeof(objtype)))\n")); // #5910 - don't hang if C code is parsed as C++
 
         // C++17: if (expr1; expr2)
-        ASSERT_EQUALS("ifx3=y;(", testAst("if (int x=3; y)"));
+        ASSERT_EQUALS("ifx3=y;(", testAst("if (int x=3; y)\n"));
 
-        ASSERT_EQUALS("xstdstring::decltypes(a::{=", testAst("auto x = std::string{ decltype(s)::a };"));
-        ASSERT_EQUALS("if0decltypest.(X::>(", testAst("if (0 > decltype(s.t)::X) {}"));
+        ASSERT_EQUALS("xstdstring::decltypes(a::{=", testAst("auto x = std::string{ decltype(s)::a };\n"));
+        ASSERT_EQUALS("if0decltypest.(X::>(", testAst("if (0 > decltype(s.t)::X) {}\n"));
     }
 
     void astexpr2() { // limit for large expressions
@@ -6934,190 +7019,190 @@ class TestTokenizer : public TestFixture {
     }
 
     void astnewdelete() {
-        ASSERT_EQUALS("aintnew=", testAst("a = new int;"));
-        ASSERT_EQUALS("aint4[new=", testAst("a = new int[4];"));
-        ASSERT_EQUALS("aFoobar(new=", testAst("a = new Foo(bar);"));
-        ASSERT_EQUALS("aFoobar(new=", testAst("a = new Foo(bar);"));
-        ASSERT_EQUALS("aFoo(new=", testAst("a = new Foo<bar>();"));
-        ASSERT_EQUALS("aXnew(", testAst("a (new (X));"));
-        ASSERT_EQUALS("aXnew5,(", testAst("a (new (X), 5);"));
-        ASSERT_EQUALS("adelete", testAst("delete a;"));
-        ASSERT_EQUALS("adelete", testAst("delete (a);"));
-        ASSERT_EQUALS("adelete", testAst("delete[] a;"));
-        ASSERT_EQUALS("ab.3c-(delete", testAst("delete[] a.b(3 - c);"));
-        ASSERT_EQUALS("aA1(new(bB2(new(,", testAst("a(new A(1)), b(new B(2))"));
-        ASSERT_EQUALS("Fred10[new", testAst(";new Fred[10];"));
-        ASSERT_EQUALS("adelete", testAst("void f() { delete a; }"));
-        ASSERT_EQUALS("Aa*A{new=", testAst("A* a = new A{};"));
-        ASSERT_EQUALS("Aa*A12,{new=", testAst("A* a = new A{ 1, 2 };"));
-        ASSERT_EQUALS("Sv0[(new", testAst("new S(v[0]);")); // #10929
-        ASSERT_EQUALS("SS::x(px0>intx[{newint1[{new:?(:", testAst("S::S(int x) : p(x > 0 ? new int[x]{} : new int[1]{}) {}")); // #10793
-        ASSERT_EQUALS("a0[T{new=", testAst("a[0] = new T{};"));
-        ASSERT_EQUALS("a0[T::{new=", testAst("a[0] = new ::T{};"));
-        ASSERT_EQUALS("a0[ST::{new=", testAst("a[0] = new S::T{};"));
-        ASSERT_EQUALS("intnewdelete", testAst("delete new int;")); // #11039
-        ASSERT_EQUALS("intnewdelete", testAst("void f() { delete new int; }"));
-        ASSERT_EQUALS("pint3[new1+=", testAst("p = (new int[3]) + 1;")); // #11327
-        ASSERT_EQUALS("aType2[T1T2,{new=", testAst("a = new Type *[2] {T1, T2};")); // #11745
-        ASSERT_EQUALS("pSthis(new=", testAst("p = new S*(this);")); // #10809
-        ASSERT_EQUALS("pint0{new=", testAst("p = new int*{ 0 };"));
-        ASSERT_EQUALS("pint5[{new=", testAst("p = new int* [5]{};"));
-        ASSERT_EQUALS("pint5[0{new=", testAst("p = new int* [5]{ 0 };"));
-        ASSERT_EQUALS("sSint(new::(new=", testAst("s = new S(::new int());")); // #12502
-        ASSERT_EQUALS("sS(new::=", testAst("s = ::new (ptr) S();")); // #12552
-        ASSERT_EQUALS("pdelete::return", testAst("return ::delete p;"));
-        ASSERT_EQUALS("gn--(delete", testAst("delete g(--n);"));
-        ASSERT_EQUALS("bdeletep1*p0*,deletep0*p1*,:?*return", testAst("return *(b ? (delete *p1, *p0) : (delete *p0, *p1));")); // #10662
+        ASSERT_EQUALS("aintnew=", testAst("a = new int;\n"));
+        ASSERT_EQUALS("aint4[new=", testAst("a = new int[4];\n"));
+        ASSERT_EQUALS("aFoobar(new=", testAst("a = new Foo(bar);\n"));
+        ASSERT_EQUALS("aFoobar(new=", testAst("a = new Foo(bar);\n"));
+        ASSERT_EQUALS("aFoo(new=", testAst("a = new Foo<bar>();\n"));
+        ASSERT_EQUALS("aXnew(", testAst("a (new (X));\n"));
+        ASSERT_EQUALS("aXnew5,(", testAst("a (new (X), 5);\n"));
+        ASSERT_EQUALS("adelete", testAst("delete a;\n"));
+        ASSERT_EQUALS("adelete", testAst("delete (a);\n"));
+        ASSERT_EQUALS("adelete", testAst("delete[] a;\n"));
+        ASSERT_EQUALS("ab.3c-(delete", testAst("delete[] a.b(3 - c);\n"));
+        ASSERT_EQUALS("aA1(new(bB2(new(,", testAst("a(new A(1)), b(new B(2))\n"));
+        ASSERT_EQUALS("Fred10[new", testAst(";new Fred[10];\n"));
+        ASSERT_EQUALS("adelete", testAst("void f() { delete a; }\n"));
+        ASSERT_EQUALS("Aa*A{new=", testAst("A* a = new A{};\n"));
+        ASSERT_EQUALS("Aa*A12,{new=", testAst("A* a = new A{ 1, 2 };\n"));
+        ASSERT_EQUALS("Sv0[(new", testAst("new S(v[0]);\n")); // #10929
+        ASSERT_EQUALS("SS::x(px0>intx[{newint1[{new:?(:", testAst("S::S(int x) : p(x > 0 ? new int[x]{} : new int[1]{}) {}\n")); // #10793
+        ASSERT_EQUALS("a0[T{new=", testAst("a[0] = new T{};\n"));
+        ASSERT_EQUALS("a0[T::{new=", testAst("a[0] = new ::T{};\n"));
+        ASSERT_EQUALS("a0[ST::{new=", testAst("a[0] = new S::T{};\n"));
+        ASSERT_EQUALS("intnewdelete", testAst("delete new int;\n")); // #11039
+        ASSERT_EQUALS("intnewdelete", testAst("void f() { delete new int; }\n"));
+        ASSERT_EQUALS("pint3[new1+=", testAst("p = (new int[3]) + 1;\n")); // #11327
+        ASSERT_EQUALS("aType2[T1T2,{new=", testAst("a = new Type *[2] {T1, T2};\n")); // #11745
+        ASSERT_EQUALS("pSthis(new=", testAst("p = new S*(this);\n")); // #10809
+        ASSERT_EQUALS("pint0{new=", testAst("p = new int*{ 0 };\n"));
+        ASSERT_EQUALS("pint5[{new=", testAst("p = new int* [5]{};\n"));
+        ASSERT_EQUALS("pint5[0{new=", testAst("p = new int* [5]{ 0 };\n"));
+        ASSERT_EQUALS("sSint(new::(new=", testAst("s = new S(::new int());\n")); // #12502
+        ASSERT_EQUALS("sS(new::=", testAst("s = ::new (ptr) S();\n")); // #12552
+        ASSERT_EQUALS("pdelete::return", testAst("return ::delete p;\n"));
+        ASSERT_EQUALS("gn--(delete", testAst("delete g(--n);\n"));
+        ASSERT_EQUALS("bdeletep1*p0*,deletep0*p1*,:?*return", testAst("return *(b ? (delete *p1, *p0) : (delete *p0, *p1));\n")); // #10662
 
         // placement new
-        ASSERT_EQUALS("X12,3,(new ab,c,", testAst("new (a,b,c) X(1,2,3);"));
-        ASSERT_EQUALS("aX::new=", testAst("a = new (b) ::X;"));
-        ASSERT_EQUALS("cCnew= abc:?", testAst("c = new(a ? b : c) C;"));
+        ASSERT_EQUALS("X12,3,(new ab,c,", testAst("new (a,b,c) X(1,2,3);\n"));
+        ASSERT_EQUALS("aX::new=", testAst("a = new (b) ::X;\n"));
+        ASSERT_EQUALS("cCnew= abc:?", testAst("c = new(a ? b : c) C;\n"));
 
         // invalid code (libreoffice), don't hang
         // #define SlideSorterViewShell
         // SfxViewFrame* pFrame;
         // new SlideSorterViewShell(pFrame,rViewShellBase,pParentWindow,pFrameViewArgument);
-        ASSERT_EQUALS("fxnewy,z,(", testAst("f(new (x,y,z));"));
+        ASSERT_EQUALS("fxnewy,z,(", testAst("f(new (x,y,z));\n"));
 
         // clang testsuite..
-        ASSERT_EQUALS("const0(new", testAst("new const auto (0);"));
-        ASSERT_EQUALS("autonew", testAst("new (auto) (0.0);"));
-        ASSERT_EQUALS("int3[4[5[new", testAst("new (int S::*[3][4][5]) ();"));
-        ASSERT_EQUALS("pSnew=", testAst("p=new (x)(S)(1,2);"));
-        ASSERT_EQUALS("inti[new(", testAst("(void)new (int[i]);"));
-        ASSERT_EQUALS("intp* pnew malloc4(", testAst("int*p; new (p) (malloc(4));"));
-        ASSERT_EQUALS("intnew", testAst("new (&w.x)(int*)(0);"));
-        ASSERT_EQUALS("&new", testAst("new (&w.x)(0);")); // <- the "(int*)" has been simplified
+        ASSERT_EQUALS("const0(new", testAst("new const auto (0);\n"));
+        ASSERT_EQUALS("autonew", testAst("new (auto) (0.0);\n"));
+        ASSERT_EQUALS("int3[4[5[new", testAst("new (int S::*[3][4][5]) ();\n"));
+        ASSERT_EQUALS("pSnew=", testAst("p=new (x)(S)(1,2);\n"));
+        ASSERT_EQUALS("inti[new(", testAst("(void)new (int[i]);\n"));
+        ASSERT_EQUALS("intp* pnew malloc4(", testAst("int*p; new (p) (malloc(4));\n"));
+        ASSERT_EQUALS("intnew", testAst("new (&w.x)(int*)(0);\n"));
+        ASSERT_EQUALS("&new", testAst("new (&w.x)(0);\n")); // <- the "(int*)" has been simplified
 
         // gcc testsuite..
-        ASSERT_EQUALS("char10[new(", testAst("(void)new(char*)[10];"));
+        ASSERT_EQUALS("char10[new(", testAst("(void)new(char*)[10];\n"));
     }
 
     void astpar() { // parentheses
-        ASSERT_EQUALS("12+3*", testAst("(1+2)*3"));
-        ASSERT_EQUALS("123+*", testAst("1*(2+3)"));
-        ASSERT_EQUALS("123+*4*", testAst("1*(2+3)*4"));
-        ASSERT_EQUALS("ifab.c&d==(", testAst("if((a.b&c)==d){}"));
+        ASSERT_EQUALS("12+3*", testAst("(1+2)*3\n"));
+        ASSERT_EQUALS("123+*", testAst("1*(2+3)\n"));
+        ASSERT_EQUALS("123+*4*", testAst("1*(2+3)*4\n"));
+        ASSERT_EQUALS("ifab.c&d==(", testAst("if((a.b&c)==d){}\n"));
 
-        ASSERT_EQUALS("pf.pf.12,(&&", testAst("((p.f) && (p.f)(1,2))"));
+        ASSERT_EQUALS("pf.pf.12,(&&", testAst("((p.f) && (p.f)(1,2))\n"));
 
-        ASSERT_EQUALS("forresdirGetFirst.file&_T(,(=;;(", testAst("for ((res = dir.GetFirst(&file, _T(" ")));;) {}"));
+        ASSERT_EQUALS("forresdirGetFirst.file&_T(,(=;;(", testAst("for ((res = dir.GetFirst(&file, _T(" ")));;) {}\n"));
 
         // problems with: if (x[y]==z)
-        ASSERT_EQUALS("ifa(0[1==(", testAst("if(a()[0]==1){}"));
-        ASSERT_EQUALS("ifbuff0[&(*1==(", testAst("if (*((DWORD*)&buff[0])==1){}"));
-        ASSERT_EQUALS("ifp*0[1==(", testAst("if((*p)[0]==1)"));
-        ASSERT_EQUALS("ifab.cd.[e==(", testAst("if(a.b[c.d]==e){}"));
+        ASSERT_EQUALS("ifa(0[1==(", testAst("if(a()[0]==1){}\n"));
+        ASSERT_EQUALS("ifbuff0[&(*1==(", testAst("if (*((DWORD*)&buff[0])==1){}\n"));
+        ASSERT_EQUALS("ifp*0[1==(", testAst("if((*p)[0]==1)\n"));
+        ASSERT_EQUALS("ifab.cd.[e==(", testAst("if(a.b[c.d]==e){}\n"));
 
-        ASSERT_EQUALS("iftpnote.i1-[note.0==tpnote.i1-[type.4>||(", testAst("if ((tp.note[i - 1].note == 0) || (tp.note[i - 1].type > 4)) {}"));
-        ASSERT_EQUALS("ab.i[j1+[", testAst("a.b[i][j+1]"));
+        ASSERT_EQUALS("iftpnote.i1-[note.0==tpnote.i1-[type.4>||(", testAst("if ((tp.note[i - 1].note == 0) || (tp.note[i - 1].type > 4)) {}\n"));
+        ASSERT_EQUALS("ab.i[j1+[", testAst("a.b[i][j+1]\n"));
 
         // problems with: x=expr
         ASSERT_EQUALS("(= x (( (. ([ a i) f)))",
-                      testAst("x = ((a[i]).f)();", AstStyle::Z3));
-        ASSERT_EQUALS("abc.de.++[=", testAst("a = b.c[++(d.e)];"));
-        ASSERT_EQUALS("abc(1+=", testAst("a = b(c**)+1;"));
-        ASSERT_EQUALS("abc.=", testAst("a = (b).c;"));
+                      testAst("x = ((a[i]).f)();\n", AstStyle::Z3));
+        ASSERT_EQUALS("abc.de.++[=", testAst("a = b.c[++(d.e)];\n"));
+        ASSERT_EQUALS("abc(1+=", testAst("a = b(c**)+1;\n"));
+        ASSERT_EQUALS("abc.=", testAst("a = (b).c;\n"));
 
         // casts
-        ASSERT_EQUALS("a1(2(+=",testAst("a=(t)1+(t)2;"));
-        ASSERT_EQUALS("a1(2+=",testAst("a=(t)1+2;"));
-        ASSERT_EQUALS("a1(2+=",testAst("a=(t*)1+2;"));
-        ASSERT_EQUALS("a1(2+=",testAst("a=(t&)1+2;"));
-        ASSERT_EQUALS("a1(2+=",testAst("a=(t&&)1+2;"));
-        ASSERT_EQUALS("ab::r&c(=", testAst("a::b& r = (a::b&)c;")); // #5261
-        ASSERT_EQUALS("ab10:?=", testAst("a=(b)?1:0;"));
-        ASSERT_EQUALS("ac5[new(=", testAst("a = (b*)(new c[5]);")); // #8786
-        ASSERT_EQUALS("a(4+", testAst("(int)(a) + 4;"));
+        ASSERT_EQUALS("a1(2(+=",testAst("a=(t)1+(t)2;\n"));
+        ASSERT_EQUALS("a1(2+=",testAst("a=(t)1+2;\n"));
+        ASSERT_EQUALS("a1(2+=",testAst("a=(t*)1+2;\n"));
+        ASSERT_EQUALS("a1(2+=",testAst("a=(t&)1+2;\n"));
+        ASSERT_EQUALS("a1(2+=",testAst("a=(t&&)1+2;\n"));
+        ASSERT_EQUALS("ab::r&c(=", testAst("a::b& r = (a::b&)c;\n")); // #5261
+        ASSERT_EQUALS("ab10:?=", testAst("a=(b)?1:0;\n"));
+        ASSERT_EQUALS("ac5[new(=", testAst("a = (b*)(new c[5]);\n")); // #8786
+        ASSERT_EQUALS("a(4+", testAst("(int)(a) + 4;\n"));
 
         // (cast){data}[index]
-        ASSERT_EQUALS("a&{(0[1[5[0=", testAst("(int (**)[i]){&a}[0][1][5] = 0;"));
-        ASSERT_EQUALS("ab12,{(0[,(", testAst("a(b, (int []){1,2}[0]);"));
-        ASSERT_EQUALS("TrivialDefCtora2[2[{1[1[n.0=", testAst("TrivialDefCtor{a[2][2]}[1][1].n = 0;"));
-        ASSERT_EQUALS("aT12,3,{1[=", testAst("a = T{1, 2, 3}[1];"));
+        ASSERT_EQUALS("a&{(0[1[5[0=", testAst("(int (**)[i]){&a}[0][1][5] = 0;\n"));
+        ASSERT_EQUALS("ab12,{(0[,(", testAst("a(b, (int []){1,2}[0]);\n"));
+        ASSERT_EQUALS("TrivialDefCtora2[2[{1[1[n.0=", testAst("TrivialDefCtor{a[2][2]}[1][1].n = 0;\n"));
+        ASSERT_EQUALS("aT12,3,{1[=", testAst("a = T{1, 2, 3}[1];\n"));
 
         // Type{data}()
-        ASSERT_EQUALS("ab{(=", testAst("a=b{}();"));
-        ASSERT_EQUALS("abc{((=", testAst("a=b(c{}());"));
-        ASSERT_EQUALS("xNULL!=0(x(:?", testAst("void f() { {} ((x != NULL) ? (void)0 : x()); }"));
+        ASSERT_EQUALS("ab{(=", testAst("a=b{}();\n"));
+        ASSERT_EQUALS("abc{((=", testAst("a=b(c{}());\n"));
+        ASSERT_EQUALS("xNULL!=0(x(:?", testAst("void f() { {} ((x != NULL) ? (void)0 : x()); }\n"));
 
         // ({..})
-        ASSERT_EQUALS("a{+d+ bc+", testAst("a+({b+c;})+d"));
-        ASSERT_EQUALS("a{d*+ bc+", testAst("a+({b+c;})*d"));
+        ASSERT_EQUALS("a{+d+ bc+", testAst("a+({b+c;})+d\n"));
+        ASSERT_EQUALS("a{d*+ bc+", testAst("a+({b+c;})*d\n"));
         ASSERT_EQUALS("xa{((= bc( yd{((= ef(",
-                      testAst("x=(int)(a({b(c);}));" // don't hang
-                              "y=(int)(d({e(f);}));"));
+                      testAst("x=(int)(a({b(c);}));\n" // don't hang
+                              "y=(int)(d({e(f);}));\n"));
         ASSERT_EQUALS("A{{,( x0= Bx1={x2={,(",  // TODO: This is not perfect!!
-                      testAst("A({},{x=0;});" // don't hang
-                              "B({x=1},{x=2});"));
+                      testAst("A({},{x=0;});\n" // don't hang
+                              "B({x=1},{x=2});\n"));
         ASSERT_EQUALS("xMACROtype.T=value.1=,{({=",
-                      testAst("x = { MACRO( { .type=T, .value=1 } ) }")); // don't hang: MACRO({..})
-        ASSERT_EQUALS("fori10=i{;;( i--", testAst("for (i=10;i;({i--;}) ) {}"));
+                      testAst("x = { MACRO( { .type=T, .value=1 } ) }\n")); // don't hang: MACRO({..})
+        ASSERT_EQUALS("fori10=i{;;( i--", testAst("for (i=10;i;({i--;}) ) {}\n"));
         ASSERT_EQUALS("c{1{,{2.3f{,(",
-                      testAst("c({{}, {1}}, {2.3f});"));
-        ASSERT_EQUALS("x{{= e0= assert0(", testAst("x = {({ int e = 0; assert(0); e; })};"));
+                      testAst("c({{}, {1}}, {2.3f});\n"));
+        ASSERT_EQUALS("x{{= e0= assert0(", testAst("x = {({ int e = 0; assert(0); e; })};\n"));
 
         // function pointer
-        TODO_ASSERT_EQUALS("todo", "va_argapvoid((,(*0=", testAst("*va_arg(ap, void(**) ()) = 0;"));
+        TODO_ASSERT_EQUALS("todo", "va_argapvoid((,(*0=", testAst("*va_arg(ap, void(**) ()) = 0;\n"));
 
         // struct/array initialization
-        ASSERT_EQUALS("name_bytes[bits~unusedBits>>unusedBits<<{=", testAst("const uint8_t name_bytes[] = { (~bits >> unusedBits) << unusedBits };"));
-        ASSERT_EQUALS("abuf.0{={=", testAst("a = { .buf = { 0 } };"));
-        ASSERT_EQUALS("ab2[a.0=b.0=,{a.0=b.0=,{,{=", testAst("struct AB ab[2] = { { .a=0, .b=0 }, { .a=0, .b=0 } };"));
-        ASSERT_EQUALS("tset{=", testAst("struct cgroup_taskset tset = {};"));
-        ASSERT_EQUALS("s1a&,{2b&,{,{=", testAst("s = { {1, &a}, {2, &b} };"));
-        ASSERT_EQUALS("s0[L.2[x={=", testAst("s = { [0].L[2] = x};"));
-        ASSERT_EQUALS("ac.0={(=", testAst("a = (b){.c=0,};")); // <- useless comma
-        ASSERT_EQUALS("xB[1y.z.1={(&=,{={=", testAst("x = { [B] = {1, .y = &(struct s) { .z=1 } } };"));
-        ASSERT_EQUALS("xab,c,{=", testAst("x={a,b,(c)};"));
-        ASSERT_EQUALS("x0fSa.1=b.2=,c.\"\"=,{(||=", testAst("x = 0 || f(S{.a = 1, .b = 2, .c = \"\" });"));
-        ASSERT_EQUALS("x0fSa.1{=b.2{,c.\"\"=,{(||=", testAst("x = 0 || f(S{.a = { 1 }, .b { 2 }, .c = \"\" });"));
-        ASSERT_EQUALS("a0\"\"abc12:?,{{,(", testAst("a(0, {{\"\", (abc) ? 1 : 2}});"));
-        ASSERT_EQUALS("a0\'\'abc12:?,{{,(", testAst("a(0, {{\'\', (abc) ? 1 : 2}});"));
-        ASSERT_EQUALS("x12,{34,{,{56,{78,{,{,{=", testAst("x = { { {1,2}, {3,4} }, { {5,6}, {7,8} } };"));
-        ASSERT_EQUALS("Sa.stdmove::s(=b.1=,{(", testAst("S({.a = std::move(s), .b = 1})"));
+        ASSERT_EQUALS("name_bytes[bits~unusedBits>>unusedBits<<{=", testAst("const uint8_t name_bytes[] = { (~bits >> unusedBits) << unusedBits };\n"));
+        ASSERT_EQUALS("abuf.0{={=", testAst("a = { .buf = { 0 } };\n"));
+        ASSERT_EQUALS("ab2[a.0=b.0=,{a.0=b.0=,{,{=", testAst("struct AB ab[2] = { { .a=0, .b=0 }, { .a=0, .b=0 } };\n"));
+        ASSERT_EQUALS("tset{=", testAst("struct cgroup_taskset tset = {};\n"));
+        ASSERT_EQUALS("s1a&,{2b&,{,{=", testAst("s = { {1, &a}, {2, &b} };\n"));
+        ASSERT_EQUALS("s0[L.2[x={=", testAst("s = { [0].L[2] = x};\n"));
+        ASSERT_EQUALS("ac.0={(=", testAst("a = (b){.c=0,};\n")); // <- useless comma
+        ASSERT_EQUALS("xB[1y.z.1={(&=,{={=", testAst("x = { [B] = {1, .y = &(struct s) { .z=1 } } };\n"));
+        ASSERT_EQUALS("xab,c,{=", testAst("x={a,b,(c)};\n"));
+        ASSERT_EQUALS("x0fSa.1=b.2=,c.\"\"=,{(||=", testAst("x = 0 || f(S{.a = 1, .b = 2, .c = \"\" });\n"));
+        ASSERT_EQUALS("x0fSa.1{=b.2{,c.\"\"=,{(||=", testAst("x = 0 || f(S{.a = { 1 }, .b { 2 }, .c = \"\" });\n"));
+        ASSERT_EQUALS("a0\"\"abc12:?,{{,(", testAst("a(0, {{\"\", (abc) ? 1 : 2}});\n"));
+        ASSERT_EQUALS("a0\'\'abc12:?,{{,(", testAst("a(0, {{\'\', (abc) ? 1 : 2}});\n"));
+        ASSERT_EQUALS("x12,{34,{,{56,{78,{,{,{=", testAst("x = { { {1,2}, {3,4} }, { {5,6}, {7,8} } };\n"));
+        ASSERT_EQUALS("Sa.stdmove::s(=b.1=,{(", testAst("S({.a = std::move(s), .b = 1})\n"));
 
         // struct initialization hang
         ASSERT_EQUALS("sbar.1{,{(={= forfieldfield++;;(",
                       testAst("struct S s = {.bar = (struct foo) { 1, { } } };\n"
-                              "void f(struct cmd *) { for (; field; field++) {} }"));
+                              "void f(struct cmd *) { for (; field; field++) {} }\n"));
 
         // template parentheses: <>
-        ASSERT_EQUALS("ab::c(de::(<=return", testAst("return a::b(c) <= d<double>::e();")); // #6195
+        ASSERT_EQUALS("ab::c(de::(<=return", testAst("return a::b(c) <= d<double>::e();\n")); // #6195
 
         // C++ initializer
-        ASSERT_EQUALS("Class{", testAst("Class{};"));
-        ASSERT_EQUALS("Class12,{", testAst("Class{1,2};"));
-        ASSERT_EQUALS("Class12,{", testAst("Class<X>{1,2};"));
-        ASSERT_EQUALS("abc{d:?=", testAst("a=b?c{}:d;"));
-        ASSERT_EQUALS("abc12,{d:?=", testAst("a=b?c{1,2}:d;"));
-        ASSERT_EQUALS("abc{d:?=", testAst("a=b?c<X>{}:d;"));
-        ASSERT_EQUALS("abc12,{d:?=", testAst("a=b?c<X>{1,2}:d;"));
-        ASSERT_EQUALS("a::12,{", testAst("::a{1,2};")); // operator precedence
-        ASSERT_EQUALS("Abc({newreturn", testAst("return new A {b(c)};"));
-        ASSERT_EQUALS("a{{return", testAst("return{{a}};"));
-        ASSERT_EQUALS("a{b{,{return", testAst("return{{a},{b}};"));
-        ASSERT_EQUALS("stdvector::{{,{return", testAst("return std::vector<std::vector<int> >{{},{}};"));
-        ASSERT_EQUALS("stdvector::{2{,{return", testAst("return std::vector<std::vector<int> >{{}, {2}};"));
-        ASSERT_EQUALS("forbstdvector::{{,{:(", testAst("for (auto b : std::vector<std::vector<int> >{{},{}});"));
-        ASSERT_EQUALS("forbstdvector::{2{,{:(", testAst("for (auto b : std::vector<std::vector<int> >{{}, {2}});"));
-        ASSERT_EQUALS("abR{{,P(,((", testAst("a(b(R{},{},P()));"));
-        ASSERT_EQUALS("f1{2{,3{,{x,(", testAst("f({{1},{2},{3}},x);"));
-        ASSERT_EQUALS("a1{ b2{", testAst("auto a{1}; auto b{2};"));
-        ASSERT_EQUALS("var1ab::23,{,{4ab::56,{,{,{", testAst("auto var{{1,a::b{2,3}}, {4,a::b{5,6}}};"));
-        ASSERT_EQUALS("var{{,{{,{", testAst("auto var{ {{},{}}, {} };"));
-        ASSERT_EQUALS("fXYabcfalse==CD:?,{,{(", testAst("f({X, {Y, abc == false ? C : D}});"));
-        ASSERT_EQUALS("stdvector::p0[{(return", testAst("return std::vector<int>({ p[0] });"));
-        ASSERT_EQUALS("vstdvector::{=", testAst("auto v = std::vector<int>{ };"));
+        ASSERT_EQUALS("Class{", testAst("Class{};\n"));
+        ASSERT_EQUALS("Class12,{", testAst("Class{1,2};\n"));
+        ASSERT_EQUALS("Class12,{", testAst("Class<X>{1,2};\n"));
+        ASSERT_EQUALS("abc{d:?=", testAst("a=b?c{}:d;\n"));
+        ASSERT_EQUALS("abc12,{d:?=", testAst("a=b?c{1,2}:d;\n"));
+        ASSERT_EQUALS("abc{d:?=", testAst("a=b?c<X>{}:d;\n"));
+        ASSERT_EQUALS("abc12,{d:?=", testAst("a=b?c<X>{1,2}:d;\n"));
+        ASSERT_EQUALS("a::12,{", testAst("::a{1,2};\n")); // operator precedence
+        ASSERT_EQUALS("Abc({newreturn", testAst("return new A {b(c)};\n"));
+        ASSERT_EQUALS("a{{return", testAst("return{{a}};\n"));
+        ASSERT_EQUALS("a{b{,{return", testAst("return{{a},{b}};\n"));
+        ASSERT_EQUALS("stdvector::{{,{return", testAst("return std::vector<std::vector<int> >{{},{}};\n"));
+        ASSERT_EQUALS("stdvector::{2{,{return", testAst("return std::vector<std::vector<int> >{{}, {2}};\n"));
+        ASSERT_EQUALS("forbstdvector::{{,{:(", testAst("for (auto b : std::vector<std::vector<int> >{{},{}});\n"));
+        ASSERT_EQUALS("forbstdvector::{2{,{:(", testAst("for (auto b : std::vector<std::vector<int> >{{}, {2}});\n"));
+        ASSERT_EQUALS("abR{{,P(,((", testAst("a(b(R{},{},P()));\n"));
+        ASSERT_EQUALS("f1{2{,3{,{x,(", testAst("f({{1},{2},{3}},x);\n"));
+        ASSERT_EQUALS("a1{ b2{", testAst("auto a{1}; auto b{2};\n"));
+        ASSERT_EQUALS("var1ab::23,{,{4ab::56,{,{,{", testAst("auto var{{1,a::b{2,3}}, {4,a::b{5,6}}};\n"));
+        ASSERT_EQUALS("var{{,{{,{", testAst("auto var{ {{},{}}, {} };\n"));
+        ASSERT_EQUALS("fXYabcfalse==CD:?,{,{(", testAst("f({X, {Y, abc == false ? C : D}});\n"));
+        ASSERT_EQUALS("stdvector::p0[{(return", testAst("return std::vector<int>({ p[0] });\n"));
+        ASSERT_EQUALS("vstdvector::{=", testAst("auto v = std::vector<int>{ };\n"));
 
         // Initialization with decltype(expr) instead of a type
-        ASSERT_EQUALS("decltypex((", testAst("decltype(x)();"));
-        ASSERT_EQUALS("decltypex({", testAst("decltype(x){};"));
-        ASSERT_EQUALS("decltypexy+(yx+(", testAst("decltype(x+y)(y+x);"));
-        ASSERT_EQUALS("decltypexy+(yx+{", testAst("decltype(x+y){y+x};"));
+        ASSERT_EQUALS("decltypex((", testAst("decltype(x)();\n"));
+        ASSERT_EQUALS("decltypex({", testAst("decltype(x){};\n"));
+        ASSERT_EQUALS("decltypexy+(yx+(", testAst("decltype(x+y)(y+x);\n"));
+        ASSERT_EQUALS("decltypexy+(yx+{", testAst("decltype(x+y){y+x};\n"));
         ASSERT_EQUALS("adecltypeac::(,decltypead::(,",
-                      testAst("template <typename a> void b(a &, decltype(a::c), decltype(a::d));"));
+                      testAst("template <typename a> void b(a &, decltype(a::c), decltype(a::d));\n"));
 
         ASSERT_NO_THROW(tokenizeAndStringify("struct A;\n" // #10839
                                              "struct B { A* hash; };\n"
@@ -7155,12 +7240,12 @@ class TestTokenizer : public TestFixture {
         (void)tokenizeAndStringify("void foo(const std::vector<std::string>& locations = {\"\"}) {\n"
                                    "    for (int i = 0; i <= 123; ++i)\n"
                                    "        x->emplace_back(y);\n"
-                                   "}");
+                                   "}\n");
         ignore_errout();
 
         ASSERT_NO_THROW(tokenizeAndStringify("void f() {\n" // #10831
                                              "    auto g = [](std::function<void()> h = []() {}) { };\n"
-                                             "}"));
+                                             "}\n"));
         ASSERT_EQUALS("", errout_str());
 
         ASSERT_NO_THROW(tokenizeAndStringify("void f() {\n" // #11379
@@ -7170,132 +7255,132 @@ class TestTokenizer : public TestFixture {
             "[test.cpp:2:15]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
             errout_str());
 
-        ASSERT_EQUALS("forinti(0=i5<=i++;;(", testAst("for (int (i) = 0; (i) <= 5; (i)++) {}")); // #13225
+        ASSERT_EQUALS("forinti(0=i5<=i++;;(", testAst("for (int (i) = 0; (i) <= 5; (i)++) {}\n")); // #13225
     }
 
     void astbrackets() { // []
-        ASSERT_EQUALS("a23+[4+", testAst("a[2+3]+4"));
-        ASSERT_EQUALS("a1[0[", testAst("a[1][0]"));
-        ASSERT_EQUALS("ab0[=", testAst("a=(b)[0];"));
-        ASSERT_EQUALS("abc.0[=", testAst("a=b.c[0];"));
-        ASSERT_EQUALS("ab0[1[=", testAst("a=b[0][1];"));
+        ASSERT_EQUALS("a23+[4+", testAst("a[2+3]+4\n"));
+        ASSERT_EQUALS("a1[0[", testAst("a[1][0]\n"));
+        ASSERT_EQUALS("ab0[=", testAst("a=(b)[0];\n"));
+        ASSERT_EQUALS("abc.0[=", testAst("a=b.c[0];\n"));
+        ASSERT_EQUALS("ab0[1[=", testAst("a=b[0][1];\n"));
     }
 
     void astvardecl() {
         // Variable declaration
-        ASSERT_EQUALS("a1[\"\"=", testAst("char a[1]=\"\";"));
-        ASSERT_EQUALS("charp*(3[char5[3[new=", testAst("char (*p)[3] = new char[5][3];"));
-        ASSERT_EQUALS("varp=", testAst("const int *var = p;"));
-        ASSERT_EQUALS("intrp0[*(&", testAst("int& r(*p[0]);"));
+        ASSERT_EQUALS("a1[\"\"=", testAst("char a[1]=\"\";\n"));
+        ASSERT_EQUALS("charp*(3[char5[3[new=", testAst("char (*p)[3] = new char[5][3];\n"));
+        ASSERT_EQUALS("varp=", testAst("const int *var = p;\n"));
+        ASSERT_EQUALS("intrp0[*(&", testAst("int& r(*p[0]);\n"));
 
         // #9127
         const char code1[] = "using uno::Ref;\n"
                              "Ref<X> r;\n"
-                             "int var(0);";
+                             "int var(0);\n";
         ASSERT_EQUALS("unoRef:: var0(", testAst(code1));
 
-        ASSERT_EQUALS("vary=", testAst("std::string var = y;"));
-        ASSERT_EQUALS("vary=", testAst("std::unique_ptr<int> var = y;")); // #14019
+        ASSERT_EQUALS("vary=", testAst("std::string var = y;\n"));
+        ASSERT_EQUALS("vary=", testAst("std::unique_ptr<int> var = y;\n")); // #14019
 
-        ASSERT_EQUALS("", testAst("void *(*var)(int);"));
-        ASSERT_EQUALS("", testAst("void *(*var[2])(int);"));
+        ASSERT_EQUALS("", testAst("void *(*var)(int);\n"));
+        ASSERT_EQUALS("", testAst("void *(*var[2])(int);\n"));
 
 
         // create ast for decltype
-        ASSERT_EQUALS("decltypex( var1=", testAst("decltype(x) var = 1;"));
-        ASSERT_EQUALS("a1bdecltypet((>2,(", testAst("a(1 > b(decltype(t)), 2);")); // #10271
-        ASSERT_EQUALS("decltypex({01:?", testAst("decltype(x){} ? 0 : 1;"));
+        ASSERT_EQUALS("decltypex( var1=", testAst("decltype(x) var = 1;\n"));
+        ASSERT_EQUALS("a1bdecltypet((>2,(", testAst("a(1 > b(decltype(t)), 2);\n")); // #10271
+        ASSERT_EQUALS("decltypex({01:?", testAst("decltype(x){} ? 0 : 1;\n"));
 
         ASSERT_EQUALS("Tp* Tt* forctp.=;;( tp.", testAst("struct T { T* p; };\n" // #10874
                                                          "void f(T * t) {\n"
                                                          "    for (decltype(t->p) (c) = t->p; ;) {}\n"
                                                          "}\n"));
         ASSERT_EQUALS("x0=a, stdtie::a(x=", testAst("int x = 0, a; std::tie(a) = x;\n"));
-        ASSERT_EQUALS("tmpa*=a*b*=,b*tmp=,", testAst("{ ((tmp) = (*a)), ((*a) = (*b)), ((*b) = (tmp)); }"));
-        ASSERT_EQUALS("a(*v=", testAst("(*(volatile unsigned int *)(a) = (v));"));
-        ASSERT_EQUALS("i(j=", testAst("(int&)(i) = j;"));
+        ASSERT_EQUALS("tmpa*=a*b*=,b*tmp=,", testAst("{ ((tmp) = (*a)), ((*a) = (*b)), ((*b) = (tmp)); }\n"));
+        ASSERT_EQUALS("a(*v=", testAst("(*(volatile unsigned int *)(a) = (v));\n"));
+        ASSERT_EQUALS("i(j=", testAst("(int&)(i) = j;\n"));
 
-        ASSERT_EQUALS("", testAst("void f(enum E* var){}"));
-        ASSERT_EQUALS("", testAst("void f(enum E*& var){}"));
-        ASSERT_EQUALS("", testAst("void f(bool& var){}"));
+        ASSERT_EQUALS("", testAst("void f(enum E* var){}\n"));
+        ASSERT_EQUALS("", testAst("void f(enum E*& var){}\n"));
+        ASSERT_EQUALS("", testAst("void f(bool& var){}\n"));
     }
 
     void astunaryop() { // unary operators
-        ASSERT_EQUALS("1a--+", testAst("1 + --a"));
-        ASSERT_EQUALS("1a--+", testAst("1 + a--"));
-        ASSERT_EQUALS("ab+!", testAst("!(a+b)"));
-        ASSERT_EQUALS("ab.++", testAst("++a.b;"));
-        ASSERT_EQUALS("ab.++", testAst("a.b++;"));
-        ASSERT_EQUALS("ab::++", testAst("a::b++;"));
-        ASSERT_EQUALS("c5[--*", testAst("*c[5]--;"));
-        ASSERT_EQUALS("xreturn", testAst("return x;"));
-        ASSERT_EQUALS("x(throw", testAst(";throw x();"));
-        ASSERT_EQUALS("a*bc:?return", testAst("return *a ? b : c;"));
-        ASSERT_EQUALS("xy*--=", testAst("x = -- * y;"));
-        ASSERT_EQUALS("x(throw", testAst(";throw (foo) x;")); // #9955
+        ASSERT_EQUALS("1a--+", testAst("1 + --a\n"));
+        ASSERT_EQUALS("1a--+", testAst("1 + a--\n"));
+        ASSERT_EQUALS("ab+!", testAst("!(a+b)\n"));
+        ASSERT_EQUALS("ab.++", testAst("++a.b;\n"));
+        ASSERT_EQUALS("ab.++", testAst("a.b++;\n"));
+        ASSERT_EQUALS("ab::++", testAst("a::b++;\n"));
+        ASSERT_EQUALS("c5[--*", testAst("*c[5]--;\n"));
+        ASSERT_EQUALS("xreturn", testAst("return x;\n"));
+        ASSERT_EQUALS("x(throw", testAst(";throw x();\n"));
+        ASSERT_EQUALS("a*bc:?return", testAst("return *a ? b : c;\n"));
+        ASSERT_EQUALS("xy*--=", testAst("x = -- * y;\n"));
+        ASSERT_EQUALS("x(throw", testAst(";throw (foo) x;\n")); // #9955
 
         // Unary :: operator
-        ASSERT_EQUALS("abcd::12,(e/:?=", testAst("a = b ? c : ::d(1,2) / e;"));
+        ASSERT_EQUALS("abcd::12,(e/:?=", testAst("a = b ? c : ::d(1,2) / e;\n"));
 
         // how is "--" handled here:
-        ASSERT_EQUALS("ab4<<c--+1:?", testAst("a ? (b << 4) + --c : 1"));
-        ASSERT_EQUALS("ab4<<c--+1:?", testAst("a ? (b << 4) + c-- : 1"));
-        ASSERT_EQUALS("ai[i= i--", testAst("a[i]=i; --i;"));
+        ASSERT_EQUALS("ab4<<c--+1:?", testAst("a ? (b << 4) + --c : 1\n"));
+        ASSERT_EQUALS("ab4<<c--+1:?", testAst("a ? (b << 4) + c-- : 1\n"));
+        ASSERT_EQUALS("ai[i= i--", testAst("a[i]=i; --i;\n"));
 
-        ASSERT_EQUALS("fint0{1&(", testAst("f(int{ 0 } & 1);")); // #11572
-        ASSERT_EQUALS("int0{1&return", testAst("int g() { return int{ 0 } & 1; }"));
+        ASSERT_EQUALS("fint0{1&(", testAst("f(int{ 0 } & 1);\n")); // #11572
+        ASSERT_EQUALS("int0{1&return", testAst("int g() { return int{ 0 } & 1; }\n"));
     }
 
     void astfunction() { // function calls
-        ASSERT_EQUALS("1f(+2+", testAst("1+f()+2"));
-        ASSERT_EQUALS("1f2(+3+", testAst("1+f(2)+3"));
-        ASSERT_EQUALS("1f23,(+4+", testAst("1+f(2,3)+4"));
-        ASSERT_EQUALS("1f2a&,(+", testAst("1+f(2,&a)"));
-        ASSERT_EQUALS("argv[", testAst("int f(char argv[]);"));
-        ASSERT_EQUALS("", testAst("void f();"));
-        ASSERT_EQUALS("", testAst("void f() {}"));
-        ASSERT_EQUALS("", testAst("int f() = delete;"));
-        ASSERT_EQUALS("", testAst("a::b f();"));
-        ASSERT_EQUALS("", testAst("a::b f() {}"));
-        ASSERT_EQUALS("", testAst("a::b f() = delete;"));
-        ASSERT_EQUALS("", testAst("int f() const = delete;"));
-        ASSERT_EQUALS("", testAst("extern unsigned f(const char *);"));
-        ASSERT_EQUALS("charformat*...,", testAst("extern void f(const char *format, ...);"));
-        ASSERT_EQUALS("int(int(void,", testAst("extern int for_each_commit_graft(int (*)(int*), void *);"));
-        ASSERT_EQUALS("for;;(", testAst("for (;;) {}"));
-        ASSERT_EQUALS("xsizeofvoid(=", testAst("x=sizeof(void*)"));
-        ASSERT_EQUALS("abc{d{,{(=", testAst("a = b({ c{}, d{} });"));
-        ASSERT_EQUALS("abc;(", testAst("a(b;c)"));
-        ASSERT_EQUALS("x{( forbc;;(", testAst("x({ for(a;b;c){} });"));
-        ASSERT_EQUALS("PT.(", testAst("P->~T();"));  // <- The "T" token::function() will be a destructor
-        ASSERT_EQUALS("double&(4[", testAst("void f(double(&)[4]) {}"));
-        ASSERT_EQUALS("voidu*", testAst("int* g ( void* (f) (void*), void* u);")); // #12475
-        ASSERT_EQUALS("f::(", testAst("::f();")); // #12544
-        ASSERT_EQUALS("(( f (, c ({ (= (. x) 0))))", testAst("f(c, { .x = 0 });", AstStyle::Z3)); // #12806
+        ASSERT_EQUALS("1f(+2+", testAst("1+f()+2\n"));
+        ASSERT_EQUALS("1f2(+3+", testAst("1+f(2)+3\n"));
+        ASSERT_EQUALS("1f23,(+4+", testAst("1+f(2,3)+4\n"));
+        ASSERT_EQUALS("1f2a&,(+", testAst("1+f(2,&a)\n"));
+        ASSERT_EQUALS("argv[", testAst("int f(char argv[]);\n"));
+        ASSERT_EQUALS("", testAst("void f();\n"));
+        ASSERT_EQUALS("", testAst("void f() {}\n"));
+        ASSERT_EQUALS("", testAst("int f() = delete;\n"));
+        ASSERT_EQUALS("", testAst("a::b f();\n"));
+        ASSERT_EQUALS("", testAst("a::b f() {}\n"));
+        ASSERT_EQUALS("", testAst("a::b f() = delete;\n"));
+        ASSERT_EQUALS("", testAst("int f() const = delete;\n"));
+        ASSERT_EQUALS("", testAst("extern unsigned f(const char *);\n"));
+        ASSERT_EQUALS("charformat*...,", testAst("extern void f(const char *format, ...);\n"));
+        ASSERT_EQUALS("int(int(void,", testAst("extern int for_each_commit_graft(int (*)(int*), void *);\n"));
+        ASSERT_EQUALS("for;;(", testAst("for (;;) {}\n"));
+        ASSERT_EQUALS("xsizeofvoid(=", testAst("x=sizeof(void*)\n"));
+        ASSERT_EQUALS("abc{d{,{(=", testAst("a = b({ c{}, d{} });\n"));
+        ASSERT_EQUALS("abc;(", testAst("a(b;c)\n"));
+        ASSERT_EQUALS("x{( forbc;;(", testAst("x({ for(a;b;c){} });\n"));
+        ASSERT_EQUALS("PT.(", testAst("P->~T();\n"));  // <- The "T" token::function() will be a destructor
+        ASSERT_EQUALS("double&(4[", testAst("void f(double(&)[4]) {}\n"));
+        ASSERT_EQUALS("voidu*", testAst("int* g ( void* (f) (void*), void* u);\n")); // #12475
+        ASSERT_EQUALS("f::(", testAst("::f();\n")); // #12544
+        ASSERT_EQUALS("(( f (, c ({ (= (. x) 0))))", testAst("f(c, { .x = 0 });\n", AstStyle::Z3)); // #12806
         ASSERT_EQUALS("(= it (( (. s insert) (, it ({ (, (, (= (. a) i) (= (. b) 2)) (= (. c) 3))))))",
-                      testAst("it = s.insert(it, { .a = i, .b = 2, .c = 3 });", AstStyle::Z3)); // #12815
+                      testAst("it = s.insert(it, { .a = i, .b = 2, .c = 3 });\n", AstStyle::Z3)); // #12815
     }
 
     void asttemplate() { // uninstantiated templates will have <,>,etc..
-        ASSERT_EQUALS("a(3==", testAst("a<int>()==3"));
+        ASSERT_EQUALS("a(3==", testAst("a<int>()==3\n"));
         ASSERT_EQUALS("", errout_str());
-        ASSERT_EQUALS("ab(== f(", testAst("a == b<c>(); f();"));
+        ASSERT_EQUALS("ab(== f(", testAst("a == b<c>(); f();\n"));
         ASSERT_EQUALS("", errout_str());
-        ASSERT_EQUALS("static_casta(i[", testAst("; static_cast<char*>(a)[i];")); // #6203
+        ASSERT_EQUALS("static_casta(i[", testAst("; static_cast<char*>(a)[i];\n")); // #6203
         ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS("reinterpret_castreinterpret_castptr(123&(",
-                      testAst(";reinterpret_cast<void*>(reinterpret_cast<unsigned>(ptr) & 123);")); // #7253
+                      testAst(";reinterpret_cast<void*>(reinterpret_cast<unsigned>(ptr) & 123);\n")); // #7253
         ASSERT_EQUALS("", errout_str());
-        ASSERT_EQUALS("bcd.(=", testAst(";a<int> && b = c->d();"));
+        ASSERT_EQUALS("bcd.(=", testAst(";a<int> && b = c->d();\n"));
         ASSERT_EQUALS("", errout_str());
 
         // This two unit tests were added to avoid a crash. The actual correct AST result for non-executable code has not been determined so far.
-        ASSERT_NO_THROW(testAst("class C : public ::a::b<bool> { };"));
+        ASSERT_NO_THROW(testAst("class C : public ::a::b<bool> { };\n"));
         ASSERT_EQUALS("", errout_str());
-        ASSERT_EQUALS("AB: abc+=", testAst("struct A : public B<C*> { void f() { a=b+c; } };"));
+        ASSERT_EQUALS("AB: abc+=", testAst("struct A : public B<C*> { void f() { a=b+c; } };\n"));
         ASSERT_EQUALS("", errout_str());
 
-        ASSERT_EQUALS("xfts(=", testAst("; auto x = f(ts...);"));
+        ASSERT_EQUALS("xfts(=", testAst("; auto x = f(ts...);\n"));
         ASSERT_EQUALS("", errout_str());
 
         ASSERT_EQUALS("dae(new= ifd(", testAst("template <typename a, typename... b>\n" // #10199
@@ -7329,44 +7414,44 @@ class TestTokenizer : public TestFixture {
 
     void astrequires()
     {
-        ASSERT_EQUALS("brequires{ac::||= ac::", testAst("template <class a> concept b = requires { a::c; } || a::c;"));
+        ASSERT_EQUALS("brequires{ac::||= ac::", testAst("template <class a> concept b = requires { a::c; } || a::c;\n"));
         ASSERT_EQUALS("crequires{ac::||= a{b{||",
-                      testAst("template <class a, class b> concept c = requires { a{} || b{}; } || a::c;"));
-        ASSERT_EQUALS("ifrequires{(", testAst("if (requires { true; }) {}")); // #13308
-        ASSERT_EQUALS("Crequires({requires({||= sizeofT(4== sizeofT(8==", testAst("concept C = requires() { sizeof(T) == 4; } || requires() { sizeof(T) == 8; };"));
+                      testAst("template <class a, class b> concept c = requires { a{} || b{}; } || a::c;\n"));
+        ASSERT_EQUALS("ifrequires{(", testAst("if (requires { true; }) {}\n")); // #13308
+        ASSERT_EQUALS("Crequires({requires({||= sizeofT(4== sizeofT(8==", testAst("concept C = requires() { sizeof(T) == 4; } || requires() { sizeof(T) == 8; };\n"));
     }
 
     void astcast() {
-        ASSERT_EQUALS("ac&(=", testAst("a = (long)&c;"));
-        ASSERT_EQUALS("ac*(=", testAst("a = (Foo*)*c;"));
-        ASSERT_EQUALS("ac-(=", testAst("a = (long)-c;"));
-        ASSERT_EQUALS("ac~(=", testAst("a = (b)~c;"));
-        ASSERT_EQUALS("ac(=", testAst("a = (some<strange, type>)c;"));
-        ASSERT_EQUALS("afoveon_avgimage((foveon_avgimage((+=", testAst("a = foveon_avg(((short(*)[4]) image)) + foveon_avg(((short(*)[4]) image));"));
-        ASSERT_EQUALS("c(40<<return", testAst("return (long long)c << 40;"));
-        ASSERT_EQUALS("ab-(=", testAst("a = ((int)-b)")); // Multiple subsequent unary operators (cast and -)
-        ASSERT_EQUALS("xdouble123(i*(=", testAst("x = (int)(double(123)*i);"));
-        ASSERT_EQUALS("ac(=", testAst("a = (::b)c;"));
-        ASSERT_EQUALS("abcd,({(=", testAst("a = (s){b(c, d)};"));
-        ASSERT_EQUALS("xatoistr({(=", testAst("x = (struct X){atoi(str)};"));
-        ASSERT_EQUALS("xa.0=b.0=,c.0=,{(=", testAst("x = (struct abc) { .a=0, .b=0, .c=0 };"));
+        ASSERT_EQUALS("ac&(=", testAst("a = (long)&c;\n"));
+        ASSERT_EQUALS("ac*(=", testAst("a = (Foo*)*c;\n"));
+        ASSERT_EQUALS("ac-(=", testAst("a = (long)-c;\n"));
+        ASSERT_EQUALS("ac~(=", testAst("a = (b)~c;\n"));
+        ASSERT_EQUALS("ac(=", testAst("a = (some<strange, type>)c;\n"));
+        ASSERT_EQUALS("afoveon_avgimage((foveon_avgimage((+=", testAst("a = foveon_avg(((short(*)[4]) image)) + foveon_avg(((short(*)[4]) image));\n"));
+        ASSERT_EQUALS("c(40<<return", testAst("return (long long)c << 40;\n"));
+        ASSERT_EQUALS("ab-(=", testAst("a = ((int)-b)\n")); // Multiple subsequent unary operators (cast and -)
+        ASSERT_EQUALS("xdouble123(i*(=", testAst("x = (int)(double(123)*i);\n"));
+        ASSERT_EQUALS("ac(=", testAst("a = (::b)c;\n"));
+        ASSERT_EQUALS("abcd,({(=", testAst("a = (s){b(c, d)};\n"));
+        ASSERT_EQUALS("xatoistr({(=", testAst("x = (struct X){atoi(str)};\n"));
+        ASSERT_EQUALS("xa.0=b.0=,c.0=,{(=", testAst("x = (struct abc) { .a=0, .b=0, .c=0 };\n"));
 
-        ASSERT_EQUALS("yz.(return", testAst("return (x)(y).z;"));
+        ASSERT_EQUALS("yz.(return", testAst("return (x)(y).z;\n"));
 
-        ASSERT_EQUALS("fon!(restoring01:?,(", testAst("f((long) !on, restoring ? 0 : 1);"));
+        ASSERT_EQUALS("fon!(restoring01:?,(", testAst("f((long) !on, restoring ? 0 : 1);\n"));
 
-        ASSERT_EQUALS("esi.!(=", testAst("E e = (E)!s->i;")); // #10882
+        ASSERT_EQUALS("esi.!(=", testAst("E e = (E)!s->i;\n")); // #10882
 
-        ASSERT_EQUALS("xp(= 12>34:?", testAst("x = ( const char ( * ) [ 1 > 2 ? 3 : 4 ] ) p ;"));
+        ASSERT_EQUALS("xp(= 12>34:?", testAst("x = ( const char ( * ) [ 1 > 2 ? 3 : 4 ] ) p ;\n"));
 
-        ASSERT_EQUALS("f{(si.,(", testAst("f((struct S){ }, s->i);")); // #11606
+        ASSERT_EQUALS("f{(si.,(", testAst("f((struct S){ }, s->i);\n")); // #11606
 
         // not cast
-        ASSERT_EQUALS("AB||", testAst("(A)||(B)"));
-        ASSERT_EQUALS("abc[1&=", testAst("a = (b[c]) & 1;"));
-        ASSERT_EQUALS("abc::(=", testAst("a = (b::c)();"));
+        ASSERT_EQUALS("AB||", testAst("(A)||(B)\n"));
+        ASSERT_EQUALS("abc[1&=", testAst("a = (b[c]) & 1;\n"));
+        ASSERT_EQUALS("abc::(=", testAst("a = (b::c)();\n"));
 
-        ASSERT_EQUALS("pcharnew(=", testAst("p = (void *)(new char);"));
+        ASSERT_EQUALS("pcharnew(=", testAst("p = (void *)(new char);\n"));
     }
 
     void astlambda() {
@@ -7375,37 +7460,37 @@ class TestTokenizer : public TestFixture {
         // `-(
         //   `-{
 
-        ASSERT_EQUALS("x{(a&[( ai=", testAst("x([&a](int i){a=i;});"));
-        ASSERT_EQUALS("{([(return 0return", testAst("return [](){ return 0; }();"));
+        ASSERT_EQUALS("x{(a&[( ai=", testAst("x([&a](int i){a=i;});\n"));
+        ASSERT_EQUALS("{([(return 0return", testAst("return [](){ return 0; }();\n"));
 
         // noexcept (which if simplified to always have a condition by the time AST is created)
-        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) noexcept(true) { a=i; });"));
-        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) mutable noexcept(true) { a=i; });"));
-        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) const noexcept(true) { a=i; });"));
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) noexcept(true) { a=i; });\n"));
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) mutable noexcept(true) { a=i; });\n"));
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) const noexcept(true) { a=i; });\n"));
 
         // both mutable and constexpr (which is simplified to 'const' by the time AST is created)
-        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) const mutable { a=i; });"));
-        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) mutable const { a=i; });"));
-        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) const mutable noexcept(true) { a=i; });"));
-        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) mutable const noexcept(true) { a=i; });"));
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) const mutable { a=i; });\n"));
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) mutable const { a=i; });\n"));
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) const mutable noexcept(true) { a=i; });\n"));
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) mutable const noexcept(true) { a=i; });\n"));
 
         // ->
-        ASSERT_EQUALS("{([(return 0return", testAst("return []() -> int { return 0; }();"));
-        ASSERT_EQUALS("{(something[(return 0return", testAst("return [something]() -> int { return 0; }();"));
-        ASSERT_EQUALS("{([cd,(return 0return", testAst("return [](int a, int b) -> int { return 0; }(c, d);"));
-        ASSERT_EQUALS("{([return", testAst("return []() -> decltype(0) {};"));
-        ASSERT_EQUALS("x{(&[=", testAst("x = [&]()->std::string const & {};"));
-        ASSERT_EQUALS("f{([=", testAst("f = []() -> foo* {};"));
-        ASSERT_EQUALS("f{([=", testAst("f = []() -> foo&& {};"));
-        ASSERT_EQUALS("f{([=", testAst("f = [](void) mutable -> foo* {};"));
-        ASSERT_EQUALS("f{([=", testAst("f = []() mutable {};"));
+        ASSERT_EQUALS("{([(return 0return", testAst("return []() -> int { return 0; }();\n"));
+        ASSERT_EQUALS("{(something[(return 0return", testAst("return [something]() -> int { return 0; }();\n"));
+        ASSERT_EQUALS("{([cd,(return 0return", testAst("return [](int a, int b) -> int { return 0; }(c, d);\n"));
+        ASSERT_EQUALS("{([return", testAst("return []() -> decltype(0) {};\n"));
+        ASSERT_EQUALS("x{(&[=", testAst("x = [&]()->std::string const & {};\n"));
+        ASSERT_EQUALS("f{([=", testAst("f = []() -> foo* {};\n"));
+        ASSERT_EQUALS("f{([=", testAst("f = []() -> foo&& {};\n"));
+        ASSERT_EQUALS("f{([=", testAst("f = [](void) mutable -> foo* {};\n"));
+        ASSERT_EQUALS("f{([=", testAst("f = []() mutable {};\n"));
 
-        ASSERT_EQUALS("x{([= 0return", testAst("x = [](){return 0; };"));
+        ASSERT_EQUALS("x{([= 0return", testAst("x = [](){return 0; };\n"));
 
-        ASSERT_EQUALS("ab{&[(= cd=", testAst("a = b([&]{c=d;});"));
+        ASSERT_EQUALS("ab{&[(= cd=", testAst("a = b([&]{c=d;});\n"));
 
         // 8628
-        ASSERT_EQUALS("f{([( switchx( 1case y++", testAst("f([](){switch(x){case 1:{++y;}}});"));
+        ASSERT_EQUALS("f{([( switchx( 1case y++", testAst("f([](){switch(x){case 1:{++y;}}});\n"));
 
         ASSERT_EQUALS("{(=[{return ab=",
                       testAst("return {\n"
@@ -7424,28 +7509,28 @@ class TestTokenizer : public TestFixture {
                               "  [=]() -> int {\n"
                               "    a=b;\n"
                               "  }\n"
-                              "}"));
+                              "}\n"));
         ASSERT_EQUALS("{(=[{return ab=",
                       testAst("return {\n"
                               "  [=]() mutable consteval -> int {\n"
                               "    a=b;\n"
                               "  }\n"
-                              "}"));
+                              "}\n"));
 
         // daca@home hang
         ASSERT_EQUALS("a{(&[= 0return b{(=[= fori0=i10!=i++;;(",
                       testAst("a = [&]() -> std::pair<int, int> { return 0; };\n"
-                              "b = [=]() { for (i = 0; i != 10; ++i); };"));
+                              "b = [=]() { for (i = 0; i != 10; ++i); };\n"));
 
         // #9662
-        ASSERT_EQUALS("b{[{ stdunique_ptr::0nullptrnullptr:?{", testAst("auto b{[] { std::unique_ptr<void *>{0 ? nullptr : nullptr}; }};"));
-        ASSERT_EQUALS("{b{[=[", testAst("void a() { [b = [] { ; }] {}; }"));
+        ASSERT_EQUALS("b{[{ stdunique_ptr::0nullptrnullptr:?{", testAst("auto b{[] { std::unique_ptr<void *>{0 ? nullptr : nullptr}; }};\n"));
+        ASSERT_EQUALS("{b{[=[", testAst("void a() { [b = [] { ; }] {}; }\n"));
 
         // Lambda capture expression (C++14)
-        ASSERT_EQUALS("a{b1=[= c2=", testAst("a = [b=1]{c=2;};"));
+        ASSERT_EQUALS("a{b1=[= c2=", testAst("a = [b=1]{c=2;};\n"));
 
         // #9729
-        ASSERT_NO_THROW(tokenizeAndStringify("void foo() { bar([]() noexcept { if (0) {} }); }"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void foo() { bar([]() noexcept { if (0) {} }); }\n"));
         ASSERT_EQUALS("", errout_str());
 
         // #11128
@@ -7467,7 +7552,7 @@ class TestTokenizer : public TestFixture {
                       testAst("x = []() -> std::vector<uint8_t> {\n"
                               "    const auto y = z;\n"
                               "    switch (y) {}\n"
-                              "};"));
+                              "};\n"));
 
         // #11357
         ASSERT_NO_THROW(tokenizeAndStringify("void f(std::vector<int>& v, bool c) {\n"
@@ -7541,106 +7626,106 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("", errout_str());
 
         // #11378
-        ASSERT_EQUALS("gT{(&[{= 0return", testAst("auto g = T{ [&]() noexcept -> int { return 0; } };"));
+        ASSERT_EQUALS("gT{(&[{= 0return", testAst("auto g = T{ [&]() noexcept -> int { return 0; } };\n"));
 
-        ASSERT_EQUALS("sf.{(i[{={", testAst("void g(int i) { S s{ .f = { [i]() {} } }; }"));
+        ASSERT_EQUALS("sf.{(i[{={", testAst("void g(int i) { S s{ .f = { [i]() {} } }; }\n"));
 
-        ASSERT_EQUALS("{([", testAst("void f() { []() {}; }")); // #13471
+        ASSERT_EQUALS("{([", testAst("void f() { []() {}; }\n")); // #13471
     }
 
     void astcase() {
-        ASSERT_EQUALS("0case", testAst("case 0:"));
-        ASSERT_EQUALS("12+case", testAst("case 1+2:"));
-        ASSERT_EQUALS("xyz:?case", testAst("case (x?y:z):"));
-        ASSERT_EQUALS("switchx( 1case y++ 2case", testAst("switch(x){case 1:{++y;break;case 2:break;}}"));
-        ASSERT_EQUALS("switchi( 12<<~case 0return", testAst("switch (i) { case ~(1 << 2) : return 0; }")); // #13197
+        ASSERT_EQUALS("0case", testAst("case 0:\n"));
+        ASSERT_EQUALS("12+case", testAst("case 1+2:\n"));
+        ASSERT_EQUALS("xyz:?case", testAst("case (x?y:z):\n"));
+        ASSERT_EQUALS("switchx( 1case y++ 2case", testAst("switch(x){case 1:{++y;break;case 2:break;}}\n"));
+        ASSERT_EQUALS("switchi( 12<<~case 0return", testAst("switch (i) { case ~(1 << 2) : return 0; }\n")); // #13197
     }
 
     void astrefqualifier() {
-        ASSERT_EQUALS("", testAst("class a { auto b() -> int&; };"));
-        ASSERT_EQUALS("", testAst("class a { auto b() -> int&&; };"));
-        ASSERT_EQUALS("", testAst("class a { void b() &&; };"));
-        ASSERT_EQUALS("", testAst("class a { void b() &; };"));
-        ASSERT_EQUALS("", testAst("class a { void b() && = delete; };"));
-        ASSERT_EQUALS("", testAst("class a { void b() & = delete; };"));
-        ASSERT_EQUALS("", testAst("class a { void b() && {} };"));
-        ASSERT_EQUALS("", testAst("class a { void b() & {} };"));
+        ASSERT_EQUALS("", testAst("class a { auto b() -> int&; };\n"));
+        ASSERT_EQUALS("", testAst("class a { auto b() -> int&&; };\n"));
+        ASSERT_EQUALS("", testAst("class a { void b() &&; };\n"));
+        ASSERT_EQUALS("", testAst("class a { void b() &; };\n"));
+        ASSERT_EQUALS("", testAst("class a { void b() && = delete; };\n"));
+        ASSERT_EQUALS("", testAst("class a { void b() & = delete; };\n"));
+        ASSERT_EQUALS("", testAst("class a { void b() && {} };\n"));
+        ASSERT_EQUALS("", testAst("class a { void b() & {} };\n"));
     }
 
     void astthrowdelete() {
-        ASSERT_EQUALS("a(", testAst("class a { virtual ~a() throw() = delete; };"));
+        ASSERT_EQUALS("a(", testAst("class a { virtual ~a() throw() = delete; };\n"));
     }
 
     void asttrailingdecltype() {
-        ASSERT_EQUALS("Cc& csize.(", testAst("template<class C> constexpr auto s(const C &c) noexcept -> decltype(c.size()) {}"));
+        ASSERT_EQUALS("Cc& csize.(", testAst("template<class C> constexpr auto s(const C &c) noexcept -> decltype(c.size()) {}\n"));
         ASSERT_EQUALS("Cc& MakeSpancdata.(csize.(,(",
-                      testAst("template <typename C> constexpr auto MakeSpan(C &c) -> decltype(MakeSpan(c.data(), c.size())) {}"));
-        ASSERT_EQUALS("Eqeq&key_typek&, eqkk,(", testAst("auto KeyTypeCanBeEq(const Eq& eq, const key_type& k) -> decltype(eq(k, k));"));
-        ASSERT_EQUALS("h{([= si. {return", testAst("auto h = []() -> decltype(s.i) { return {}; };"));
+                      testAst("template <typename C> constexpr auto MakeSpan(C &c) -> decltype(MakeSpan(c.data(), c.size())) {}\n"));
+        ASSERT_EQUALS("Eqeq&key_typek&, eqkk,(", testAst("auto KeyTypeCanBeEq(const Eq& eq, const key_type& k) -> decltype(eq(k, k));\n"));
+        ASSERT_EQUALS("h{([= si. {return", testAst("auto h = []() -> decltype(s.i) { return {}; };\n"));
     }
     void astnoexcept() {
-        ASSERT_EQUALS("noexceptaswap.b((", testAst("void f() noexcept(noexcept(a.swap(b))) {}"));
-        ASSERT_EQUALS("{([ noexceptaswap.b((", testAst("[]() noexcept(noexcept(a.swap(b))) {}"));
+        ASSERT_EQUALS("noexceptaswap.b((", testAst("void f() noexcept(noexcept(a.swap(b))) {}\n"));
+        ASSERT_EQUALS("{([ noexceptaswap.b((", testAst("[]() noexcept(noexcept(a.swap(b))) {}\n"));
     }
 
     //Verify that returning a newly constructed object generates the correct AST even when the class name is scoped
     //Addresses https://trac.cppcheck.net/ticket/9700
     void astnewscoped() {
-        ASSERT_EQUALS("(return (new A))", testAst("return new A;", AstStyle::Z3));
-        ASSERT_EQUALS("(return (new (( A)))", testAst("return new A();", AstStyle::Z3));
-        ASSERT_EQUALS("(return (new (( A true)))", testAst("return new A(true);", AstStyle::Z3));
-        ASSERT_EQUALS("(return (new (:: A B)))", testAst("return new A::B;", AstStyle::Z3));
-        ASSERT_EQUALS("(return (new (( (:: A B))))", testAst("return new A::B();", AstStyle::Z3));
-        ASSERT_EQUALS("(return (new (( (:: A B) true)))", testAst("return new A::B(true);", AstStyle::Z3));
-        ASSERT_EQUALS("(return (new (:: (:: A B) C)))", testAst("return new A::B::C;", AstStyle::Z3));
-        ASSERT_EQUALS("(return (new (( (:: (:: A B) C))))", testAst("return new A::B::C();", AstStyle::Z3));
-        ASSERT_EQUALS("(return (new (( (:: (:: A B) C) true)))", testAst("return new A::B::C(true);", AstStyle::Z3));
-        ASSERT_EQUALS("(return (new (:: (:: (:: A B) C) D)))", testAst("return new A::B::C::D;", AstStyle::Z3));
-        ASSERT_EQUALS("(return (new (( (:: (:: (:: A B) C) D))))", testAst("return new A::B::C::D();", AstStyle::Z3));
-        ASSERT_EQUALS("(return (new (( (:: (:: (:: A B) C) D) true)))", testAst("return new A::B::C::D(true);", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new A))", testAst("return new A;\n", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( A)))", testAst("return new A();\n", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( A true)))", testAst("return new A(true);\n", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (:: A B)))", testAst("return new A::B;\n", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( (:: A B))))", testAst("return new A::B();\n", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( (:: A B) true)))", testAst("return new A::B(true);\n", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (:: (:: A B) C)))", testAst("return new A::B::C;\n", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( (:: (:: A B) C))))", testAst("return new A::B::C();\n", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( (:: (:: A B) C) true)))", testAst("return new A::B::C(true);\n", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (:: (:: (:: A B) C) D)))", testAst("return new A::B::C::D;\n", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( (:: (:: (:: A B) C) D))))", testAst("return new A::B::C::D();\n", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( (:: (:: (:: A B) C) D) true)))", testAst("return new A::B::C::D(true);\n", AstStyle::Z3));
     }
 
     void astdecltypescope() {
-        ASSERT_EQUALS("sizedecltypethism_P.(XSize::::{", testAst("size { decltype(this->m_P)::X::Size };"));
+        ASSERT_EQUALS("sizedecltypethism_P.(XSize::::{", testAst("size { decltype(this->m_P)::X::Size };\n"));
     }
 
     void astdesignatedinit() {
-        ASSERT_EQUALS("(( f ({ (= (. x) 1)))", testAst("f({ .x = 1 });", AstStyle::Z3));
+        ASSERT_EQUALS("(( f ({ (= (. x) 1)))", testAst("f({ .x = 1 });\n", AstStyle::Z3));
     }
 
     void astrvaluedecl() {
-        ASSERT_EQUALS("varstdmove::var(=", testAst("std::string&& var = std::move(var);"));
+        ASSERT_EQUALS("varstdmove::var(=", testAst("std::string&& var = std::move(var);\n"));
     }
 
     void astorkeyword() {
-        ASSERT_EQUALS("ifsp.\"\"==sp.0==||(", testAst("void f() { if (s.p == \"\" or s.p == 0) {} }"));
+        ASSERT_EQUALS("ifsp.\"\"==sp.0==||(", testAst("void f() { if (s.p == \"\" or s.p == 0) {} }\n"));
     }
 
     void astenumdecl() {
-        ASSERT_EQUALS("A0U=", testAst("enum class myclass : unsigned char { A = 0U, };"));
-        ASSERT_EQUALS("A0U=", testAst("enum myclass : unsigned char { A = 0U, };"));
+        ASSERT_EQUALS("A0U=", testAst("enum class myclass : unsigned char { A = 0U, };\n"));
+        ASSERT_EQUALS("A0U=", testAst("enum myclass : unsigned char { A = 0U, };\n"));
     }
 
     void astcompound() {
-        ASSERT_EQUALS("sn0=={(tmp:?=", testAst("Str s = n == 0 ? (Str) { 0 } : tmp;")); // #14548
-        ASSERT_EQUALS("s(sstrlens(0:?,{(return", testAst("return (struct Str) { (unsigned char*)s, s ? strlen(s) : 0 };"));
+        ASSERT_EQUALS("sn0=={(tmp:?=", testAst("Str s = n == 0 ? (Str) { 0 } : tmp;\n")); // #14548
+        ASSERT_EQUALS("s(sstrlens(0:?,{(return", testAst("return (struct Str) { (unsigned char*)s, s ? strlen(s) : 0 };\n"));
     }
 
     void astfuncdecl() {
-        ASSERT_EQUALS("", testAst("bool operator==(const S& a, const S& b);", AstStyle::Simple, ListSimplification::Full));
-        ASSERT_EQUALS("", testAst("::int32_t f();"));
-        ASSERT_EQUALS("", testAst("void f(int&& var);"));
+        ASSERT_EQUALS("", testAst("bool operator==(const S& a, const S& b);\n", AstStyle::Simple, ListSimplification::Full));
+        ASSERT_EQUALS("", testAst("::int32_t f();\n"));
+        ASSERT_EQUALS("", testAst("void f(int&& var);\n"));
     }
 
     void astarrayinit() { // #11738
-        ASSERT_EQUALS("a2[12,{", testAst("int a[2]{ 1, 2 };"));
-        ASSERT_EQUALS("a2[2[ 12, 34,{", testAst("int a[2][2]{ { 1, 2 }, { 3, 4 } };"));
+        ASSERT_EQUALS("a2[12,{", testAst("int a[2]{ 1, 2 };\n"));
+        ASSERT_EQUALS("a2[2[ 12, 34,{", testAst("int a[2][2]{ { 1, 2 }, { 3, 4 } };\n"));
     }
 
     void astbracedinit() {
-        ASSERT_EQUALS("ab{", testAst("int &a { b };", AstStyle::Simple, ListSimplification::Full));
-        ASSERT_EQUALS("a0{", testAst("int &&a { 0 };", AstStyle::Simple, ListSimplification::Full));
-        ASSERT_EQUALS("anullptr{", testAst("int *a { nullptr };", AstStyle::Simple, ListSimplification::Full));
+        ASSERT_EQUALS("ab{", testAst("int &a { b };\n", AstStyle::Simple, ListSimplification::Full));
+        ASSERT_EQUALS("a0{", testAst("int &&a { 0 };\n", AstStyle::Simple, ListSimplification::Full));
+        ASSERT_EQUALS("anullptr{", testAst("int *a { nullptr };\n", AstStyle::Simple, ListSimplification::Full));
     }
 
 #define isStartOfExecutableScope(offset, code) isStartOfExecutableScope_(offset, code, __FILE__, __LINE__)
@@ -7653,88 +7738,88 @@ class TestTokenizer : public TestFixture {
     }
 
     void startOfExecutableScope() {
-        ASSERT(isStartOfExecutableScope(3, "void foo() { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() const { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() volatile { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() override { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() noexcept { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() NOEXCEPT { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() CONST NOEXCEPT { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() const noexcept { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() noexcept(true) { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() const noexcept(true) { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() throw() { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() THROW() { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() CONST THROW() { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() const throw() { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() throw(int) { }"));
-        ASSERT(isStartOfExecutableScope(3, "void foo() const throw(int) { }"));
-        ASSERT(isStartOfExecutableScope(2, "foo() : a(1) { }"));
-        ASSERT(isStartOfExecutableScope(2, "foo() : a(1), b(2) { }"));
-        ASSERT(isStartOfExecutableScope(2, "foo() : a{1} { }"));
-        ASSERT(isStartOfExecutableScope(2, "foo() : a{1}, b{2} { }"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() const { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() volatile { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() override { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() noexcept { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() NOEXCEPT { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() CONST NOEXCEPT { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() const noexcept { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() noexcept(true) { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() const noexcept(true) { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() throw() { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() THROW() { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() CONST THROW() { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() const throw() { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() throw(int) { }\n"));
+        ASSERT(isStartOfExecutableScope(3, "void foo() const throw(int) { }\n"));
+        ASSERT(isStartOfExecutableScope(2, "foo() : a(1) { }\n"));
+        ASSERT(isStartOfExecutableScope(2, "foo() : a(1), b(2) { }\n"));
+        ASSERT(isStartOfExecutableScope(2, "foo() : a{1} { }\n"));
+        ASSERT(isStartOfExecutableScope(2, "foo() : a{1}, b{2} { }\n"));
     }
 
     void removeMacroInClassDef() { // #6058
-        ASSERT_EQUALS("class Fred { } ;", tokenizeAndStringify("class DLLEXPORT Fred { } ;"));
-        ASSERT_EQUALS("class Fred : Base { } ;", tokenizeAndStringify("class Fred FINAL : Base { } ;"));
-        ASSERT_EQUALS("class Fred : Base { } ;", tokenizeAndStringify("class DLLEXPORT Fred final : Base { } ;")); // #11422
+        ASSERT_EQUALS("class Fred { } ;", tokenizeAndStringify("class DLLEXPORT Fred { } ;\n"));
+        ASSERT_EQUALS("class Fred : Base { } ;", tokenizeAndStringify("class Fred FINAL : Base { } ;\n"));
+        ASSERT_EQUALS("class Fred : Base { } ;", tokenizeAndStringify("class DLLEXPORT Fred final : Base { } ;\n")); // #11422
         // Regression for C code:
-        ASSERT_EQUALS("struct Fred { } ;", tokenizeAndStringify("struct DLLEXPORT Fred { } ;", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("struct Fred { } ;", tokenizeAndStringify("struct DLLEXPORT Fred { } ;\n", dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void sizeofAddParentheses() {
-        ASSERT_EQUALS("sizeof ( sizeof ( 1 ) ) ;", tokenizeAndStringify("sizeof sizeof 1;"));
-        ASSERT_EQUALS("sizeof ( a . b ) + 3 ;", tokenizeAndStringify("sizeof a.b+3;"));
-        ASSERT_EQUALS("sizeof ( a [ 2 ] . b ) + 3 ;", tokenizeAndStringify("sizeof a[2].b+3;"));
-        ASSERT_EQUALS("f ( 0 , sizeof ( ptr . bar ) ) ;", tokenizeAndStringify("f(0, sizeof ptr->bar );"));
-        ASSERT_EQUALS("sizeof ( a ) > sizeof ( & main ) ;", tokenizeAndStringify("sizeof a > sizeof &main;"));
+        ASSERT_EQUALS("sizeof ( sizeof ( 1 ) ) ;", tokenizeAndStringify("sizeof sizeof 1;\n"));
+        ASSERT_EQUALS("sizeof ( a . b ) + 3 ;", tokenizeAndStringify("sizeof a.b+3;\n"));
+        ASSERT_EQUALS("sizeof ( a [ 2 ] . b ) + 3 ;", tokenizeAndStringify("sizeof a[2].b+3;\n"));
+        ASSERT_EQUALS("f ( 0 , sizeof ( ptr . bar ) ) ;", tokenizeAndStringify("f(0, sizeof ptr->bar );\n"));
+        ASSERT_EQUALS("sizeof ( a ) > sizeof ( & main ) ;", tokenizeAndStringify("sizeof a > sizeof &main;\n"));
     }
 
     void reportUnknownMacros() {
         const char code1[] = "MY_UNKNOWN_IMP1(IInStream)\n"
-                             "STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize) { if (ptr); }";
+                             "STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize) { if (ptr); }\n";
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code1), UNKNOWN_MACRO);
 
-        const char code2[] = "void foo() { dostuff(x 0); }";
+        const char code2[] = "void foo() { dostuff(x 0); }\n";
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code2), UNKNOWN_MACRO);
 
-        const char code3[] = "f(\"1\" __stringify(48) \"1\");";
+        const char code3[] = "f(\"1\" __stringify(48) \"1\");\n";
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code3), UNKNOWN_MACRO);
 
         const char code4[] = "struct Foo {\n"
                              "  virtual MACRO(int) f1() {}\n"
                              "  virtual MACRO(int) f2() {}\n"
-                             "};";
+                             "};\n";
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code4), UNKNOWN_MACRO);
 
         const char code5[] = "void foo() {\n"
                              "  EVALUATE(123, int x=a; int y=b+c;);\n"
-                             "}";
+                             "}\n";
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code5), UNKNOWN_MACRO);
 
-        const char code6[] = "void foo() { dostuff(a, .x=0); }";
+        const char code6[] = "void foo() { dostuff(a, .x=0); }\n";
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code6), UNKNOWN_MACRO);
 
-        const char code7[] = "void foo() { dostuff(ZEND_NUM_ARGS() TSRMLS_CC, x, y); }"; // #9476
+        const char code7[] = "void foo() { dostuff(ZEND_NUM_ARGS() TSRMLS_CC, x, y); }\n"; // #9476
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code7), UNKNOWN_MACRO);
 
-        const char code8[] = "void foo() { a = [](int x, decltype(vec) y){}; }";
+        const char code8[] = "void foo() { a = [](int x, decltype(vec) y){}; }\n";
         ASSERT_NO_THROW(tokenizeAndStringify(code8));
 
-        const char code9[] = "void f(std::exception c) { b(M() c.what()); }";
+        const char code9[] = "void f(std::exception c) { b(M() c.what()); }\n";
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code9), UNKNOWN_MACRO);
 
-        const char code10[] = "void f(std::exception c) { b(M() M() + N(c.what())); }";
+        const char code10[] = "void f(std::exception c) { b(M() M() + N(c.what())); }\n";
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code10), UNKNOWN_MACRO);
 
-        const char code11[] = "struct B { B(B&&) noexcept {} ~B() noexcept {} };";
+        const char code11[] = "struct B { B(B&&) noexcept {} ~B() noexcept {} };\n";
         ASSERT_NO_THROW(tokenizeAndStringify(code11));
 
-        ASSERT_NO_THROW(tokenizeAndStringify("alignas(8) alignas(16) int x;")); // alignas is not unknown macro
+        ASSERT_NO_THROW(tokenizeAndStringify("alignas(8) alignas(16) int x;\n")); // alignas is not unknown macro
 
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo() { if(x) SYSTEM_ERROR }"), UNKNOWN_MACRO);
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo() { dostuff(); SYSTEM_ERROR }"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo() { if(x) SYSTEM_ERROR }\n"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo() { dostuff(); SYSTEM_ERROR }\n"), UNKNOWN_MACRO);
 
         ASSERT_NO_THROW(tokenizeAndStringify("void f(void* q) {\n"
                                              "    g(&(S) { .p = (int*)q });\n"
@@ -7759,8 +7844,8 @@ class TestTokenizer : public TestFixture {
 
     void findGarbageCode() { // Test Tokenizer::findGarbageCode()
         // C++ try/catch in global scope
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("try { }"), SYNTAX, "syntax error: keyword 'try' is not allowed in global scope");
-        ASSERT_NO_THROW(tokenizeAndStringify("void f() try { } catch (int) { }"));
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("try { }\n"), SYNTAX, "syntax error: keyword 'try' is not allowed in global scope");
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() try { } catch (int) { }\n"));
         ASSERT_NO_THROW(tokenizeAndStringify("struct S {\n" // #9716
                                              "    S();\n"
                                              "    int x, y;\n"
@@ -7775,61 +7860,61 @@ class TestTokenizer : public TestFixture {
                                              "    catch (...) { h(); }\n"));
 
         // before if|for|while|switch
-        ASSERT_NO_THROW(tokenizeAndStringify("void f() { do switch (a) {} while (1); }"));
-        ASSERT_NO_THROW(tokenizeAndStringify("void f() { label: switch (a) {} }"));
-        ASSERT_NO_THROW(tokenizeAndStringify("void f() { UNKNOWN_MACRO if (a) {} }"));
-        ASSERT_NO_THROW(tokenizeAndStringify("void f() { []() -> int * {}; }"));
-        ASSERT_NO_THROW(tokenizeAndStringify("void f() { const char* var = \"1\" \"2\"; }"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() { do switch (a) {} while (1); }\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() { label: switch (a) {} }\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() { UNKNOWN_MACRO if (a) {} }\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() { []() -> int * {}; }\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() { const char* var = \"1\" \"2\"; }\n"));
 
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f() { MACRO(switch); }"), UNKNOWN_MACRO);
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f() { MACRO(x,switch); }"), UNKNOWN_MACRO);
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo() { for_chain( if (!done) done = 1); }"), UNKNOWN_MACRO);
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo() { for_chain( a, b, if (!done) done = 1); }"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f() { MACRO(switch); }\n"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f() { MACRO(x,switch); }\n"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo() { for_chain( if (!done) done = 1); }\n"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo() { for_chain( a, b, if (!done) done = 1); }\n"), UNKNOWN_MACRO);
 
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { if (retval==){} }"), SYNTAX, "syntax error: ==)");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { if (retval==){} }\n"), SYNTAX, "syntax error: ==)");
 
         // after (expr)
-        ASSERT_NO_THROW(tokenizeAndStringify("void f() { switch (a) int b; }"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() { switch (a) int b; }\n"));
 
-        ASSERT_NO_THROW(tokenizeAndStringify("S s = { .x=2, .y[0]=3 };"));
-        ASSERT_NO_THROW(tokenizeAndStringify("S s = { .ab.a=2, .ab.b=3 };"));
+        ASSERT_NO_THROW(tokenizeAndStringify("S s = { .x=2, .y[0]=3 };\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("S s = { .ab.a=2, .ab.b=3 };\n"));
 
-        ASSERT_NO_THROW(tokenizeAndStringify("extern \"C\" typedef void FUNC();"));
+        ASSERT_NO_THROW(tokenizeAndStringify("extern \"C\" typedef void FUNC();\n"));
 
         // Ticket #9572
         ASSERT_NO_THROW(tokenizeAndStringify("struct poc { "
                                              "  struct { int d; } port[1]; "
                                              "}; "
-                                             "struct poc p = { .port[0] = {.d = 3} };"));
+                                             "struct poc p = { .port[0] = {.d = 3} };\n"));
 
         // Ticket #9664
-        ASSERT_NO_THROW(tokenizeAndStringify("S s = { .x { 2 }, .y[0] { 3 } };"));
+        ASSERT_NO_THROW(tokenizeAndStringify("S s = { .x { 2 }, .y[0] { 3 } };\n"));
 
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("f(0, .x());"), SYNTAX); // #12823
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("f(0, .x());\n"), SYNTAX); // #12823
 
         // Ticket #11134
         ASSERT_NO_THROW(tokenizeAndStringify("struct my_struct { int x; }; "
                                              "std::string s; "
-                                             "func(my_struct{ .x=42 }, s.size());"));
+                                             "func(my_struct{ .x=42 }, s.size());\n"));
         ASSERT_NO_THROW(tokenizeAndStringify("struct my_struct { int x; int y; }; "
                                              "std::string s; "
-                                             "func(my_struct{ .x{42}, .y=3 }, s.size());"));
+                                             "func(my_struct{ .x{42}, .y=3 }, s.size());\n"));
         ASSERT_NO_THROW(tokenizeAndStringify("struct my_struct { int x; int y; }; "
                                              "std::string s; "
-                                             "func(my_struct{ .x=42, .y{3} }, s.size());"));
+                                             "func(my_struct{ .x=42, .y{3} }, s.size());\n"));
         ASSERT_NO_THROW(tokenizeAndStringify("struct my_struct { int x; }; "
                                              "void h() { "
                                              "  for (my_struct ms : { my_struct{ .x=5 } }) {} "
-                                             "}"));
+                                             "}\n"));
         ASSERT_NO_THROW(tokenizeAndStringify("struct my_struct { int x; int y; }; "
                                              "void h() { "
                                              "  for (my_struct ms : { my_struct{ .x=5, .y{42} } }) {} "
-                                             "}"));
+                                             "}\n"));
 
         ASSERT_NO_THROW(tokenizeAndStringify("template <typename T> void foo() {} "
                                              "void h() { "
                                              "  [func=foo<int>]{func();}(); "
-                                             "}"));
+                                             "}\n"));
         ASSERT_NO_THROW(tokenizeAndStringify("template <class T> constexpr int n = 1;\n"
                                              "template <class T> T a[n<T>];\n"));
 
@@ -7838,23 +7923,23 @@ class TestTokenizer : public TestFixture {
 
 
         // op op
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { dostuff (x==>y); }"), SYNTAX, "syntax error: == >");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { dostuff (x==>y); }\n"), SYNTAX, "syntax error: == >");
 
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { assert(a==()); }"), SYNTAX, "syntax error: ==()");
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { assert(a+()); }"), SYNTAX, "syntax error: +()");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { assert(a==()); }\n"), SYNTAX, "syntax error: ==()");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { assert(a+()); }\n"), SYNTAX, "syntax error: +()");
 
         // #9445 - typeof is not a keyword in C
-        ASSERT_NO_THROW(tokenizeAndStringify("void foo() { char *typeof, *value; }", dinit(TokenizeOptions, $.expand = false, $.cpp = false)));
+        ASSERT_NO_THROW(tokenizeAndStringify("void foo() { char *typeof, *value; }\n", dinit(TokenizeOptions, $.expand = false, $.cpp = false)));
 
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("enum : { };"), SYNTAX, "syntax error: Unexpected token '{'");
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("enum : 3 { };"), SYNTAX, "syntax error: Unexpected token '3'");
-        ASSERT_NO_THROW(tokenizeAndStringify("enum { E = int{} };"));
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("enum : { };\n"), SYNTAX, "syntax error: Unexpected token '{'");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("enum : 3 { };\n"), SYNTAX, "syntax error: Unexpected token '3'");
+        ASSERT_NO_THROW(tokenizeAndStringify("enum { E = int{} };\n"));
 
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("int a() { b((c)return 0) }"), SYNTAX, "syntax error");
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("int f() { MACRO(x) return 0; }"),
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("int a() { b((c)return 0) }\n"), SYNTAX, "syntax error");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("int f() { MACRO(x) return 0; }\n"),
                                      UNKNOWN_MACRO,
                                      "There is an unknown macro here somewhere. Configuration is required. If MACRO is a macro then please configure it.");
-        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("bool f() { unknown return 0; }"),
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("bool f() { unknown return 0; }\n"),
                                      UNKNOWN_MACRO,
                                      "There is an unknown macro here somewhere. Configuration is required. If unknown is a macro then please configure it.");
 
@@ -7915,32 +8000,32 @@ class TestTokenizer : public TestFixture {
                                      UNKNOWN_MACRO,
                                      "There is an unknown macro here somewhere. Configuration is required. If MACRO is a macro then please configure it.");
 
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("{ for (()()) }"), SYNTAX); // #11643
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("{ for (()()) }\n"), SYNTAX); // #11643
 
         ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f(const std::vector<std::string>& v) {\n" // #14326
                                                    "    for (const std::string&s : v)\n"
-                                                   "}"),
+                                                   "}\n"),
                               SYNTAX);
 
         ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f(T* p) {\n"
                                                    "    g(p->x TSRMLS_CC);"
-                                                   "}"),
+                                                   "}\n"),
                               UNKNOWN_MACRO);
 
-        ASSERT_NO_THROW(tokenizeAndStringify("S* g = ::new(ptr) S();")); // #12552
-        ASSERT_NO_THROW(tokenizeAndStringify("void f(int* p) { return ::delete p; }"));
+        ASSERT_NO_THROW(tokenizeAndStringify("S* g = ::new(ptr) S();\n")); // #12552
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int* p) { return ::delete p; }\n"));
 
         ASSERT_NO_THROW(tokenizeAndStringify("template <typename T, int N>\n" // #12659
-                                             "constexpr void f(T(&&a)[N]) {}"));
+                                             "constexpr void f(T(&&a)[N]) {}\n"));
 
-        ASSERT_NO_THROW(tokenizeAndStringify("typedef struct { typedef int T; } S;")); // #12700
+        ASSERT_NO_THROW(tokenizeAndStringify("typedef struct { typedef int T; } S;\n")); // #12700
 
         ASSERT_NO_THROW(tokenizeAndStringify("class A { bool restrict() const; };\n"
-                                             "bool A::restrict() const { return true; }")); // #12718
+                                             "bool A::restrict() const { return true; }\n")); // #12718
 
-        ASSERT_NO_THROW(tokenizeAndStringify("enum { E = sizeof(struct { int i; }) };")); // #13249
+        ASSERT_NO_THROW(tokenizeAndStringify("enum { E = sizeof(struct { int i; }) };\n")); // #13249
 
-        ASSERT_NO_THROW(tokenizeAndStringify("struct S { unsigned u:2, :30; };")); // #14393
+        ASSERT_NO_THROW(tokenizeAndStringify("struct S { unsigned u:2, :30; };\n")); // #14393
 
         ASSERT_NO_THROW(tokenizeAndStringify("struct S {};\n" // #14400
                                              "auto f(bool b) -> struct S {\n"
@@ -8172,7 +8257,7 @@ class TestTokenizer : public TestFixture {
                             "  });\n"
                             "}\n"));
 
-        ASSERT_NO_THROW(tokenizeAndStringify("a<b?0:1>()==3;"));
+        ASSERT_NO_THROW(tokenizeAndStringify("a<b?0:1>()==3;\n"));
 
         // #10336
         ASSERT_NO_THROW(tokenizeAndStringify("struct a {\n"
@@ -8226,14 +8311,14 @@ class TestTokenizer : public TestFixture {
     }
 
     void checkNamespaces() {
-        ASSERT_NO_THROW(tokenizeAndStringify("namespace x { namespace y { namespace z {}}}"));
+        ASSERT_NO_THROW(tokenizeAndStringify("namespace x { namespace y { namespace z {}}}\n"));
     }
 
     void checkLambdas() {
-        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [=, &i] {}; }"));
-        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [&, i] {}; }"));
-        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [&, i = std::move(i)] {}; }"));
-        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [=, i = std::move(i)] {}; }"));
+        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [=, &i] {}; }\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [&, i] {}; }\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [&, i = std::move(i)] {}; }\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [=, i = std::move(i)] {}; }\n"));
         ASSERT_NO_THROW(tokenizeAndStringify("struct c {\n"
                                              "  void d() {\n"
                                              "    int a;\n"
@@ -8446,7 +8531,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void noCrash3() {
-        ASSERT_NO_THROW(tokenizeAndStringify("void a(X<int> x, typename Y1::Y2<int, A::B::C, 2> y, Z z = []{});"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void a(X<int> x, typename Y1::Y2<int, A::B::C, 2> y, Z z = []{});\n"));
     }
 
     void noCrash4() {
@@ -8486,17 +8571,17 @@ class TestTokenizer : public TestFixture {
     }
 
     void checkConfiguration() {
-        ASSERT_THROW_INTERNAL_EQUALS(checkConfig("void f() { DEBUG(x();y()); }"),
+        ASSERT_THROW_INTERNAL_EQUALS(checkConfig("void f() { DEBUG(x();y()); }\n"),
                                      UNKNOWN_MACRO,
                                      "There is an unknown macro here somewhere. Configuration is required. If DEBUG is a macro then please configure it.");
     }
 
     void unknownMacroBeforeReturn() {
-        ASSERT_THROW_INTERNAL(tokenizeAndStringify("int f() { X return 0; }"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("int f() { X return 0; }\n"), UNKNOWN_MACRO);
     }
 
     void cppKeywordInCSource() {
-        ASSERT_NO_THROW(tokenizeAndStringify("int throw() {}", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_NO_THROW(tokenizeAndStringify("int throw() {}\n", dinit(TokenizeOptions, $.cpp = false)));
 
         const char code[] = "void requires(const char*);\n" // #14613
                             "void f() { requires(\"abc\"); }\n";
@@ -8524,7 +8609,7 @@ class TestTokenizer : public TestFixture {
     void ccast() {
         const char code[] = "a = (int)x;\n" // #13579
                             "int (*p)[10];\n"
-                            "b = (void (S::*)(int) const)&y;";
+                            "b = (void (S::*)(int) const)&y;\n";
 
         SimpleTokenizer tokenizer(settingsDefault, *this);
         ASSERT(tokenizer.tokenize(code));
@@ -8557,7 +8642,7 @@ class TestTokenizer : public TestFixture {
                             "    int a = 1;\n"
                             "    void f() { g(1); }\n"
                             "    template <typename T> void g(T x) { a = 2; }\n" // <- template is used and should be kept
-                            "};";
+                            "};\n";
 
         ASSERT_EQUALS("\n\n##file 1\n"
                       "1: struct A {\n"
@@ -8577,29 +8662,29 @@ class TestTokenizer : public TestFixture {
     }
 
     void removeExtraTemplateKeywords() {
-        const char code1[] = "typename GridView::template Codim<0>::Iterator iterator;";
+        const char code1[] = "typename GridView::template Codim<0>::Iterator iterator;\n";
         const char expected1[] = "GridView :: Codim < 0 > :: Iterator iterator ;";
         ASSERT_EQUALS(expected1, tokenizeAndStringify(code1));
 
-        const char code2[] = "typename GridView::template Codim<0>::Iterator it = gv.template begin<0>();";
+        const char code2[] = "typename GridView::template Codim<0>::Iterator it = gv.template begin<0>();\n";
         const char expected2[] = "GridView :: Codim < 0 > :: Iterator it ; it = gv . begin < 0 > ( ) ;";
         ASSERT_EQUALS(expected2, tokenizeAndStringify(code2));
     }
 
     void removeAlignas1() {
-        const char code[] = "alignas(float) unsigned char c[sizeof(float)];";
+        const char code[] = "alignas(float) unsigned char c[sizeof(float)];\n";
         const char expected[] = "unsigned char c [ sizeof ( float ) ] ;";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     void removeAlignas2() { // Do not remove alignas and alignof in the same way
-        const char code[] = "static_assert( alignof( VertexC ) == 4 );";
+        const char code[] = "static_assert( alignof( VertexC ) == 4 );\n";
         const char expected[] = "static_assert ( alignof ( VertexC ) == 4 ) ;";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     void removeAlignas3() {
-        const char code[] = "alignas(16) int x;";
+        const char code[] = "alignas(16) int x;\n";
         const char expected[] = "int x ;";
         // According to cppreference alignas() is a C23 macro; but it is often available when compiling C11.
         // Misra C has C11 examples with alignas.
@@ -8610,7 +8695,7 @@ class TestTokenizer : public TestFixture {
 
     void dumpAlignas() {
         SimpleTokenizer tokenizer(settingsDefault, *this, false);
-        ASSERT(tokenizer.tokenize("int alignas(8) alignas(16) x;"));
+        ASSERT(tokenizer.tokenize("int alignas(8) alignas(16) x;\n"));
         ASSERT(Token::simpleMatch(tokenizer.tokens(), "int x ;"));
         std::ostringstream ostr;
         tokenizer.dump(ostr);
@@ -8621,15 +8706,15 @@ class TestTokenizer : public TestFixture {
     void simplifyCoroutines() {
         const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
 
-        const char code1[] = "generator<int> f() { co_yield start++; }";
+        const char code1[] = "generator<int> f() { co_yield start++; }\n";
         const char expected1[] = "generator < int > f ( ) { co_yield ( start ++ ) ; }";
         ASSERT_EQUALS(expected1, tokenizeAndStringify(code1, settings));
 
-        const char code2[] = "task<> f() { co_await foo(); }";
+        const char code2[] = "task<> f() { co_await foo(); }\n";
         const char expected2[] = "task < > f ( ) { co_await ( foo ( ) ) ; }";
         ASSERT_EQUALS(expected2, tokenizeAndStringify(code2, settings));
 
-        const char code3[] = "generator<int> f() { co_return 7; }";
+        const char code3[] = "generator<int> f() { co_return 7; }\n";
         const char expected3[] = "generator < int > f ( ) { co_return ( 7 ) ; }";
         ASSERT_EQUALS(expected3, tokenizeAndStringify(code3, settings));
     }
@@ -8637,41 +8722,41 @@ class TestTokenizer : public TestFixture {
     void simplifySpaceshipOperator() {
         const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
 
-        ASSERT_EQUALS("; x <=> y ;", tokenizeAndStringify(";x<=>y;", settings));
+        ASSERT_EQUALS("; x <=> y ;", tokenizeAndStringify(";x<=>y;\n", settings));
     }
 
     void simplifyIfSwitchForInit1() {
         const Settings settings = settingsBuilder().cpp(Standards::CPP17).build();
-        const char code[] = "void f() { if (a;b) {} }";
+        const char code[] = "void f() { if (a;b) {} }\n";
         ASSERT_EQUALS("void f ( ) { { a ; if ( b ) { } } }", tokenizeAndStringify(code, settings));
     }
 
     void simplifyIfSwitchForInit2() {
         const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
-        const char code[] = "void f() { if (a;b) {} else {} }";
+        const char code[] = "void f() { if (a;b) {} else {} }\n";
         ASSERT_EQUALS("void f ( ) { { a ; if ( b ) { } else { } } }", tokenizeAndStringify(code, settings));
     }
 
     void simplifyIfSwitchForInit3() {
         const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
-        const char code[] = "void f() { switch (a;b) {} }";
+        const char code[] = "void f() { switch (a;b) {} }\n";
         ASSERT_EQUALS("void f ( ) { { a ; switch ( b ) { } } }", tokenizeAndStringify(code, settings));
     }
 
     void simplifyIfSwitchForInit4() {
         const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
-        const char code[] = "void f() { for (a;b:c) {} }";
+        const char code[] = "void f() { for (a;b:c) {} }\n";
         ASSERT_EQUALS("void f ( ) { { a ; for ( b : c ) { } } }", tokenizeAndStringify(code, settings));
     }
 
     void simplifyIfSwitchForInit5() {
         const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
-        const char code[] = "void f() { if ([] { ; }) {} }";
+        const char code[] = "void f() { if ([] { ; }) {} }\n";
         ASSERT_EQUALS("void f ( ) { if ( [ ] { ; } ) { } }", tokenizeAndStringify(code, settings));
     }
 
     void newPlacementArgsCppInit() { // #13775
-        const char code[] = "::new(nullptr) int {};";
+        const char code[] = "::new(nullptr) int {};\n";
         SimpleTokenizer tokenizer(settings1, *this);
         tokenizer.tokenize(code);
         const Token *inttok = Token::findsimplematch(tokenizer.tokens(), "int");
@@ -8684,7 +8769,7 @@ class TestTokenizer : public TestFixture {
 
     void cpp20_default_bitfield_initializer() {
         const Settings s1 = settingsBuilder().cpp(Standards::CPP20).build();
-        const char code[] = "struct S { int a:2 = 0; };";
+        const char code[] = "struct S { int a:2 = 0; };\n";
         ASSERT_EQUALS("struct S { int a ; a = 0 ; } ;", tokenizeAndStringify(code, s1));
         const Settings s2 = settingsBuilder().cpp(Standards::CPP17).build();
         ASSERT_THROW_INTERNAL(tokenizeAndStringify(code, s2), SYNTAX);
@@ -8701,44 +8786,44 @@ class TestTokenizer : public TestFixture {
             ASSERT_LOC(tok->isCpp11init() == expected, file, line);
         };
 
-        testIsCpp11init("class X : public A<int>, C::D {};",
+        testIsCpp11init("class X : public A<int>, C::D {};\n",
                         "D {",
                         Token::Cpp11init::NOINIT);
 
-        testIsCpp11init("auto f() -> void {}",
+        testIsCpp11init("auto f() -> void {}\n",
                         "void {",
                         Token::Cpp11init::NOINIT);
-        testIsCpp11init("auto f() & -> void {}",
+        testIsCpp11init("auto f() & -> void {}\n",
                         "void {",
                         Token::Cpp11init::NOINIT);
-        testIsCpp11init("auto f() const noexcept(false) -> void {}",
+        testIsCpp11init("auto f() const noexcept(false) -> void {}\n",
                         "void {",
                         Token::Cpp11init::NOINIT);
-        testIsCpp11init("auto f() -> std::vector<int> { return {}; }",
+        testIsCpp11init("auto f() -> std::vector<int> { return {}; }\n",
                         "{ return",
                         Token::Cpp11init::NOINIT);
-        testIsCpp11init("auto f() -> std::vector<int> { return {}; }",
+        testIsCpp11init("auto f() -> std::vector<int> { return {}; }\n",
                         "vector",
                         Token::Cpp11init::NOINIT);
-        testIsCpp11init("auto f() -> std::vector<int> { return {}; }",
+        testIsCpp11init("auto f() -> std::vector<int> { return {}; }\n",
                         "std ::",
                         Token::Cpp11init::NOINIT);
 
-        testIsCpp11init("class X{};",
+        testIsCpp11init("class X{};\n",
                         "{ }",
                         Token::Cpp11init::NOINIT);
-        testIsCpp11init("class X{}", // forgotten ; so not properly recognized as a class
+        testIsCpp11init("class X{}\n", // forgotten ; so not properly recognized as a class
                         "{ }",
                         Token::Cpp11init::CPP11INIT);
 
-        testIsCpp11init("namespace abc::def { TEST(a, b) {} }",
+        testIsCpp11init("namespace abc::def { TEST(a, b) {} }\n",
                         "{ TEST",
                         Token::Cpp11init::NOINIT);
-        testIsCpp11init("namespace { TEST(a, b) {} }", // anonymous namespace
+        testIsCpp11init("namespace { TEST(a, b) {} }\n", // anonymous namespace
                         "{ TEST",
                         Token::Cpp11init::NOINIT);
 
-        testIsCpp11init("enum { e = decltype(s)::i };",
+        testIsCpp11init("enum { e = decltype(s)::i };\n",
                         "{ e",
                         Token::Cpp11init::NOINIT);
 
@@ -8814,7 +8899,7 @@ class TestTokenizer : public TestFixture {
                         "{ 1",
                         Token::Cpp11init::CPP11INIT);
 
-        testIsCpp11init("void f() { g([] { if (int x = 1; x) {} }); }", // #14790
+        testIsCpp11init("void f() { g([] { if (int x = 1; x) {} }); }\n", // #14790
                         "{ int",
                         Token::Cpp11init::NOINIT); // don't hang
 
@@ -9067,7 +9152,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void genericInIf() { // #13561
-        const char code[] = "  if (_Generic(s, char * : 1, const float * : (a ? b, c : d), volatile int * : 3, default : 0)) {}";
+        const char code[] = "  if (_Generic(s, char * : 1, const float * : (a ? b, c : d), volatile int * : 3, default : 0)) {}\n";
         const char ast[] = "(( if (( _Generic (, (, (, (, s 1) (? a (: (, b c) d))) 3) 0)))";
         ASSERT_EQUALS(ast, testAst(code, AstStyle::Z3));
     }
@@ -9105,22 +9190,22 @@ class TestTokenizer : public TestFixture {
                             "    if (fp_t const fp = s.g<fp_t>()) {}\n"
                             "}\n";
         ASSERT_NO_THROW(tokenizeAndStringify(code));
-        ASSERT_EQUALS("void ( * const f ) ( ) ;", tokenizeAndStringify("typedef void (*fp_t)(); fp_t const f;"));
+        ASSERT_EQUALS("void ( * const f ) ( ) ;", tokenizeAndStringify("typedef void (*fp_t)(); fp_t const f;\n"));
     }
 
     void simplifyPlatformTypes() {
         {
-            const char code[] = "size_t f();";
+            const char code[] = "size_t f();\n";
             ASSERT_EQUALS("unsigned long f ( ) ;", tokenizeAndStringify(code, settings2_unix32));
             ASSERT_EQUALS("unsigned long f ( ) ;", tokenizeAndStringify(code, settings2_unix64));
         }
         {
-            const char code[] = "ssize_t f();";
+            const char code[] = "ssize_t f();\n";
             ASSERT_EQUALS("long f ( ) ;", tokenizeAndStringify(code, settings2_unix32));
             ASSERT_EQUALS("long f ( ) ;", tokenizeAndStringify(code, settings2_unix64));
         }
         {
-            const char code[] = "std::ptrdiff_t f();";
+            const char code[] = "std::ptrdiff_t f();\n";
             ASSERT_EQUALS("long f ( ) ;", tokenizeAndStringify(code, settings2_unix32));
             ASSERT_EQUALS("long f ( ) ;", tokenizeAndStringify(code, settings2_unix64));
         }
@@ -9141,7 +9226,7 @@ class TestTokenizer : public TestFixture {
                             "            i();\n"
                             "            break;\n"
                             "    }\n"
-                            "}";
+                            "}\n";
         SimpleTokenizer tokenizer(settingsDefault, *this, false);
         ASSERT(tokenizer.tokenize(code));
         std::ostringstream ostr;
@@ -9159,7 +9244,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void simplifyEnum1() {
-        const char code[] = "static enum {A,B} ab;";
+        const char code[] = "static enum {A,B} ab;\n";
         ASSERT_EQUALS("enum Anonymous0 { A , B } ; static enum Anonymous0 ab ;", tokenizeAndStringify(code));
         SimpleTokenizer tokenizer(settingsDefault, *this);
         tokenizer.tokenize(code);
@@ -9170,7 +9255,7 @@ class TestTokenizer : public TestFixture {
     }
 
     void simplifyEnum2() {
-        const char code[] = "enum AB {A,B}; enum AB static ab; ";
+        const char code[] = "enum AB {A,B}; enum AB static ab; \n";
         ASSERT_EQUALS("enum AB { A , B } ; static enum AB ab ;", tokenizeAndStringify(code));
         SimpleTokenizer tokenizer(settingsDefault, *this);
         tokenizer.tokenize(code);
diff --git a/test/testtokenlist.cpp b/test/testtokenlist.cpp
index 4e658743f92..0374ad6b4a2 100644
--- a/test/testtokenlist.cpp
+++ b/test/testtokenlist.cpp
@@ -65,7 +65,7 @@ class TestTokenList : public TestFixture {
     }
 
     void inc() const {
-        const char code[] = "a++1;1++b;";
+        const char code[] = "a++1;1++b;\n";
 
         const SimpleTokenList tokenlist(code);
         ASSERT(Token::simpleMatch(tokenlist.front(), "a + + 1 ; 1 + + b ;"));
@@ -73,7 +73,7 @@ class TestTokenList : public TestFixture {
 
     void isKeyword() const {
 
-        const char code[] = "for a int delete true";
+        const char code[] = "for a int delete true\n";
 
         {
             const SimpleTokenList tokenlist(code, Standards::Language::C);
@@ -109,19 +109,19 @@ class TestTokenList : public TestFixture {
         }
 
         {
-            const char code2[] = "_Generic"; // C11 keyword
+            const char code2[] = "_Generic\n"; // C11 keyword
             const SimpleTokenList tokenlist(code2); // default settings use latest standard
             ASSERT_EQUALS(false, tokenlist.front()->isKeyword());
         }
 
         {
-            const char code2[] = "_Generic"; // C11 keyword
+            const char code2[] = "_Generic\n"; // C11 keyword
             const SimpleTokenList tokenlist(code2, Standards::Language::C); // default settings use latest standard
             ASSERT_EQUALS(true, tokenlist.front()->isKeyword());
         }
 
         {
-            const char code2[] = "_Generic"; // C11 keyword
+            const char code2[] = "_Generic\n"; // C11 keyword
             const Settings s = settingsBuilder().c(Standards::C89).build();
             TokenList tokenlist(s, Standards::Language::C);
             tokenlist.appendFileIfNew("a.c");
@@ -130,19 +130,19 @@ class TestTokenList : public TestFixture {
         }
 
         {
-            const char code2[] = "co_return"; // C++20 keyword
+            const char code2[] = "co_return\n"; // C++20 keyword
             const SimpleTokenList tokenlist(code2); // default settings use latest standard
             ASSERT_EQUALS(true, tokenlist.front()->isKeyword());
         }
 
         {
-            const char code2[] = "co_return"; // C++20 keyword
+            const char code2[] = "co_return\n"; // C++20 keyword
             const SimpleTokenList tokenlist(code2, Standards::Language::C); // default settings use latest standard
             ASSERT_EQUALS(false, tokenlist.front()->isKeyword());
         }
 
         {
-            const char code2[] = "noexcept"; // C++11 keyword
+            const char code2[] = "noexcept\n"; // C++11 keyword
             const Settings s = settingsBuilder().cpp(Standards::CPP03).build();
             TokenList tokenlist(s, Standards::Language::CPP);
             tokenlist.appendFileIfNew("a.cpp");
@@ -154,9 +154,9 @@ class TestTokenList : public TestFixture {
     void notokens() {
         // analyzing /usr/include/poll.h caused Path::identify() to be called with an empty filename from
         // TokenList::determineCppC() because there are no tokens
-        const char code[] = "#include <sys/poll.h>";
+        const char code[] = "#include <sys/poll.h>\n";
         std::vector<std::string> files;
-        simplecpp::TokenList tokens1(code, files, "poll.h", nullptr);
+        simplecpp::TokenList tokens1(code, files, "poll.h", {}, nullptr);
         Preprocessor preprocessor(tokens1, settingsDefault, *this, Path::identify(tokens1.getFiles()[0], false));
         simplecpp::OutputList outputList_pp;
         simplecpp::TokenList tokensP = preprocessor.preprocess("", files, outputList_pp);
@@ -166,7 +166,7 @@ class TestTokenList : public TestFixture {
     }
 
     void ast1() const {
-        const char code[] = "('Release|x64' == 'Release|x64');";
+        const char code[] = "('Release|x64' == 'Release|x64');\n";
 
         TokenList tokenlist(settingsDefault, Standards::Language::C);
         ASSERT(tokenlist.createTokensFromString(code));
diff --git a/test/testtokenrange.cpp b/test/testtokenrange.cpp
index e27e6c5b038..f2ac218fec2 100644
--- a/test/testtokenrange.cpp
+++ b/test/testtokenrange.cpp
@@ -67,19 +67,19 @@ class TestTokenRange : public TestFixture {
     }
 
     void enumerationToEnd() const {
-        const char code[] = "void a(){} void main(){ if(true){a();} }";
+        const char code[] = "void a(){} void main(){ if(true){a();} }\n";
         const SimpleTokenList tokenList(code);
         ASSERT_EQUALS("", testTokenRange(ConstTokenRange{ tokenList.front(), nullptr }, tokenList.front(), nullptr));
     }
 
     void untilHelperToEnd() const {
-        const char code[] = "void a(){} void main(){ if(true){a();} }";
+        const char code[] = "void a(){} void main(){ if(true){a();} }\n";
         const SimpleTokenList tokenList(code);
         ASSERT_EQUALS("", testTokenRange(tokenList.front()->until(nullptr), tokenList.front(), nullptr));
     }
 
     void untilHelperPartWay() const {
-        const char code[] = "void a(){} void main(){ if(true){a();} }";
+        const char code[] = "void a(){} void main(){ if(true){a();} }\n";
         const SimpleTokenList tokenList(code);
         const Token* start = tokenList.front()->tokAt(4);
         const Token* end = start->tokAt(8);
@@ -87,7 +87,7 @@ class TestTokenRange : public TestFixture {
     }
 
     void partialEnumeration() const {
-        const char code[] = "void a(){} void main(){ if(true){a();} }";
+        const char code[] = "void a(){} void main(){ if(true){a();} }\n";
         const SimpleTokenList tokenList(code);
         const Token* start = tokenList.front()->tokAt(4);
         const Token* end = tokenList.front()->tokAt(10);
@@ -96,7 +96,7 @@ class TestTokenRange : public TestFixture {
 
     void scopeExample() {
         SimpleTokenizer tokenizer(settingsDefault, *this);
-        const char code[] = "void a(){} void main(){ if(true){a();} }";
+        const char code[] = "void a(){} void main(){ if(true){a();} }\n";
         ASSERT(tokenizer.tokenize(code));
 
         const SymbolDatabase* sd = tokenizer.getSymbolDatabase();
@@ -110,7 +110,7 @@ class TestTokenRange : public TestFixture {
     }
 
     void exampleAlgorithms() const {
-        const char code[] = "void a(){} void main(){ if(true){a();} }";
+        const char code[] = "void a(){} void main(){ if(true){a();} }\n";
         const SimpleTokenList tokenList(code);
         ConstTokenRange range{ tokenList.front(), nullptr };
         ASSERT_EQUALS(true, std::all_of(range.begin(), range.end(), [](const Token*) {
diff --git a/test/testtype.cpp b/test/testtype.cpp
index 2bcab8c91dc..a8617beb01d 100644
--- a/test/testtype.cpp
+++ b/test/testtype.cpp
@@ -105,13 +105,13 @@ class TestType : public TestFixture {
         {
             const std::string types[] = {"unsigned char", "bool", "unsigned short", "unsigned int", "unsigned long"};
             for (const std::string& type : types) {
-                check(type + " f(" + type +" x) { return x << 31; }", dinit(CheckOptions, $.settings = &settings));
+                check(type + " f(" + type +" x) { return x << 31; }\n", dinit(CheckOptions, $.settings = &settings));
                 ASSERT_EQUALS_MSG("", errout_str(), type);
-                check(type + " f(" + type +" x) { return x << 33; }", dinit(CheckOptions, $.settings = &settings));
+                check(type + " f(" + type +" x) { return x << 33; }\n", dinit(CheckOptions, $.settings = &settings));
                 ASSERT_EQUALS_MSG("[test.cpp:1]: (error) Shifting 32-bit value by 33 bits is undefined behaviour\n", errout_str(), type);
-                check(type + " f(int x) { return (x = (" + type + ")x << 32); }", dinit(CheckOptions, $.settings = &settings));
+                check(type + " f(int x) { return (x = (" + type + ")x << 32); }\n", dinit(CheckOptions, $.settings = &settings));
                 ASSERT_EQUALS_MSG("[test.cpp:1]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n", errout_str(), type);
-                check(type + " foo(" + type + " x) { return x << 31; }", dinit(CheckOptions, $.settings = &settings));
+                check(type + " foo(" + type + " x) { return x << 31; }\n", dinit(CheckOptions, $.settings = &settings));
                 ASSERT_EQUALS_MSG("", errout_str(), type);
             }
         }
@@ -121,68 +121,68 @@ class TestType : public TestFixture {
             const std::string types[] = {"signed char", "signed short", /*[signed]*/ "short", "wchar_t", /*[signed]*/ "int", "signed int", /*[signed]*/ "long", "signed long"};
             for (const std::string& type : types) {
                 // c++11
-                check(type + " f(" + type +" x) { return x << 33; }", dinit(CheckOptions, $.settings = &settings));
+                check(type + " f(" + type +" x) { return x << 33; }\n", dinit(CheckOptions, $.settings = &settings));
                 ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 33 bits is undefined behaviour\n", errout_str());
-                check(type + " f(int x) { return (x = (" + type + ")x << 32); }", dinit(CheckOptions, $.settings = &settings));
+                check(type + " f(int x) { return (x = (" + type + ")x << 32); }\n", dinit(CheckOptions, $.settings = &settings));
                 ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n", errout_str());
-                check(type + " foo(" + type + " x) { return x << 31; }", dinit(CheckOptions, $.settings = &settings));
+                check(type + " foo(" + type + " x) { return x << 31; }\n", dinit(CheckOptions, $.settings = &settings));
                 ASSERT_EQUALS("[test.cpp:1]: (error) Shifting signed 32-bit value by 31 bits is undefined behaviour\n", errout_str());
-                check(type + " foo(" + type + " x) { return x << 30; }", dinit(CheckOptions, $.settings = &settings));
+                check(type + " foo(" + type + " x) { return x << 30; }\n", dinit(CheckOptions, $.settings = &settings));
                 ASSERT_EQUALS("", errout_str());
 
                 // c++14
-                check(type + " foo(" + type + " x) { return x << 31; }", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
+                check(type + " foo(" + type + " x) { return x << 31; }\n", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
                 ASSERT_EQUALS("[test.cpp:1]: (portability) Shifting signed 32-bit value by 31 bits is implementation-defined behaviour\n", errout_str());
-                check(type + " f(int x) { return (x = (" + type + ")x << 32); }", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
+                check(type + " f(int x) { return (x = (" + type + ")x << 32); }\n", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
                 ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n", errout_str());
             }
         }
         // 64 bit width types
         {
             // unsigned long long
-            check("unsigned long long foo(unsigned long long x) { return x << 64; }",dinit(CheckOptions, $.settings = &settings));
+            check("unsigned long long foo(unsigned long long x) { return x << 64; }\n",dinit(CheckOptions, $.settings = &settings));
             ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
-            check("unsigned long long f(int x) { return (x = (unsigned long long)x << 64); }",dinit(CheckOptions, $.settings = &settings));
+            check("unsigned long long f(int x) { return (x = (unsigned long long)x << 64); }\n",dinit(CheckOptions, $.settings = &settings));
             ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
-            check("unsigned long long f(unsigned long long x) { return x << 63; }",dinit(CheckOptions, $.settings = &settings));
+            check("unsigned long long f(unsigned long long x) { return x << 63; }\n",dinit(CheckOptions, $.settings = &settings));
             ASSERT_EQUALS("", errout_str());
             // [signed] long long
-            check("long long foo(long long x) { return x << 64; }",dinit(CheckOptions, $.settings = &settings));
+            check("long long foo(long long x) { return x << 64; }\n",dinit(CheckOptions, $.settings = &settings));
             ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
-            check("long long f(int x) { return (x = (long long)x << 64); }",dinit(CheckOptions, $.settings = &settings));
+            check("long long f(int x) { return (x = (long long)x << 64); }\n",dinit(CheckOptions, $.settings = &settings));
             ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
-            check("long long f(long long x) { return x << 63; }",dinit(CheckOptions, $.settings = &settings));
+            check("long long f(long long x) { return x << 63; }\n",dinit(CheckOptions, $.settings = &settings));
             ASSERT_EQUALS("[test.cpp:1]: (error) Shifting signed 64-bit value by 63 bits is undefined behaviour\n", errout_str());
-            check("long long f(long long x) { return x << 62; }",dinit(CheckOptions, $.settings = &settings));
+            check("long long f(long long x) { return x << 62; }\n",dinit(CheckOptions, $.settings = &settings));
             ASSERT_EQUALS("", errout_str());
             // signed long long
-            check("signed long long foo(signed long long x) { return x << 64; }",dinit(CheckOptions, $.settings = &settings));
+            check("signed long long foo(signed long long x) { return x << 64; }\n",dinit(CheckOptions, $.settings = &settings));
             ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
-            check("signed long long f(long long x) { return (x = (signed long long)x << 64); }",dinit(CheckOptions, $.settings = &settings));
+            check("signed long long f(long long x) { return (x = (signed long long)x << 64); }\n",dinit(CheckOptions, $.settings = &settings));
             ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
-            check("signed long long f(signed long long x) { return x << 63; }",dinit(CheckOptions, $.settings = &settings));
+            check("signed long long f(signed long long x) { return x << 63; }\n",dinit(CheckOptions, $.settings = &settings));
             ASSERT_EQUALS("[test.cpp:1]: (error) Shifting signed 64-bit value by 63 bits is undefined behaviour\n", errout_str());
-            check("signed long long f(signed long long x) { return x << 62; }",dinit(CheckOptions, $.settings = &settings));
+            check("signed long long f(signed long long x) { return x << 62; }\n",dinit(CheckOptions, $.settings = &settings));
             ASSERT_EQUALS("", errout_str());
 
             // c++14
-            check("signed long long foo(signed long long x) { return x << 64; }", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
+            check("signed long long foo(signed long long x) { return x << 64; }\n", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
             ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
-            check("signed long long f(long long x) { return (x = (signed long long)x << 64); }", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
+            check("signed long long f(long long x) { return (x = (signed long long)x << 64); }\n", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
             ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
-            check("signed long long f(signed long long x) { return x << 63; }", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
+            check("signed long long f(signed long long x) { return x << 63; }\n", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
             ASSERT_EQUALS("[test.cpp:1]: (portability) Shifting signed 64-bit value by 63 bits is implementation-defined behaviour\n", errout_str());
-            check("signed long long f(signed long long x) { return x << 62; }",dinit(CheckOptions, $.settings = &settings));
+            check("signed long long f(signed long long x) { return x << 62; }\n",dinit(CheckOptions, $.settings = &settings));
             ASSERT_EQUALS("", errout_str());
         }
 
-        check("void f() { int x; x = 1 >> 64; }", dinit(CheckOptions, $.settings = &settings));
+        check("void f() { int x; x = 1 >> 64; }\n", dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 64 bits is undefined behaviour\n", errout_str());
 
         check("void foo() {\n"
               "  QList<int> someList;\n"
               "  someList << 300;\n"
-              "}", dinit(CheckOptions, $.settings = &settings));
+              "}\n", dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #6793
@@ -190,14 +190,14 @@ class TestType : public TestFixture {
               "const unsigned int f = foo<31>(0);\n"
               "const unsigned int g = foo<100>(0);\n"
               "template<unsigned int I> int hoo(unsigned int x) { return x << 32; }\n"
-              "const unsigned int h = hoo<100>(0);", dinit(CheckOptions, $.settings = &settings));
+              "const unsigned int h = hoo<100>(0);\n", dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:4]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n"
                       "[test.cpp:1]: (error) Shifting 32-bit value by 100 bits is undefined behaviour\n", errout_str());
 
         // #7266: C++, shift in macro
         check("void f(unsigned int x) {\n"
               "    UINFO(x << 1234);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8640
@@ -207,7 +207,7 @@ class TestType : public TestFixture {
               "    constexpr const int shift[1] = {32};\n"
               "    constexpr const int ret = a << shift[0];\n" // shift too many bits
               "    return ret;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n"
                       "[test.cpp:5]: (error) Signed integer overflow for expression 'a<<shift[0]'.\n", errout_str());
 
@@ -218,7 +218,7 @@ class TestType : public TestFixture {
               "  if (k > 32)\n"
               "    return 0;\n"
               "  return rm>> k;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4] -> [test.cpp:6]: (warning) Shifting signed 32-bit value by 31 bits is undefined behaviour. See condition at line 4.\n",
             errout_str());
@@ -230,7 +230,7 @@ class TestType : public TestFixture {
               "    return 0;\n"
               "  else\n"
               "    return rm>> k;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4] -> [test.cpp:7]: (warning) Shifting signed 32-bit value by 31 bits is undefined behaviour. See condition at line 4.\n",
             errout_str());
@@ -242,20 +242,20 @@ class TestType : public TestFixture {
               "    return 0;\n"
               "  else\n"
               "    return rm>> k;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("static long long f(int x, long long y) {\n"
               "    if (x >= 64)\n"
               "        return 0;\n"
               "    return -(y << (x-1));\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("bool f() {\n"
               "    std::ofstream outfile;\n"
               "    outfile << vec_points[0](0) << static_cast<int>(d) << ' ';\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(unsigned b, int len, unsigned char rem) {\n" // #10773
@@ -273,45 +273,45 @@ class TestType : public TestFixture {
     void checkIntegerOverflow() {
         const Settings settings = settingsBuilder().severity(Severity::warning).platform(Platform::Type::Unix32).build();
 
-        check("x = (int)0x10000 * (int)0x10000;", dinit(CheckOptions, $.settings = &settings));
+        check("x = (int)0x10000 * (int)0x10000;\n", dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:1:18]: (error) Signed integer overflow for expression '(int)0x10000*(int)0x10000'. [integerOverflow]\n", errout_str());
 
-        check("x = (long)0x10000 * (long)0x10000;", dinit(CheckOptions, $.settings = &settings));
+        check("x = (long)0x10000 * (long)0x10000;\n", dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:1:19]: (error) Signed integer overflow for expression '(long)0x10000*(long)0x10000'. [integerOverflow]\n", errout_str());
 
         check("void foo() {\n"
               "    int intmax = 0x7fffffff;\n"
               "    return intmax + 1;\n"
-              "}",dinit(CheckOptions, $.settings = &settings));
+              "}\n",dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:3:19]: (error) Signed integer overflow for expression 'intmax+1'. [integerOverflow]\n", errout_str());
 
         check("void foo() {\n"
               "    int intmax = 0x7fffffff;\n"
               "    return intmax - 1;\n"
-              "}",dinit(CheckOptions, $.settings = &settings));
+              "}\n",dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("", errout_str());
 
         check("int foo(signed int x) {\n"
               "   if (x==123456) {}\n"
               "   return x * x;\n"
-              "}",dinit(CheckOptions, $.settings = &settings));
+              "}\n",dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:13]: (warning) Either the condition 'x==123456' is redundant or there is signed integer overflow for expression 'x*x'. [integerOverflowCond]\n", errout_str());
 
         check("int foo(signed int x) {\n"
               "   if (x==123456) {}\n"
               "   return -123456 * x;\n"
-              "}",dinit(CheckOptions, $.settings = &settings));
+              "}\n",dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:19]: (warning) Either the condition 'x==123456' is redundant or there is signed integer underflow for expression '-123456*x'. [integerOverflowCond]\n", errout_str());
 
         check("int foo(signed int x) {\n"
               "   if (x==123456) {}\n"
               "   return 123456U * x;\n"
-              "}",dinit(CheckOptions, $.settings = &settings));
+              "}\n",dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("", errout_str());
 
         check("int f(int i) {\n" // #12117
               "    return (i == 31) ? 1 << i : 0;\n"
-              "}", dinit(CheckOptions, $.settings = &settings));
+              "}\n", dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:2:15] -> [test.cpp:2:26]: (warning) Shifting signed 32-bit value by 31 bits is undefined behaviour. See condition at line 2. [shiftTooManyBitsSigned]\n", errout_str());
 
         check("void f() {\n" // #13092
@@ -319,7 +319,7 @@ class TestType : public TestFixture {
               "    for (int i = 0; i < 10; i++) {\n"
               "        n = n * 47163 - 57412;\n"
               "    }\n"
-              "}", dinit(CheckOptions, $.settings = &settings));
+              "}\n", dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:4:15]: (error) Signed integer underflow for expression 'n*47163'. [integerOverflow]\n"
                       "[test.cpp:4:23]: (error) Signed integer underflow for expression 'n*47163-57412'. [integerOverflow]\n",
                       errout_str());
@@ -327,22 +327,22 @@ class TestType : public TestFixture {
 
     void signConversion() {
         const Settings settings = settingsBuilder().platform(Platform::Type::Unix64).build();
-        check("x = -4 * (unsigned)y;");
+        check("x = -4 * (unsigned)y;\n");
         ASSERT_EQUALS("[test.cpp:1:6]: (warning) Expression '-4' has a negative value. That is converted to an unsigned value and used in an unsigned calculation. [signConversion]\n", errout_str());
 
-        check("x = (unsigned)y * -4;");
+        check("x = (unsigned)y * -4;\n");
         ASSERT_EQUALS("[test.cpp:1:20]: (warning) Expression '-4' has a negative value. That is converted to an unsigned value and used in an unsigned calculation. [signConversion]\n", errout_str());
 
         check("unsigned int dostuff(int x) {\n" // x is signed
               "  if (x==0) {}\n"
               "  return (x-1)*sizeof(int);\n"
-              "}", dinit(CheckOptions, $.settings = &settings));
+              "}\n", dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:2:8] -> [test.cpp:3:12]: (warning) Expression 'x-1' can have a negative value. That is converted to an unsigned value and used in an unsigned calculation. [signConversionCond]\n", errout_str());
 
         check("unsigned int f1(signed int x, unsigned int y) {" // x is signed
               "  return x * y;\n"
               "}\n"
-              "void f2() { f1(-4,4); }");
+              "void f2() { f1(-4,4); }\n");
         ASSERT_EQUALS(
             "[test.cpp:1:57]: (warning) Expression 'x' can have a negative value. That is converted to an unsigned value and used in an unsigned calculation. [signConversion]\n",
             errout_str());
@@ -350,7 +350,7 @@ class TestType : public TestFixture {
         check("unsigned int f1(int x) {"
               "  return x * 5U;\n"
               "}\n"
-              "void f2() { f1(-4); }");
+              "void f2() { f1(-4); }\n");
         ASSERT_EQUALS(
             "[test.cpp:1:34]: (warning) Expression 'x' can have a negative value. That is converted to an unsigned value and used in an unsigned calculation. [signConversion]\n",
             errout_str());
@@ -358,19 +358,19 @@ class TestType : public TestFixture {
         check("unsigned int f1(int x) {" // #6168: FP for inner calculation
               "  return 5U * (1234 - x);\n" // <- signed subtraction, x is not sign converted
               "}\n"
-              "void f2() { f1(-4); }");
+              "void f2() { f1(-4); }\n");
         ASSERT_EQUALS("", errout_str());
 
         // Don't warn for + and -
         check("void f1(int x) {"
               "  a = x + 5U;\n"
               "}\n"
-              "void f2() { f1(-4); }");
+              "void f2() { f1(-4); }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("size_t foo(size_t x) {\n"
               " return -2 * x;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (warning) Expression '-2' has a negative value. That is converted to an unsigned value and used in an unsigned calculation. [signConversion]\n", errout_str());
 
         checkP("void f() {\n" // #12110 FP signConversion with integer overflow
@@ -503,42 +503,42 @@ class TestType : public TestFixture {
     }
 
     void checkFloatToIntegerOverflow() {
-        check("x = (int)1E100;");
+        check("x = (int)1E100;\n");
         ASSERT_EQUALS("[test.cpp:1:5]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         check("void f(void) {\n"
               "  return (int)1E100;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         check("void f(void) {\n"
               "  return (int)-1E100;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         check("void f(void) {\n"
               "  return (short)1E6;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         check("void f(void) {\n"
               "  return (unsigned char)256.0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         check("void f(void) {\n"
               "  return (unsigned char)255.5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", removeFloat(errout_str()));
 
         check("void f(void) {\n"
               "  char c = 1234.5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         check("char f(void) {\n"
               "  return 1234.5;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:2:3]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         checkP("#define TEST(b, f) b ? 5000 : (unsigned short)f\n" // #11685
@@ -608,14 +608,14 @@ class TestType : public TestFixture {
                "int f()\n"
                "{\n"
                "    fun(INT_MIN);\n"
-               "}", dinit(CheckPOptions, $.settings = &s));
+               "}\n", dinit(CheckPOptions, $.settings = &s));
         ASSERT_EQUALS("[test.cpp:3:17]: (error) Signed integer overflow for expression '-x'. [integerOverflow]\n", errout_str());
 
         checkP("void f() {\n" // #8399
                "    int32_t i = INT32_MAX;\n"
                "    i << 1;\n"
                "    i << 2;\n"
-               "}", dinit(CheckPOptions, $.settings = &s));
+               "}\n", dinit(CheckPOptions, $.settings = &s));
         ASSERT_EQUALS("[test.cpp:4:7]: (error) Signed integer overflow for expression 'i<<2'. [integerOverflow]\n", errout_str());
     }
 
diff --git a/test/testuninitvar.cpp b/test/testuninitvar.cpp
index 6a43493cd0d..1874e020fa8 100644
--- a/test/testuninitvar.cpp
+++ b/test/testuninitvar.cpp
@@ -148,13 +148,13 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("void foo() {\n"
                        "    int a;\n"
                        "    b = c - a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo() {\n"
                        "    int a;\n"
                        "    b = a - c;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         // Ticket #6455 - some compilers allow const variables to be uninitialized
@@ -162,27 +162,27 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("void foo() {\n"
                        "    const int a;\n"
                        "    b = c - a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
         // extracttests.enable
 
         checkUninitVar("void foo() {\n"
                        "    int *p;\n"
                        "    realloc(p,10);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo() {\n" // #5240
                        "    char *p = malloc(100);\n"
                        "    char *tmp = realloc(p,1000);\n"
                        "    if (!tmp) free(p);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo() {\n"
                        "    int *p = NULL;\n"
                        "    realloc(p,10);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // dereferencing uninitialized pointer..
@@ -191,7 +191,7 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    Foo *p;\n"
                        "    p->abcd();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         // extracttests.start: template<class T> struct Foo { void abcd(); };
@@ -199,7 +199,7 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    Foo<int> *p;\n"
                        "    p->abcd();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         // extracttests.start: struct Foo { void* a; };
@@ -207,90 +207,90 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    int a;\n"
                        "    p->a = malloc(4 * a);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:23]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int *p;\n"
                        "    delete p;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int *p;\n"
                        "    delete [] p;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:15]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int *p;\n"
                        "    *p = 135;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int *p;\n"
                        "    p[0] = 135;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int *x;\n"
                        "    int y = *x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:14]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int *x;\n"
                        "    int &y(*x);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    int x;\n"
                        "    int *y = &x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    int *x;\n"
                        "    int *&y = x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    int x = xyz::x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    int a;\n"
                        "    a = 5 + a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    int a;\n"
                        "    a++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    extern int a;\n"
                        "    a++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // extracttests.start: void bar(int);
@@ -298,28 +298,28 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    int a;\n"
                        "    bar(4 * a);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int i;\n"
                        "    if (i);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int i;\n"
                        "    for (int x = 0; i < 10; x++);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:21]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int i;\n"
                        "    for (int x = 0; x < 10; i++);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:29]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo(int x)\n"
@@ -328,7 +328,7 @@ class TestUninitVar : public TestFixture {
                        "    if (x)\n"
                        "        i = 0;\n"
                        "    i++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
@@ -336,7 +336,7 @@ class TestUninitVar : public TestFixture {
                        "    int ar[10];\n"
                        "    int i;\n"
                        "    ar[i] = 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:8]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
@@ -344,13 +344,13 @@ class TestUninitVar : public TestFixture {
                        "    int x, y;\n"
                        "    x = (y = 10);\n"
                        "    int z = y * 2;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void foo() {\n"
                        "    int x, y;\n"
                        "    x = ((y) = 10);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #3597
@@ -358,27 +358,27 @@ class TestUninitVar : public TestFixture {
                        "    int a;\n"
                        "    int b = 1;\n"
                        "    (b += a) = 1;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f() {\n"
                        "    int a,b,c;\n"
                        "    a = b = c;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:0]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    Foo p;\n"
                        "    p.abcd();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    Foo p;\n"
                        "    int x = p.abcd();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Unknown types
@@ -388,7 +388,7 @@ class TestUninitVar : public TestFixture {
                            "{\n"
                            "    A ret;\n"
                            "    return ret;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("void a()\n"
@@ -405,7 +405,7 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("void f(float x) {\n"
                        "  union lf { long l; float f; } u_lf;\n"
                        "  float hx = (u_lf.f = (x), u_lf.l);\n"
-                       "}",
+                       "}\n",
                        dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
@@ -413,7 +413,7 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    int x[10];\n"
                        "    int *y = x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a()\n"
@@ -422,7 +422,7 @@ class TestUninitVar : public TestFixture {
                        "    int *y = &x;\n"
                        "    *y = 0;\n"
                        "    x++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a()\n"
@@ -431,7 +431,7 @@ class TestUninitVar : public TestFixture {
                        "    char *z = x;\n"
                        "    memset(z, 0, sizeof(x));\n"
                        "    memcpy(y, x, sizeof(x));\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Handling >> and <<
@@ -440,26 +440,26 @@ class TestUninitVar : public TestFixture {
                            "    int ret;\n"
                            "    std::cin >> ret;\n"
                            "    ret++;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("void f(int b) {\n"
                            "    int a;\n"
                            "    std::cin >> b >> a;\n"
                            "    return a;"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("void f() {\n"
                            "    int ret[2];\n"
                            "    std::cin >> ret[0];\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("void f(int i) {\n"
                            "    int a;\n"
                            "    i >> a;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("[test.cpp:3:10]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
             checkUninitVar("int a() {\n"
@@ -473,14 +473,14 @@ class TestUninitVar : public TestFixture {
                            "    Node node;\n"
                            "    int x;\n"
                            "    node[\"abcd\"] >> x;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("int a(FArchive &arc) {\n"   // #3060 (initialization through operator<<)
                            "    int *p;\n"
                            "    arc << p;\n" // <- TODO initialization?
                            "    return *p;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
             checkUninitVar("void a() {\n"
@@ -495,32 +495,32 @@ class TestUninitVar : public TestFixture {
                            "    int a;\n"
                            "    a << 1;\n"  // <- TODO initialization?
                            "    return a;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
             // #4673
             checkUninitVar("void f() {\n"
                            "    int a;\n"
                            "    std::cout << a;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("[test.cpp:3:18]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
             checkUninitVar("void f(std::ostringstream& os) {\n"
                            "    int a;\n"
                            "    os << a;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("[test.cpp:3:11]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
             checkUninitVar("void f() {\n"
                            "    int a;\n"
                            "    std::cout << 1 << a;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("[test.cpp:3:23]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
             checkUninitVar("void f(std::ostringstream& os) {\n"
                            "    int a;\n"
                            "    os << 1 << a;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
             {
@@ -528,25 +528,25 @@ class TestUninitVar : public TestFixture {
                 checkUninitVar("void f() {\n"
                                "  char *p = new char[10];\n"
                                "  std::cout << (void *)p << 1;\n"
-                               "}");
+                               "}\n");
                 ASSERT_EQUALS("", errout_str());
 
                 checkUninitVar("void f() {\n"
                                "  char p[10];\n"
                                "  std::cout << (void *)p << 1;\n"
-                               "}");
+                               "}\n");
                 ASSERT_EQUALS("", errout_str());
 
                 checkUninitVar("void f() {\n"
                                "  char *p = new char[10];\n"
                                "  std::cout << p << 1;\n"
-                               "}");
+                               "}\n");
                 ASSERT_EQUALS("[test.cpp:3:16]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
 
                 checkUninitVar("void f() {\n" // #9696
                                "  int *p = new int[10];\n"
                                "  std::cout << p << 1;\n"
-                               "}");
+                               "}\n");
                 ASSERT_EQUALS("", errout_str());
 
                 checkUninitVar("void f() {\n"
@@ -556,7 +556,7 @@ class TestUninitVar : public TestFixture {
                                "  std::cout << c;\n"
                                "  wchar_t w[10];\n"
                                "  std::cout << w;\n"
-                               "}");
+                               "}\n");
                 ASSERT_EQUALS("[test.cpp:5:16]: (error) Uninitialized variable: c [legacyUninitvar]\n"
                               "[test.cpp:7:16]: (error) Uninitialized variable: w [legacyUninitvar]\n",
                               errout_str());
@@ -564,13 +564,13 @@ class TestUninitVar : public TestFixture {
                 checkUninitVar("void f() {\n"
                                "  char p[10];\n"
                                "  std::cout << p << 1;\n"
-                               "}");
+                               "}\n");
                 ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
                 checkUninitVar("void f() {\n"
                                "  char p[10];\n"
                                "  std::cout << *p << 1;\n"
-                               "}");
+                               "}\n");
                 ASSERT_EQUALS("[test.cpp:3:17]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
             }
 
@@ -586,47 +586,47 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("void f() {\n"
                        "  int x;\n"
                        "  a & x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int a) {\n"
                        "  int x;\n"
                        "  a & x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "  int a,b,c;\n"
                        "  ar & a & b & c;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a() {\n"   // asm
                        "    int x;\n"
                        "    asm();\n"
                        "    x++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a()\n"
                        "{\n"
                        "    int x[10];\n"
                        "    struct xyz xyz1 = { .x = x };\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a()\n"
                        "{\n"
                        "    struct S *s;\n"
                        "    s->x = 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: s [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "   char *buf = malloc(100);\n"
                        "   struct ABC *abc = buf;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("class Fred {\n"
@@ -637,7 +637,7 @@ class TestUninitVar : public TestFixture {
                        "Fred::~Fred()\n"
                        "{\n"
                        "    fclose(f);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
@@ -645,7 +645,7 @@ class TestUninitVar : public TestFixture {
                        "    int c;\n"
                        "    ab(sizeof(xyz), &c);\n"
                        "    if (c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
@@ -653,7 +653,7 @@ class TestUninitVar : public TestFixture {
                        "    int c;\n"
                        "    a = (f2(&c));\n"
                        "    c++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int a)\n"
@@ -662,7 +662,7 @@ class TestUninitVar : public TestFixture {
                        "        char *p;\n"
                        "        *p = 0;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         // +=
@@ -670,14 +670,14 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    int c;\n"
                        "    c += 2;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    int a[10];\n"
                        "    a[0] = 10 - a[1];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (error) Uninitialized variable: a[1] [legacyUninitvar]\n", errout_str());
 
         // goto/setjmp/longjmp..
@@ -693,7 +693,7 @@ class TestUninitVar : public TestFixture {
                        "\n"
                        "found:\n"
                        "    int a = b;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo()\n"
@@ -705,7 +705,7 @@ class TestUninitVar : public TestFixture {
                        "        return a;\n"
                        "    a = 1;\n"
                        "    longjmp(env, 1);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // macro_for..
@@ -719,7 +719,7 @@ class TestUninitVar : public TestFixture {
                        "  else\n"
                        "    retval = 2;\n"
                        "  return retval;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo()\n"
@@ -728,7 +728,7 @@ class TestUninitVar : public TestFixture {
                        "    goto exit;\n"
                        "    i++;\n"
                        "exit:\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo() {\n"
@@ -738,7 +738,7 @@ class TestUninitVar : public TestFixture {
                        "    x = a;\n"
                        "    y = 1;\n"
                        "    goto again;\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #3873 (false positive)
@@ -747,7 +747,7 @@ class TestUninitVar : public TestFixture {
                        "  if (!Range)\n"
                        "    Range = new MachineLoopRange(Loop, Allocator, *Indexes);\n"
                        "  return Range;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4040 - False positive
@@ -763,7 +763,7 @@ class TestUninitVar : public TestFixture {
                        "        iter = x;\n"
                        "    }\n"
                        "    return 1 + iter;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // C++11 style initialization
@@ -771,7 +771,7 @@ class TestUninitVar : public TestFixture {
                        "    int i = 0;\n"
                        "    int j{ i };\n"
                        "    return j;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #5646
@@ -779,7 +779,7 @@ class TestUninitVar : public TestFixture {
                        "  float source[2] = {3.1, 3.1};\n"
                        "  float (*sink)[2] = &source;\n"
                        "  return (*sink)[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #9296
@@ -787,14 +787,14 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    int x;\n"
                        "    int z = (x) & ~__round_mask(1, 1);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:14]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f(void)\n"
                        "{\n"
                        "    int x;\n"
                        "    int z = (x) | ~__round_mask(1, 1);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:14]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int __round_mask(int, int);\n"
@@ -802,7 +802,7 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    int x;\n"
                        "    int* z = &x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -813,7 +813,7 @@ class TestUninitVar : public TestFixture {
                        "  int x;\n"
                        "  a = x;\n"
                        "  b = x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
     }
 
@@ -822,7 +822,7 @@ class TestUninitVar : public TestFixture {
         const char code[] = "void f() {\n"
                             "    dfs a;\n"
                             "    return a;\n"
-                            "}";
+                            "}\n";
 
         // Assume dfs is a non POD type if file is C++
         checkUninitVar(code);
@@ -836,7 +836,7 @@ class TestUninitVar : public TestFixture {
                              "void f() {\n"
                              "    struct AB ab;\n"
                              "    return ab;\n"
-                             "}";
+                             "}\n";
         checkUninitVar(code2);
         ASSERT_EQUALS("[test.cpp:4:12]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n"
                       "[test.cpp:4:12]: (error) Uninitialized struct member: ab.b [uninitStructMember]\n", errout_str());
@@ -847,14 +847,14 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("void f() {\n"
                        "    std::map<int,bool> x;\n"
                        "    return x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #3906 - False positive for std::vector pointer
         checkUninitVar("void f() {\n"
                        "    std::vector<int> *x = NULL;\n"
                        "    return x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         {
@@ -867,7 +867,7 @@ class TestUninitVar : public TestFixture {
             checkUninitVar("void f() {\n"
                            "  Fred _tm;\n"
                            "  _tm.dostuff();\n"
-                           "}", s);
+                           "}\n", s);
             ASSERT_EQUALS("", errout_str());
         }
 
@@ -876,7 +876,7 @@ class TestUninitVar : public TestFixture {
                        "    A a,b;\n"
                        "    b[0] = 0;"
                        "    return a;\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -893,7 +893,7 @@ class TestUninitVar : public TestFixture {
                        "        _Bit_reference(_Bit_type * __x, _Bit_type __y)\n"
                        "         : _M_p(__x), _M_mask(__y) { }\n"
                        "    };\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -903,13 +903,13 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("void foo() {\n"
                        "    int b;\n"
                        "    c = a | b;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: b [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo() {\n"
                        "    int b;\n"
                        "    c = b | a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: b [legacyUninitvar]\n", errout_str());
     }
 
@@ -922,7 +922,7 @@ class TestUninitVar : public TestFixture {
                        "    if (x)\n"
                        "        p = new Foo;\n"
                        "    p->abcd();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo(int x)\n"
@@ -931,7 +931,7 @@ class TestUninitVar : public TestFixture {
                        "    if (x==1);\n"
                        "    if (x==2);\n"
                        "    x = a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:6:9]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int foo() {\n"
@@ -939,7 +939,7 @@ class TestUninitVar : public TestFixture {
                        "    if (1)\n"
                        "        i = 11;\n"
                        "    return i;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int bar(int x) {\n"
@@ -949,7 +949,7 @@ class TestUninitVar : public TestFixture {
                        "    else if ( x == 11 )\n"
                        "      n = 2;\n"
                        "    return n;\n"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         checkUninitVar("int foo()\n"
@@ -960,7 +960,7 @@ class TestUninitVar : public TestFixture {
                        "    else\n"
                        "        i = 33;\n"
                        "    return i;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo(int x)\n" // #5503
@@ -971,7 +971,7 @@ class TestUninitVar : public TestFixture {
                        "    else if (x >= 2)\n" // condition is always true
                        "        i = 33;\n"
                        "    return i;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo()\n"
@@ -985,7 +985,7 @@ class TestUninitVar : public TestFixture {
                        "        i = 33;\n"
                        "    }\n"
                        "    return i;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo()\n"
@@ -1001,7 +1001,7 @@ class TestUninitVar : public TestFixture {
                        "        i = 33;\n"
                        "    }\n"
                        "    return i;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void foo(int x)\n"
@@ -1011,7 +1011,7 @@ class TestUninitVar : public TestFixture {
                        "        p = new Foo;\n"
                        "    if (x)\n"
                        "        p->abcd();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo(int a)\n"
@@ -1029,7 +1029,7 @@ class TestUninitVar : public TestFixture {
                        "    if( n == 0) {\n"
                        "        a=condition;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
@@ -1037,20 +1037,20 @@ class TestUninitVar : public TestFixture {
                        "    C *c;\n"
                        "    if (fun(&c));\n"
                        "    c->Release();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    C c;\n"
                        "    if (fun(&c.d));\n"
                        "    return c;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "   char a[10];\n"
                        "   if (a[0] = x){}\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo(int x)\n"
@@ -1061,7 +1061,7 @@ class TestUninitVar : public TestFixture {
                        "    else\n"
                        "        return 3;\n"
                        "    return i;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #2207 - False positive
@@ -1072,7 +1072,7 @@ class TestUninitVar : public TestFixture {
                        "    if (!x)\n"
                        "        return;\n"
                        "    b = (c - a);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo()\n"
@@ -1083,7 +1083,7 @@ class TestUninitVar : public TestFixture {
                        "    else\n"
                        "        throw 3;\n"
                        "    return ret;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int a)\n"
@@ -1094,7 +1094,7 @@ class TestUninitVar : public TestFixture {
                        "    else\n"
                        "        XYZ ret = 2;\n"  // XYZ may be an unexpanded macro so bailout the checking of "ret".
                        "    return ret;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:8:12]: (error) Uninitialized variable: ret [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f(int a, int b)\n"
@@ -1107,7 +1107,7 @@ class TestUninitVar : public TestFixture {
                        "      x = b;\n"
                        "   }\n"
                        "   return x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo(long verbose,bool bFlag)\n"
@@ -1120,7 +1120,7 @@ class TestUninitVar : public TestFixture {
                        "    if (verbose)\n"
                        "      std::cout << (12-t);\n"
                        "  }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int test(int cond1, int cond2) {\n"
@@ -1132,7 +1132,7 @@ class TestUninitVar : public TestFixture {
                        "  if (cond2) {\n"
                        "    int t = foo*foo;\n"
                        "  }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo(int *pix) {\n"
@@ -1143,14 +1143,14 @@ class TestUninitVar : public TestFixture {
                        "    }\n"
                        "    if (pix)\n"
                        "        a = dest_x;\n" // <- not uninitialized
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ? :
         checkUninitVar("static void foo(int v) {\n"
                        "    int x;\n"
                        "    x = v <= 0 ? -1 : x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:23]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo()\n"
@@ -1162,19 +1162,19 @@ class TestUninitVar : public TestFixture {
                        "    }\n"
                        "    ret = ret <= 0 ? -1 :\n"
                        "          strcmp(msgid1, msgid2) == 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo(int a, int b)\n"
                        "{\n"
                        "    int x; x = (a<b) ? 1 : 0;\n"
                        "    int y = y;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: y [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo() {\n" // pidgin-2.11.0/finch/libgnt/gnttree.c
                        "  int x = (x = bar()) ? x : 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ; { .. }
@@ -1187,7 +1187,7 @@ class TestUninitVar : public TestFixture {
                        "  else\n"
                        "    retval = 2;\n"
                        "  return retval;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
@@ -1198,7 +1198,7 @@ class TestUninitVar : public TestFixture {
                        "  }\n"
                        "\n"
                        "  { }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ({ .. })
@@ -1207,7 +1207,7 @@ class TestUninitVar : public TestFixture {
                        "    if (abc) { x = 123; }\n"
                        "    else { a = ({b=c;}); x = 456; }\n"
                        "    ++x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #3098 - False negative uninitialized variable
@@ -1217,7 +1217,7 @@ class TestUninitVar : public TestFixture {
                        "    if(strcoll(c1,c2))\n"
                        "    {\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (error) Uninitialized variable: c1 [legacyUninitvar]\n"
                       "[test.cpp:4:19]: (error) Uninitialized variable: c2 [legacyUninitvar]\n", errout_str());
 
@@ -1226,26 +1226,26 @@ class TestUninitVar : public TestFixture {
                        "    if(strcoll(c1,c2))\n"
                        "    {\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    char *c1;\n"
                        "    c1=strcpy(c1,\"test\");\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:15]: (error) Uninitialized variable: c1 [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f(char *c1)\n"
                        "{\n"
                        "    c1=strcpy(c1,\"test\");\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "  X var;\n"
                        "  memset(var, 0, sizeof(var));\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f() {\n" // #8692
@@ -1306,8 +1306,8 @@ class TestUninitVar : public TestFixture {
                        "    for (int i = 0; i < 4; ++i) {\n"
                        "        int a;\n"
                        "        b(4*a);\n"
-                       "    }"
-                       "}");
+                       "    }\n"
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -1315,7 +1315,7 @@ class TestUninitVar : public TestFixture {
                        "    for (int i = 0; i < 4; ++i) {\n"
                        "        k = k + 2;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: k [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -1323,7 +1323,7 @@ class TestUninitVar : public TestFixture {
                        "    for (int i = 0; i < 4; ++i) {\n"
                        "        int sz = sizeof(sel);\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("enum ABCD { A, B, C, D };\n"
@@ -1333,7 +1333,7 @@ class TestUninitVar : public TestFixture {
                        "    for (i = 0; i < D; i++) {\n"
                        "        str[i] = 0;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void x() {\n"
@@ -1343,7 +1343,7 @@ class TestUninitVar : public TestFixture {
                        "        {\n"
                        "        }\n"
                        "    } while (tok2);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo(void) {\n"
@@ -1356,7 +1356,7 @@ class TestUninitVar : public TestFixture {
                        "            x = 2;\n"
                        "        }\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo(void) {\n"
@@ -1368,7 +1368,7 @@ class TestUninitVar : public TestFixture {
                        "            a = 1;\n"
                        "        }\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:6:24]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo(int n) {\n"
@@ -1378,7 +1378,7 @@ class TestUninitVar : public TestFixture {
                        "      f = one[i];\n"
                        "    one[rank] = -1;\n"
                        "  }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #2226: C++0x loop
@@ -1386,7 +1386,7 @@ class TestUninitVar : public TestFixture {
                        "    container c;\n"
                        "    for (iterator it : c) {\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #2345: False positive in sub-condition in if inside a loop
@@ -1397,7 +1397,7 @@ class TestUninitVar : public TestFixture {
                        "        { }\n"
                        "        x--;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
         // extracttests.start: struct PoolItem { bool operator!=(const PoolItem&) const; };
         checkUninitVar("void f(int x, const PoolItem& rPool) {\n"
@@ -1407,7 +1407,7 @@ class TestUninitVar : public TestFixture {
                        "        { }\n"
                        "        x--;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:14]: (error) Uninitialized variable: pItem [legacyUninitvar]\n", errout_str());
 
         // #2231 - conditional initialization in loop..
@@ -1422,7 +1422,7 @@ class TestUninitVar : public TestFixture {
                        "    }\n"
                        "\n"
                        "    return x;\n"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:11]: (error) Uninitialized variable: x\n", "", errout_str());
 
         // Ticket #2796
@@ -1433,7 +1433,7 @@ class TestUninitVar : public TestFixture {
                        "        else break;\n"
                        "        return x;\n"   // <- x is initialized
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Assignment in for. Ticket #3287
@@ -1442,7 +1442,7 @@ class TestUninitVar : public TestFixture {
                        "    if (b) for (c = in; *c == 0; ++c) {}\n"
                        "    else c = in + strlen(in) - 1;\n"
                        "    *c = 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #10273 - assignment in conditional code
@@ -1453,7 +1453,7 @@ class TestUninitVar : public TestFixture {
                        "        if (!(learn & PORT_LEARN_DISABLE))\n"
                        "            learn = 123;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:15]: (error) Uninitialized variable: learn [legacyUninitvar]\n", errout_str());
 
         // extracttests.start: struct Entry { Entry *next; }; Entry *buckets[10];
@@ -1504,7 +1504,7 @@ class TestUninitVar : public TestFixture {
                        "        *p = 7;\n" // <<
                        "        p = new int(9);\n"
                        "    } while (*p != 8);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:11:10]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         // #6952 - while-loop
@@ -1515,7 +1515,7 @@ class TestUninitVar : public TestFixture {
                        "        *p = 7;\n"
                        "        p = new int(9);\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         // switch in loop
@@ -1531,7 +1531,7 @@ class TestUninitVar : public TestFixture {
                        "    };\n"
                        "    ++p\n"
                        "  }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1545,7 +1545,7 @@ class TestUninitVar : public TestFixture {
                        "        c++;\n"
                        "        break;\n"
                        "    };\n"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6:5]: (error) Uninitialized variable: c [uninitvar]\n", "", errout_str());
 
         checkUninitVar("char * f()\n"
@@ -1558,7 +1558,7 @@ class TestUninitVar : public TestFixture {
                        "        case 2: return ret;\n"
                        "    }\n"
                        "    return 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo(const int iVar, unsigned int slot, unsigned int pin)\n"
@@ -1581,7 +1581,7 @@ class TestUninitVar : public TestFixture {
                        "        }\n"
                        "    }\n"
                        "    return i;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #1855 - switch(foo(&x))
@@ -1593,7 +1593,7 @@ class TestUninitVar : public TestFixture {
                        "        case 1:\n"
                        "            return x;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3231 - ({ switch .. })
@@ -1607,7 +1607,7 @@ class TestUninitVar : public TestFixture {
                        "        break;\n"
                        "    };\n"
                        "    })\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1617,7 +1617,7 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    char a[10];\n"
                        "    a[a[0]] = 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:8]: (error) Uninitialized variable: a[0] [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f()\n"
@@ -1625,59 +1625,59 @@ class TestUninitVar : public TestFixture {
                        "    char a[10];\n"
                        "    *a = '\\0';\n"
                        "    int i = strlen(a);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    char a, b[10];\n"
                        "    a = b[0] = 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    char a[10], b[10];\n"
                        "    a[0] = b[0] = 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    char a[10], *p;\n"
                        "    *(p = a) = 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char a[10], *p;\n"
                        "    p = &(a[10]);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // array usage in ?: (tests that the isVariableUsed() works)
         checkUninitVar("void f() {\n"
                        "    char a[10], *p;\n"
                        "    p = c?a:0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "    char a[10], c;\n"
                        "    c = *(x?a:0);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char a[10], c;\n"
                        "    strcpy(dest, x?a:\"\");\n"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "  int a[2];\n"
                        "  y *= (x ? 1 : 2);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // passing array to library functions
@@ -1685,25 +1685,25 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    char c[50] = \"\";\n"
                        "    strcat(c, \"test\");\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(char *s2) {\n"
                        "    char s[20];\n"
                        "    strcpy(s2, s);\n"
-                       "};");
+                       "};\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: s [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char s[20];\n"
                        "    strcat(s, \"abc\");\n"
-                       "};");
+                       "};\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: s [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char s[20];\n"
                        "    strchr(s, ' ');\n"
-                       "};");
+                       "};\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: s [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo()\n"
@@ -1712,7 +1712,7 @@ class TestUninitVar : public TestFixture {
                        "        int s;\n"
                        "        GetField( y + 0, y + 1 );\n"
                        "        s = y[0] * y[1];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
@@ -1720,14 +1720,14 @@ class TestUninitVar : public TestFixture {
                        "        int a[2];\n"
                        "        init(a - 1);\n"
                        "        int b = a[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "        Fred a[2];\n"
                        "        Fred b = a[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo() {\n"
@@ -1748,40 +1748,40 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    int a[10];\n"
                        "    f(a[0]);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:7]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         // Ticket #2320
         checkUninitVar("void foo() {\n"
                        "        char a[2];\n"
                        "        unsigned long b = (unsigned long)(a+2) & ~7;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"   // Ticket #3050
                        "    char a[2];\n"
                        "    printf(\"%s\", a);\n"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", "", errout_str());
 
         checkUninitVar("void f() {\n"   // Ticket #5108 (fp)
                        "    const char *a;\n"
                        "    printf(\"%s\", a=\"abc\");\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"    // Ticket #3497
                        "    char header[1];\n"
                        "    *((unsigned char*)(header)) = 0xff;\n"
                        "    return header[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"    // Ticket #3497
                        "    char header[1];\n"
                        "    *((unsigned char*)((unsigned char *)(header))) = 0xff;\n"
                        "    return header[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -1791,7 +1791,7 @@ class TestUninitVar : public TestFixture {
                        "    abc.a = a;\n"
                        "    init(&abc);\n"
                        "    return a[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #3344
@@ -1800,7 +1800,7 @@ class TestUninitVar : public TestFixture {
                        "   char *buffer=(char*)malloc(128*sizeof(char));\n"
                        "   strcpy(strMsg,buffer);\n"
                        "   free(buffer);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (error) Memory is allocated but not initialized: buffer [uninitdata]\n", errout_str());
 
         checkUninitVar("void f(){\n"
@@ -1808,45 +1808,45 @@ class TestUninitVar : public TestFixture {
                        "   char *buffer=static_cast<char*>(malloc(128*sizeof(char)));\n"
                        "   strcpy(strMsg,buffer);\n"
                        "   free(buffer);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (error) Memory is allocated but not initialized: buffer [uninitdata]\n", errout_str());
 
         // #3845
         checkUninitVar("int foo() {\n"
                        "    int a[1] = {5};\n"
                        "    return a[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo() {\n"
                        "    int a[2][2] = {{3,4}, {5,6}};\n"
                        "    return a[0][1];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo() {\n"
                        "    int a[1];\n"
                        "    return a[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int foo() {\n"
                        "    int a[2][2];\n"
                        "    return a[0][1];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int foo() {\n"
                        "    int a[10];\n"
                        "    dostuff(a[0]);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // # 4740
         checkUninitVar("void f() {\n"
                        "    int *a[2][19];\n"
                        "    int **b = a[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6869 - FP when passing uninit array to function
@@ -1854,7 +1854,7 @@ class TestUninitVar : public TestFixture {
                        "void foo() {\n"
                        "  char x[10];\n"
                        "  bar(x);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // struct
@@ -1863,7 +1863,7 @@ class TestUninitVar : public TestFixture {
                        "void f() {\n"
                        "  struct Fred fred[10];\n"
                        "  fred[1].x = 0;\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("char f() {\n"
@@ -1906,7 +1906,7 @@ class TestUninitVar : public TestFixture {
                        "        vertices[i][1][2] = 4.0;\n"
                        "        vertices[i][1][3] = 5.0;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: vertices [legacyUninitvar]\n",
                       errout_str());
 
@@ -1922,7 +1922,7 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("double foo(bool flag) {\n"
                        "    double adIHPoint_local[4][4]{};\n"
                        "    function(*adIHPoint_local);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1931,96 +1931,96 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("void f() {\n"
                        "    char *s = (char *)malloc(100);\n"
                        "    strcat(s, \"abc\");\n"
-                       "};");
+                       "};\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Memory is allocated but not initialized: s [uninitdata]\n", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    char *s1 = new char[10];\n"
                        "    char *s2 = new char[strlen(s1)];\n"
-                       "};");
+                       "};\n");
         ASSERT_EQUALS("[test.cpp:4:32]: (error) Memory is allocated but not initialized: s1 [uninitdata]\n", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    char *p = (char*)malloc(64);\n"
                        "    int x = p[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char *p = (char*)malloc(64);\n"
                        "    if (p[0]) { }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (error) Memory is allocated but not initialized: p[0] [uninitdata]\n", errout_str());
 
         checkUninitVar("char f() {\n"
                        "    char *p = (char*)malloc(64);\n"
                        "    return p[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    Fred *fred = new Fred;\n"
                        "    fred->foo();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct Fred { int i; Fred(int, float); };\n"
                        "void f() {\n"
                        "    Fred *fred = new Fred(1, 2);\n"
                        "    fred->foo();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    Fred *fred = malloc(sizeof(Fred));\n"
                        "    x(&fred->f);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    Fred *fred = malloc(sizeof(Fred));\n"
                        "    x(fred->f);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo(char *s)\n"
                        "{\n"
                        "    char *a = malloc(100);\n"
                        "    *a = *s;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    char *a;\n"
                        "    if (a);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    char *a = malloc(100);\n"
                        "    if (a);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    ABC *abc = malloc(100);\n"
                        "    abc->a = 123;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    ABC *abc = malloc(100);\n"
                        "    abc->a.word = 123;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
@@ -2028,14 +2028,14 @@ class TestUninitVar : public TestFixture {
                        "    ABC *abc = malloc(100);\n"
                        "    abc->a = 123;\n"
                        "    abc->a += 123;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    ABC *abc = malloc(100);\n"
                        "    free(abc);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
@@ -2044,14 +2044,14 @@ class TestUninitVar : public TestFixture {
                        "    if (!s)\n"
                        "        return;\n"
                        "    char c = *s;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:6:15]: (error) Memory is allocated but not initialized: s [uninitdata]\n", errout_str());
 
         // #3708 - false positive when using ptr typedef
         checkUninitVar("void f() {\n"
                        "    uintptr_t x = malloc(100);\n"
                        "    uintptr_t y = x + 10;\n"  // <- not bad usage
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -2060,7 +2060,7 @@ class TestUninitVar : public TestFixture {
                        "  strm.next_out = buf;\n"
                        "  deflate(&strm, Z_FINISH);\n"
                        "  memcpy(body, buf, 10);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6451 - allocation in subscope
@@ -2076,7 +2076,7 @@ class TestUninitVar : public TestFixture {
                        "    else\n"
                        "        pNewStrm = new StgStrm(rIo);\n"
                        "    pNewStrm->Write();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6450 - calling a member function is allowed if memory was allocated by new
@@ -2087,7 +2087,7 @@ class TestUninitVar : public TestFixture {
                        "void processObjectRecord() {\n"
                        "    EMFPFont *font = new EMFPFont();\n"
                        "    font->Initialize();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7623 - new can also initialize the memory, don't warn in this case
@@ -2096,14 +2096,14 @@ class TestUninitVar : public TestFixture {
                        "    int* p2 = new int();\n"
                        "    int* arr = new int[5]();\n"
                        "    std::cout << *p1 << *p2 << arr[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // new in C code does not allocate..
         checkUninitVar("int main() {\n"
                        "    char * pBuf = new(10);\n"
                        "    a = *pBuf;\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("class A {};\n" // #10698
@@ -2210,7 +2210,7 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    int i;\n"
                        "    int a() { return i; }\n"
-                       "};");
+                       "};\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
@@ -2221,16 +2221,16 @@ class TestUninitVar : public TestFixture {
                        "            surface->MoveTo();\n"
                        "        }\n"
                        "    };\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    static const struct ab {\n"
                        "        int a,b;\n"
-                       "        int get_a() { return a; }"
+                       "        int get_a() { return a; }\n"
                        "    } x = { 0, 0 };\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
@@ -2243,13 +2243,13 @@ class TestUninitVar : public TestFixture {
                        "        i = 0;\n"
                        "    }\n"
                        "    return i;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "    struct AB ab;\n"
                        "    x = ab.x = 12;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2260,7 +2260,7 @@ class TestUninitVar : public TestFixture {
                        "    enum AB { a, b };\n"
                        "    AB ab;\n"
                        "    if (ab);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:9]: (error) Uninitialized variable: ab [legacyUninitvar]\n", errout_str());
     }
 
@@ -2272,7 +2272,7 @@ class TestUninitVar : public TestFixture {
                        "    int &b = a;\n"
                        "    b = 0;\n"
                        "    int x = a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(struct blame_entry *ent)\n"
@@ -2280,14 +2280,14 @@ class TestUninitVar : public TestFixture {
                        "    struct origin *suspect = ent->suspect;\n"
                        "    char hex[41];\n"
                        "    strcpy(hex, sha1_to_hex(suspect->commit->object.sha1));\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    const std::string s(x());\n"
                        "    strchr(s.c_str(), ',');\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6717
@@ -2296,7 +2296,7 @@ class TestUninitVar : public TestFixture {
                        "    thing it;\n"
                        "    int& referenced_int = it.value;\n"
                        "    referenced_int = 123;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2305,19 +2305,19 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("static int foo() {\n"
                        "    int ret;\n"
                        "    return ret;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: ret [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static int foo() {\n"
                        "    int ret;\n"
                        "    return ret+5;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: ret [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static int foo() {\n"
                        "    int ret;\n"
                        "    return ret = 5;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         {
@@ -2325,7 +2325,7 @@ class TestUninitVar : public TestFixture {
                            "    int ret;\n"
                            "    cin >> ret;\n"
                            "    return ret;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("static int foo() {\n"
@@ -2337,10 +2337,10 @@ class TestUninitVar : public TestFixture {
 
         // Ticket #6341- False negative
         {
-            checkUninitVar("wchar_t f() { int i; return btowc(i); }");
+            checkUninitVar("wchar_t f() { int i; return btowc(i); }\n");
             ASSERT_EQUALS("[test.cpp:1:35]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
-            checkUninitVar("wchar_t f(int i) { return btowc(i); }");
+            checkUninitVar("wchar_t f(int i) { return btowc(i); }\n");
             ASSERT_EQUALS("", errout_str());
 
             // Avoid a potential false positive (#6341)
@@ -2352,7 +2352,7 @@ class TestUninitVar : public TestFixture {
                 "int f() {\n"
                 "  int x;\n"
                 "  return setvalue(x);\n"
-                "}");
+                "}\n");
             ASSERT_EQUALS("", errout_str());
         }
 
@@ -2365,7 +2365,7 @@ class TestUninitVar : public TestFixture {
                            "        f = 0.0;\n"
                            "    }\n"
                            "    printf (\"%f\",f);\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("[test.cpp:7:18]: (error) Uninitialized variable: f [legacyUninitvar]\n", errout_str());
 
             // Check for potential FP
@@ -2376,7 +2376,7 @@ class TestUninitVar : public TestFixture {
                            "        f = 0.0;\n"
                            "    }\n"
                            "    printf (\"%f\",f);\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("", errout_str());
         }
 
@@ -2384,7 +2384,7 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("int f(int x) {\n"
                        "    int y;\n"
                        "    return x ? 1 : y;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (error) Uninitialized variable: y [legacyUninitvar]\n", errout_str());
 
         // Ticket #3106 - False positive
@@ -2392,13 +2392,13 @@ class TestUninitVar : public TestFixture {
             checkUninitVar("int f() {\n"
                            "    int i;\n"
                            "    return x(&i) ? i : 0;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("int f() {\n"
                            "    int i;\n"
                            "    return x() ? i : 0;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
         }
     }
@@ -2411,7 +2411,7 @@ class TestUninitVar : public TestFixture {
                        "    struct A msg = { .buf = {&key} };\n"
                        "    init(&msg);\n"
                        "    key++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #5660 - False positive
@@ -2420,7 +2420,7 @@ class TestUninitVar : public TestFixture {
                        "    int *res[] = {&result};\n"
                        "    foo(res);\n"
                        "    return result;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6873
@@ -2429,7 +2429,7 @@ class TestUninitVar : public TestFixture {
                        "    char *b[] = {a};\n"
                        "    foo(b);\n"
                        "    return atoi(a);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // = { .. }
@@ -2438,7 +2438,7 @@ class TestUninitVar : public TestFixture {
                        "    int *p[] = { &a };\n"
                        "    *p[0] = 0;\n"
                        "    return a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
     }
@@ -2453,7 +2453,7 @@ class TestUninitVar : public TestFixture {
                        "    char a[100];\n"
                        "    strncpy(a, s, 20);\n"
                        "    strncat(a, s, 20);\n"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Dangerous usage of 'a' (strncpy doesn't always null-terminate it).\n", "", errout_str());
 
         checkUninitVar("void f()\n"
@@ -2461,7 +2461,7 @@ class TestUninitVar : public TestFixture {
                        "    char a[100];\n"
                        "    strncpy(a, \"hello\", 3);\n"
                        "    strncat(a, \"world\", 20);\n"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Dangerous usage of 'a' (strncpy doesn't always null-terminate it).\n", "", errout_str());
 
         checkUninitVar("void f()\n"
@@ -2469,7 +2469,7 @@ class TestUninitVar : public TestFixture {
                        "    char a[100];\n"
                        "    strncpy(a, \"hello\", sizeof(a));\n"
                        "    strncat(a, \"world\", 20);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #3245 - false positive
@@ -2478,14 +2478,14 @@ class TestUninitVar : public TestFixture {
                            "    char a[100];\n"
                            "    strncpy(a,p,10);\n"
                            "    memcmp(a,q,10);\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("void f() {\n"
                            "    char a[100];\n"
                            "    strncpy(a,p,10);\n"
                            "    if (memcmp(a,q,10)==0);\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("", errout_str());
         }
 
@@ -2494,7 +2494,7 @@ class TestUninitVar : public TestFixture {
                        "    char buf[10];\n"
                        "    strncpy(buf, dev, 10);\n"
                        "    strncpy(str, buf, 10);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -2502,40 +2502,40 @@ class TestUninitVar : public TestFixture {
                        "  const char* source = \"You\";\n"
                        "  strncpy(dst, source, sizeof(dst));\n"
                        "  char value = dst[2];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     // valid and invalid use of 'int a(int x) { return x + x; }'
     void func_uninit_var() {
-        const std::string funca("int a(int x) { return x + x; }");
+        const std::string funca("int a(int x) { return x + x; }\n");
 
         checkUninitVar(funca +
                        "void b() {\n"
                        "    int x;\n"
                        "    a(x);\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:3:7]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar(funca +
                        "void b() {\n"
                        "    int *p;\n"
                        "    a(*p);\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:3:8]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:4:8]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
     }
 
 
     // valid and invalid use of 'void a(int *p) { *p = 0; }'
     void func_uninit_pointer() {
-        const std::string funca("void a(int *p) { *p = 0; }");
+        const std::string funca("void a(int *p) { *p = 0; }\n");
 
         // ok - initialized pointer
         checkUninitVar(funca +
                        "void b() {\n"
                        "    int buf[10];\n"
                        "    a(buf);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // not ok - uninitialized pointer
@@ -2543,32 +2543,32 @@ class TestUninitVar : public TestFixture {
                        "void b() {\n"
                        "    int *p;\n"
                        "    a(p);\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:3:7]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
     }
 
     void uninitvar_typeof() {
         checkUninitVar("void f() {\n"
                        "    struct Fred *fred;\n"
                        "    typeof(fred->x);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    struct SData * s;\n"
                        "    ab(typeof(s->status));\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    struct SData * s;\n"
                        "    TYPEOF(s->status);\n"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("", "[test.cpp:3:12]: (error) Uninitialized variable: s [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int *n = ({ typeof(*n) z;  (typeof(*n)*)z; })\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2576,25 +2576,25 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("void foo() {\n"
                        "  int i;\n"
                        "  dostuff((int&)i, 0);\n" // <- cast is not use
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo() {\n"
                        "  int i;\n"
                        "  return (int&)i + 2;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo() {\n"
                        "  int i;\n"
                        "  dostuff(*&i, 0);\n" // <- *& is not use
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo() {\n"
                        "  int i;\n"
                        "  return *&i;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
     }
 
@@ -2603,121 +2603,121 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    x++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         // extracttests.start: char str[10];
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    str[x] = 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n" // #7736
                        "    int buf[12];\n"
                        "    printf (\"%d\", buf[0] );\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (error) Uninitialized variable: buf [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    int y = x & 3;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    int y = 3 & x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    x = 3 + x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    x = x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         // extracttests.start: struct ABC {int a;};
         checkUninitVar("void f() {\n"
                        "    struct ABC *abc;\n"
                        "    abc->a = 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: abc [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f() {\n"
                        "    static int x;\n"
                        "    return ++x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f() {\n"
                        "    extern int x;\n"
                        "    return ++x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"  // #3926 - weird cast.
                        "    int x;\n"
                        "    *(((char *)&x) + 0) = 0;\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n" // #4737 - weird cast.
                        "    int x;\n"
                        "    do_something(&((char*)&x)[0], 1);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    char *p = (char*)&x + 1;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int i;\n"
                        "    i=f(), i!=2;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // using uninit var in condition
         checkUninitVar("void f(void) {\n"
                        "    int x;\n"
                        "    if (x) { }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    if (1 == (3 & x)) { }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         // ?:
         checkUninitVar("int f(int *ptr) {\n"
                        "    int a;\n"
                        "    int *p = ptr ? ptr : &a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int a) {\n"
                        "    int x;\n"
                        "    if (a==3) { x=2; }\n"
                        "    y = (a==3) ? x : a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // = ({ .. })
         checkUninitVar("void f() {\n"
                        "    int x = ({ 1 + 2; });\n"
                        "    int y = 1 + (x ? y : y);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:22]: (error) Uninitialized variable: y [legacyUninitvar]\n", errout_str());
 
         // >> => initialization / usage
@@ -2725,7 +2725,7 @@ class TestUninitVar : public TestFixture {
             const char code[] = "void f() {\n"
                                 "    int x;\n"
                                 "    if (i >> x) { }\n"
-                                "}";
+                                "}\n";
             checkUninitVar(code);
             ASSERT_EQUALS("", errout_str());
 
@@ -2736,7 +2736,7 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("void f() {\n"
                        "    int i, i2;\n"
                        "    strm >> i >> i2;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // unconditional initialization
@@ -2745,7 +2745,7 @@ class TestUninitVar : public TestFixture {
                        "    if (a) { ret = 1; }\n"
                        "    else { {} ret = 2; }\n"
                        "    return ret;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f() {\n"
@@ -2753,7 +2753,7 @@ class TestUninitVar : public TestFixture {
                        "    if (a) { ret = 1; }\n"
                        "    else { s=foo(1,{2,3},4); ret = 2; }\n"
                        "    return ret;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // conditional initialization
@@ -2762,7 +2762,7 @@ class TestUninitVar : public TestFixture {
                        "    if (y == 1) { x = 1; }\n"
                        "    else { if (y == 2) { x = 1; } }\n"
                        "    return x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -2771,7 +2771,7 @@ class TestUninitVar : public TestFixture {
                        "    else { if (y == 2) { x = 1; } }\n"
                        "    if (y == 3) { }\n"   // <- ignore condition
                        "    return x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:6:12]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         // initialization in condition
@@ -2779,7 +2779,7 @@ class TestUninitVar : public TestFixture {
                        "    int a;\n"
                        "    if (init(&a)) { }\n"
                        "    a++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // return, break, continue, goto
@@ -2788,14 +2788,14 @@ class TestUninitVar : public TestFixture {
                        "    if (y == 1) { return; }\n"
                        "    else { x = 1; }\n"
                        "    return x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    if (y == 1) { return; }\n"
                        "    return x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f(int x) {\n"
@@ -2808,7 +2808,7 @@ class TestUninitVar : public TestFixture {
                        "out1:\n"
                        "out2:\n"
                        "    return ret;\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -2819,7 +2819,7 @@ class TestUninitVar : public TestFixture {
                        "        goto out;\n"
                        "    }\n"
                        "    i++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f() {\n"
@@ -2827,7 +2827,7 @@ class TestUninitVar : public TestFixture {
                        "    for (i=0;i<9;++i)\n"
                        "        if (foo) break;\n"
                        "    return x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f() {\n"
@@ -2835,7 +2835,7 @@ class TestUninitVar : public TestFixture {
                        "    while (foo)\n"
                        "        if (bar) break;\n"
                        "    return x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         // try/catch : don't warn about exception variable
@@ -2845,7 +2845,7 @@ class TestUninitVar : public TestFixture {
                        "        trace();\n"
                        "        e->Delete();\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n" // #5347
@@ -2853,7 +2853,7 @@ class TestUninitVar : public TestFixture {
                        "    } catch (const char* e) {\n"
                        "        A a = e;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // exit
@@ -2862,7 +2862,7 @@ class TestUninitVar : public TestFixture {
                        "    if (y == 1) { exit(0); }\n"
                        "    else { x = 1; }\n"
                        "    return x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // strange code.. don't crash (#3415)
@@ -2870,14 +2870,14 @@ class TestUninitVar : public TestFixture {
                        "    int i;\n"
                        "    ({ if (0); });\n"
                        "    for_each(i) { }\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
 
         // if, if
         checkUninitVar("void f(int a) {\n"
                        "    int i;\n"
                        "    if (a) i = 0;\n"
                        "    if (a) i++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -2889,7 +2889,7 @@ class TestUninitVar : public TestFixture {
                        "        }\n"
                        "    }\n"
                        "    if (b) a++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -2897,41 +2897,41 @@ class TestUninitVar : public TestFixture {
                        "    if (x) { }\n"
                        "    else { if (y==2) { a=1; b=2; } }\n"
                        "    if (a) { ++b; }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void f(int x, int y) {\n"
                        "    int a;\n"
                        "    if (x == 0) { a = y; }\n"
                        "    if (x == 0 && (a == 1)) { }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void f() {\n"
                        "    int a=0, b;\n"
                        "    if (something) { a = dostuff(&b); }\n"
                        "    if (!a || b) { }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void f(int x, int y) {\n"
                        "    int a;\n"
                        "    if (x == 0 && (a == 1)) { }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:20]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int a;\n"
                        "    if (x) { a = 0; }\n"
                        "    if (x) { if (y) { a++; } }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int a;\n"
                        "    if (x) { a = 0; }\n"
                        "    if (x) { if (y) { } else { a++; } }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
@@ -2940,7 +2940,7 @@ class TestUninitVar : public TestFixture {
                        "    if (x) ab = getAB();\n"
                        "    else ab.a = 0;\n"
                        "    if (ab.a == 1) b = ab.b;\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(void) {\n"
@@ -2951,7 +2951,7 @@ class TestUninitVar : public TestFixture {
                        "    if (i==1) { a = 0; }\n"
                        "    else { a = 1; }\n"
                        "    return a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int a) {\n" // #4560
@@ -2961,7 +2961,7 @@ class TestUninitVar : public TestFixture {
                        "    if (x) y = 123;\n" // <- y is always initialized
                        "    else {}\n"
                        "    return y;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int a) {\n" // #6583
@@ -2970,7 +2970,7 @@ class TestUninitVar : public TestFixture {
                        "    else if (a == 2) x = 0;\n"
                        "    else exit(2);\n"
                        "    return x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int a) {\n" // #4560
@@ -2980,7 +2980,7 @@ class TestUninitVar : public TestFixture {
                        "    if (x) {}\n"
                        "    else y = 123;\n" // <- y is always initialized
                        "    return y;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n" // #3948
@@ -2988,7 +2988,7 @@ class TestUninitVar : public TestFixture {
                        "  if (x !=-1)\n"
                        "    value = getvalue();\n"
                        "  if (x == -1 || value > 300) {}\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("enum t_err { ERR_NONE, ERR_BAD_ARGS };\n" // #9649
@@ -3001,7 +3001,7 @@ class TestUninitVar : public TestFixture {
                        "        ret = init_box(&box2, 20);\n"
                        "    if (ret == ERR_NONE)\n"
                        "        z = x + box2.value;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
@@ -3010,7 +3010,7 @@ class TestUninitVar : public TestFixture {
                        "    value = getvalue();\n"
                        "  if (x == 1)\n"
                        "    v = value;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:6:9]: (error) Uninitialized variable: value [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f(int x) {\n"
@@ -3019,7 +3019,7 @@ class TestUninitVar : public TestFixture {
                        "    value = getvalue();\n"
                        "  if (x == 32) {}\n"
                        "  else v = value;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:6:12]: (error) Uninitialized variable: value [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static int x;" // #4773
@@ -3029,7 +3029,7 @@ class TestUninitVar : public TestFixture {
                        "    if (x) y = 123;\n"
                        "    else y = 456;\n"
                        "    return y;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static int x;" // #4773
@@ -3039,7 +3039,7 @@ class TestUninitVar : public TestFixture {
                        "    if (x) y = 123;\n"
                        "    else y = 456;\n"
                        "    return y;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int a) {\n"
@@ -3049,7 +3049,7 @@ class TestUninitVar : public TestFixture {
                        "    if (!a) {}\n"
                        "    else if (x) {}\n"
                        "  }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // asm
@@ -3057,74 +3057,74 @@ class TestUninitVar : public TestFixture {
                        "    int x;\n"
                        "    asm();\n"
                        "    x++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // sizeof / typeof / offsetof / etc
         checkUninitVar("void f() {\n"
                        "    int i;\n"
                        "    sizeof(i+1);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int i;\n"
                        "    if (100 == sizeof(i+1));\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    struct ABC *abc;\n"
                        "    int i = ARRAY_SIZE(abc.a);"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("", "[test.cpp:3:24]: (error) Uninitialized variable: abc [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int *abc;\n"
                        "    typeof(*abc);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    struct ABC *abc;\n"
                        "    return do_something(typeof(*abc));\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    A *a;\n"
                        "    a = malloc(sizeof(*a));\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // &
         checkUninitVar("void f() {\n"  // #4426 - address of uninitialized variable
                        "    int a,b;\n"
                        "    if (&a == &b);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"  // #4439 - cast address of uninitialized variable
                        "    int a;\n"
                        "    x((LPARAM)(RECT*)&a);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int main() {\n"
                        "    int done;\n"
                        "    dostuff(1, (AuPointer) &done);\n" // <- It is not conclusive if the "&" is a binary or unary operator. Bailout.
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n" // #4778 - cast address of uninitialized variable
                        "    long a;\n"
                        "    &a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n" // #4717 - ({})
                        "    int a = ({ long b = (long)(123); 2 + b; });\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3135,7 +3135,7 @@ class TestUninitVar : public TestFixture {
                        "    int &x = buf[0];\n"
                        "    buf[0] = 0;\n"
                        "    x++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3145,14 +3145,14 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("void f() {\n"
                        "    x<char> c;\n"
                        "    c << 2345;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ensure there is no false negative
         checkUninitVar("void f() {\n"
                        "    char c;\n"
                        "    char a = c << 2;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
     }
 
@@ -3182,7 +3182,7 @@ class TestUninitVar : public TestFixture {
                             "    dsmp_t type;\n"
                             "    int syncpos, len;\n"
                             "    Sync(syncpos, type, len);\n"
-                            "}";
+                            "}\n";
         checkUninitVar(code);
         ASSERT_EQUALS("", errout_str());
     }
@@ -3191,7 +3191,7 @@ class TestUninitVar : public TestFixture {
         const char code[] = "namespace Ns { class C; }\n"
                             "void f1() { char *p; *p = 0; }\n"
                             "class Ns::C* p;\n"
-                            "void f2() { char *p; *p = 0; }";
+                            "void f2() { char *p; *p = 0; }\n";
         checkUninitVar(code);
         ASSERT_EQUALS("[test.cpp:2:23]: (error) Uninitialized variable: p [legacyUninitvar]\n"
                       "[test.cpp:4:23]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
@@ -3211,7 +3211,7 @@ class TestUninitVar : public TestFixture {
                             "int global() {\n"
                             "    int bar = 1;\n"
                             "    return bar;\n"
-                            "}";
+                            "}\n";
         checkUninitVar(code);
         ASSERT_EQUALS("", errout_str());
     }
@@ -3221,7 +3221,7 @@ class TestUninitVar : public TestFixture {
                             "void foo () {\n"
                             "    int x;\n"
                             "    x = get(x) && x;\n"
-                            "}";
+                            "}\n";
         checkUninitVar(code);
         ASSERT_EQUALS("", errout_str());
     }
@@ -3230,7 +3230,7 @@ class TestUninitVar : public TestFixture {
         const char code[] = "void fp() {\n"
                             "  std::stringstream ss;\n"
                             "  for (int i; ss >> i;) {}\n"
-                            "}";
+                            "}\n";
         checkUninitVar(code);
         ASSERT_EQUALS("", errout_str());
     }
@@ -3252,7 +3252,7 @@ class TestUninitVar : public TestFixture {
                             "    free(ccb);\n"
                             " \n"
                             "  return rez;\n"
-                            "}";
+                            "}\n";
         checkUninitVar(code);
         ASSERT_EQUALS("", errout_str());
     }
@@ -3261,7 +3261,7 @@ class TestUninitVar : public TestFixture {
         const char code[] = "void f() {\n"
                             "    int b;\n"
                             "    *(&b) = 0;\n"
-                            "}";
+                            "}\n";
         checkUninitVar(code);
         ASSERT_EQUALS("", errout_str());
     }
@@ -3273,7 +3273,7 @@ class TestUninitVar : public TestFixture {
                        "    {\n"
                        "        return i;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f() {\n"
@@ -3281,7 +3281,7 @@ class TestUninitVar : public TestFixture {
                        "    try {\n"
                        "        return i;\n"
                        "    } catch(...) {}\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f(bool x) {\n"
@@ -3321,20 +3321,20 @@ class TestUninitVar : public TestFixture {
                        "    Reference< XStorageBasedLibraryContainer >(*Factory)(const Reference< XComponentContext >&, const Reference< XStorageBasedDocument >&)\n"
                        "        = &DocumentDialogLibraryContainer::create;\n"
                        "    rxContainer.set((*Factory)(m_aContext, xDocument));\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo() {\n"
                        "    void* x;\n"
                        "    int (*f)(int, int) = x;\n"
                        "    dostuff((*f)(a,b));\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:26]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void getLibraryContainer() {\n"
                        "    Reference< XStorageBasedLibraryContainer >(*Factory)(const Reference< XComponentContext >&, const Reference< XStorageBasedDocument >&);\n"
                        "    rxContainer.set((*Factory)(m_aContext, xDocument));\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:23]: (error) Uninitialized variable: Factory [legacyUninitvar]\n", errout_str());
 
         // extracttests.enable
@@ -3354,14 +3354,14 @@ class TestUninitVar : public TestFixture {
                        "  Sink s2;\n"
                        "  int n;\n"
                        "  foo >> s2.v >> n;\n" // Initialized by operator>>
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:6:16]: (error) Uninitialized struct member: s.v [uninitStructMember]\n", errout_str());
 
         checkUninitVar("struct Fred { int a; };\n"
                        "void foo() {\n"
                        "  Fred fred;\n"
                        "  std::cin >> fred.a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3374,7 +3374,7 @@ class TestUninitVar : public TestFixture {
                        "   int *b = 0;\n"
                        "   bar(a,b);\n" // <<
                        "   return 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:8]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         // non-pointer variable
@@ -3382,35 +3382,35 @@ class TestUninitVar : public TestFixture {
                        "void b() {\n"
                        "    char c;\n"
                        "    a(c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void a(char c);\n"  // value => error
                        "void b() {\n"
                        "    char c;\n"
                        "    a(c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void a(const char c);\n"  // const value => error
                        "void b() {\n"
                        "    char c;\n"
                        "    a(c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void a(char *c);\n"  // address => no error
                        "void b() {\n"
                        "    char c;\n"
                        "    a(&c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a(pstr s);\n"  // address => no error
                        "void b() {\n"
                        "    char c;\n"
                        "    a(&c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a(const char *c);\n"  // const address => data is not changed
@@ -3418,7 +3418,7 @@ class TestUninitVar : public TestFixture {
                        "    char c;\n"
                        "    a(&c);\n"  // <- no warning
                        "    c++;\n"  // <- uninitialized variable
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: c\n", "", errout_str());
 
         // pointer variable
@@ -3426,7 +3426,7 @@ class TestUninitVar : public TestFixture {
                        "void b() {\n"
                        "    char *c;\n"
                        "    a(*c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:8]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
 
@@ -3434,7 +3434,7 @@ class TestUninitVar : public TestFixture {
                        "void b() {\n"
                        "    char *c;\n"
                        "    a(c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("typedef struct { int a; int b; } AB;\n"
@@ -3442,42 +3442,42 @@ class TestUninitVar : public TestFixture {
                        "void b() {\n"
                        "    AB *ab;\n"
                        "    a(ab);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:7]: (error) Uninitialized variable: ab [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void a(const char *c);\n"  // const address => error
                        "void b() {\n"
                        "    char *c;\n"
                        "    a(c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void a(const char c[]);\n"  // const address => error
                        "void b() {\n"
                        "    char *c;\n"
                        "    a(c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void a(char **c);\n"  // address of pointer => no error
                        "void b() {\n"
                        "    char *c;\n"
                        "    a(&c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a(char *c);\n"  // address of pointer (suspicious cast to pointer) => no error
                        "void b() {\n"
                        "    char *c;\n"
                        "    a(&c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a(const char **c);\n"  // const address of pointer => no error
                        "void b() {\n"
                        "    const char *c;\n"
                        "    a(&c);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // array
@@ -3485,14 +3485,14 @@ class TestUninitVar : public TestFixture {
                        "void f() {\n"
                        "    int x[10];\n"
                        "    calc(x,10);\n"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4:14]: (error) Uninitialized variable: x [legacyUninitvar]\n",
                            "", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x[10];\n"
                        "    int &x0(*x);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ....
@@ -3502,25 +3502,25 @@ class TestUninitVar : public TestFixture {
                        "    struct ABC abc;\n"
                        "    clear(abc);\n"
                        "    return abc.a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void write_packet() {\n"
                        "    time_t now0;\n"
                        "    time(&now0);\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void write_packet() {\n"
                        "    time_t* now0;\n"
                        "    time(now0);\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:3:10]: (error) Uninitialized variable: now0 [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void write_packet() {\n"
                        "    char now0;\n"
                        "    strcmp(&now0, sth);\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:3:13]: (error) Uninitialized variable: now0 [legacyUninitvar]\n", errout_str());
 
         // #2775 - uninitialized struct pointer in subfunction
@@ -3532,7 +3532,7 @@ class TestUninitVar : public TestFixture {
                        "void b() {\n"
                        "    struct Fred *p;\n"
                        "    a(p);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:7:7]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         // #2946 - FP array is initialized in subfunction
@@ -3543,14 +3543,14 @@ class TestUninitVar : public TestFixture {
                        "    char buf[10];\n"
                        "    a(buf);\n"
                        "    buf[1] = buf[0];\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // unknown macro
         checkUninitVar("void f() {\n"
                        "  struct listnode *item;\n"
                        "  list_for_each(item, &key_list) {}\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3562,7 +3562,7 @@ class TestUninitVar : public TestFixture {
                        "        if (y != 0) return;\n"
                        "        i++;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -3572,7 +3572,7 @@ class TestUninitVar : public TestFixture {
                        "        if (y != 0) return;\n"
                        "        i++;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -3581,14 +3581,14 @@ class TestUninitVar : public TestFixture {
                        "    else y = get_value(i);\n"
                        "    if (y != 0) return;\n" // <- condition is always true if i is uninitialized
                        "    i++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "    int i;\n"
                        "    if (x) i = 0;\n"
                        "    if (!x || i>0) {}\n" // <- no error
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
@@ -3596,7 +3596,7 @@ class TestUninitVar : public TestFixture {
                        "    if (!x) { }\n"
                        "    else i = 0;\n"
                        "    if (x || i>0) {}\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:14]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f(int x) {\n"
@@ -3604,7 +3604,7 @@ class TestUninitVar : public TestFixture {
                        "    if (x) { }\n"
                        "    else i = 0;\n"
                        "    if (x || i>0) {}\n" // <- no error
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int x) {\n"
@@ -3612,7 +3612,7 @@ class TestUninitVar : public TestFixture {
                        "    if (x) y = do_something();\n"
                        "    if (!x) return 0;\n"
                        "    return y;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // extracttests.start: int y;
@@ -3621,7 +3621,7 @@ class TestUninitVar : public TestFixture {
                        "    if (x)\n"
                        "        a = y;\n"
                        "    return x ? 2*a : 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int x) {\n"
@@ -3629,13 +3629,13 @@ class TestUninitVar : public TestFixture {
                        "    if (x)\n"
                        "        a = y;\n"
                        "    return y ? 2*a : 3*a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:14]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         ASSERT_THROW_INTERNAL(checkUninitVar("void f() {\n" // Don't crash
                                              "    int a;\n"
                                              "    dostuff(\"ab\" cd \"ef\", x?a:z);\n" // <- No AST is created for ?
-                                             "}"), UNKNOWN_MACRO);
+                                             "}\n"), UNKNOWN_MACRO);
 
         // Unknown => bail out..
         checkUninitVar("void f(int x) {\n"
@@ -3643,7 +3643,7 @@ class TestUninitVar : public TestFixture {
                        "    if (a(x)) i = 0;\n"
                        "    if (b(x)) return;\n"
                        "    i++;\n" // <- no error if b(x) is always true when a(x) is false
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
@@ -3652,7 +3652,7 @@ class TestUninitVar : public TestFixture {
                        "    while (condition) {\n"
                        "        if (x) i++;\n" // <- no error
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
@@ -3661,7 +3661,7 @@ class TestUninitVar : public TestFixture {
                        "    while (condition) {\n"
                        "        i++;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
@@ -3683,7 +3683,7 @@ class TestUninitVar : public TestFixture {
                             "    if (!({ int *p = &x; *p = 1; 1; }))\n"
                             "        return 0;\n"
                             "    return x;\n"
-                            "}";
+                            "}\n";
         valueFlowUninit(code, false);
         ASSERT_EQUALS("", errout_str());
     }
@@ -3697,7 +3697,7 @@ class TestUninitVar : public TestFixture {
                         "        if (y != 0) return;\n"
                         "        i++;\n"
                         "    }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
@@ -3707,7 +3707,7 @@ class TestUninitVar : public TestFixture {
                         "        if (y != 0) return;\n"
                         "        i++;\n"
                         "    }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
@@ -3716,21 +3716,21 @@ class TestUninitVar : public TestFixture {
                         "    else y = get_value(i);\n"
                         "    if (y != 0) return;\n" // <- condition is always true if i is uninitialized
                         "    i++;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f(int x) {\n"
                         "    int i;\n"
                         "    if (!x) i = 0;\n"
                         "    if (!x || i>0) {}\n" // <- error
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:4:15]: (warning) Uninitialized variable: i [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f(int x) {\n"
                         "    int i;\n"
                         "    if (x) i = 0;\n"
                         "    if (!x || i>0) {}\n" // <- no error
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f(int x) {\n"
@@ -3738,7 +3738,7 @@ class TestUninitVar : public TestFixture {
                         "    if (!x) { }\n"
                         "    else i = 0;\n"
                         "    if (x || i>0) {}\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:5:14]: (warning) Uninitialized variable: i [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f(int x) {\n"
@@ -3746,7 +3746,7 @@ class TestUninitVar : public TestFixture {
                         "    if (x) { }\n"
                         "    else i = 0;\n"
                         "    if (x || i>0) {}\n" // <- no error
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("int f(int x) {\n"
@@ -3754,7 +3754,7 @@ class TestUninitVar : public TestFixture {
                         "    if (x) y = do_something();\n"
                         "    if (!x) return 0;\n"
                         "    return y;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // extracttests.start: int y;
@@ -3763,7 +3763,7 @@ class TestUninitVar : public TestFixture {
                         "    if (x)\n"
                         "        a = y;\n"
                         "    return x ? 2*a : 0;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("int f(int x, int y) {\n"
@@ -3771,13 +3771,13 @@ class TestUninitVar : public TestFixture {
                         "    if (x)\n"
                         "        a = y;\n"
                         "    return y ? 2*a : 3*a;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:5:18]: (warning) Uninitialized variable: a [uninitvar]\n", errout_str());
 
         ASSERT_THROW_INTERNAL(valueFlowUninit("void f() {\n" // Don't crash
                                               "    int a;\n"
                                               "    dostuff(\"ab\" cd \"ef\", x?a:z);\n" // <- No AST is created for ?
-                                              "}"), UNKNOWN_MACRO);
+                                              "}\n"), UNKNOWN_MACRO);
 
         // Unknown => bail out..
         valueFlowUninit("void f(int x) {\n"
@@ -3785,7 +3785,7 @@ class TestUninitVar : public TestFixture {
                         "    if (a(x)) i = 0;\n"
                         "    if (b(x)) return;\n"
                         "    i++;\n" // <- no error if b(x) is always true when a(x) is false
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f(int x) {\n"
@@ -3794,7 +3794,7 @@ class TestUninitVar : public TestFixture {
                         "    while (condition) {\n"
                         "        if (x) i++;\n" // <- no error
                         "    }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f(int x) {\n"
@@ -3803,13 +3803,13 @@ class TestUninitVar : public TestFixture {
                         "    while (condition) {\n"
                         "        i++;\n"
                         "    }\n"
-                        "}");
+                        "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         valueFlowUninit("void f ( void ){\n" // #9313 - FN
                         " int *p;\n"
                         " int a[ 2 ] = { [ 0 ] = *p++, [ 1 ] = 1 };\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:26]: (error) Uninitialized variable: p [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f(int height) {\n"
@@ -3831,7 +3831,7 @@ class TestUninitVar : public TestFixture {
                         "        break;\n"
                         "    }\n"
                         "    ++c;\n"
-                        "}", false);
+                        "}\n", false);
         ASSERT_EQUALS("", errout_str());
 
         // #12030
@@ -3901,122 +3901,122 @@ class TestUninitVar : public TestFixture {
         valueFlowUninit("void f() {\n"
                         "    int x;\n"
                         "    x++;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         // extracttests.start: char str[10];
         valueFlowUninit("void f() {\n"
                         "    int x;\n"
                         "    str[x] = 0;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f() {\n" // #7736
                         "    int buf[12];\n"
                         "    printf (\"%d\", buf[0] );\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (error) Uninitialized variable: buf [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    int x;\n"
                         "    int y = x & 3;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    int x;\n"
                         "    int y = 3 & x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    int x;\n"
                         "    x = 3 + x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    int x;\n"
                         "    x = x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         // extracttests.start: struct ABC {int a;};
         valueFlowUninit("void f() {\n"
                         "    struct ABC *abc;\n"
                         "    abc->a = 0;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: abc [uninitvar]\n", errout_str());
 
         valueFlowUninit("int f() {\n"
                         "    static int x;\n"
                         "    return ++x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("int f() {\n"
                         "    extern int x;\n"
                         "    return ++x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n" // #3926 - weird cast.
                         "    int x;\n"
                         "    *(((char *)&x) + 0) = 0;\n"
-                        "}",
+                        "}\n",
                         false);
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n" // #4737 - weird cast.
                         "    int x;\n"
                         "    do_something(&((char*)&x)[0], 1);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    int x;\n"
                         "    char *p = (char*)&x + 1;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    int i;\n"
                         "    i=f(), i!=2;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // using uninit var in condition
         valueFlowUninit("void f(void) {\n"
                         "    int x;\n"
                         "    if (x) { }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    int x;\n"
                         "    if (1 == (3 & x)) { }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         // ?:
         valueFlowUninit("int f(int *ptr) {\n"
                         "    int a;\n"
                         "    int *p = ptr ? ptr : &a;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("int f(int a) {\n"
                         "    int x;\n"
                         "    if (a==3) { x=2; }\n"
                         "    y = (a==3) ? x : a;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // = ({ .. })
         valueFlowUninit("void f() {\n"
                         "    int x = ({ 1 + 2; });\n"
                         "    int y = 1 + (x ? y : y);\n"
-                        "}");
+                        "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3:14]: (error) Uninitialized variable: y [legacyUninitvar]\n", "", errout_str());
 
         // >> => initialization / usage
@@ -4024,7 +4024,7 @@ class TestUninitVar : public TestFixture {
             const char code[] = "void f() {\n"
                                 "    int x;\n"
                                 "    if (i >> x) { }\n"
-                                "}";
+                                "}\n";
             valueFlowUninit(code, true);
             ASSERT_EQUALS("", errout_str());
 
@@ -4035,7 +4035,7 @@ class TestUninitVar : public TestFixture {
         valueFlowUninit("void f() {\n"
                         "    int i, i2;\n"
                         "    strm >> i >> i2;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // unconditional initialization
@@ -4044,7 +4044,7 @@ class TestUninitVar : public TestFixture {
                         "    if (a) { ret = 1; }\n"
                         "    else { {} ret = 2; }\n"
                         "    return ret;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("int f() {\n"
@@ -4052,7 +4052,7 @@ class TestUninitVar : public TestFixture {
                         "    if (a) { ret = 1; }\n"
                         "    else { s=foo(1,{2,3},4); ret = 2; }\n"
                         "    return ret;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // conditional initialization
@@ -4061,7 +4061,7 @@ class TestUninitVar : public TestFixture {
                         "    if (y == 1) { x = 1; }\n"
                         "    else { if (y == 2) { x = 1; } }\n"
                         "    return x;\n"
-                        "}");
+                        "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: x [legacyUninitvar]\n", "", errout_str());
 
         valueFlowUninit("void f() {\n"
@@ -4070,7 +4070,7 @@ class TestUninitVar : public TestFixture {
                         "    else { if (y == 2) { x = 1; } }\n"
                         "    if (y == 3) { }\n" // <- ignore condition
                         "    return x;\n"
-                        "}");
+                        "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6:24]: (error) Uninitialized variable: x [legacyUninitvar]\n", "", errout_str());
 
         // initialization in condition
@@ -4078,7 +4078,7 @@ class TestUninitVar : public TestFixture {
                         "    int a;\n"
                         "    if (init(&a)) { }\n"
                         "    a++;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // return, break, continue, goto
@@ -4087,14 +4087,14 @@ class TestUninitVar : public TestFixture {
                         "    if (y == 1) { return; }\n"
                         "    else { x = 1; }\n"
                         "    return x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    int x;\n"
                         "    if (y == 1) { return; }\n"
                         "    return x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         valueFlowUninit("int f(int x) {\n"
@@ -4107,7 +4107,7 @@ class TestUninitVar : public TestFixture {
                         "out1:\n"
                         "out2:\n"
                         "    return ret;\n"
-                        "}",
+                        "}\n",
                         false);
         ASSERT_EQUALS("", errout_str());
 
@@ -4119,7 +4119,7 @@ class TestUninitVar : public TestFixture {
                         "        goto out;\n"
                         "    }\n"
                         "    i++;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("int f() {\n"
@@ -4127,7 +4127,7 @@ class TestUninitVar : public TestFixture {
                         "    for (i=0;i<9;++i)\n"
                         "        if (foo) break;\n"
                         "    return x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         valueFlowUninit("int f() {\n"
@@ -4135,7 +4135,7 @@ class TestUninitVar : public TestFixture {
                         "    while (foo)\n"
                         "        if (bar) break;\n"
                         "    return x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         // try/catch : don't warn about exception variable
@@ -4145,7 +4145,7 @@ class TestUninitVar : public TestFixture {
                         "        trace();\n"
                         "        e->Delete();\n"
                         "    }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n" // #5347
@@ -4153,7 +4153,7 @@ class TestUninitVar : public TestFixture {
                         "    } catch (const char* e) {\n"
                         "        A a = e;\n"
                         "    }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // exit
@@ -4162,7 +4162,7 @@ class TestUninitVar : public TestFixture {
                         "    if (y == 1) { exit(0); }\n"
                         "    else { x = 1; }\n"
                         "    return x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // strange code.. don't crash (#3415)
@@ -4170,7 +4170,7 @@ class TestUninitVar : public TestFixture {
                         "    int i;\n"
                         "    ({ if (0); });\n"
                         "    for_each(i) { }\n"
-                        "}",
+                        "}\n",
                         false);
 
         // if, if
@@ -4178,7 +4178,7 @@ class TestUninitVar : public TestFixture {
                         "    int i;\n"
                         "    if (a) i = 0;\n"
                         "    if (a) i++;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
@@ -4190,7 +4190,7 @@ class TestUninitVar : public TestFixture {
                         "        }\n"
                         "    }\n"
                         "    if (b) a++;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
@@ -4198,27 +4198,27 @@ class TestUninitVar : public TestFixture {
                         "    if (x) { }\n"
                         "    else { if (y==2) { a=1; b=2; } }\n"
                         "    if (a) { ++b; }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("static void f(int x, int y) {\n"
                         "    int a;\n"
                         "    if (x == 0) { a = y; }\n"
                         "    if (x == 0 && (a == 1)) { }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("static void f() {\n"
                         "    int a=0, b;\n"
                         "    if (something) { a = dostuff(&b); }\n"
                         "    if (!a || b) { }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("static void f(int x, int y) {\n"
                         "    int a;\n"
                         "    if (x == 0 && (a == 1)) { }\n"
-                        "}",
+                        "}\n",
                         true);
         ASSERT_EQUALS("[test.cpp:3:20]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
 
@@ -4226,14 +4226,14 @@ class TestUninitVar : public TestFixture {
                         "    int a;\n"
                         "    if (x) { a = 0; }\n"
                         "    if (x) { if (y) { a++; } }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    int a;\n"
                         "    if (x) { a = 0; }\n"
                         "    if (x) { if (y) { } else { a++; } }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct AB { int a; int b; };\n"
@@ -4242,7 +4242,7 @@ class TestUninitVar : public TestFixture {
                         "    if (x) ab = getAB();\n"
                         "    else ab.a = 0;\n"
                         "    if (ab.a == 1) b = ab.b;\n"
-                        "}",
+                        "}\n",
                         false);
         ASSERT_EQUALS("", errout_str());
 
@@ -4254,7 +4254,7 @@ class TestUninitVar : public TestFixture {
                         "    if (i==1) { a = 0; }\n"
                         "    else { a = 1; }\n"
                         "    return a;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("int f(int a) {\n" // #4560
@@ -4264,7 +4264,7 @@ class TestUninitVar : public TestFixture {
                         "    if (x) y = 123;\n" // <- y is always initialized
                         "    else {}\n"
                         "    return y;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str()); // #4560: escaping else keeps x known, so x is true and y is initialized
 
         valueFlowUninit("int f(int a) {\n" // #6583
@@ -4273,7 +4273,7 @@ class TestUninitVar : public TestFixture {
                         "    else if (a == 2) x = 0;\n"
                         "    else exit(2);\n"
                         "    return x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("int f(int a) {\n" // #4560
@@ -4283,7 +4283,7 @@ class TestUninitVar : public TestFixture {
                         "    if (x) {}\n"
                         "    else y = 123;\n" // <- y is always initialized
                         "    return y;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("",
                       errout_str()); // #4560: fork-based condition analysis tracks x==0 -> else branch -> y initialized
 
@@ -4292,7 +4292,7 @@ class TestUninitVar : public TestFixture {
                         "  if (x !=-1)\n"
                         "    value = getvalue();\n"
                         "  if (x == -1 || value > 300) {}\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("enum t_err { ERR_NONE, ERR_BAD_ARGS };\n" // #9649
@@ -4305,7 +4305,7 @@ class TestUninitVar : public TestFixture {
                         "        ret = init_box(&box2, 20);\n"
                         "    if (ret == ERR_NONE)\n"
                         "        z = x + box2.value;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f(int x) {\n"
@@ -4314,7 +4314,7 @@ class TestUninitVar : public TestFixture {
                         "    value = getvalue();\n"
                         "  if (x == 1)\n"
                         "    v = value;\n"
-                        "}");
+                        "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6:9]: (error) Uninitialized variable: value [legacyUninitvar]\n", "", errout_str());
 
         valueFlowUninit("void f(int x) {\n"
@@ -4323,7 +4323,7 @@ class TestUninitVar : public TestFixture {
                         "    value = getvalue();\n"
                         "  if (x == 32) {}\n"
                         "  else v = value;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:6:12]: (warning) Uninitialized variable: value [uninitvar]\n", errout_str());
 
         valueFlowUninit("static int x;" // #4773
@@ -4333,7 +4333,7 @@ class TestUninitVar : public TestFixture {
                         "    if (x) y = 123;\n"
                         "    else y = 456;\n"
                         "    return y;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("static int x;" // #4773
@@ -4343,7 +4343,7 @@ class TestUninitVar : public TestFixture {
                         "    if (x) y = 123;\n"
                         "    else y = 456;\n"
                         "    return y;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f(int a) {\n"
@@ -4353,7 +4353,7 @@ class TestUninitVar : public TestFixture {
                         "    if (!a) {}\n"
                         "    else if (x) {}\n"
                         "  }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // asm
@@ -4361,75 +4361,75 @@ class TestUninitVar : public TestFixture {
                         "    int x;\n"
                         "    asm();\n"
                         "    x++;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // sizeof / typeof / offsetof / etc
         valueFlowUninit("void f() {\n"
                         "    int i;\n"
                         "    sizeof(i+1);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    int i;\n"
                         "    if (100 == sizeof(i+1));\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    struct ABC *abc;\n"
                         "    int i = ARRAY_SIZE(abc.a);"
-                        "}");
+                        "}\n");
         // FP ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    int *abc;\n"
                         "    typeof(*abc);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    struct ABC *abc;\n"
                         "    return do_something(typeof(*abc));\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    A *a;\n"
                         "    a = malloc(sizeof(*a));\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // &
         valueFlowUninit("void f() {\n" // #4426 - address of uninitialized variable
                         "    int a,b;\n"
                         "    if (&a == &b);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n" // #4439 - cast address of uninitialized variable
                         "    int a;\n"
                         "    x((LPARAM)(RECT*)&a);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit(
             "int main() {\n"
             "    int done;\n"
             "    dostuff(1, (AuPointer) &done);\n" // <- It is not conclusive if the "&" is a binary or unary operator. Bailout.
-            "}");
+            "}\n");
         TODO_ASSERT_EQUALS("", "[test.cpp:3:29]: (error) Uninitialized variable: done [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f() {\n" // #4778 - cast address of uninitialized variable
                         "    long a;\n"
                         "    &a;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n" // #4717 - ({})
                         "    int a = ({ long b = (long)(123); 2 + b; });\n"
-                        "}",
+                        "}\n",
                         false);
         ASSERT_EQUALS("", errout_str());
     }
@@ -4442,7 +4442,7 @@ class TestUninitVar : public TestFixture {
                         "void foo() {\n"
                         "  struct myst item;\n"
                         "  bar(&item);\n"
-                        "}", false);
+                        "}\n", false);
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct myst { int a; };\n"
@@ -4451,7 +4451,7 @@ class TestUninitVar : public TestFixture {
                         "  struct myst item;\n"
                         "  bar(&item);\n"
                         "  a = item.a;\n" // <- item.a is not initialized
-                        "}", false);
+                        "}\n", false);
         ASSERT_EQUALS("[test.c:6:12]: (error) Uninitialized variable: item.a [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct myst { int a; };\n"
@@ -4460,14 +4460,14 @@ class TestUninitVar : public TestFixture {
                         "  struct myst item;\n"
                         "  bar(&item);\n"
                         "  a = item.a;\n"
-                        "}", false);
+                        "}\n", false);
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f(int& r) {}\n" // #12536
                         "void g() {\n"
                         "    int i;\n"
                         "    f(i);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("int f(int& i, int j, int k) {\n" // #12514
@@ -4478,7 +4478,7 @@ class TestUninitVar : public TestFixture {
                         "int main() {\n"
                         "    int i;\n"
                         "    return f(i, 1, 0);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:8:14] -> [test.cpp:4:12]: (warning) Uninitialized variable: i [uninitvar]\n", errout_str());
 
         valueFlowUninit("int f(int& i, int k) {\n"
@@ -4489,7 +4489,7 @@ class TestUninitVar : public TestFixture {
                         "int main() {\n"
                         "    int i;\n"
                         "    return f(i, 0);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:8:14] -> [test.cpp:4:12]: (warning) Uninitialized variable: i [uninitvar]\n", errout_str());
     }
 
@@ -4498,21 +4498,21 @@ class TestUninitVar : public TestFixture {
                        "void f(void) {\n"
                        "    struct AB ab;\n"
                        "    int a = ab.a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
                        "void f(void) {\n"
                        "    AB ab;\n"
                        "    int a = ab.a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
                        "void f(void) {\n"
                        "    struct AB ab;\n"
                        "    ab.a = ab.a + 1;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
@@ -4538,7 +4538,7 @@ class TestUninitVar : public TestFixture {
                        "    struct AB ab;\n"
                        "    ab.a = 0;\n"
                        "    do_something(ab);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
@@ -4552,7 +4552,7 @@ class TestUninitVar : public TestFixture {
                        "void f(void) {\n"
                        "    AB ab1;\n"
                        "    AB ab2 = { ab1.a, 0 };\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:20]: (error) Uninitialized struct member: ab1.a [uninitStructMember]\n", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
@@ -4591,7 +4591,7 @@ class TestUninitVar : public TestFixture {
                        "};\n"
                        "void test() {\n"
                        "    Element *element; element->f();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("struct Element {\n"
@@ -4599,7 +4599,7 @@ class TestUninitVar : public TestFixture {
                        "};\n"
                        "void test() {\n"
                        "    Element *element; (*element).f();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("struct Element {\n"
@@ -4607,7 +4607,7 @@ class TestUninitVar : public TestFixture {
                        "};\n"
                        "void test() {\n"
                        "    Element *element; element->v;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("struct Element {\n"
@@ -4615,7 +4615,7 @@ class TestUninitVar : public TestFixture {
                        "};\n"
                        "void test() {\n"
                        "    Element *element; (*element).v;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("struct Element {\n"
@@ -4623,7 +4623,7 @@ class TestUninitVar : public TestFixture {
                        "};\n"
                        "void test() {\n"
                        "    Element *element; element->f();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("struct Element {\n"
@@ -4631,7 +4631,7 @@ class TestUninitVar : public TestFixture {
                        "};\n"
                        "void test() {\n"
                        "    Element *element; (*element).f();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("struct Element {\n"
@@ -4639,7 +4639,7 @@ class TestUninitVar : public TestFixture {
                        "};\n"
                        "void test() {\n"
                        "    Element *element; element->v;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("struct Element {\n"
@@ -4647,7 +4647,7 @@ class TestUninitVar : public TestFixture {
                        "};\n"
                        "void test() {\n"
                        "    Element *element; (*element).v;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"  // pass struct member by address
@@ -4663,7 +4663,7 @@ class TestUninitVar : public TestFixture {
                        "    Cstring res;\n"
                        "    if ( ! maybe() ) return;\n"  // <- fp goes away if this is removed
                        "    ( ((res).text = (void*)0), ((res).size = (res).alloc = 0) );\n"  // <- fp goes away if parentheses are removed
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         {
@@ -4751,7 +4751,7 @@ class TestUninitVar : public TestFixture {
                            "    struct AB ab;\n"
                            "    ab.set();\n"
                            "    x = ab;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("struct AB { int a; int get() const; };\n"
@@ -4759,7 +4759,7 @@ class TestUninitVar : public TestFixture {
                            "    struct AB ab;\n"
                            "    ab.get();\n"
                            "    x = ab;\n"
-                           "}");
+                           "}\n");
             ASSERT_EQUALS("[test.cpp:5:9]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
 
             checkUninitVar("struct AB { int a; void dostuff() {} };\n"
@@ -4767,7 +4767,7 @@ class TestUninitVar : public TestFixture {
                            "    struct AB ab;\n"
                            "    ab.dostuff();\n"
                            "    x = ab;\n"
-                           "}");
+                           "}\n");
             TODO_ASSERT_EQUALS("error", "", errout_str());
         }
 
@@ -4806,7 +4806,7 @@ class TestUninitVar : public TestFixture {
                        "    struct PIXEL p1;\n"
                        "    p1.color = 255;\n"
                        "    return p1.red;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
@@ -4817,7 +4817,7 @@ class TestUninitVar : public TestFixture {
                        "      a = ab->a;\n"
                        "    }\n"
                        "  }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
@@ -4827,7 +4827,7 @@ class TestUninitVar : public TestFixture {
                        "    ab = getab();\n"
                        "  }\n"
                        "  if (x == 0 && (ab != NULL || ab->a == 0)) { }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct A { int *x; };\n" // declarationId is 0 for "delete"
@@ -4835,7 +4835,7 @@ class TestUninitVar : public TestFixture {
                        "void bar(void) {\n"
                        "  struct A *delete = 0;\n"
                        "  foo( info, NULL );\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct ABC { int a; int b; int c; };\n"
@@ -4844,7 +4844,7 @@ class TestUninitVar : public TestFixture {
                        "  struct ABC abc;\n"
                        "  foo(123, &abc);\n"
                        "  return abc.b;\n"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized struct member: abc.a\n"
                            "[test.cpp:5]: (error) Uninitialized struct member: abc.b\n"
                            "[test.cpp:5]: (error) Uninitialized struct member: abc.c\n",
@@ -4855,13 +4855,13 @@ class TestUninitVar : public TestFixture {
                        "void foo() {\n"
                        "  struct ABC abc;\n"
                        "  dostuff((uint32_t *)&abc.a);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(void) {\n"
                        "    struct tm t;\n"
                        "    t.tm_year = 123;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // return
@@ -4925,20 +4925,20 @@ class TestUninitVar : public TestFixture {
                        "void f() {\n"
                        "    struct Fred fred;\n"
                        "    if (fred.a==1) {}\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:4:9]: (error) Uninitialized struct member: fred.a [uninitStructMember]\n", errout_str());
 
         checkUninitVar("struct S { int n; int m; };\n"
                        "void f(void) {\n"
                        " struct S s;\n"
                        " for (s.n = 0; s.n <= 10; s.n++) { }\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void test2() {\n"
                        "  struct { char type; } s_d;\n"
                        "  if (foo(&s_d.type)){}\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // for
@@ -4946,21 +4946,21 @@ class TestUninitVar : public TestFixture {
                        "void f() {\n"
                        "    struct AB ab;\n"
                        "    while (x) { clear(ab); z = ab.a; }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct AB { int a; };\n"
                        "void f() {\n"
                        "    struct AB ab;\n"
                        "    while (x) { ab.a = ab.a + 1; }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:24]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
 
         checkUninitVar("struct AB { int a; };\n"
                        "void f() {\n"
                        "    struct AB ab;\n"
                        "    while (x) { init(&ab); z = ab.a; }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // address of member
@@ -4968,7 +4968,7 @@ class TestUninitVar : public TestFixture {
                        "void f() {\n"
                        "    struct AB ab;\n"
                        "    int *p = ab.a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Reference
@@ -4978,7 +4978,7 @@ class TestUninitVar : public TestFixture {
                        "  int& x = a.x;\n"
                        "  x = 0;\n"
                        "  return a.x;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // non static data-member initialization
@@ -4987,7 +4987,7 @@ class TestUninitVar : public TestFixture {
                        "    struct AB ab;\n"
                        "    int a = ab.a;\n"
                        "    int b = ab.b;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:13]: (error) Uninitialized struct member: ab.b [uninitStructMember]\n", errout_str());
 
         // STL class member
@@ -4998,7 +4998,7 @@ class TestUninitVar : public TestFixture {
                        "void foo() {\n"
                        "    A a;\n"
                        "    x = a.m;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Unknown type (C++)
@@ -5009,7 +5009,7 @@ class TestUninitVar : public TestFixture {
                        "void foo() {\n"
                        "    A a;\n"
                        "    x = a.m;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Unknown type (C)
@@ -5020,7 +5020,7 @@ class TestUninitVar : public TestFixture {
                        "void foo() {\n"
                        "    A a;\n"
                        "    x = a.m;\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:7:9]: (error) Uninitialized struct member: a.m [uninitStructMember]\n", errout_str());
 
         // Type with constructor
@@ -5032,7 +5032,7 @@ class TestUninitVar : public TestFixture {
                        "void foo() {\n"
                        "    A a;\n"
                        "    x = a.m;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #11002
@@ -5055,7 +5055,7 @@ class TestUninitVar : public TestFixture {
                        "  if (flag) {\n"
                        "    a = ab.a;\n"
                        "  }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct S { int x; };\n"
@@ -5070,7 +5070,7 @@ class TestUninitVar : public TestFixture {
                        "    S& r{ s };\n"
                        "    r.x = 0;\n"
                        "    return s;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct S { int i; };\n" // #12142
@@ -5100,7 +5100,7 @@ class TestUninitVar : public TestFixture {
                        "    while (a) {\n"
                        "        x = x + 1;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -5108,18 +5108,18 @@ class TestUninitVar : public TestFixture {
                        "    do {\n"
                        "        x = x + 1;\n"
                        "    } while (a);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    for (int x = x; x < 10; x++) {}\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         // extracttests.start: struct Element{Element*Next();};
         checkUninitVar("void f() {\n"
                        "    for (Element *ptr3 = ptr3->Next(); ptr3; ptr3 = ptr3->Next()) {}\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:2:26]: (error) Uninitialized variable: ptr3 [legacyUninitvar]\n", errout_str());
 
         // extracttests.start: int a;
@@ -5129,7 +5129,7 @@ class TestUninitVar : public TestFixture {
                        "        init(&x);\n"
                        "        x++;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -5138,7 +5138,7 @@ class TestUninitVar : public TestFixture {
                        "        if (b) x++;\n"
                        "        else x = 0;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
@@ -5146,13 +5146,13 @@ class TestUninitVar : public TestFixture {
                        "    for (int i = 0; i < 10; i += x) {\n"
                        "        x = y;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    for (int i = 0; i < 10; i += x) { }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:34]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f() {\n"
@@ -5160,14 +5160,14 @@ class TestUninitVar : public TestFixture {
                        "    for (i=0;i<9;++i)\n"
                        "        if (foo()) return i;\n"
                        "    return 9;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int i;\n"
                        "    do {} while (!getvalue(&i));\n"
                        "    i++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(void) {\n"
@@ -5179,7 +5179,7 @@ class TestUninitVar : public TestFixture {
                        "       }\n"
                        "   }\n"
                        "   return x;\n"
-                       "}");
+                       "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         checkUninitVar("int f(void) {\n"
@@ -5190,7 +5190,7 @@ class TestUninitVar : public TestFixture {
                        "       }\n"
                        "   }\n"
                        "   return 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // extracttests.start: void do_something(int);
@@ -5200,7 +5200,7 @@ class TestUninitVar : public TestFixture {
                        "       int a = x+1;\n"
                        "       do_something(a);\n"
                        "   }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:16]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("struct AB {int a; int b;};\n"
@@ -5220,7 +5220,7 @@ class TestUninitVar : public TestFixture {
                        "        for (int i=0;i<10;i++)\n"
                        "            buffer[i] = 0;\n" // <- fp
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(){\n" // #4519 - fp: inline assembler in loop
@@ -5229,14 +5229,14 @@ class TestUninitVar : public TestFixture {
                        "        asm(\"foo\");\n"
                        "        if (x & 0xf1) { }\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void f(void) {\n"
                        "    struct ABC *abc;\n"
                        "    for (i = 0; i < 10; i++)\n"
                        "        x += sizeof(*abc);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(void) {\n" // #4879
@@ -5245,7 +5245,7 @@ class TestUninitVar : public TestFixture {
                        "        for (i = 0; i < 5; i++)\n"
                        "            a[i] = b[i];\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(void) {\n" // #5658
@@ -5254,7 +5254,7 @@ class TestUninitVar : public TestFixture {
                        "            foo = malloc(sizeof(*foo));\n"
                        "            foo->x = 0;\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(void) {\n"
@@ -5262,28 +5262,28 @@ class TestUninitVar : public TestFixture {
                        "  while (x) {\n"
                        "    for (i=0,y=i;;){}\n"
                        "  }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "  char *p = (char *)malloc(256);\n"
                        "  while(*p && *p == '_')\n"
                        "    p++;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Memory is allocated but not initialized: *p [uninitdata]\n", errout_str());
 
         // #6646 - init in for loop
         checkUninitVar("void f() {\n" // No FP
                        "  for (int i;;i++)\n"
                        "    dostuff(&i);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // extracttests.start: int a;
         checkUninitVar("void f() {\n" // No FN
                        "  for (int i;;i++)\n"
                        "    a=i;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:2:15]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("namespace N {\n" // #7377
@@ -5321,7 +5321,7 @@ class TestUninitVar : public TestFixture {
                        "    void ff(void) { char *p; ::N1::Fred::f2(p); }\n"
                        "    void fg(void) { char *p; Foo::f1(p); }\n"
                        "    void fh(void) { char *p; Foo::f2(p); }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:6:39]: (error) Uninitialized variable: p [legacyUninitvar]\n"
                       "[test.cpp:8:45]: (error) Uninitialized variable: p [legacyUninitvar]\n"
                       "[test.cpp:13:33]: (error) Uninitialized variable: p [legacyUninitvar]\n"
@@ -5336,7 +5336,7 @@ class TestUninitVar : public TestFixture {
                        "void f(void) {\n"
                        "    char *p;\n"
                        "    fred.f1(p);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:8:13]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("class Fred {\n"
@@ -5359,7 +5359,7 @@ class TestUninitVar : public TestFixture {
                        "void f(void) {\n"
                        "    char *p;\n"
                        "    fred.wilma.barney.betty.f1(p);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:20:32]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
     }
 
@@ -5367,20 +5367,20 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("int f() {\n"
                        "    int *p = (int*)malloc(40);\n"
                        "    return *p;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int *p = (int*)malloc(40);\n"
                        "    int var = *p;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
                        "int f() {\n"
                        "    struct AB *ab = (AB*)malloc(sizeof(struct AB));\n"
                        "    return ab->a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (error) Memory is allocated but not initialized: ab [uninitdata]\n"
                       "[test.cpp:4:12]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n",
                       errout_str());
@@ -5391,31 +5391,31 @@ class TestUninitVar : public TestFixture {
                        "  struct t_udf_file *newf;\n"
                        "  newf = malloc(sizeof(*newf));\n"
                        "  if (!newf) {};\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char *s = malloc(100);\n"
                        "    if (s != NULL) { }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char *p = malloc(100);\n"
                        "    p || assert_failed();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char *p = malloc(100);\n"
                        "    x = p;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int* f() {\n"
                        "    int *p = (int*)malloc(40);\n"
                        "    return p;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // function parameter (treat it as initialized until malloc is used)
@@ -5423,7 +5423,7 @@ class TestUninitVar : public TestFixture {
                        "    if (*p == 1) {}\n" // no error
                        "    p = (int*)malloc(256);\n"
                        "    return *p;\n" // error
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
@@ -5431,7 +5431,7 @@ class TestUninitVar : public TestFixture {
                        "    if (ab->a == 1) {}\n" // no error
                        "    ab = (AB*)malloc(sizeof(struct AB));\n"
                        "    return ab->a;\n" // error
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
@@ -5439,13 +5439,13 @@ class TestUninitVar : public TestFixture {
                        "void f() {\n"
                        "    struct AB *ab = (AB*)malloc(sizeof(struct AB));\n"
                        "    do_something(ab);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // analysis failed. varid 0.
         checkUninitVar("void *vlc_custom_create (vlc_object_t *parent, size_t length, const char *typename) {\n"
                        "  assert (length >= sizeof (vlc_object_t));\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5459,7 +5459,7 @@ class TestUninitVar : public TestFixture {
                        "        b = p;\n"
                        "    }\n"
                        "    return a ? b->asd : 0;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5477,19 +5477,19 @@ class TestUninitVar : public TestFixture {
                        "        expr->operate();\n"
                        "        expr->operate();\n"
                        "    }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int *item;\n"
                        "    for (item: itemList) {}\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int buf[10];\n"
                        "    for (int &i: buf) { i = 0; }\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5504,7 +5504,7 @@ class TestUninitVar : public TestFixture {
                        "  X::P_t P; "
                        "  P.p = 0; "
                        "  result.push_back(P); "
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5525,7 +5525,7 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("struct AB { int a; int b; };\n"
                        "void f() {\n"
                        "    struct AB *ab = (struct AB*)calloc(1, sizeof(*ab));\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5544,7 +5544,7 @@ class TestUninitVar : public TestFixture {
                        "  using_planner_action = true;\n"
                        "}\n"
                        "if (using_planner_action) {}\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5555,7 +5555,7 @@ class TestUninitVar : public TestFixture {
                             "  struct flex_array *group;\n"
                             "  struct cgroup_taskset tset = { };\n"
                             "  do { } while_each_thread(leader, tsk);\n"
-                            "}";
+                            "}\n";
         ASSERT_THROW_INTERNAL(checkUninitVar(code), SYNTAX);
     }
 
@@ -5565,7 +5565,7 @@ class TestUninitVar : public TestFixture {
                        "  char *dp;\n"
                        "  dp=(char *)d;\n"
                        "  init(dp);\n"
-                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
         // Unknown type
         TODO_ASSERT_EQUALS("", "[test.c:4:14]: (error) Uninitialized variable: d [legacyUninitvar]\n", errout_str());
     }
@@ -5612,7 +5612,7 @@ class TestUninitVar : public TestFixture {
                         "    status s;\n"
                         "    s.x = 42;\n"
                         "    bar(&s);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:18:9] -> [test.cpp:12:13] -> [test.cpp:8:15]: (warning) Uninitialized variable: s->flag [uninitvar]\n", errout_str());
 
         // A value narrowed by a nested condition (dimensions < 1 here) must survive the enclosing
@@ -5632,7 +5632,7 @@ class TestUninitVar : public TestFixture {
                         "    if (dimensions == 1)\n"
                         "        return;\n"
                         "    if (!mightBeLarger) {}\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS(
             "[test.cpp:5:9] -> [test.cpp:7:24] -> [test.cpp:14:10]: (warning) Uninitialized variable: mightBeLarger [uninitvar]\n",
             errout_str());
@@ -5653,20 +5653,20 @@ class TestUninitVar : public TestFixture {
                         "    if (dimensions == 0)\n"
                         "        return;\n"
                         "    if (!mightBeLarger) {}\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #2207 - False negative
         valueFlowUninit("void foo() {\n"
                         "    int a;\n"
                         "    b = c - a;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
 
         valueFlowUninit("void foo() {\n"
                         "    int a;\n"
                         "    b = a - c;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
 
         // Ticket #6455 - some compilers allow const variables to be uninitialized
@@ -5674,59 +5674,59 @@ class TestUninitVar : public TestFixture {
         valueFlowUninit("void foo() {\n"
                         "    const int a;\n"
                         "    b = c - a;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
         // extracttests.enable
 
         valueFlowUninit("void foo() {\n"
                         "    int *p;\n"
                         "    realloc(p,10);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: p [uninitvar]\n", errout_str());
 
         valueFlowUninit("void foo() {\n" // #5240
                         "    char *p = malloc(100);\n"
                         "    char *tmp = realloc(p,1000);\n"
                         "    if (!tmp) free(p);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void foo() {\n"
                         "    int *p = NULL;\n"
                         "    realloc(p,10);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "  int x;\n"
                         "  switch (x) {}\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         valueFlowUninit("int f() {\n"
                         "  int x;\n"
                         "  init(x);\n"
                         "  return x;\n" // TODO: inconclusive ?
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n" // #8172
                         "  char **x;\n"
                         "  if (2 < sizeof(*x)) {}\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void foo() {\n" // #5259 - False negative
                         "    int a;\n"
                         "    int x[] = {a,2};\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
 
         valueFlowUninit("void foo()\n"
                         "{\n"
                         "    int x;\n"
                         "    int *y = &x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void foo()\n"
@@ -5734,20 +5734,20 @@ class TestUninitVar : public TestFixture {
                         "    int *x;\n"
                         "    int *&y = x;\n"
                         "    y = nullptr;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void foo()\n"
                         "{\n"
                         "    int x = xyz::x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f()\n"
                         "{\n"
                         "    extern int a;\n"
                         "    a++;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("static void foo()\n"
@@ -5755,27 +5755,27 @@ class TestUninitVar : public TestFixture {
                         "    int x, y;\n"
                         "    x = (y = 10);\n"
                         "    int z = y * 2;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("static void foo() {\n"
                         "    int x, y;\n"
                         "    x = ((y) = 10);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("static void foo()\n"
                         "{\n"
                         "    Foo p;\n"
                         "    p.abcd();\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("static void foo()\n"
                         "{\n"
                         "    Foo p;\n"
                         "    int x = p.abcd();\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // struct
@@ -5797,7 +5797,7 @@ class TestUninitVar : public TestFixture {
                         "    if (b)\n"
                         "        p = new S(io);\n"
                         "    p->Write();\n"
-                        "}");
+                        "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:10]: (warning) Uninitialized variable: p\n",
                            "[test.cpp:8:9] -> [test.cpp:10:5]: (warning) Uninitialized variable: p.rIo [uninitvar]\n",
                            errout_str());
@@ -5808,14 +5808,14 @@ class TestUninitVar : public TestFixture {
                             "{\n"
                             "    A ret;\n"
                             "    return ret;\n"
-                            "}");
+                            "}\n");
             ASSERT_EQUALS("", errout_str());
 
             // #3916 - avoid false positive
             valueFlowUninit("void f(float x) {\n"
                             "  union lf { long l; float f; } u_lf;\n"
                             "  float hx = (u_lf.f = (x), u_lf.l);\n"
-                            "}");
+                            "}\n");
             ASSERT_EQUALS("", errout_str());
         }
 
@@ -5823,7 +5823,7 @@ class TestUninitVar : public TestFixture {
                         "{\n"
                         "    int x[10];\n"
                         "    int *y = x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void a()\n"
@@ -5832,7 +5832,7 @@ class TestUninitVar : public TestFixture {
                         "    int *y = &x;\n"
                         "    *y = 0;\n"
                         "    x++;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void a()\n"
@@ -5841,7 +5841,7 @@ class TestUninitVar : public TestFixture {
                         "    char *z = x;\n"
                         "    memset(z, 0, sizeof(x));\n"
                         "    memcpy(y, x, sizeof(x));\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Handling >> and <<
@@ -5850,28 +5850,28 @@ class TestUninitVar : public TestFixture {
                             "    int ret;\n"
                             "    std::cin >> ret;\n"
                             "    ret++;\n"
-                            "}");
+                            "}\n");
             ASSERT_EQUALS("", errout_str());
 
             valueFlowUninit("void f(int b) {\n"
                             "    int a;\n"
                             "    std::cin >> b >> a;\n"
                             "    return a;"
-                            "}");
+                            "}\n");
             ASSERT_EQUALS("", errout_str());
 
             valueFlowUninit("void foo() {\n"   // #3707
                             "    Node node;\n"
                             "    int x;\n"
                             "    node[\"abcd\"] >> x;\n"
-                            "}");
+                            "}\n");
             ASSERT_EQUALS("", errout_str());
 
             valueFlowUninit("int a(FArchive &arc) {\n"  // #3060 (initialization through operator<<)
                             "    int *p;\n"
                             "    arc << p;\n"  // <- TODO initialization?
                             "    return *p;\n"
-                            "}");
+                            "}\n");
             ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: p [uninitvar]\n", errout_str());
 
             // #4320
@@ -5879,7 +5879,7 @@ class TestUninitVar : public TestFixture {
                             "    int a;\n"
                             "    a << 1;\n"
                             "    return a;\n"
-                            "}");
+                            "}\n");
             ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
 
             // #9750
@@ -5891,7 +5891,7 @@ class TestUninitVar : public TestFixture {
                             "void test(std::istringstream& in) {\n"
                             "    S p;\n"
                             "    in >> p.one >> p.two;\n"
-                            "}");
+                            "}\n");
             ASSERT_EQUALS("", errout_str());
         }
 
@@ -5899,28 +5899,28 @@ class TestUninitVar : public TestFixture {
                         "void f() {\n"
                         "    S s;\n"
                         "    return s(1);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void a() {\n"   // asm
                         "    int x;\n"
                         "    asm();\n"
                         "    x++;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void a()\n"
                         "{\n"
                         "    int x[10];\n"
                         "    struct xyz xyz1 = { .x = x };\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void foo()\n"
                         "{\n"
                         "   char *buf = malloc(100);\n"
                         "   struct ABC *abc = buf;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("class Fred {\n"
@@ -5931,7 +5931,7 @@ class TestUninitVar : public TestFixture {
                         "Fred::~Fred()\n"
                         "{\n"
                         "    fclose(f);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f()\n"
@@ -5939,7 +5939,7 @@ class TestUninitVar : public TestFixture {
                         "    int c;\n"
                         "    ab(sizeof(xyz), &c);\n"
                         "    if (c);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f()\n"
@@ -5947,7 +5947,7 @@ class TestUninitVar : public TestFixture {
                         "    int c;\n"
                         "    a = (f2(&c));\n"
                         "    c++;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // goto/setjmp/longjmp..
@@ -5963,7 +5963,7 @@ class TestUninitVar : public TestFixture {
                         "\n"
                         "found:\n"
                         "    int a = b;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("int foo()\n"
@@ -5975,14 +5975,14 @@ class TestUninitVar : public TestFixture {
                         "        return a;\n"
                         "    a = 1;\n"
                         "    longjmp(env, 1);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // range for..
         valueFlowUninit("void f() {\n"
                         "    X *item;\n"
                         "    for (item: itemList) {}\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("X f() {\n"
@@ -6006,7 +6006,7 @@ class TestUninitVar : public TestFixture {
                         "  else\n"
                         "    retval = 2;\n"
                         "  return retval;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void foo(struct qb_list_head *list) {\n"
@@ -6018,7 +6018,7 @@ class TestUninitVar : public TestFixture {
         valueFlowUninit("void json_parse_nat_type_flags(json_t *root) {\n"
                         "    int index;\n"
                         "    json_array_foreach(root, index, value) {}\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("int foo()\n"
@@ -6027,7 +6027,7 @@ class TestUninitVar : public TestFixture {
                         "    goto exit;\n"
                         "    i++;\n"
                         "exit:\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("int foo() {\n"
@@ -6037,7 +6037,7 @@ class TestUninitVar : public TestFixture {
                         "    x = a;\n"
                         "    y = 1;\n"
                         "    goto again;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #4040 - False positive
@@ -6053,7 +6053,7 @@ class TestUninitVar : public TestFixture {
                         "        iter = x;\n"
                         "    }\n"
                         "    return 1 + iter;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // C++11 style initialization
@@ -6061,7 +6061,7 @@ class TestUninitVar : public TestFixture {
                         "    int i = 0;\n"
                         "    int j{ i };\n"
                         "    return j;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #5646
@@ -6069,7 +6069,7 @@ class TestUninitVar : public TestFixture {
                         "  float source[2] = {3.1, 3.1};\n"
                         "  float (*sink)[2] = &source;\n"
                         "  return (*sink)[0];\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Ticket #8755
@@ -6081,14 +6081,14 @@ class TestUninitVar : public TestFixture {
                         "        a = 1;\n"
                         "    if (b == 'x') {}\n"
                         "    if (a) {}\n"
-                        "}");
+                        "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:8]: (error) Uninitialized variable: a\n", "", errout_str());
 
         valueFlowUninit("void h() {\n"
                         "  int i;\n"
                         "  int* v = &i;\n"
                         "  sscanf(\"0\", \"%d\", v);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void test(int p) {\n"
@@ -6097,7 +6097,7 @@ class TestUninitVar : public TestFixture {
                         "        f = 0;\n"
                         "    if (p > 1)\n"
                         "        f += 1;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("unsigned char get();\n"
@@ -6193,14 +6193,14 @@ class TestUninitVar : public TestFixture {
                         "int main() {\n"
                         "    int me;\n"
                         "     dowork(me);\n" // <- me is uninitialized
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:7:13]: (error) Uninitialized variable: me [uninitvar]\n", errout_str());
 
         valueFlowUninit("int foo() {\n"
                         "  int x;\n"
                         "  int a = x;\n" // <- x is uninitialized
                         "  return a;\n" // <- a has been initialized
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         // #10468
@@ -6565,7 +6565,7 @@ class TestUninitVar : public TestFixture {
                         "    int a[1], b[1];\n"
                         "    while (a[0] = g()) {}\n"
                         "    if ((b[0] = g()) == 0) {}\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f(const char *x, char *y);\n" // #4527
@@ -6573,7 +6573,7 @@ class TestUninitVar : public TestFixture {
                         "    char a[1000];\n"
                         "    f(a, b);\n"
                         "    printf(\"%s\", a);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
 
         valueFlowUninit("void usage(const char *);\n" // #10330
@@ -6593,7 +6593,7 @@ class TestUninitVar : public TestFixture {
                         "    if (user)\n"
                         "        pwd = getpwnam(user);\n"
                         "    if (pwd == NULL) {}\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:15:9] -> [test.cpp:17:9]: (warning) Uninitialized variable: pwd [uninitvar]\n", errout_str());
 
         valueFlowUninit("size_t Read(unsigned char* buffer, size_t len);\n" // #11540
@@ -6799,7 +6799,7 @@ class TestUninitVar : public TestFixture {
                         "    wcsstruct *x;\n"
                         "    memcpy(wcsin, x, sizeof(wcsstruct));\n" // <- warning
                         "    x->wcsprm = NULL;\n" // <- no warning
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:7:19]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct wcsstruct {\n"
@@ -6810,7 +6810,7 @@ class TestUninitVar : public TestFixture {
                         "    wcsstruct *x;\n"
                         "    sizeof(x);\n"
                         "    x->wcsprm = NULL;\n" // <- Warn
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:8:5]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct wcsstruct {\n"
@@ -6823,7 +6823,7 @@ class TestUninitVar : public TestFixture {
                         "    wcsstruct *x;\n"
                         "    x->wcsprm = NULL;\n" // <- warn here
                         "    init_wcs(x);\n" // <- no warning
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:9:5]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
     }
 
@@ -6838,7 +6838,7 @@ class TestUninitVar : public TestFixture {
                         "void f(void) {\n"
                         "    someType_t gVar;\n"
                         "    bar(&gVar);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:9:9]: (error) Uninitialized variable: &gVar [uninitvar]\n", errout_str());
 
         valueFlowUninit("typedef struct\n"
@@ -6848,7 +6848,7 @@ class TestUninitVar : public TestFixture {
                         "void f(void) {\n"
                         "        someType_t gVar;\n"
                         "        if(gVar.flags[1] == 42){}\n"
-                        "}");
+                        "}\n");
         // TODO : find bugs for member arrays
         TODO_ASSERT_EQUALS("[test.cpp:7]: (error) Uninitialized variable: gVar.flags\n", "", errout_str());
 
@@ -6858,7 +6858,7 @@ class TestUninitVar : public TestFixture {
                         "    char control[123];\n"
                         "  } u;\n"
                         "  char *x = u.control;\n" // <- no error
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct pc_data {\n"
@@ -6869,7 +6869,7 @@ class TestUninitVar : public TestFixture {
                         "void f() {\n"
                         "    struct pc_data *pcdata;\n"
                         "    if ( *pcdata->wampiryzm.strefa == '\\0' ) { }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:8:11]: (error) Uninitialized variable: pcdata [uninitvar]\n", errout_str());
 
         // # 9293
@@ -6882,7 +6882,7 @@ class TestUninitVar : public TestFixture {
                         "    struct S s1;\n"
                         "    int * x = &s1.x;\n"
                         "    struct S s2 = {*x, 0};\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:9:20]: (error) Uninitialized variable: *x [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct S {\n"
@@ -6895,7 +6895,7 @@ class TestUninitVar : public TestFixture {
                         "    struct S s2;\n"
                         "    int * x = &s1.x;\n"
                         "    s2.x = *x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:10:12]: (error) Uninitialized variable: *x [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f(bool * x) {\n"
@@ -6904,7 +6904,7 @@ class TestUninitVar : public TestFixture {
                         "void g() {\n"
                         "    bool b;\n"
                         "    f(&b);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f(bool * x) {\n"
@@ -6914,7 +6914,7 @@ class TestUninitVar : public TestFixture {
                         "void g() {\n"
                         "    bool x;\n"
                         "    f(&x);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
@@ -6922,7 +6922,7 @@ class TestUninitVar : public TestFixture {
                         "    bool * x = &b;\n"
                         "    if (x != nullptr)\n"
                         "        x = 1;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct A { bool b; };"
@@ -6932,14 +6932,14 @@ class TestUninitVar : public TestFixture {
                         "void g() {\n"
                         "    A b;\n"
                         "    f(&b);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("std::string f() {\n"
                         "    std::ostringstream ostr;\n"
                         "    ostr << \"\";\n"
                         "    return ostr.str();\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
         // #9281
         valueFlowUninit("struct s {\n"
@@ -6954,7 +6954,7 @@ class TestUninitVar : public TestFixture {
                         "void a() {\n"
                         "    struct s s1;\n"
                         "    b(&s1);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // # 9290
@@ -6965,7 +6965,7 @@ class TestUninitVar : public TestFixture {
                         "    A * c;\n"
                         "    c->x = 42;\n"
                         "    return c->x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:6:5]: (error) Uninitialized variable: c [uninitvar]\n",
                       errout_str());
 
@@ -6976,7 +6976,7 @@ class TestUninitVar : public TestFixture {
                         "    A c;\n"
                         "    c.x = 42;\n"
                         "    return c.x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct A {\n"
@@ -6989,7 +6989,7 @@ class TestUninitVar : public TestFixture {
                         "double b() {\n"
                         "    A c;\n"
                         "    return d(&c);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // # 9302
@@ -7002,7 +7002,7 @@ class TestUninitVar : public TestFixture {
                         "    vz.typ      = 42;\n"
                         "    if (pvz->typ == 0)\n"
                         "        return;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // # 9305
@@ -7018,7 +7018,7 @@ class TestUninitVar : public TestFixture {
                         "    set( pb);\n"
                         "    if (pb->x)\n"
                         "        return;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // # 9348
@@ -7029,7 +7029,7 @@ class TestUninitVar : public TestFixture {
                         "void g() {\n"
                         "  int i;\n"
                         "  f(&i);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // # 9631
@@ -7040,7 +7040,7 @@ class TestUninitVar : public TestFixture {
                         "  size_t bytesCopied;\n"
                         "  bool copied_all = true;\n"
                         "  g(&copied_all, 5, 6, &bytesCopied);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:7:24] -> [test.cpp:2:18]: (warning) Uninitialized variable: *buflen [uninitvar]\n", errout_str());
 
         // # 9953
@@ -7069,7 +7069,7 @@ class TestUninitVar : public TestFixture {
                         "    struct AB ab;\n"
                         "    ab.a = 0;\n"
                         "    do_something(ab);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct AB { int a; int b; };\n"
@@ -7078,7 +7078,7 @@ class TestUninitVar : public TestFixture {
                         "    struct AB ab;\n"
                         "    ab.a = 0;\n"
                         "    do_something(ab);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:6:18] -> [test.cpp:2:49]: (warning) Uninitialized variable: ab.b [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct AB { int a; int b; };\n"
@@ -7093,7 +7093,7 @@ class TestUninitVar : public TestFixture {
                         "void f(void) {\n"
                         "    AB ab1;\n"
                         "    AB ab2 = { ab1.a, 0 };\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:4:20]: (error) Uninitialized variable: ab1.a [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct AB { int a; int b; };\n"
@@ -7136,7 +7136,7 @@ class TestUninitVar : public TestFixture {
                         "};\n"
                         "void test() {\n"
                         "    Element *element; element->f();\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct Element {\n"
@@ -7144,7 +7144,7 @@ class TestUninitVar : public TestFixture {
                         "};\n"
                         "void test() {\n"
                         "    Element *element; (*element).f();\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct Element {\n"
@@ -7152,7 +7152,7 @@ class TestUninitVar : public TestFixture {
                         "};\n"
                         "void test() {\n"
                         "    Element *element; element->v;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct Element {\n"
@@ -7160,7 +7160,7 @@ class TestUninitVar : public TestFixture {
                         "};\n"
                         "void test() {\n"
                         "    Element *element; (*element).v;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct Element {\n"
@@ -7168,7 +7168,7 @@ class TestUninitVar : public TestFixture {
                         "};\n"
                         "void test() {\n"
                         "    Element *element; element->f();\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct Element {\n"
@@ -7176,7 +7176,7 @@ class TestUninitVar : public TestFixture {
                         "};\n"
                         "void test() {\n"
                         "    Element *element; (*element).f();\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct Element {\n"
@@ -7184,7 +7184,7 @@ class TestUninitVar : public TestFixture {
                         "};\n"
                         "void test() {\n"
                         "    Element *element; element->v;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct Element {\n"
@@ -7192,7 +7192,7 @@ class TestUninitVar : public TestFixture {
                         "};\n"
                         "void test() {\n"
                         "    Element *element; (*element).v;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct AB { int a; int b; };\n" // pass struct member by address
@@ -7210,7 +7210,7 @@ class TestUninitVar : public TestFixture {
             "    Cstring res;\n"
             "    if ( ! maybe() ) return;\n"                                     // <- fp goes away if this is removed
             "    ( ((res).text = (void*)0), ((res).size = (res).alloc = 0) );\n" // <- fp goes away if parentheses are removed
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct AB { int a; int b; };\n"
@@ -7275,7 +7275,7 @@ class TestUninitVar : public TestFixture {
                             "    struct AB ab;\n"
                             "    ab.set();\n"
                             "    x = ab;\n"
-                            "}");
+                            "}\n");
             ASSERT_EQUALS("", errout_str());
 
             valueFlowUninit("struct AB { int a; int get() const; };\n"
@@ -7283,7 +7283,7 @@ class TestUninitVar : public TestFixture {
                             "    struct AB ab;\n"
                             "    ab.get();\n"
                             "    x = ab;\n"
-                            "}");
+                            "}\n");
             ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: ab [uninitvar]\n", errout_str());
 
             valueFlowUninit("struct AB { int a; void dostuff() {} };\n"
@@ -7291,7 +7291,7 @@ class TestUninitVar : public TestFixture {
                             "    struct AB ab;\n"
                             "    ab.dostuff();\n"
                             "    x = ab;\n"
-                            "}");
+                            "}\n");
             TODO_ASSERT_EQUALS("error", "", errout_str());
         }
 
@@ -7332,7 +7332,7 @@ class TestUninitVar : public TestFixture {
                         "    struct PIXEL p1;\n"
                         "    p1.color = 255;\n"
                         "    return p1.red;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct AB { int a; int b; };\n"
@@ -7343,7 +7343,7 @@ class TestUninitVar : public TestFixture {
                         "      a = ab->a;\n"
                         "    }\n"
                         "  }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct AB { int a; int b; };\n"
@@ -7353,7 +7353,7 @@ class TestUninitVar : public TestFixture {
                         "    ab = getab();\n"
                         "  }\n"
                         "  if (x == 0 && (ab != NULL || ab->a == 0)) { }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct A { int *x; };\n" // declarationId is 0 for "delete"
@@ -7361,7 +7361,7 @@ class TestUninitVar : public TestFixture {
                         "void bar(void) {\n"
                         "  struct A *delete = 0;\n"
                         "  foo( info, NULL );\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct ABC { int a; int b; int c; };\n"
@@ -7370,20 +7370,20 @@ class TestUninitVar : public TestFixture {
                         "  struct ABC abc;\n"
                         "  foo(123, &abc);\n"
                         "  return abc.b;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: &abc [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct ABC { int a; int b; int c; };\n"
                         "void foo() {\n"
                         "  struct ABC abc;\n"
                         "  dostuff((uint32_t *)&abc.a);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f(void) {\n"
                         "    struct tm t;\n"
                         "    t.tm_year = 123;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // return
@@ -7451,7 +7451,7 @@ class TestUninitVar : public TestFixture {
                         "void f() {\n"
                         "    struct Fred fred;\n"
                         "    if (fred.a==1) {}\n"
-                        "}",
+                        "}\n",
                         false);
         ASSERT_EQUALS("[test.c:4:14]: (error) Uninitialized variable: fred.a [uninitvar]\n", errout_str());
 
@@ -7459,14 +7459,14 @@ class TestUninitVar : public TestFixture {
                         "void f(void) {\n"
                         " struct S s;\n"
                         " for (s.n = 0; s.n <= 10; s.n++) { }\n"
-                        "}",
+                        "}\n",
                         false);
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void test2() {\n"
                         "  struct { char type; } s_d;\n"
                         "  if (foo(&s_d.type)){}\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // for
@@ -7474,21 +7474,21 @@ class TestUninitVar : public TestFixture {
                         "void f() {\n"
                         "    struct AB ab;\n"
                         "    while (x) { clear(ab); z = ab.a; }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct AB { int a; };\n"
                         "void f() {\n"
                         "    struct AB ab;\n"
                         "    while (x) { ab.a = ab.a + 1; }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:4:27]: (error) Uninitialized variable: ab.a [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct AB { int a; };\n"
                         "void f() {\n"
                         "    struct AB ab;\n"
                         "    while (x) { init(&ab); z = ab.a; }\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // address of member
@@ -7496,7 +7496,7 @@ class TestUninitVar : public TestFixture {
                         "void f() {\n"
                         "    struct AB ab;\n"
                         "    int *p = ab.a;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Reference
@@ -7506,7 +7506,7 @@ class TestUninitVar : public TestFixture {
                         "  int& x = a.x;\n"
                         "  x = 0;\n"
                         "  return a.x;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // non static data-member initialization
@@ -7515,7 +7515,7 @@ class TestUninitVar : public TestFixture {
                         "    struct AB ab;\n"
                         "    int a = ab.a;\n"
                         "    int b = ab.b;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:5:16]: (error) Uninitialized variable: ab.b [uninitvar]\n", errout_str());
 
         // STL class member
@@ -7526,7 +7526,7 @@ class TestUninitVar : public TestFixture {
                         "void foo() {\n"
                         "    A a;\n"
                         "    x = a.m;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Unknown type (C++)
@@ -7537,7 +7537,7 @@ class TestUninitVar : public TestFixture {
                         "void foo() {\n"
                         "    A a;\n"
                         "    x = a.m;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // Unknown type (C)
@@ -7548,7 +7548,7 @@ class TestUninitVar : public TestFixture {
                         "void foo() {\n"
                         "    A a;\n"
                         "    x = a.m;\n"
-                        "}",
+                        "}\n",
                         false);
         ASSERT_EQUALS("[test.c:7:11]: (error) Uninitialized variable: a.m [uninitvar]\n", errout_str());
 
@@ -7561,7 +7561,7 @@ class TestUninitVar : public TestFixture {
                         "void foo() {\n"
                         "    A a;\n"
                         "    x = a.m;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct S {\n"
@@ -7591,7 +7591,7 @@ class TestUninitVar : public TestFixture {
                         "   S s;\n"
                         "   s.t[0] = 1;\n"
                         "   f(&s);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct X {\n"
@@ -7901,7 +7901,7 @@ class TestUninitVar : public TestFixture {
                         "void f() {\n"
                         "    C *c;\n"
                         "    if (c->x() == 4) {}\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:6:9]: (error) Uninitialized variable: c [uninitvar]\n", errout_str());
 
         valueFlowUninit("struct A { \n"
@@ -7923,7 +7923,7 @@ class TestUninitVar : public TestFixture {
                         "int main() {\n"
                         "  Foo* foo;\n"
                         "  foo->bar = 3;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:7:3]: (error) Uninitialized variable: foo [uninitvar]\n", errout_str());
     }
 
@@ -7933,7 +7933,7 @@ class TestUninitVar : public TestFixture {
                        "  char *b;\n"
                        "  extern int f(struct a *);\n"
                        "  return f(&(struct a){.b = 0});\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct a { int b, c; };\n"
@@ -7941,7 +7941,7 @@ class TestUninitVar : public TestFixture {
                        "  char *c;\n"
                        "  extern int f(struct a *);\n"
                        "  return f(&(struct a){.b = 0, .c = 0});\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7960,38 +7960,38 @@ class TestUninitVar : public TestFixture {
         checkUninitVar("void f() {\n"
                        "    char a[10];\n"
                        "    char c = *a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         // extracttests.start: extern const int SIZE;
         checkUninitVar("void f() {\n"
                        "    char a[SIZE+10];\n"
                        "    char c = *a;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char a[10];\n"
                        "    *a += 10;\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "  int a[10][10];\n"
                        "  dostuff(*a);\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    void (*fp[1]) (void) = {function1};\n"
                        "    (*fp[0])();\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n" // #14708
                        "    int a[1], b[1];\n"
                        "    int* c[2]{ a, b };\n"
-                       "}");
+                       "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -8001,32 +8001,32 @@ class TestUninitVar : public TestFixture {
         valueFlowUninit("void f() {\n"
                         "    char a[10];\n"
                         "    char c = *a;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (error) Uninitialized variable: *a [uninitvar]\n", errout_str());
 
         // extracttests.start: extern const int SIZE;
         valueFlowUninit("void f() {\n"
                         "    char a[SIZE+10];\n"
                         "    char c = *a;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (error) Uninitialized variable: *a [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    char a[10];\n"
                         "    *a += 10;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: *a [uninitvar]\n", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "  int a[10][10];\n"
                         "  dostuff(*a);\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("void f() {\n"
                         "    void (*fp[1]) (void) = {function1};\n"
                         "    (*fp[0])();\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("template <typename T, int value> T Get() {return value;}\n"
@@ -8064,7 +8064,7 @@ class TestUninitVar : public TestFixture {
                         "    foo a;\n"
                         "    ((&a)->bar) =  reinterpret_cast<char*>(*p);\n"
                         "    if ((&a)->bar) ;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct foo{char *bar;};\n"
@@ -8072,7 +8072,7 @@ class TestUninitVar : public TestFixture {
                         "    foo a;\n"
                         "    ((&(a))->bar) =  reinterpret_cast<char*>(*p);\n"
                         "    if ((&a)->bar) ;\n"
-                        "}");
+                        "}\n");
         ASSERT_EQUALS("", errout_str());
 
         valueFlowUninit("struct A {\n" // #10200
@@ -8174,7 +8174,7 @@ class TestUninitVar : public TestFixture {
             "int main() {\n"
             "  int x;\n"
             "  f(&x);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:6:4] -> [test.cpp:2:10]: (error) Using argument p that points at uninitialized variable x [ctuuninitvar]\n", errout_str());
 
         ctu("void use(int *p) { a = *p + 3; }\n"
@@ -8182,7 +8182,7 @@ class TestUninitVar : public TestFixture {
             "int main() {\n"
             "  int x;\n"
             "  call(4,&x);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:5:7] -> [test.cpp:2:33] -> [test.cpp:1:25]: (error) Using argument p that points at uninitialized variable x [ctuuninitvar]\n", errout_str());
 
         ctu("void dostuff(int *x, int *y) {\n"
@@ -8194,7 +8194,7 @@ class TestUninitVar : public TestFixture {
             "void f() {\n"
             "  int x;\n"
             "  dostuff(a, &x);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         ctu("void dostuff(int *x, int *y) {\n"
@@ -8206,7 +8206,7 @@ class TestUninitVar : public TestFixture {
             "void f() {\n"
             "  int x;\n"
             "  dostuff(a, &x);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         ctu("void f(int *p) {\n"
@@ -8215,7 +8215,7 @@ class TestUninitVar : public TestFixture {
             "int main() {\n"
             "  int x;\n"
             "  f(&x);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         ctu("void f(int *v) {\n"
@@ -8224,7 +8224,7 @@ class TestUninitVar : public TestFixture {
             "int main() {\n"
             "  int x;\n"
             "  f(&x);\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         ctu("void increment(int& i) { ++i; }\n" // #6475
diff --git a/test/testunusedfunctions.cpp b/test/testunusedfunctions.cpp
index 938a1394394..e38cfc25df0 100644
--- a/test/testunusedfunctions.cpp
+++ b/test/testunusedfunctions.cpp
@@ -132,7 +132,7 @@ class TestUnusedFunctions : public TestFixture {
               "{\n"
               "    if (f1())\n"
               "    { }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:5]: (style) The function 'f1' is never used. [unusedFunction]\n", errout_str());
     }
 
@@ -140,7 +140,7 @@ class TestUnusedFunctions : public TestFixture {
         check("int f1()\n"
               "{\n"
               "    return f1();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:5]: (style) The function 'f1' is never used. [unusedFunction]\n", errout_str());
     }
 
@@ -148,7 +148,7 @@ class TestUnusedFunctions : public TestFixture {
         check("char * foo()\n"
               "{\n"
               "    return foo();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:8]: (style) The function 'foo' is never used. [unusedFunction]\n", errout_str());
     }
 
@@ -166,7 +166,7 @@ class TestUnusedFunctions : public TestFixture {
               "}\n"
               "int main() {\n"
               "  indirectHello();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -174,7 +174,7 @@ class TestUnusedFunctions : public TestFixture {
         check("void f1()\n"
               "{\n"
               "    void (*f)() = cond ? f1 : NULL;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'f1' is never used. [unusedFunction]\n", errout_str());
     }
 
@@ -187,7 +187,7 @@ class TestUnusedFunctions : public TestFixture {
               "\n"
               "void C::callback() {}\n" // <- not unused
               "\n"
-              "void C::start() { ev.set<C, &C::callback>(this); }");
+              "void C::start() { ev.set<C, &C::callback>(this); }\n");
         ASSERT_EQUALS("[test.cpp:9:9]: (style) The function 'start' is never used. [unusedFunction]\n", errout_str());
     }
 
@@ -196,7 +196,7 @@ class TestUnusedFunctions : public TestFixture {
               "{\n"
               "    if (cond) ;\n"
               "    else f1();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'f1' is never used. [unusedFunction]\n", errout_str());
     }
 
@@ -205,14 +205,14 @@ class TestUnusedFunctions : public TestFixture {
               "int main() {\n"
               "    f(&foo);\n"
               "    return 0\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void foo() { }\n"
               "int main() {\n"
               "    f(&::foo);\n"
               "    return 0\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("namespace abc {\n"
@@ -221,7 +221,7 @@ class TestUnusedFunctions : public TestFixture {
               "int main() {\n"
               "    f(&abc::foo);\n"
               "    return 0\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("namespace abc {\n"
@@ -230,7 +230,7 @@ class TestUnusedFunctions : public TestFixture {
               "int main() {\n"
               "    f = &abc::foo;\n"
               "    return 0\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("namespace abc {\n"
@@ -239,7 +239,7 @@ class TestUnusedFunctions : public TestFixture {
               "int main() {\n"
               "    f = &::abc::foo;\n"
               "    return 0\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("namespace abc {\n"  // #3875
@@ -248,7 +248,7 @@ class TestUnusedFunctions : public TestFixture {
               "int main() {\n"
               "    f(abc::foo);\n"
               "    return 0\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("template <class T> T f()\n" // #13117
@@ -270,7 +270,7 @@ class TestUnusedFunctions : public TestFixture {
               "{\n"
               "    foo<int>();\n"
               "    return 0\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -282,7 +282,7 @@ class TestUnusedFunctions : public TestFixture {
               "    f();\n"
               "}\n"
               "\n"
-              "void h() { g<int>(); h(); }");
+              "void h() { g<int>(); h(); }\n");
         ASSERT_EQUALS("[test.cpp:8:6]: (style) The function 'h' is never used. [unusedFunction]\n", errout_str());
     }
 
@@ -293,7 +293,7 @@ class TestUnusedFunctions : public TestFixture {
               "private:\n"
               "    template<typename T> void foo( T t ) const;\n"
               "};\n"
-              "template<typename T> void X::foo( T t ) const { }");
+              "template<typename T> void X::foo( T t ) const { }\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) The function 'bar' is never used. [unusedFunction]\n", errout_str());
     }
 
@@ -313,7 +313,7 @@ class TestUnusedFunctions : public TestFixture {
               "        call<int>(1, 2, 3);\n"
               "        test();\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:11:10]: (style) The function 'test' is never used. [unusedFunction]\n", errout_str());
     }
 
@@ -325,7 +325,7 @@ class TestUnusedFunctions : public TestFixture {
               "template <Filter fun>\n"
               "void g() { fun(); }\n"
               "\n"
-              "int main() { g<f>(); return 0;}");
+              "int main() { g<f>(); return 0;}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -403,45 +403,45 @@ class TestUnusedFunctions : public TestFixture {
     }
 
     void throwIsNotAFunction() {
-        check("struct A {void f() const throw () {}}; int main() {A a; a.f();}");
+        check("struct A {void f() const throw () {}}; int main() {A a; a.f();}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void unusedError() {
         check("void foo() {}\n"
-              "int main()");
+              "int main()\n");
         ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'foo' is never used. [unusedFunction]\n", errout_str());
 
         check("void foo() const {}\n"
-              "int main()");
+              "int main()\n");
         ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'foo' is never used. [unusedFunction]\n", errout_str());
 
         check("void foo() const throw() {}\n"
-              "int main()");
+              "int main()\n");
         ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'foo' is never used. [unusedFunction]\n", errout_str());
 
         check("void foo() throw() {}\n"
-              "int main()");
+              "int main()\n");
         ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'foo' is never used. [unusedFunction]\n", errout_str());
     }
 
     void unusedMain() {
-        check("int main() { }");
+        check("int main() { }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void initializationIsNotAFunction() {
         check("struct B: N::A {\n"
               "  B(): N::A() {};\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void operator1() {
-        check("struct Foo { void operator()(int a) {} };");
+        check("struct Foo { void operator()(int a) {} };\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("struct Foo { operator std::string(int a) {} };");
+        check("struct Foo { operator std::string(int a) {} };\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -459,56 +459,56 @@ class TestUnusedFunctions : public TestFixture {
     }
 
     void returnRef() {
-        check("int& foo() {return x;}");
+        check("int& foo() {return x;}\n");
         ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'foo' is never used. [unusedFunction]\n", errout_str());
     }
 
     void attribute() { // #3471 - FP __attribute__((constructor))
-        check("void __attribute__((constructor)) f() {}");
+        check("void __attribute__((constructor)) f() {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void __attribute__((constructor(1000))) f() {}");
+        check("void __attribute__((constructor(1000))) f() {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void __attribute__((destructor)) f() {}");
+        check("void __attribute__((destructor)) f() {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("void __attribute__((destructor(1000))) f() {}");
+        check("void __attribute__((destructor(1000))) f() {}\n");
         ASSERT_EQUALS("", errout_str());
 
         // alternate syntax
-        check("__attribute__((constructor)) void f() {}");
+        check("__attribute__((constructor)) void f() {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("__attribute__((constructor(1000))) void f() {}");
+        check("__attribute__((constructor(1000))) void f() {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("__attribute__((destructor)) void f() {}");
+        check("__attribute__((destructor)) void f() {}\n");
         ASSERT_EQUALS("", errout_str());
 
-        check("__attribute__((destructor(1000))) void f() {}");
+        check("__attribute__((destructor(1000))) void f() {}\n");
         ASSERT_EQUALS("", errout_str());
 
         // alternate syntax
         check("void f() __attribute__((constructor));\n"
-              "void f() { }");
+              "void f() { }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() __attribute__((constructor(1000)));\n"
-              "void f() { }");
+              "void f() { }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() __attribute__((destructor));\n"
-              "void f() { }");
+              "void f() { }\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f() __attribute__((destructor(1000)));\n"
-              "void f() { }");
+              "void f() { }\n");
         ASSERT_EQUALS("", errout_str());
 
         // Don't crash on wrong syntax
         check("int x __attribute__((constructor));\n"
-              "int y __attribute__((destructor));");
+              "int y __attribute__((destructor));\n");
 
         // #10661
         check("extern \"C\" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataSize) { return 0; }\n");
@@ -525,7 +525,7 @@ class TestUnusedFunctions : public TestFixture {
               "    A() : m_i(foo())\n"
               "    {}\n"
               "int m_i;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         // #8580
@@ -536,7 +536,7 @@ class TestUnusedFunctions : public TestFixture {
               "public:\n"
               "  A() : a(bar([] { return foo(); })) {}\n"
               "  const int a;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -550,7 +550,7 @@ class TestUnusedFunctions : public TestFixture {
               "    void (Foo::*ptr)();\n"
               "    ptr = (argc > 1 && !strcmp(argv[1], \"F2\")) ? &Foo::F2 : &Foo::F1;\n"
               "    (foo.*ptr)();\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -594,7 +594,7 @@ class TestUnusedFunctions : public TestFixture {
     void multipleFiles() {
         CheckUnusedFunctions c;
 
-        const char code[] = "static void f() { }";
+        const char code[] = "static void f() { }\n";
 
         for (int i = 1; i <= 2; ++i) {
             const std::string fname = "test" + std::to_string(i) + ".cpp";
@@ -614,17 +614,17 @@ class TestUnusedFunctions : public TestFixture {
     void lineNumber() {
         check("void foo();\n"
               "void bar() {}\n"
-              "int main() {}");
+              "int main() {}\n");
         ASSERT_EQUALS("[test.cpp:2:6]: (style) The function 'bar' is never used. [unusedFunction]\n", errout_str());
     }
 
     void ignore_declaration() {
         check("void f();\n"
-              "void f() {}");
+              "void f() {}\n");
         ASSERT_EQUALS("[test.cpp:2:6]: (style) The function 'f' is never used. [unusedFunction]\n", errout_str());
 
         check("void f(void) {}\n"
-              "void (*list[])(void) = {f};");
+              "void (*list[])(void) = {f};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -635,7 +635,7 @@ class TestUnusedFunctions : public TestFixture {
               "};\n"
               "std::ostream & operator<<(std::ostream &os, const A&) {\n"
               "    os << \"This is class A\";\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A{};\n"
@@ -672,7 +672,7 @@ class TestUnusedFunctions : public TestFixture {
               "A operator ++ (const A &){ return A(); }\n"
               "A operator -- (const A &, const int){ return A(); }\n"
               "A operator -- (const A &){ return A(); }\n"
-              "A operator , (const A &, const A &){ return A(); }");
+              "A operator , (const A &, const A &){ return A(); }\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -686,39 +686,39 @@ class TestUnusedFunctions : public TestFixture {
               "}\n"
               "void * A::operator new[](std::size_t s) {\n"
               "    return malloc(s);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void entrypointsWin() {
-        check("int WinMain() { }");
+        check("int WinMain() { }\n");
         ASSERT_EQUALS("[test.cpp:1:5]: (style) The function 'WinMain' is never used. [unusedFunction]\n", errout_str());
 
-        check("int _tmain() { }");
+        check("int _tmain() { }\n");
         ASSERT_EQUALS("[test.cpp:1:5]: (style) The function '_tmain' is never used. [unusedFunction]\n", errout_str());
 
         const Settings s = settingsBuilder(settings).library("windows.cfg").build();
 
-        check("int WinMain() { }", s);
+        check("int WinMain() { }\n", s);
         ASSERT_EQUALS("", errout_str());
 
-        check("int _tmain() { }", s);
+        check("int _tmain() { }\n", s);
         ASSERT_EQUALS("", errout_str());
     }
 
     void entrypointsWinU() {
-        check("int wWinMain() { }");
+        check("int wWinMain() { }\n");
         ASSERT_EQUALS("[test.cpp:1:5]: (style) The function 'wWinMain' is never used. [unusedFunction]\n", errout_str());
 
-        check("int _tmain() { }");
+        check("int _tmain() { }\n");
         ASSERT_EQUALS("[test.cpp:1:5]: (style) The function '_tmain' is never used. [unusedFunction]\n", errout_str());
 
         const Settings s = settingsBuilder(settings).library("windows.cfg").build();
 
-        check("int wWinMain() { }", s);
+        check("int wWinMain() { }\n", s);
         ASSERT_EQUALS("", errout_str());
 
-        check("int _tmain() { }", s);
+        check("int _tmain() { }\n", s);
         ASSERT_EQUALS("", errout_str());
     }
 
diff --git a/test/testunusedprivfunc.cpp b/test/testunusedprivfunc.cpp
index 09f8c21d102..621ee11f184 100644
--- a/test/testunusedprivfunc.cpp
+++ b/test/testunusedprivfunc.cpp
@@ -119,7 +119,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "{ }\n"
               "\n"
               "unsigned int Fred::f()\n"
-              "{ }");
+              "{ }\n");
 
         ASSERT_EQUALS("[test.cpp:4:18] -> [test.cpp:12:20]: (style) Unused private function: 'Fred::f' [unusedPrivateFunction]\n", errout_str());
 
@@ -137,7 +137,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "{ }\n"
               "\n"
               "unsigned int Fred::f()\n"
-              "{ }");
+              "{ }\n");
 
         ASSERT_EQUALS("[p.h:4:18] -> [p.cpp:4:20]: (style) Unused private function: 'Fred::f' [unusedPrivateFunction]\n", errout_str());
 
@@ -153,7 +153,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "\n"
               "void Fred::f()\n"
               "{\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[p.h:4:6] -> [p.cpp:2:12]: (style) Unused private function: 'Fred::f' [unusedPrivateFunction]\n", errout_str());
 
         // Don't warn about include files which implementation we don't see
@@ -169,7 +169,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "\n"
               "int main()\n"
               "{\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -187,7 +187,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "};\n"
               "\n"
               "A::A()\n"
-              "{ }");
+              "{ }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -202,7 +202,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "};\n"
               "\n"
               "A::~A()\n"
-              "{ B(); }");
+              "{ B(); }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -217,7 +217,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "};\n"
               "\n"
               "A::A() : _owner(false)\n"
-              "{ b(); }");
+              "{ b(); }\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -228,14 +228,14 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    A() : lock(new Lock())\n"
               "    { }\n"
               "    Lock *lock;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void test6() { // ticket #2602 segmentation fault
         check("class A {\n"
               "    A& operator=(const A&);\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -272,7 +272,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "};\n"
               "\n"
               "Fred::Fred()\n"
-              "{}");
+              "{}\n");
 
         ASSERT_EQUALS("[test.cpp:6:12] -> [test.cpp:6:12]: (style) Unused private function: 'Fred::get' [unusedPrivateFunction]\n", errout_str());
     }
@@ -291,7 +291,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    void callback(const& unsigned) const {}\n"
               "\n"
               "    Observer<UnusedPrivateFunctionMemberPointer, unsigned> mObserver;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -305,7 +305,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "\n"
               "private:\n"
               "    void f1() const {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -319,7 +319,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    void (*fptr)();\n"
               "};\n"
               "myclass::myclass() { fptr = &f; }\n"
-              "void myclass::f() {}");
+              "void myclass::f() {}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -331,7 +331,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    void (*f)();\n"
               "private:\n"
               "    static void func() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -344,7 +344,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    void test(void* f = a) {\n"
               "        f(\"test\");\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -385,7 +385,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    }\n"
               "\n"
               "    int numOfThreads;\n"
-              "};");
+              "};\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -398,7 +398,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "  double TotalWeighting() { return 123.0; }\n"  // called from constructor
               "public:\n"
               "  double totalWeighting_;\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -406,7 +406,7 @@ class TestUnusedPrivateFunction : public TestFixture {
         check("class C {\n"
               "    C() = default;\n"
               "    void f() const { (void)this; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:3:10]: (style) Unused private function: 'C::f' [unusedPrivateFunction]\n", errout_str());
     }
 
@@ -423,7 +423,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    static void f()\n"
               "    { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:10:17] -> [test.cpp:10:17]: (style) Unused private function: 'A::f' [unusedPrivateFunction]\n", errout_str());
 
         check("class A\n"
@@ -442,7 +442,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "        B(A *a)\n"
               "        { a->f(); }\n"
               "    };\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"  // #6968 - outer definition
@@ -453,7 +453,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "};\n"
               "class A::B {"
               "  B() { A a; a.f(); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class C {\n" // #13790
@@ -476,7 +476,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    void f() { }\n"
               "    void f(int) { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -488,7 +488,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    derived() : base() { }\n"
               "private:\n"
               "    void f();\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class base {\n"
@@ -500,7 +500,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    void foo() {}\n" // Skip for overrides of virtual functions of base
               "    void bar() {}\n" // Don't skip if no function is overridden
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:9:10] -> [test.cpp:9:10]: (style) Unused private function: 'derived::bar' [unusedPrivateFunction]\n", errout_str());
 
         check("class Base {\n"
@@ -519,7 +519,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "class Derived2: public Derived1 {\n"
               "private:\n"
               "    void func() {}\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Base {\n"
@@ -537,7 +537,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    Derived* f() {\n"
               "      return 0;\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -547,7 +547,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    friend Bar;\n" // Unknown friend class
               "    void f() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Bar {\n"
@@ -557,7 +557,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    friend Bar;\n"
               "    void f();\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("struct Bar {\n"
@@ -567,7 +567,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    friend Bar;\n"
               "    void f() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Bar {\n" // Friend class seen, f() not used in it
@@ -575,7 +575,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "class Foo {\n"
               "    friend Bar;\n"
               "    void f() { }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:5:10] -> [test.cpp:5:10]: (style) Unused private function: 'Foo::f' [unusedPrivateFunction]\n", errout_str());
 
         check("struct F;\n" // #10265
@@ -589,7 +589,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    bool operator()(const S& lhs, const S& rhs) const {\n"
               "        return lhs.f() < rhs.f();\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -603,7 +603,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "public:\n"
               "    Foo() { }\n"
               "    __property int x = {read=getx}\n"
-              "};", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+              "};\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -616,7 +616,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    }\n"
               "public:\n"
               "    Foo() { }\n"
-              "};", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+              "};\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -634,7 +634,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "template <class T>\n"
               "T A::getVal() const {\n"
               "    return internalGetVal();\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -650,7 +650,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    void startListening() {\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
@@ -662,100 +662,100 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    void startListening() {\n"
               "    }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("[test.cpp:8:10] -> [test.cpp:8:10]: (style) Unused private function: 'Fred::startListening' [unusedPrivateFunction]\n", errout_str());
 
         // #5059
         check("class Fred {\n"
               "    void* operator new(size_t obj_size, size_t buf_size) {}\n"
-              "};");
+              "};\n");
         TODO_ASSERT_EQUALS("[test.cpp:2]: (style) Unused private function: 'Fred::operatornew'\n", "", errout_str()); // No message for operators - we currently cannot check their usage
 
         check("class Fred {\n"
               "    void* operator new(size_t obj_size, size_t buf_size) {}\n"
               "public:\n"
               "    void* foo() { return new(size) Fred(); }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void testDoesNotIdentifyMethodAsFirstFunctionArgument() {
-        check("void callback(void (*func)(int), int arg)"
-              "{"
-              "    (*func)(arg);"
-              "}"
-              "class MountOperation"
-              "{"
-              "    static void Completed(int i);"
-              "public:"
-              "    MountOperation(int i);"
-              "};"
-              "void MountOperation::Completed(int i)"
-              "{"
-              "    std::cerr << i << std::endl;"
-              "}"
-              "MountOperation::MountOperation(int i)"
-              "{"
-              "    callback(MountOperation::Completed, i);"
-              "}"
-              "int main(void)"
-              "{"
-              "    MountOperation aExample(10);"
-              "}"
+        check("void callback(void (*func)(int), int arg)\n"
+              "{\n"
+              "    (*func)(arg);\n"
+              "}\n"
+              "class MountOperation\n"
+              "{\n"
+              "    static void Completed(int i);\n"
+              "public:\n"
+              "    MountOperation(int i);\n"
+              "};\n"
+              "void MountOperation::Completed(int i)\n"
+              "{\n"
+              "    std::cerr << i << std::endl;\n"
+              "}\n"
+              "MountOperation::MountOperation(int i)\n"
+              "{\n"
+              "    callback(MountOperation::Completed, i);\n"
+              "}\n"
+              "int main(void)\n"
+              "{\n"
+              "    MountOperation aExample(10);\n"
+              "}\n"
               );
         ASSERT_EQUALS("", errout_str());
     }
 
     void testDoesNotIdentifyMethodAsMiddleFunctionArgument() {
-        check("void callback(char, void (*func)(int), int arg)"
-              "{"
-              "    (*func)(arg);"
-              "}"
-              "class MountOperation"
-              "{"
-              "    static void Completed(int i);"
-              "public:"
-              "    MountOperation(int i);"
-              "};"
-              "void MountOperation::Completed(int i)"
-              "{"
-              "    std::cerr << i << std::endl;"
-              "}"
-              "MountOperation::MountOperation(int i)"
-              "{"
-              "    callback('a', MountOperation::Completed, i);"
-              "}"
-              "int main(void)"
-              "{"
-              "    MountOperation aExample(10);"
-              "}"
+        check("void callback(char, void (*func)(int), int arg)\n"
+              "{\n"
+              "    (*func)(arg);\n"
+              "}\n"
+              "class MountOperation\n"
+              "{\n"
+              "    static void Completed(int i);\n"
+              "public:\n"
+              "    MountOperation(int i);\n"
+              "};\n"
+              "void MountOperation::Completed(int i)\n"
+              "{\n"
+              "    std::cerr << i << std::endl;\n"
+              "}\n"
+              "MountOperation::MountOperation(int i)\n"
+              "{\n"
+              "    callback('a', MountOperation::Completed, i);\n"
+              "}\n"
+              "int main(void)\n"
+              "{\n"
+              "    MountOperation aExample(10);\n"
+              "}\n"
               );
         ASSERT_EQUALS("", errout_str());
     }
 
     void testDoesNotIdentifyMethodAsLastFunctionArgument() {
-        check("void callback(int arg, void (*func)(int))"
-              "{"
-              "    (*func)(arg);"
-              "}"
-              "class MountOperation"
-              "{"
-              "    static void Completed(int i);"
-              "public:"
-              "    MountOperation(int i);"
-              "};"
-              "void MountOperation::Completed(int i)"
-              "{"
-              "    std::cerr << i << std::endl;"
-              "}"
-              "MountOperation::MountOperation(int i)"
-              "{"
-              "    callback(i, MountOperation::Completed);"
-              "}"
-              "int main(void)"
-              "{"
-              "    MountOperation aExample(10);"
-              "}"
+        check("void callback(int arg, void (*func)(int))\n"
+              "{\n"
+              "    (*func)(arg);\n"
+              "}\n"
+              "class MountOperation\n"
+              "{\n"
+              "    static void Completed(int i);\n"
+              "public:\n"
+              "    MountOperation(int i);\n"
+              "};\n"
+              "void MountOperation::Completed(int i)\n"
+              "{\n"
+              "    std::cerr << i << std::endl;\n"
+              "}\n"
+              "MountOperation::MountOperation(int i)\n"
+              "{\n"
+              "    callback(i, MountOperation::Completed);\n"
+              "}\n"
+              "int main(void)\n"
+              "{\n"
+              "    MountOperation aExample(10);\n"
+              "}\n"
               );
         ASSERT_EQUALS("", errout_str());
     }
@@ -767,7 +767,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    virtual void F() const;\n"
               "};\n"
-              "void Bla::F() const { }");
+              "void Bla::F() const { }\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -786,7 +786,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "};\n"
               "void InfiniteA::foo() {\n"
               "    C a;\n"
-              "}");
+              "}\n");
 
         ASSERT_EQUALS("", errout_str());
     }
@@ -796,7 +796,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    static int i;\n"
               "    static int F() const { return 1; }\n"
               "};\n"
-              "int Foo::i = Foo::F();");
+              "int Foo::i = Foo::F();\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Foo {\n"
@@ -804,15 +804,15 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    int F() const { return 1; }\n"
               "};\n"
               "Foo f;\n"
-              "int Foo::i = f.F();");
+              "int Foo::i = f.F();\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class Foo {\n"
               "    static int i;\n"
               "    static int F() const { return 1; }\n"
               "};\n"
-              "int Foo::i = sth();"
-              "int i = F();");
+              "int Foo::i = sth();\n"
+              "int i = F();\n");
         ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:3:16]: (style) Unused private function: 'Foo::F' [unusedPrivateFunction]\n", errout_str());
     }
 
@@ -835,14 +835,14 @@ class TestUnusedPrivateFunction : public TestFixture {
               "int main() {\n"
               "    CTest::Greeting<bool>(true);\n"
               "    return 0;\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void maybeUnused() {
         check("class C {\n"
               "    [[maybe_unused]] int f() { return 42; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class C {\n"
@@ -855,7 +855,7 @@ class TestUnusedPrivateFunction : public TestFixture {
     void attributeUnused() {
         check("class C {\n"
               "    __attribute__((unused)) int f() { return 42; }\n"
-              "};");
+              "};\n");
         ASSERT_EQUALS("", errout_str());
 
         check("class C {\n"
diff --git a/test/testunusedvar.cpp b/test/testunusedvar.cpp
index a56af38c0f5..049c1200c31 100644
--- a/test/testunusedvar.cpp
+++ b/test/testunusedvar.cpp
@@ -268,7 +268,7 @@ class TestUnusedVar : public TestFixture {
 
         TEST_CASE(lambdaFunction); // #5078
         TEST_CASE(namespaces); // #7557
-        TEST_CASE(bracesInitCpp11);// #7895 - "int var{123}" initialization
+        TEST_CASE(bracesInitCpp11);// #7895 - "int var{123}\n" initialization
 
         TEST_CASE(argument);
         TEST_CASE(argumentClass);
@@ -350,7 +350,7 @@ class TestUnusedVar : public TestFixture {
             "class A {};\n"
             "void f() {\n"
             "   A a;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:3:6]: (style) Unused variable: a [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -361,7 +361,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   B b;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: b [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -371,7 +371,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:6:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -381,7 +381,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   D d;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:6:6]: (style) Unused variable: d [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -391,7 +391,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   E e;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:6:6]: (style) Unused variable: e [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -402,7 +402,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -413,7 +413,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -425,7 +425,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:8:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -437,7 +437,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -449,7 +449,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -461,7 +461,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -473,7 +473,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
 
         // non-empty constructor
@@ -487,7 +487,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         // constructor with hidden definition
@@ -501,7 +501,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "int main() {\n"
             "   A a;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // side-effect variable
@@ -519,7 +519,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   G g;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // side-effect variable in initialization list
@@ -538,7 +538,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   G g;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // unknown variable type
@@ -549,7 +549,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   H h;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // unknown variable type in initialization list
@@ -562,7 +562,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   H h;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // unknown variable type used for initialization
@@ -575,7 +575,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -587,7 +587,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -598,7 +598,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -609,7 +609,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -620,7 +620,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -631,7 +631,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -670,7 +670,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   F f;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // function forward declaration
@@ -683,7 +683,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // return literal
@@ -696,7 +696,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:8:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // return variable without side effects
@@ -712,7 +712,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:11:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // return variable with side effects
@@ -728,7 +728,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // return unknown variable
@@ -743,7 +743,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // return variable is global, but not changed
@@ -759,7 +759,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:11:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // changing global variable in return
@@ -775,7 +775,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // changing global variable in function body
@@ -792,7 +792,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -808,7 +808,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -824,7 +824,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -840,7 +840,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // global variable use in function body without change
@@ -857,7 +857,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:12:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // changing global array variable in function body
@@ -874,7 +874,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -890,7 +890,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -906,7 +906,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // pointer arithmetic on global array
@@ -923,7 +923,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -939,7 +939,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -956,7 +956,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:13:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -973,7 +973,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:13:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         functionVariableUsage(
@@ -989,7 +989,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
@@ -1004,7 +1004,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // changing local variable
@@ -1022,7 +1022,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:13:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // variable of user-defined class without side effects
@@ -1039,7 +1039,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:12:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // variable of user-defined class with side effects
@@ -1059,7 +1059,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // unknown type variable
@@ -1075,7 +1075,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // nested clean function call
@@ -1092,7 +1092,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:12:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // nested side-effects function call
@@ -1112,7 +1112,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // unknown nested function
@@ -1128,7 +1128,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // clean function recursion
@@ -1147,7 +1147,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:14:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // indirect clean function recursion
@@ -1169,7 +1169,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:17:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // side-effect function recursion
@@ -1190,7 +1190,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // multiple returns (side-effect & clean)
@@ -1206,7 +1206,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // multiple clean returns
@@ -1222,7 +1222,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:11:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // multiple side-effect returns
@@ -1238,7 +1238,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // argument return
@@ -1253,7 +1253,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:10:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // global variable modifying through function argument
@@ -1270,7 +1270,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // global variable modifying through local pointer
@@ -1288,7 +1288,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // global variable assigning to local pointer, but not modifying
@@ -1306,7 +1306,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:13:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // global struct variable modification
@@ -1323,7 +1323,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // global struct variable without modification
@@ -1340,7 +1340,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:12:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         // global pointer to struct variable modification
@@ -1358,7 +1358,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // global pointer to struct variable without modification
@@ -1376,7 +1376,7 @@ class TestUnusedVar : public TestFixture {
             "};\n"
             "void f() {\n"
             "   C c;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:13:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
     }
 
@@ -1389,7 +1389,7 @@ class TestUnusedVar : public TestFixture {
                               "void foo() {\n"
                               "    Fred fred;\n"
                               "    throw fred;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1400,7 +1400,7 @@ class TestUnusedVar : public TestFixture {
                               "void foo() {\n"
                               "    Fred fred;\n"
                               "    throw fred;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1410,7 +1410,7 @@ class TestUnusedVar : public TestFixture {
                                "    int a;\n"
                                "    int b;\n"
                                "    int c;\n"
-                               "};");
+                               "};\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) struct member 'abc::a' is never used. [unusedStructMember]\n"
                       "[test.cpp:4:9]: (style) struct member 'abc::b' is never used. [unusedStructMember]\n"
                       "[test.cpp:5:9]: (style) struct member 'abc::c' is never used. [unusedStructMember]\n", errout_str());
@@ -1420,7 +1420,7 @@ class TestUnusedVar : public TestFixture {
                                "    int a;\n"
                                "    int b;\n"
                                "    int c;\n"
-                               "};");
+                               "};\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) union member 'abc::a' is never used. [unusedStructMember]\n"
                       "[test.cpp:4:9]: (style) union member 'abc::b' is never used. [unusedStructMember]\n"
                       "[test.cpp:5:9]: (style) union member 'abc::c' is never used. [unusedStructMember]\n", errout_str());
@@ -1436,7 +1436,7 @@ class TestUnusedVar : public TestFixture {
                                "void f() {\n"
                                "    union DoubleInt di;\n"
                                "    di.asIntel.hi = 3;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("[test.cpp:2:12]: (style) union member 'DoubleInt::asDouble' is never used. [unusedStructMember]\n"
                       "[test.cpp:3:14]: (style) union member 'DoubleInt::asInt' is never used. [unusedStructMember]\n",
                       errout_str());
@@ -1456,7 +1456,7 @@ class TestUnusedVar : public TestFixture {
                                "    int a = abc.a;\n"
                                "    int b = abc.b;\n"
                                "    int c = abc.c;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1475,7 +1475,7 @@ class TestUnusedVar : public TestFixture {
                                "    int a = abc[0].a;\n"
                                "    int b = abc[0].b;\n"
                                "    int c = abc[0].c;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1489,7 +1489,7 @@ class TestUnusedVar : public TestFixture {
                                "{\n"
                                "    ABC abc;\n"
                                "    if (abc.a == 2);\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1509,7 +1509,7 @@ class TestUnusedVar : public TestFixture {
                                "{\n"
                                "    struct AB ab;\n"
                                "    ab.reset();\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1523,7 +1523,7 @@ class TestUnusedVar : public TestFixture {
                                "void foo(char *buf)\n"
                                "{\n"
                                "    struct AB *ab = (struct AB *)&buf[10];\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
 
         checkStructMemberUsage("struct AB\n"
@@ -1535,7 +1535,7 @@ class TestUnusedVar : public TestFixture {
                                "void foo(char *buf)\n"
                                "{\n"
                                "    struct AB *ab = (AB *)&buf[10];\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1549,7 +1549,7 @@ class TestUnusedVar : public TestFixture {
                                "void foo(struct AB *ab)\n"
                                "{\n"
                                "    ab->a = 0;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (style) struct member 'AB::b' is never used. [unusedStructMember]\n", errout_str());
 
         checkStructMemberUsage("struct AB\n"
@@ -1561,7 +1561,7 @@ class TestUnusedVar : public TestFixture {
                                "void foo(struct AB _shuge *ab)\n"
                                "{\n"
                                "    ab->a = 0;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (style) struct member 'AB::b' is never used. [unusedStructMember]\n", errout_str());
     }
 
@@ -1575,7 +1575,7 @@ class TestUnusedVar : public TestFixture {
                                "void foo(char *ab)\n"
                                "{\n"
                                "    ((AB *)ab)->b = 0;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1585,7 +1585,7 @@ class TestUnusedVar : public TestFixture {
                                "};\n"
                                "\n"
                                "struct derived : public base {"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1593,19 +1593,19 @@ class TestUnusedVar : public TestFixture {
         // Fred may have some useful side-effects
         checkStructMemberUsage("struct abc {\n"
                                "    Fred fred;\n"
-                               "};");
+                               "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void structmember11() { // #4168
         checkStructMemberUsage("struct abc { int x; };\n"
                                "struct abc s = {0};\n"
-                               "void f() { do_something(&s); }");
+                               "void f() { do_something(&s); }\n");
         ASSERT_EQUALS("", errout_str());
 
         checkStructMemberUsage("struct abc { int x; };\n"
                                "struct abc s = {0};\n"
-                               "void f() { }");
+                               "void f() { }\n");
         TODO_ASSERT_EQUALS("abc::x is not used", "", errout_str());
     }
 
@@ -1625,14 +1625,14 @@ class TestUnusedVar : public TestFixture {
                                "{\n"
                                "    printf(\"var.struct1.a = %d\", var.struct1.a);\n"
                                "    return 1;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void structmember13() { // #3088 - struct members required by hardware
         checkStructMemberUsage("struct S {\n"
                                "  int x;\n"
-                               "} __attribute__((packed));");
+                               "} __attribute__((packed));\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1640,7 +1640,7 @@ class TestUnusedVar : public TestFixture {
         checkStructMemberUsage("struct bstr { char *bstart; size_t len; };\n"
                                "struct bstr bstr0(void) {\n"
                                "  return (struct bstr){\"hello\",6};\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1651,7 +1651,7 @@ class TestUnusedVar : public TestFixture {
         simplecpp::Location loc;
         loc.line = 1;
         directives.emplace_back(tokenList, loc, "#pragma pack(1)");
-        checkStructMemberUsage("\nstruct Foo { int x; int y; };", dinit(CheckStructMemberUsageOptions, $.directives = &directives));
+        checkStructMemberUsage("\nstruct Foo { int x; int y; };\n", dinit(CheckStructMemberUsageOptions, $.directives = &directives));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1666,7 +1666,7 @@ class TestUnusedVar : public TestFixture {
                                "void foo()\n"
                                "{\n"
                                "    ab.b = 0;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // global linkage => no false positive
@@ -1679,7 +1679,7 @@ class TestUnusedVar : public TestFixture {
                                "void foo()\n"
                                "{\n"
                                "    ab.b = 0;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // static linkage => error message
@@ -1692,7 +1692,7 @@ class TestUnusedVar : public TestFixture {
                                "void foo()\n"
                                "{\n"
                                "    ab.b = 0;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) struct member 'AB::a' is never used. [unusedStructMember]\n", errout_str());
 
         checkStructMemberUsage("struct A\n"
@@ -1703,7 +1703,7 @@ class TestUnusedVar : public TestFixture {
                                "int foo()\n"
                                "{\n"
                                "    return A::a;\n"
-                               "}");
+                               "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -1712,14 +1712,14 @@ class TestUnusedVar : public TestFixture {
                                "  uint8_t message_type;\n"
                                "}\n"
                                "\n"
-                               "input.skip(sizeof(Header));");
+                               "input.skip(sizeof(Header));\n");
         ASSERT_EQUALS("", errout_str());
 
         checkStructMemberUsage("struct Header {\n"
                                "  uint8_t message_type;\n"
                                "}\n"
                                "\n"
-                               "input.skip(sizeof(struct Header));");
+                               "input.skip(sizeof(struct Header));\n");
         ASSERT_EQUALS("", errout_str());
 
         checkStructMemberUsage("struct S { int a, b, c; };\n" // #6561
@@ -1932,7 +1932,7 @@ class TestUnusedVar : public TestFixture {
         ASSERT_EQUALS("[test.cpp:10:9]: (style) struct member 'S::f' is never used. [unusedStructMember]\n", errout_str());
 
         checkStructMemberUsage("struct A { int i; };\n"
-                               "struct B { struct A* pA; };");
+                               "struct B { struct A* pA; };\n");
         ASSERT_EQUALS("[test.cpp:1:16]: (style) struct member 'A::i' is never used. [unusedStructMember]\n"
                       "[test.cpp:2:22]: (style) struct member 'B::pA' is never used. [unusedStructMember]\n",
                       errout_str());
@@ -2129,7 +2129,7 @@ class TestUnusedVar : public TestFixture {
                                "struct B {\n"
                                "    constexpr int x = 20;\n" // <- not unused
                                "    A<uint32_t, x> a;\n" // <- unused
-                               "};");
+                               "};\n");
         ASSERT_EQUALS("[test.cpp:4:20]: (style) struct member 'B::a' is never used. [unusedStructMember]\n", errout_str());
     }
 
@@ -2206,7 +2206,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:11]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2214,7 +2214,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i(0);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         // if a is undefined then Cppcheck can't determine if "int i(a)" is a
@@ -2223,14 +2223,14 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i(a);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int j = 0;\n"
                               "    int i(j);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:10]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2238,7 +2238,7 @@ class TestUnusedVar : public TestFixture {
                               "    int j = 0;\n"
                               "    int & i = j;\n"
                               "    x(j);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:13]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2246,7 +2246,7 @@ class TestUnusedVar : public TestFixture {
                               "    int j = 0;\n"
                               "    const int & i = j;\n"
                               "    x(j);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:19]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2254,7 +2254,7 @@ class TestUnusedVar : public TestFixture {
                               "    int j = 0;\n"
                               "    int & i(j);\n"
                               "    x(j);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2262,27 +2262,27 @@ class TestUnusedVar : public TestFixture {
                               "    int j = 0;\n"
                               "    const int & i(j);\n"
                               "    x(j);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int * j = Data;\n"
                               "    int * i(j);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int * j = Data;\n"
                               "    const int * i(j);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    bool i = false;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:12]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2290,7 +2290,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    bool i = true;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:12]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2299,14 +2299,14 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    char *i;\n"
                               "    i = fgets();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         // undefined variables are not reported because they may be classes with constructors
         functionVariableUsage("undefined foo()\n"
                               "{\n"
                               "    undefined i = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (information) --check-library: Provide <type-checks><unusedvar> configuration for undefined [checkLibraryCheckType]\n", errout_str());
 
         functionVariableUsage("undefined foo()\n"
@@ -2321,7 +2321,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i = undefined;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:11]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2329,7 +2329,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int * i = Data;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:13]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2337,7 +2337,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    void * i = Data;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:14]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2345,7 +2345,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const void * i = Data;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:20]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2353,7 +2353,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    struct S * i = DATA;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:18]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2361,7 +2361,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const struct S * i = DATA;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:24]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2369,19 +2369,19 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    struct S & i = j;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:18]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const struct S & i = j;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:24]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    undefined * i = X;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:19]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2390,7 +2390,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int i = 0;\n"
                               "    int j = i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:11]: (style) Variable 'j' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2398,25 +2398,25 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i[10] = { 0 };\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:15]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo(int n)\n"
                               "{\n"
                               "    int i[n] = { 0 };\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char i[10] = \"123456789\";\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char *i = \"123456789\";\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:13]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2424,7 +2424,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:11]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2436,7 +2436,7 @@ class TestUnusedVar : public TestFixture {
                               "        std::cout<<code<<std::endl;\n"
                               "        code += 2;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2447,7 +2447,7 @@ class TestUnusedVar : public TestFixture {
                               "        code += 2;\n"
                               "        d = code;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:24]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:7:11]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n",
                       errout_str());
@@ -2461,7 +2461,7 @@ class TestUnusedVar : public TestFixture {
                               "        g(d);\n"
                               "        d = code;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2475,7 +2475,7 @@ class TestUnusedVar : public TestFixture {
                               "        }\n"
                               "        d = code;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2487,7 +2487,7 @@ class TestUnusedVar : public TestFixture {
                               "        a=b;\n"
                               "        b=tmp;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2497,7 +2497,7 @@ class TestUnusedVar : public TestFixture {
                               "        std::cout<<code<<std::endl;\n"
                               "        code += 2;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2508,7 +2508,7 @@ class TestUnusedVar : public TestFixture {
                               "        code += 2;\n"
                               "        d += code;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:18]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:7:11]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
@@ -2521,7 +2521,7 @@ class TestUnusedVar : public TestFixture {
                               "        g(d);\n"
                               "        d += code;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2535,7 +2535,7 @@ class TestUnusedVar : public TestFixture {
                               "        }\n"
                               "        d += code;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2547,7 +2547,7 @@ class TestUnusedVar : public TestFixture {
                               "        a=b;\n"
                               "        b=tmp;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2557,7 +2557,7 @@ class TestUnusedVar : public TestFixture {
                               "        std::cout<<code<<std::endl;\n"
                               "        code += 2;\n"
                               "    } while(code < 20);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2568,7 +2568,7 @@ class TestUnusedVar : public TestFixture {
                               "        code += 2;\n"
                               "        d += code;\n"
                               "    } while(code < 20);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:18]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:7:11]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
@@ -2581,7 +2581,7 @@ class TestUnusedVar : public TestFixture {
                               "        g(d);\n"
                               "        d += code;\n"
                               "    } while(code < 20);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2595,7 +2595,7 @@ class TestUnusedVar : public TestFixture {
                               "        }\n"
                               "        d += code;\n"
                               "    } while(code < 20);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2607,7 +2607,7 @@ class TestUnusedVar : public TestFixture {
                               "        a=b;\n"
                               "        b=tmp;\n"
                               "    } while( a!=30 );\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2619,7 +2619,7 @@ class TestUnusedVar : public TestFixture {
                               "            code += 2;\n"
                               "        }\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2631,7 +2631,7 @@ class TestUnusedVar : public TestFixture {
                               "        }\n"
                               "        code += 2;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2643,7 +2643,7 @@ class TestUnusedVar : public TestFixture {
                               "            code += 2;\n"
                               "        }\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -2655,12 +2655,12 @@ class TestUnusedVar : public TestFixture {
                               "            code += 2;\n"
                               "        }\n"
                               "    } while(code < 20);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo(int j = 0) {\n" // #5985 - default function parameters should not affect checking results
                               "    int i = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:11]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -2674,14 +2674,14 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int i;\n"
                               "    return i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         functionVariableUsage("bool foo()\n"
                               "{\n"
                               "    bool i;\n"
                               "    return i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         // undefined variables are not reported because they may be classes with constructors
@@ -2689,7 +2689,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    undefined i;\n"
                               "    return i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("undefined foo()\n"
@@ -2704,35 +2704,35 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    undefined * i;\n"
                               "    return i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         functionVariableUsage("int *foo()\n"
                               "{\n"
                               "    int * i;\n"
                               "    return i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         functionVariableUsage("const int *foo()\n"
                               "{\n"
                               "    const int * i;\n"
                               "    return i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         functionVariableUsage("struct S *foo()\n"
                               "{\n"
                               "    struct S * i;\n"
                               "    return i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         functionVariableUsage("const struct S *foo()\n"
                               "{\n"
                               "    const struct S * i;\n"
                               "    return i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:22]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         // assume f() can write a
@@ -2740,7 +2740,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a[10];\n"
                               "    f(a[0]);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // assume f() can write a
@@ -2748,7 +2748,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a[10];\n"
                               "    f(a[0], 0);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // assume f() can write a
@@ -2756,7 +2756,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a[10];\n"
                               "    f(0, a[0]);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // assume f() can write a
@@ -2764,7 +2764,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a[10];\n"
                               "    f(0, a[0], 0);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // f() can not write a (not supported yet)
@@ -2773,7 +2773,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a[10];\n"
                               "    f(a[0]);\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'a' is not assigned a value.\n",
                            "", errout_str());
 
@@ -2783,7 +2783,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a[10];\n"
                               "    f(a[0]);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(int * i);\n"
@@ -2791,7 +2791,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a[10];\n"
                               "    f(a+1);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
         // extracttests.enable
     }
@@ -2803,7 +2803,7 @@ class TestUnusedVar : public TestFixture {
                               "    if ( abc )\n"
                               "        ;\n"
                               "    else i = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:6:12]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -2812,14 +2812,14 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int i = 0;\n"
                               "    f(i);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i = 0;\n"
                               "    f(&i);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2828,7 +2828,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a = 0;\n"
                               "    b = (char)a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -2837,7 +2837,7 @@ class TestUnusedVar : public TestFixture {
                               "    int b[10];\n"
                               "    for (int i=0;i<10;++i)\n"
                               "        b[i] = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:14]: (style) Variable 'b[i]' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo() {\n"
@@ -2845,14 +2845,14 @@ class TestUnusedVar : public TestFixture {
                               "    int b[10];\n"
                               "    for (int i=0;i<10;++i)\n"
                               "        b[i] = ++a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:5:14]: (style) Variable 'b[i]' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "    int b[10];\n"
                               "    for (int i=0;i<10;++i)\n"
                               "        *(b+i) = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (style) Variable '*(b+i)' is assigned a value that is never used.\n", "", errout_str());
 
         functionVariableUsage("void f() {\n" // #11832, #11923
@@ -2866,25 +2866,25 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i[2];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    void * i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const void * i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:18]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         // extracttests.start: struct A {int x;};
@@ -2892,68 +2892,68 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    A * i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    struct A * i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const struct A * i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:22]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int * i[2];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const int * i[2];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    void * i[2];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const void * i[2];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:18]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    struct A * i[2];\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", "", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const struct A * i[2];\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", "", errout_str());
 
         functionVariableUsage("void foo(int n)\n"
                               "{\n"
                               "    int i[n];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i = 0;\n"
                               "    int &j = i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'j' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:3:9]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
                       errout_str());
@@ -2962,7 +2962,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int i;\n"
                               "    int &j = i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'j' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
@@ -2971,7 +2971,7 @@ class TestUnusedVar : public TestFixture {
                               "    int i;\n"
                               "    int &j = i;\n"
                               "    j = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'i' is assigned a value that is never used.\n",
                            "",
                            errout_str());
@@ -2981,48 +2981,48 @@ class TestUnusedVar : public TestFixture {
                               "    double i = 0.0;\n"
                               "    const double j = i;\n"
                               "    return j;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    A * i;\n"
                               "    i->f();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char * i;\n"
                               "    if (i);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char * i = 0;\n"
                               "    if (i);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char * i = new char[10];\n"
                               "    if (i);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char *i;\n"
                               "    f(i);\n"
-                              "}");
+                              "}\n");
 
         functionVariableUsage("int a;\n"
                               "void foo()\n"
                               "{\n"
                               "    return &a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int a[10];\n"
@@ -3031,7 +3031,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *p = a;\n"
                               "    for (int i = 0; i < 10; i++)\n"
                               "        p[i] = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int a[10];\n"
@@ -3040,7 +3040,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *p = &a[0];\n"
                               "    for (int i = 0; i < 10; i++)\n"
                               "        p[i] = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -3049,7 +3049,7 @@ class TestUnusedVar : public TestFixture {
                               "    int x;\n"
                               "    a[0] = 0;\n"
                               "    x = a[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:6:7]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         // extracttests.start: int f();
@@ -3057,7 +3057,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a, b, c;\n"
                               "    a = b = c = f();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:4:11]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:4:15]: (style) Variable 'c' is assigned a value that is never used. [unreadVariable]\n",
@@ -3066,7 +3066,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("int * foo()\n"
                               "{\n"
                               "    return &undefined[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3077,7 +3077,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    for (int i = 0; i < 10; )\n"
                               "        a[i++] = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:5:16]: (style) Variable 'a[i++]' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -3090,7 +3090,7 @@ class TestUnusedVar : public TestFixture {
                               "    } else {\n"
                               "        int i;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n"
                       "[test.cpp:5:13]: (style) Unused variable: i [unusedVariable]\n"
                       "[test.cpp:7:13]: (style) Unused variable: i [unusedVariable]\n", errout_str());
@@ -3102,7 +3102,7 @@ class TestUnusedVar : public TestFixture {
                               "        int i;\n"
                               "    else\n"
                               "        int i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n"
                       "[test.cpp:5:13]: (style) Unused variable: i [unusedVariable]\n"
                       "[test.cpp:7:13]: (style) Unused variable: i [unusedVariable]\n", errout_str());
@@ -3115,7 +3115,7 @@ class TestUnusedVar : public TestFixture {
                               "    } else {\n"
                               "        int i = 0;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:7:15]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n"
                       "[test.cpp:5:13]: (style) Unused variable: i [unusedVariable]\n",
@@ -3130,7 +3130,7 @@ class TestUnusedVar : public TestFixture {
                               "        int i;\n"
                               "    }\n"
                               "    i = 1;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:9:7]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:5:13]: (style) Unused variable: i [unusedVariable]\n"
                       "[test.cpp:7:13]: (style) Unused variable: i [unusedVariable]\n", errout_str());
@@ -3146,7 +3146,7 @@ class TestUnusedVar : public TestFixture {
                               "        return;\n"
                               "    }\n"
                               "    x = a;\n"  // redundant assignment
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:6:11]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:9:7]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
@@ -3162,7 +3162,7 @@ class TestUnusedVar : public TestFixture {
                               "    else\n"
                               "        return;\n"
                               "    x = a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:10:7]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -3172,7 +3172,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a, b, c, d, e, f;\n"
                               "    a = b = c = d = e = f = 15;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:7]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
             "[test.cpp:4:11]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n"
@@ -3187,7 +3187,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a, b, c = 0;\n"
                               "    a = b = c;\n"
                               "\n"
-                              "}");
+                              "}\n");
 
         TODO_ASSERT_EQUALS(
             "[test.cpp:4:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
@@ -3205,7 +3205,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int x;\n"
                               "    x = obj->ySize / 8;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -3214,7 +3214,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int a[10];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: a [unusedVariable]\n", errout_str());
     }
 
@@ -3225,7 +3225,7 @@ class TestUnusedVar : public TestFixture {
                               "    int b[a];\n"
                               "    b[0] = 0;\n"
                               "    return b[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
@@ -3234,7 +3234,7 @@ class TestUnusedVar : public TestFixture {
                               "    int * b[a];\n"
                               "    b[0] = &c;\n"
                               "    return *b[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int * foo()\n"
@@ -3243,7 +3243,7 @@ class TestUnusedVar : public TestFixture {
                               "    const int * b[a];\n"
                               "    b[0] = &c;\n"
                               "    return b[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct B * foo()\n"
@@ -3252,7 +3252,7 @@ class TestUnusedVar : public TestFixture {
                               "    struct B * b[a];\n"
                               "    b[0] = &c;\n"
                               "    return b[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("const struct B * foo()\n"
@@ -3261,7 +3261,7 @@ class TestUnusedVar : public TestFixture {
                               "    const struct B * b[a];\n"
                               "    b[0] = &c;\n"
                               "    return b[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3271,7 +3271,7 @@ class TestUnusedVar : public TestFixture {
                               "    char buf[5];\n"
                               "    char *ptr = buf;\n"
                               "    *(ptr++) = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'buf' is assigned a value that is never used.\n", "", errout_str());
 
         // #3910
@@ -3280,7 +3280,7 @@ class TestUnusedVar : public TestFixture {
                               "    char *data[2];\n"
                               "    data[0] = buf;\n"
                               "    do_something(data);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo() {\n"
@@ -3290,7 +3290,7 @@ class TestUnusedVar : public TestFixture {
                               "    data[0] = buf1;\n"
                               "    data[1] = buf2;\n"
                               "    do_something(data);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3307,7 +3307,7 @@ class TestUnusedVar : public TestFixture {
                               "    line_start = ptr;\n"
                               "    data->info = k;\n"
                               "    line_start = ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:10:16]: (style) Variable 'line_start' is assigned a value that is never used. [unreadVariable]\n", errout_str());
         // extracttests.enable
     }
@@ -3316,7 +3316,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("A::A(int iValue) {\n"
                               "    UserDefinedException* pe = new UserDefinedException();\n"
                               "    throw pe;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3325,7 +3325,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    int c;\n"
                               "    c = *(a);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (style) Variable 'c' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:2:9]: (style) Variable 'a' is not assigned a value. [unassignedVariable]\n", errout_str());
     }
@@ -3336,7 +3336,7 @@ class TestUnusedVar : public TestFixture {
                               "    char c1 = 'c';\n"
                               "    char c2[] = { c1 };\n"
                               "    a(c2);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3345,7 +3345,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    char buffer[1024];\n"
                               "    bar((void *)buffer);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3356,7 +3356,7 @@ class TestUnusedVar : public TestFixture {
                               "    h = 0 ? u : v;\n"
                               "    i = 1 ? u : v;\n"
                               "    return h + i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3367,7 +3367,7 @@ class TestUnusedVar : public TestFixture {
                               "    int b[10];\n"
                               "    a = b[c] = 0;\n"
                               "    return a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:5:14]: (style) Variable 'b[c]' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -3378,7 +3378,7 @@ class TestUnusedVar : public TestFixture {
                               "    {\n"
                               "        throw *this;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3389,7 +3389,7 @@ class TestUnusedVar : public TestFixture {
                               "    const char*edge = ppos? \" +\" : pneg ? \" -\" : \"\";\n"
                               "    printf(\"This should be a '+' -> %s\\n\", edge);\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3398,7 +3398,7 @@ class TestUnusedVar : public TestFixture {
                               "    const Fred &fred = getfred();\n"
                               "    int *p = fred.x();\n"
                               "    *p = 0;"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3406,7 +3406,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void f(struct s *ptr) {\n"
                               "    int param = 1;\n"
                               "    ptr->param = param++;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:23]: (style) Variable 'param' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -3415,7 +3415,7 @@ class TestUnusedVar : public TestFixture {
                               "    char* pos = buffer;\n"
                               "    int size = value;\n"
                               "    *(int*)pos = size;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3424,7 +3424,7 @@ class TestUnusedVar : public TestFixture {
                               "    float s_ranges[] = { 0, 256 };\n"
                               "    float* ranges[] = { s_ranges };\n"
                               "    cout << ranges[0][0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3432,7 +3432,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void f() {\n"
                               "    Engine *engine = e;\n"
                               "    x->engine = engine->clone();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3440,7 +3440,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void f() {\n"
                               "    int x = 0;\n"
                               "    a.x = x - b;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3450,33 +3450,33 @@ class TestUnusedVar : public TestFixture {
                               "    int x;\n"
                               "    fstream &f = getfile();\n"
                               "    f >> x;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #4596 - if (c >>= x) {}
         functionVariableUsage("void f(int x) {\n"
                               "    C c;\n" // possibly some stream class
                               "    if (c >>= x) {}\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (information) --check-library: Provide <type-checks><unusedvar> configuration for C [checkLibraryCheckType]\n", errout_str());
 
         functionVariableUsage("void f(int x) {\n"
                               "    C c;\n"
                               "    if (c >>= x) {}\n"
-                              "}", dinit(FunctionVariableUsageOptions, $.cpp = false));
+                              "}\n", dinit(FunctionVariableUsageOptions, $.cpp = false));
         ASSERT_EQUALS("[test.c:3:11]: (style) Variable 'c' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    int x, y;\n"
                               "    std::cin >> x >> y;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // ticket #8494
         functionVariableUsage("void f(C c) {\n"
                               "  int x;\n"
                               "  c & x;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3486,7 +3486,7 @@ class TestUnusedVar : public TestFixture {
                               "    while (0 != (abc = abc->next())) {\n"
                               "        ++nOldNum;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3497,7 +3497,7 @@ class TestUnusedVar : public TestFixture {
                               "    } else {\n"
                               "        j -= i;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3505,7 +3505,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void f() {\n"
                               "    int a, b;\n"
                               "    x(1,a,b);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3514,32 +3514,32 @@ class TestUnusedVar : public TestFixture {
                               "    int a, b;\n"
                               "    a = 2 * (b = 3);\n"
                               "    return a + b;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int f() {\n" // ticket #4318
                               "    int a,b;\n"
                               "    x(a, b=2);\n"  // <- if param2 is passed-by-reference then b might be used in x
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n" // ticket #6147
                               "    int a = 0;\n"
                               "    bar(a=a+2);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n" // ticket #6147
                               "    int a = 0;\n"
                               "    bar(a=2);\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
 
         functionVariableUsage("void bar(int);\n"
                               "int foo() {\n"
                               "    int a = 0;\n"
                               "    bar(a=a+2);\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
@@ -3547,7 +3547,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void f() {\n"
                               "    int a = 2;\n"
                               "    ints.at(a) = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3557,7 +3557,7 @@ class TestUnusedVar : public TestFixture {
                               "    const std::string s1(sizeof_(code));\n"
                               "    const std::string s2 = sizeof_(code);\n"
                               "    return(s1+s2);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3565,7 +3565,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void f() {\n"
                               "    int a = 1;\n"
                               "    foo(x*a);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3573,7 +3573,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("int f() {\n"
                               "    int a = 1;\n"
                               "    return x & a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3583,7 +3583,7 @@ class TestUnusedVar : public TestFixture {
                               "    int x = 1;\n"
                               "    int y = FOO::VALUE * x;\n"
                               "    return y;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3595,7 +3595,7 @@ class TestUnusedVar : public TestFixture {
                               "    const float floatA = 2.2f;\n"
                               "    const float floatTot = g_float * floatA;\n"
                               "    SomeTestFunc(floatTot);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("float g_float = 1;\n"
@@ -3605,7 +3605,7 @@ class TestUnusedVar : public TestFixture {
                               "    const float floatB = 2.2f;\n"
                               "    const float floatTot = floatB * g_float;\n"
                               "    SomeTestFunc(floatTot);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("float g_float = 1;\n"
@@ -3615,7 +3615,7 @@ class TestUnusedVar : public TestFixture {
                               "    const float floatC = 2.2f;\n"
                               "    float floatTot = g_float * floatC;\n"
                               "    SomeTestFunc(floatTot);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3641,7 +3641,7 @@ class TestUnusedVar : public TestFixture {
                               "        piArray[uiIndex] = -1234;\n"
                               "    }\n"
                               "    delete [] piArray;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int f() {\n" // #9877
@@ -3649,7 +3649,7 @@ class TestUnusedVar : public TestFixture {
                               "    MACRO(2U, x.size())\n"
                               "    int i = 0;\n"
                               "    return i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3657,7 +3657,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void func() {\n"
                               "    int *sp_mem[2] = { global1, global2 };\n"
                               "    sp_mem[0][3] = 123;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3666,7 +3666,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a = 123;\n"
                               "    int b = (short)-a;;\n"
                               "    return b;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3675,7 +3675,7 @@ class TestUnusedVar : public TestFixture {
                               "    int i = 0;\n"
                               "    int j{i};\n"
                               "    return j;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(bool b, bool c, double& r) {\n"
@@ -3695,17 +3695,17 @@ class TestUnusedVar : public TestFixture {
                               "    std::mutex m;\n"
                               "    std::unique_lock<std::mutex> l{ m };\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int func() {\n"
                               "    std::shared_lock<std::shared_timed_mutex> lock( m );\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n" // #10490
                               "    std::shared_lock lock = GetLock();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n"
@@ -3735,7 +3735,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void f() {\n"
                               "    int (SfxUndoManager::*retrieveCount)(bool) const\n"
                               "        = (flag) ? &SfxUndoManager::foo : &SfxUndoManager::bar;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Variable 'retrieveCount' is assigned a value that is never used. [unreadVariable]\n", errout_str());
         // extracttests.enable
     }
@@ -3743,7 +3743,7 @@ class TestUnusedVar : public TestFixture {
     void localvar48() { // #6954
         functionVariableUsage("void foo() {\n"
                               "  long (*pKoeff)[256] = new long[9][256];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3764,7 +3764,7 @@ class TestUnusedVar : public TestFixture {
                               "}\n"
                               "void A::DoSomething(void) {\n"
                               "    const std::string x = Bar();\n"  // <- warning
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:16:25]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -3775,13 +3775,13 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo() {\n"
                               "  char buf1[10];\n"
                               "  dostuff(cond?buf1:buf2);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "  char buf1[10];\n"
                               "  dostuff(cond?buf2:buf1);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6542 - ternary operator
@@ -3789,7 +3789,7 @@ class TestUnusedVar : public TestFixture {
                               "  char buf1[10], buf2[10];\n"
                               "  char *p = c ? buf1 : buf2;\n"
                               "  dostuff(p);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3798,13 +3798,13 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo(const Token *var) {\n"
                               "  const Token *tok = nameToken();\n"
                               "  tok = tok->next();\n"  // read+write
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (style) Variable 'tok' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "  int x = 4;\n"
                               "  x = 15 + x;\n"  // read+write
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -3813,7 +3813,7 @@ class TestUnusedVar : public TestFixture {
                               "  std::vector<int> data;\n"
                               "  data[2] = 32;\n"
                               "  return data;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3826,7 +3826,7 @@ class TestUnusedVar : public TestFixture {
                               "      continue;\n"
                               "    }\n"
                               "  }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo(int a, int loop) {\n"
@@ -3838,7 +3838,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "  }\n"
                               "  return x;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3846,7 +3846,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("Padding fun() {\n"
                               "  Distance d = DISTANCE;\n"
                               "  return (Padding){ d, d, d, d };\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3862,7 +3862,7 @@ class TestUnusedVar : public TestFixture {
                               "            data[x] = 0;\n"
                               "        }\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:6:15]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n",
                       errout_str());
@@ -3873,7 +3873,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int x = 31;\n"
                               "    mask[x] |= 123;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3882,7 +3882,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int x = 0;\n"
                               "    x++;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:6]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -3890,13 +3890,13 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void f() {\n"
                               "    int x = 0;\n"
                               "    if (--x > 0) {}\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    int x = 0;\n"
                               "    if (x-- > 0) {}\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -3904,7 +3904,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("Response foo() {\n"
                               "    const std::vector<char> cmanifest = z;\n"
                               "    return {.a = cmanifest, .b =0};\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -3914,7 +3914,7 @@ class TestUnusedVar : public TestFixture {
                               "        auto& p = m_points[i];\n"
                               "        p += scale;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo(int c[]) {\n" // #10597
@@ -3972,7 +3972,7 @@ class TestUnusedVar : public TestFixture {
                               "  int x=3;\n"             // <- set but not used
                               "  goto y;\n"
                               "  y:return;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:2:7]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -4117,7 +4117,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void fun(int c) {\n"
                               "  int x;\n"
                               "  while (c) { x=10; }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void dostuff(int x);\n"
@@ -4127,7 +4127,7 @@ class TestUnusedVar : public TestFixture {
                               "    dostuff(x);\n"
                               "    if (y) { x=10; break; }\n"
                               "  }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:6:15]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void dostuff(int &x);\n"
@@ -4137,7 +4137,7 @@ class TestUnusedVar : public TestFixture {
                               "    dostuff(x);\n"
                               "    if (y) { x=10; break; }\n"
                               "  }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:6:15]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void fun() {\n"
@@ -4146,13 +4146,13 @@ class TestUnusedVar : public TestFixture {
                               "    dostuff(x);\n"
                               "    x = 10;\n"
                               "  }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void fun() {\n"
                               "  int x = 0;\n"
                               "  while (x < 10) { x = x + 1; }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void fun()\n"
@@ -4160,7 +4160,7 @@ class TestUnusedVar : public TestFixture {
                               "    int   status = 0;\n"
                               "    for (ind = 0; ((ind < nrArgs) && (status < 10)); ind++)\n"
                               "        status = x;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f()\n"
@@ -4168,7 +4168,7 @@ class TestUnusedVar : public TestFixture {
                               "    int sum = 0U;\n"
                               "    for (i = 0U; i < 2U; i++)\n"
                               "        sum += 123;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:13]: (style) Variable 'sum' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:5:13]: (style) Variable 'sum' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
@@ -4233,7 +4233,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a;\n"
                               "    int *b = &a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:3:9]: (style) Unused variable: a [unusedVariable]\n",
                       errout_str());
@@ -4242,7 +4242,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a[10];\n"
                               "    int *b = a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:3:9]: (style) Unused variable: a [unusedVariable]\n",
                       errout_str());
@@ -4252,7 +4252,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a;\n"
                               "    int *b = &a;\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4262,7 +4262,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a;\n"
                               "    char *b = (char *)&a;\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4272,7 +4272,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a;\n"
                               "    char *b = (char *)(&a);\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4282,7 +4282,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a;\n"
                               "    const char *b = (const char *)&a;\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4292,7 +4292,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a;\n"
                               "    const char *b = (const char *)(&a);\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4302,7 +4302,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a;\n"
                               "    char *b = static_cast<char *>(&a);\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4312,7 +4312,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a;\n"
                               "    const char *b = static_cast<const char *>(&a);\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4322,7 +4322,7 @@ class TestUnusedVar : public TestFixture {
                               "void foo()\n"
                               "{\n"
                               "    int *b = &a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:12]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -4331,7 +4331,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo(int a)\n"
                               "{\n"
                               "    int *b = &a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:12]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -4344,7 +4344,7 @@ class TestUnusedVar : public TestFixture {
                               "    {\n"
                               "        int *b = &a;\n"
                               "    }\n"
-                              "};");
+                              "};\n");
         ASSERT_EQUALS(
             "[test.cpp:6:16]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -4354,14 +4354,14 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int *b = &a;\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo(int a)\n"
                               "{\n"
                               "    int *b = &a;\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class A\n"
@@ -4372,7 +4372,7 @@ class TestUnusedVar : public TestFixture {
                               "        int *b = &a;\n"
                               "        *b = 0;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -4380,7 +4380,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    int *b = a;\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4390,7 +4390,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    char *b = (char *)a;\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4400,7 +4400,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    char *b = (char *)(a);\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4410,7 +4410,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    const char *b = (const char *)a;\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4420,7 +4420,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    const char *b = (const char *)(a);\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4430,7 +4430,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    char *b = static_cast<char *>(a);\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4440,7 +4440,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    const char *b = static_cast<const char *>(a);\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -4450,7 +4450,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int *b = a;\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int a[10];\n"
@@ -4459,7 +4459,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *b = a;\n"
                               "    int *c = b;\n"
                               "    *c = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -4467,7 +4467,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *b = a;\n"
                               "    int *c = b;\n"
                               "    *c = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -4475,7 +4475,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *b = a;\n"
                               "    int *c = b;\n"
                               "    *c = b[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // extracttests.start: int a[10];
@@ -4484,7 +4484,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *b = a;\n"
                               "    int c = b[0];\n"
                               "    x(c);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -4492,7 +4492,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *b = a;\n"
                               "    int c = b[0];\n"
                               "    x(c);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int a[10];\n"
@@ -4500,28 +4500,28 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int *b = &a[0];\n"
                               "    a[0] = b[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int *b = &a[0];\n"
                               "    a[0] = b[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int *b = a;\n"
                               "    a[0] = b[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo(int a[10])\n"
                               "{\n"
                               "    int *b = a;\n"
                               "    *b = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class A\n"
@@ -4532,7 +4532,7 @@ class TestUnusedVar : public TestFixture {
                               "        int *b = a;\n"
                               "        *b = 0;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -4541,7 +4541,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *b = a;\n"
                               "    int *c = b;\n"
                               "    *c = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'a' is assigned a value that is never used.\n",
                            "",
                            errout_str());
@@ -4553,7 +4553,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *c = a;\n"
                               "    int *d = b;\n"
                               "    *d = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:5:12]: (style) Variable 'c' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:3:9]: (style) Unused variable: a [unusedVariable]\n",
                       errout_str());
@@ -4565,7 +4565,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *c = a;\n"
                               "    c = b;\n"
                               "    *c = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: a [unusedVariable]\n",
                       errout_str());
 
@@ -4578,7 +4578,7 @@ class TestUnusedVar : public TestFixture {
                               "    *c = 0;\n"
                               "    c = a;\n"
                               "    *c = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:9]: (style) Variable 'a' is assigned a value that is never used.\n"
                            "[test.cpp:7]: (style) Variable 'b' is assigned a value that is never used.\n",
                            "",
@@ -4588,7 +4588,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a[10], * b = a + 10;\n"
                               "    b[-10] = 1;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'b[-10]' is assigned a value that is never used.\n",
                            "",
                            errout_str());
@@ -4598,7 +4598,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10], * b = a + 10;\n"
                               "    b[-10] = 0;\n"
                               "    int * c = b - 10;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS(
             "[test.cpp:4:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
             "[test.cpp:5:13]: (style) Variable 'c' is assigned a value that is never used. [unreadVariable]\n",
@@ -4609,7 +4609,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10], * b = a + 10;\n"
                               "    int * c = b - 10;\n"
                               "    c[1] = 3;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'c[1]' is assigned a value that is never used.\n",
                            "",
                            errout_str());
@@ -4619,7 +4619,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10], * b = a + 10;\n"
                               "    int * c = b - 10;\n"
                               "    c[1] = c[0];\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'c[1]' is assigned a value that is never used.\n",
                            "",
                            errout_str());
@@ -4630,7 +4630,7 @@ class TestUnusedVar : public TestFixture {
                               "    b[0] = &a[0];\n"
                               "    int *d = b[0];\n"
                               "    return *d;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo() {\n" // #4022 - FP (a is assigned a value that is never used)
@@ -4639,7 +4639,7 @@ class TestUnusedVar : public TestFixture {
                               "    b[0] = &a[0];\n"
                               "    int d = b[0].value;\n"
                               "    return d;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct S { char c[100]; };\n"
@@ -4648,7 +4648,7 @@ class TestUnusedVar : public TestFixture {
                               "    char a[100];\n"
                               "    struct S * s = (struct S *)a;\n"
                               "    s->c[0] = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct S { char c[100]; };\n"
@@ -4656,7 +4656,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    char a[100];\n"
                               "    struct S * s = (struct S *)a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:5:18]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:4:10]: (style) Unused variable: a [unusedVariable]\n",
                       errout_str());
@@ -4666,7 +4666,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    char a[100];\n"
                               "    const struct S * s = (const struct S *)a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:5:24]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:4:10]: (style) Unused variable: a [unusedVariable]\n",
                       errout_str());
@@ -4676,7 +4676,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    char a[100];\n"
                               "    struct S * s = static_cast<struct S *>(a);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:5:18]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:4:10]: (style) Unused variable: a [unusedVariable]\n",
                       errout_str());
@@ -4686,7 +4686,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    char a[100];\n"
                               "    const struct S * s = static_cast<const struct S *>(a);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:5:24]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:4:10]: (style) Unused variable: a [unusedVariable]\n",
                       errout_str());
@@ -4701,7 +4701,7 @@ class TestUnusedVar : public TestFixture {
                               "    d = a;\n"
                               "    d = c;\n"
                               "    *d = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (style) Unused variable: b [unusedVariable]\n",
                       errout_str());
 
@@ -4714,7 +4714,7 @@ class TestUnusedVar : public TestFixture {
                               "    d = b; *d = 0;\n"
                               "    d = a; *d = 0;\n"
                               "    d = c; *d = 0;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'b' is assigned a value that is never used.\n"
                            "[test.cpp:9]: (style) Variable 'c' is assigned a value that is never used.\n",
                            "",
@@ -4726,7 +4726,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int * a;\n"
                               "    x(a);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4737,7 +4737,7 @@ class TestUnusedVar : public TestFixture {
                               "    char          szDisplayName[MAX_PATH];\n"
                               "    info.pszDisplayName = szDisplayName;\n"
                               "    SHBrowseForFolder(&info);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4746,7 +4746,7 @@ class TestUnusedVar : public TestFixture {
                               "void foo()\n"
                               "{\n"
                               "    int * a = &ab.a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -4756,7 +4756,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int * a = &ab.a;\n"
                               "    *a = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct AB { int a; int b; };\n"
@@ -4764,7 +4764,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    struct AB ab;\n"
                               "    int * a = &ab.a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:4:15]: (style) Variable 'ab' is not assigned a value. [unassignedVariable]\n",
                       errout_str());
@@ -4775,7 +4775,7 @@ class TestUnusedVar : public TestFixture {
                               "    struct AB ab;\n"
                               "    int * a = &ab.a;\n"
                               "    *a = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4786,7 +4786,7 @@ class TestUnusedVar : public TestFixture {
                               "    char *p = &buf[0];\n"
                               "    *p++ = 0;\n"
                               "    return buf[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("char foo()\n"
@@ -4795,7 +4795,7 @@ class TestUnusedVar : public TestFixture {
                               "    char *p = &buf[1];\n"
                               "    *p-- = 0;\n"
                               "    return buf[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("char foo()\n"
@@ -4804,7 +4804,7 @@ class TestUnusedVar : public TestFixture {
                               "    char *p = &buf[0];\n"
                               "    *++p = 0;\n"
                               "    return buf[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("char foo()\n"
@@ -4813,7 +4813,7 @@ class TestUnusedVar : public TestFixture {
                               "    char *p = &buf[1];\n"
                               "    *--p = 0;\n"
                               "    return buf[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4830,7 +4830,7 @@ class TestUnusedVar : public TestFixture {
                               "        srcdata = vdata;\n"
                               "    }\n"
                               "    b(srcdata);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -4843,7 +4843,7 @@ class TestUnusedVar : public TestFixture {
                               "        srcdata = vdata;\n"
                               "    }\n"
                               "    b(srcdata);\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'buf' is assigned a value that is never used.\n",
                            "",
                            errout_str());
@@ -4858,7 +4858,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    srcdata = vdata;\n"
                               "    b(srcdata);\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'buf' is assigned a value that is never used.\n",
                            "",
                            errout_str());
@@ -4872,7 +4872,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    srcdata = vdata;\n"
                               "    b(srcdata);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) Unused variable: buf [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -4884,7 +4884,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    srcdata = buf;\n"
                               "    b(srcdata);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -4899,7 +4899,7 @@ class TestUnusedVar : public TestFixture {
                               "        srcdata = vdata;\n"
                               "    }\n"
                               "    b(srcdata);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -4913,7 +4913,7 @@ class TestUnusedVar : public TestFixture {
                               "        srcdata = vdata;\n"
                               "    }\n"
                               "    b(srcdata);\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'buf' is assigned a value that is never used.\n",
                            "",
                            errout_str());
@@ -4929,7 +4929,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    srcdata = vdata;\n"
                               "    b(srcdata);\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'buf' is assigned a value that is never used.\n",
                            "",
                            errout_str());
@@ -4944,7 +4944,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    srcdata = vdata;\n"
                               "    b(srcdata);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) Unused variable: buf [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -4957,7 +4957,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    srcdata = buf;\n"
                               "    b(srcdata);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:5:10]: (style) Unused variable: vdata [unusedVariable]\n", errout_str());
     }
 
@@ -4968,7 +4968,7 @@ class TestUnusedVar : public TestFixture {
                               "    char **cp;\n"
                               "    cp = c;\n"
                               "    *cp = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -4989,7 +4989,7 @@ class TestUnusedVar : public TestFixture {
                               "    else\n"
                               "        pb = b4;\n"
                               "    b(pb);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -5010,7 +5010,7 @@ class TestUnusedVar : public TestFixture {
                               "        pb = b4;\n"
                               "    }\n"
                               "    b(pb);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -5033,7 +5033,7 @@ class TestUnusedVar : public TestFixture {
                               "        pb = b4;\n"
                               "    }\n"
                               "    b(pb);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -5052,7 +5052,7 @@ class TestUnusedVar : public TestFixture {
                               "        pb = b3;\n"
                               "    pb = b4;\n"
                               "    b(pb);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) Unused variable: b1 [unusedVariable]\n"
                       "[test.cpp:4:10]: (style) Unused variable: b2 [unusedVariable]\n"
                       "[test.cpp:5:10]: (style) Unused variable: b3 [unusedVariable]\n", errout_str());
@@ -5077,7 +5077,7 @@ class TestUnusedVar : public TestFixture {
                               "        }\n"
                               "    }\n"
                               "    b(pb);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -5102,7 +5102,7 @@ class TestUnusedVar : public TestFixture {
                               "        }\n"
                               "    }\n"
                               "    b(pb);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -5129,7 +5129,7 @@ class TestUnusedVar : public TestFixture {
                               "        }\n"
                               "    }\n"
                               "    b(pb);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -5151,7 +5151,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    pb = b4;\n"
                               "    b(pb);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:10]: (style) Unused variable: b1 [unusedVariable]\n"
                       "[test.cpp:4:10]: (style) Unused variable: b2 [unusedVariable]\n"
                       "[test.cpp:5:10]: (style) Unused variable: b3 [unusedVariable]\n", errout_str());
@@ -5163,7 +5163,7 @@ class TestUnusedVar : public TestFixture {
                               "    Foo foo;\n"
                               "    Foo &ref = foo;\n"
                               "    ref[0] = 123;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5173,7 +5173,7 @@ class TestUnusedVar : public TestFixture {
                               "    Foo &ref = foo;\n"
                               "    int *x = &ref.x();\n"
                               "    *x = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5181,7 +5181,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void f(Foo &foo) {\n"
                               "    std::set<int>::iterator x = foo.dostuff();\n"
                               "    *(x) = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5190,14 +5190,14 @@ class TestUnusedVar : public TestFixture {
                               "    int a[4];\n"
                               "    int *b = (int*)((int*)a+1);\n"
                               "    x(b);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int f(void) {\n" // #4628
                               "    int x=1,y;\n"
                               "    y = (x * a) / 100;\n"
                               "    return y;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5206,14 +5206,14 @@ class TestUnusedVar : public TestFixture {
                               "    char a[4];\n"
                               "    p = a;\n"
                               "    strcpy(p, \"x\");\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(char *p) {\n"
                               "    char a[4];\n"
                               "    p = a;\n"
                               "    strcpy(p, \"x\");\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("a is assigned value that is never used", "", errout_str());
     }
 
@@ -5222,20 +5222,20 @@ class TestUnusedVar : public TestFixture {
                               "void f() {\n"
                               "    char a[4], *p=a;\n"
                               "    p = dostuff(p);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (style) Variable 'p' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("char * dostuff(char *&p);\n"
                               "void f() {\n"
                               "    char a[4], *p=a;\n"
                               "    p = dostuff(p);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str()); // TODO: we can warn in this special case; variable is local and there are no function calls after the assignment
 
         functionVariableUsage("void f() {\n"
                               "    char a[4], *p=a;\n"
                               "    p = dostuff(p);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str()); // TODO: we can warn in this special case; variable is local and there are no function calls after the assignment
     }
 
@@ -5245,7 +5245,7 @@ class TestUnusedVar : public TestFixture {
                               "  int *p = &x;\n"
                               "  int *p2[1] = {p};\n"
                               "  dostuff(p2);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5254,7 +5254,7 @@ class TestUnusedVar : public TestFixture {
                               "  auto x = dostuff();\n"
                               "  p = x;\n"
                               "  x->data[0] = 9;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5263,7 +5263,7 @@ class TestUnusedVar : public TestFixture {
                               "  int x;\n"
                               "  unknown_type p = &x;\n"
                               "  *p = 9;\n"
-                              "}", dinit(FunctionVariableUsageOptions, $.cpp = false));
+                              "}\n", dinit(FunctionVariableUsageOptions, $.cpp = false));
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5279,7 +5279,7 @@ class TestUnusedVar : public TestFixture {
                               "            break;\n"
                               "        }\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(const std::vector<int>& v) {\n" // #13303
@@ -5368,7 +5368,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a;\n"
                               "    asm();\n"
                               "    b = a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5377,7 +5377,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    static const struct{ int x, y, w, h; } bounds = {1,2,3,4};\n"
                               "    return bounds.x + bounds.y + bounds.w + bounds.h;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5386,7 +5386,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    struct ABC { int a, b, c; };\n"
                               "    struct ABC abc = { 1, 2, 3 };\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:4:20]: (style) Variable 'abc' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -5400,7 +5400,7 @@ class TestUnusedVar : public TestFixture {
                               "    do {\n"
                               "        func();\n"
                               "    } while(a--);\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (style) Unused variable: x\n"
                            "[test.cpp:4]: (style) Unused variable: z\n", "", errout_str());
     }
@@ -5410,13 +5410,13 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("int foo() {\n"
                               "    A a;\n"
                               "    return a.i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n"
@@ -5431,7 +5431,7 @@ class TestUnusedVar : public TestFixture {
                               "int foo() {\n"
                               "    A a;\n"
                               "    return a.i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct A { int i; };\n"
@@ -5439,14 +5439,14 @@ class TestUnusedVar : public TestFixture {
                               "    A a;\n"
                               "    a.i = 0;\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:9]: (style) Variable 'a.i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("struct A { int i; };\n"
                               "int foo() {\n"
                               "    A a = { 0 };\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:9]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -5456,7 +5456,7 @@ class TestUnusedVar : public TestFixture {
                               "int foo() {\n"
                               "    A a = { 0 };\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:9]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -5466,42 +5466,42 @@ class TestUnusedVar : public TestFixture {
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct A { int i; };\n"
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (style) Unused variable: a [unusedVariable]\n", errout_str());
 
         functionVariableUsage("class A { int i; };\n"
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (style) Unused variable: a [unusedVariable]\n", errout_str());
 
         functionVariableUsage("class A { int i; public: A(); { } };\n"
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class A { unknown i; };\n"
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class A : public Fred { int i; };\n"
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class Fred {char c;};\n"
@@ -5509,7 +5509,7 @@ class TestUnusedVar : public TestFixture {
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:7]: (style) Unused variable: a [unusedVariable]\n", errout_str());
     }
 
@@ -5520,7 +5520,7 @@ class TestUnusedVar : public TestFixture {
                               "    Type & get() { return t; }\n"
                               "private:\n"
                               "    Type t;\n"
-                              "};");
+                              "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5534,7 +5534,7 @@ class TestUnusedVar : public TestFixture {
                               "  args = &aatt;\n"
                               "  aatt.text = tmp;\n"
                               "  dostuff(args);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // extracttests.start: void dostuff(int*);
@@ -5548,7 +5548,7 @@ class TestUnusedVar : public TestFixture {
                               "  int *p = &aatt.b;\n"
                               "  aatt.a = 123;\n"
                               "  dostuff(p);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:9:10]: (style) Variable 'aatt.a' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("struct AB {\n"
@@ -5561,7 +5561,7 @@ class TestUnusedVar : public TestFixture {
                               "  int &a = ab.a;\n"
                               "  ab.a = 123;\n"
                               "  dostuff(a);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5580,7 +5580,7 @@ class TestUnusedVar : public TestFixture {
                               "      struct s test;\n"
                               "      test.raw = 0x100;\n"
                               "      dostuff(test.fld1, test.fld2);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5590,7 +5590,7 @@ class TestUnusedVar : public TestFixture {
                               "void foo() {\n"
                               "      struct XY xy(get());\n"
                               "      return xy.x + xy.y;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5601,7 +5601,7 @@ class TestUnusedVar : public TestFixture {
                               "    struct S s;\n"
                               "    s.x = 3;\n"
                               "    memcpy (&s, &s2, sizeof (S));\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:5:9]: (style) Variable 's.x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -5613,7 +5613,7 @@ class TestUnusedVar : public TestFixture {
                               "    Point p;\n"
                               "    p.x = 42;\n"
                               "    return scale(&p).y;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5623,7 +5623,7 @@ class TestUnusedVar : public TestFixture {
                               "void Set() {\n"
                               "    S s;\n"
                               "    s.Ref() = true;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5662,7 +5662,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void f() {\n"
                               "    struct X x[10];\n"
                               "    x[0].a = 5;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:12]: (style) Variable 'x[0].a' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -5674,7 +5674,7 @@ class TestUnusedVar : public TestFixture {
                               "    x.c[0] = fgetuc(fp);\n"
                               "    x.c[1] = fgetuc(fp);\n"
                               "    return x.s;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5685,7 +5685,7 @@ class TestUnusedVar : public TestFixture {
                              "{\n"
                              "    int tmp = 10;\n"
                              "    return 123 " + std::string(1, *p) + " tmp;\n"
-                             "}");
+                             "}\n");
             functionVariableUsage(code.c_str());
             ASSERT_EQUALS("", errout_str());
         }
@@ -5696,7 +5696,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int tmp = 10;\n"
                               "    return ~tmp;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5707,7 +5707,7 @@ class TestUnusedVar : public TestFixture {
                               "    if ( tmp )\n"
                               "        return 1;\n"
                               "    return 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("bool argsMatch(const Token *first, const Token *second) {\n" // #6145
@@ -5735,7 +5735,7 @@ class TestUnusedVar : public TestFixture {
                               "    int tmp2 = 2;\n"
                               "    int tmp3 = 3;\n"
                               "    return tmp1 ? tmp2 : tmp3;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5746,7 +5746,7 @@ class TestUnusedVar : public TestFixture {
                               "        return 2;\n"
                               "    else\n"
                               "        return 1;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:15]: (style) Variable 'y' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -5757,7 +5757,7 @@ class TestUnusedVar : public TestFixture {
                               "        return y;\n"
                               "    else\n"
                               "        return 1;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo(int x)\n"
@@ -5766,7 +5766,7 @@ class TestUnusedVar : public TestFixture {
                               "        return 2;\n"
                               "    else\n"
                               "        return y;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int f(int i) {\n" // #11788
@@ -5807,14 +5807,14 @@ class TestUnusedVar : public TestFixture {
                               "    int a = 1;\n"
                               "    int b = 2;\n"
                               "    a |= b;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
                       "[test.cpp:5:7]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "    int a = 1;\n"
                               "    (b).x += a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo() {\n"
@@ -5822,7 +5822,7 @@ class TestUnusedVar : public TestFixture {
                               "    b[0] = x;\n"
                               "    a += b[0];\n"
                               "    return a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(int *start, int *stop) {\n"
@@ -5830,14 +5830,14 @@ class TestUnusedVar : public TestFixture {
                               "  if (length < 10000)\n"
                               "    length = 10000;\n"
                               "  *stop -= length;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(int a) {\n"
                               "  int x = 3;\n"
                               "  a &= ~x;\n"
                               "  return a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // extracttests.disable
@@ -5845,14 +5845,14 @@ class TestUnusedVar : public TestFixture {
                               "  Fred fred;\n"
                               "  int *a; a = b;\n"
                               "  fred += a;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:8]: (information) --check-library: Provide <type-checks><unusedvar> configuration for Fred [checkLibraryCheckType]\n", errout_str());
         // extracttests.enable
 
         functionVariableUsage("void f(std::pair<int,int> x) {\n"
                               "  std::pair<int,int> fred;\n"  // class with library configuration
                               "  fred = x;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:8]: (style) Variable 'fred' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -5861,13 +5861,13 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a = 1;\n"
                               "    for (;a;);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "    for (int i = 0; (pci = cdi_list_get(pciDevices, i)); i++)\n"
                               "    {}\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(const int* b, int x) {\n" // #11125
@@ -5895,7 +5895,7 @@ class TestUnusedVar : public TestFixture {
                               "        if (i==x) return x;\n"
                               "        i = x;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #5154 - MSVC 'for each'
@@ -5903,7 +5903,7 @@ class TestUnusedVar : public TestFixture {
                               "  std::map<int,int> ints;\n"
                               "  ints[0]= 1;\n"
                               "  for each(std::pair<int,int> i in ints) { x += i.first; }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5912,7 +5912,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int var = 1;\n"
                               "    return 1 >> var;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5921,14 +5921,14 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    QList<int *> ints;\n"
                               "    ints << 1;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n" // #4320
                               "    int x;\n"
                               "    x << 1;\n"
                               "    return x;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5938,7 +5938,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a = 1;\n"
                               "    int b = static_cast<int>(a);\n"
                               "    return b;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5949,7 +5949,7 @@ class TestUnusedVar : public TestFixture {
                               "        int a;\n"
                               "        int f() { return a; }\n"
                               "    } b;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -5957,44 +5957,44 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    bool test __attribute__((unused));\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    bool test __attribute__((unused)) = true;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    bool __attribute__((unused)) test;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    bool __attribute__((unused)) test = true;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    bool test __attribute__((used));\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    bool __attribute__((used)) test;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    char a[1] __attribute__((unused));\n"
                               "    char b[1][2] __attribute__((unused));\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6005,7 +6005,7 @@ class TestUnusedVar : public TestFixture {
                               "  function_type fn;\n"
                               "  fn = reinterpret_cast<function_type>(dlsym(h, \"try_allocation\"));\n"
                               "  fn();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6016,7 +6016,7 @@ class TestUnusedVar : public TestFixture {
                               "    static const int ci;\n"
                               "    static std::string s;\n"
                               "    static const std::string cs;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (style) Unused variable: i [unusedVariable]\n"
                       "[test.cpp:4:22]: (style) Unused variable: ci [unusedVariable]\n"
                       "[test.cpp:5:24]: (style) Unused variable: s [unusedVariable]\n"
@@ -6026,14 +6026,14 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    static int i = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:16]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
                       errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    static int i(0);\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -6042,7 +6042,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    static int j = 0;\n"
                               "    static int i(j);\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:4:10]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -6054,7 +6054,7 @@ class TestUnusedVar : public TestFixture {
                               "    static int c[] = { 5, 6, 7, 8 };\n"
                               "    b[1] = 1;\n"
                               "    return x ? a : c;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:6:16]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n",
                            "",
                            errout_str());
@@ -6064,7 +6064,7 @@ class TestUnusedVar : public TestFixture {
                               "    static int i = 0;\n"
                               "    if(i < foo())\n"
                               "        i += 5;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo() {\n"
@@ -6074,14 +6074,14 @@ class TestUnusedVar : public TestFixture {
                               "        x = 0;\n"
                               "    else\n"
                               "        x++;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo(int value) {\n"
                               "    static int array[16] = {0};\n"
                               "    if(array[value]) {}\n"
                               "    array[value] = 1;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int fun() {\n" // #11310
@@ -6106,7 +6106,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo() {\n"
                               "    extern int i;\n"
                               "    i = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6115,14 +6115,14 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    void* ptr = malloc(16);\n"
                               "    free(ptr);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:17]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char* ptr = new char[16];\n"
                               "    delete[] ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         // extracttests.disable
@@ -6131,14 +6131,14 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    char* ptr = new ( nothrow ) char[16];\n"
                               "    delete[] ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char* ptr = new ( std::nothrow ) char[16];\n"
                               "    delete[] ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         // extracttests.enable
@@ -6147,7 +6147,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    char* ptr = new char;\n"
                               "    delete ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -6155,7 +6155,7 @@ class TestUnusedVar : public TestFixture {
                               "    void* ptr = malloc(16);\n"
                               "    ptr[0] = 123;\n"
                               "    free(ptr);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -6163,7 +6163,7 @@ class TestUnusedVar : public TestFixture {
                               "    char* ptr = new char[16];\n"
                               "    ptr[0] = 123;\n"
                               "    delete[] ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -6171,7 +6171,7 @@ class TestUnusedVar : public TestFixture {
                               "    Fred* fred = new Fred;\n"
                               "    std::cout << \"test\" << std::endl;\n"
                               "    delete fred;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct Fred { int a; };\n"
@@ -6180,7 +6180,7 @@ class TestUnusedVar : public TestFixture {
                               "    Fred* fred = new Fred;\n"
                               "    std::cout << \"test\" << std::endl;\n"
                               "    delete fred;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Variable 'fred' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("struct Fred { int a; Fred() : a(0) {} };\n"
@@ -6189,7 +6189,7 @@ class TestUnusedVar : public TestFixture {
                               "    Fred* fred = new Fred;\n"
                               "    std::cout << \"test\" << std::endl;\n"
                               "    delete fred;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Variable 'fred' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
@@ -6197,7 +6197,7 @@ class TestUnusedVar : public TestFixture {
                               "    Fred* fred = malloc(sizeof(Fred));\n"
                               "    std::cout << \"test\" << std::endl;\n"
                               "    free(fred);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:18]: (style) Variable 'fred' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
 
@@ -6205,7 +6205,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    char* ptr = names[i];\n"
                               "    delete[] ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6215,7 +6215,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    Fred* ptr = (Fred*)malloc(sizeof(Fred));\n"
                               "    free(ptr);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:31]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
@@ -6224,7 +6224,7 @@ class TestUnusedVar : public TestFixture {
                               "    Fred* ptr = (Fred*)malloc(sizeof(Fred));\n"
                               "    ptr->i = 0;\n"
                               "    free(ptr);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
@@ -6232,7 +6232,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    struct Fred* ptr = (Fred*)malloc(sizeof(Fred));\n"
                               "    free(ptr);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:38]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
@@ -6241,7 +6241,7 @@ class TestUnusedVar : public TestFixture {
                               "    struct Fred* ptr = (Fred*)malloc(sizeof(Fred));\n"
                               "    ptr->i = 0;\n"
                               "    free(ptr);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
@@ -6249,7 +6249,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    Fred* ptr = new Fred();\n"
                               "    delete ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         // extracttests.disable
@@ -6259,7 +6259,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    Fred* ptr = new (nothrow ) Fred();\n"
                               "    delete ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
@@ -6267,7 +6267,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    Fred* ptr = new (std::nothrow) Fred();\n"
                               "    delete ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         // extracttests.enable
@@ -6278,7 +6278,7 @@ class TestUnusedVar : public TestFixture {
                               "    Fred* ptr = new Fred();\n"
                               "    ptr->i = 0;\n"
                               "    delete ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
@@ -6286,7 +6286,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    struct Fred* ptr = new Fred();\n"
                               "    delete ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:18]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
@@ -6295,7 +6295,7 @@ class TestUnusedVar : public TestFixture {
                               "    struct Fred* ptr = new Fred();\n"
                               "    ptr->i = 0;\n"
                               "    free(ptr);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class Fred { public: int i; };\n"
@@ -6303,7 +6303,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    Fred* ptr = (Fred*)malloc(sizeof(Fred));\n"
                               "    free(ptr);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:31]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("class Fred { public: int i; };\n"
@@ -6312,7 +6312,7 @@ class TestUnusedVar : public TestFixture {
                               "    Fred* ptr = (Fred*)malloc(sizeof(Fred));\n"
                               "    ptr->i = 0;\n"
                               "    free(ptr);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class Fred { public: int i; };\n"
@@ -6320,7 +6320,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    Fred* ptr = new Fred();\n"
                               "    delete ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:4:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("class Fred { public: int i; };\n"
@@ -6329,7 +6329,7 @@ class TestUnusedVar : public TestFixture {
                               "    Fred* ptr = new Fred();\n"
                               "    ptr->i = 0;\n"
                               "    delete ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6340,7 +6340,7 @@ class TestUnusedVar : public TestFixture {
                               "    int* p = data;\n"
                               "    for ( int i = 0; i < 10; ++i )\n"
                               "        p++;\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'p' is modified but its new value is never used.\n",
                            "",
                            errout_str());
@@ -6350,7 +6350,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo() {\n"
                               "    int p[5];\n"
                               "    *p = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6359,7 +6359,7 @@ class TestUnusedVar : public TestFixture {
                               "    int p[5][5];\n"
                               "    p[0][0] = 0;\n"
                               "    return p[0][0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6368,7 +6368,7 @@ class TestUnusedVar : public TestFixture {
                               "    int p[5][5];\n"
                               "    *((int*)p[0]) = 0;\n"
                               "    return p[0][0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6378,7 +6378,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *pp[0];\n"
                               "    p[0] = 1;\n"
                               "    *pp[0] = p[0];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6386,24 +6386,24 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("int foo() {\n"
                               "    int p[5][5];\n"
                               "    dostuff(*p);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n"
                               "    int p[5];\n"
                               "    dostuff(*p);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n"
                               "    int p[5][5][5];\n"
                               "    dostuff(**p);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n" // #11872
                               "    char v[1][2];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:2:10]: (style) Unused variable: v [unusedVariable]\n", errout_str());
     }
 
@@ -6421,25 +6421,25 @@ class TestUnusedVar : public TestFixture {
     void localvarstring1() { // ticket #1597
         functionVariableUsage("void foo() {\n"
                               "    std::string s;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (style) Unused variable: s [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "    std::string s;\n"
                               "    s = \"foo\";\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "    std::string s = \"foo\";\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:19]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
 
         functionVariableUsage("void foo() {\n" // #8901
                               "    const std::string s = \"foo\";\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:25]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -6447,23 +6447,23 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("std::string foo() {\n"
                               "    std::string s;\n" // Class instances are initialized. Assignment is not necessary
                               "    return s;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("std::string foo() {\n"
                               "    std::string s = \"foo\";\n"
                               "    return s;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    std::string s(\"foo\");\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    std::string s{ \"foo\" };\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:2:18]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
@@ -6471,7 +6471,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo() {\n"
                               "    std::string s;\n"
                               "    int i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:2:17]: (style) Unused variable: s [unusedVariable]\n"
                       "[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", errout_str());
     }
@@ -6479,7 +6479,7 @@ class TestUnusedVar : public TestFixture {
     void localvarconst1() {
         functionVariableUsage("void foo() {\n"
                               "    const bool b = true;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:18]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
@@ -6489,7 +6489,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo() {\n"
                               "    const int N = 10;\n"
                               "    struct X { int x[N]; };\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6504,27 +6504,27 @@ class TestUnusedVar : public TestFixture {
                               "        bar() {}\n"
                               "    };\n"
                               "    return MyInt;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
     void localvarmaybeunused() {
         functionVariableUsage("int main() {\n"
                               "    [[maybe_unused]] int x;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("[[nodiscard]] int getX() { return 4; }\n"
                               "int main() {\n"
                               "    [[maybe_unused]] int x = getX();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("[[nodiscard]] int getX() { return 4; }\n"
                               "int main() {\n"
                               "    [[maybe_unused]] int x = getX();\n"
                               "    x = getX();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("[[nodiscard]] int getX() { return 4; }\n"
@@ -6532,72 +6532,72 @@ class TestUnusedVar : public TestFixture {
                               "    [[maybe_unused]] int x = getX();\n"
                               "    x = getX();\n"
                               "    std::cout << x;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    [[maybe_unused]] const int x = getX();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    [[maybe_unused]] const int& x = getX();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    [[maybe_unused]] const int* x = getX();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    [[maybe_unused]] int& x = getX();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    [[maybe_unused]] int* x = getX();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    [[maybe_unused]] auto x = getX();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    [[maybe_unused]] auto&& x = getX();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    [[maybe_unused]] int x[] = getX();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    [[maybe_unused]] constexpr volatile static int x = 1;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
-        functionVariableUsage("[[maybe_unused]] inline int x = 1;");
+        functionVariableUsage("[[maybe_unused]] inline int x = 1;\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    [[maybe_unused]] [[anotherattribute]] const int* = 1;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    [[maybe_unused]] char a[1];\n"
                               "    [[maybe_unused]] char b[1][2];\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    std::string a [[maybe_unused]];\n"
                               "    f();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6622,9 +6622,9 @@ class TestUnusedVar : public TestFixture {
 
     void localvarthrow() { // ticket #3687
         functionVariableUsage("void foo() {\n"
-                              "    try {}"
+                              "    try {}\n"
                               "    catch(Foo& bar) {}\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6633,40 +6633,40 @@ class TestUnusedVar : public TestFixture {
 
         functionVariableUsage("void f() {\n"
                               "    std::string x = foo();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:19]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n",
             errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    std::vector<int> x;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:2:22]: (style) Unused variable: x [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    std::vector<int> x(100);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:2:23]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    std::vector<MyClass> x;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:2:26]: (style) Unused variable: x [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    std::lock_guard<MyClass> lock(mutex_);\n" // Has a side-effect #4385
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    pLocker = std::shared_ptr<jfxLocker>(new jfxLocker(m_lock, true));\n" // Could have side-effects (#4355)
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    std::mutex m;\n"
                               "    std::unique_lock<std::mutex> lock(m);\n" // #4624
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n" // #7732
@@ -6710,13 +6710,13 @@ class TestUnusedVar : public TestFixture {
     void localVarClass() {
         functionVariableUsage("void f() {\n"
                               "    Fred f;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class C { int x; };\n"
                               "void f() {\n"
                               "    C c;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:7]: (style) Unused variable: c [unusedVariable]\n", errout_str());
 
         functionVariableUsage("class ExampleClass\n" // #10000
@@ -6739,13 +6739,13 @@ class TestUnusedVar : public TestFixture {
                               "void foo()\n"
                               "{\n"
                               "   ExampleClass ex(1, 2, 3, 4);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:20:19]: (style) Variable 'ex' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("class C { public: C(int); ~C(); };\n"
                               "void f() {\n"
                               "    C c(12);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #14643
@@ -6844,7 +6844,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void f() {\n"
                               "    bool x = foo();\n"
                               "    if (NOT x) { }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6854,7 +6854,7 @@ class TestUnusedVar : public TestFixture {
                               "    if (m_errorflags & flag) {\n"
                               "        return 1;\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6868,7 +6868,7 @@ class TestUnusedVar : public TestFixture {
                               "        default: ptr=def; break;\n"
                               "    }\n"
                               "    return ptr;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str()); // Don't write an error that "a" is not used
 
         functionVariableUsage("void x() {\n"
@@ -6886,7 +6886,7 @@ class TestUnusedVar : public TestFixture {
                               "    for (iIndice = 1; iIndice <= (pnodeCurrent->usLen / 2); iIndice++) {\n"
                               "        *pcData = gacHexChar[(*pcOctet >> 4) & 0x0F];\n"
                               "    }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str()); // Don't write an error that "fValeur" is not used
     }
 
@@ -6896,13 +6896,13 @@ class TestUnusedVar : public TestFixture {
                               "    foo(p);\n"
                               "    free(p);\n"
                               "    p = NULL;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(Foo *p) {\n"
                               "    free(p);\n"
                               "    p = (Foo *)NULL;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n" // #11079
@@ -6943,7 +6943,7 @@ class TestUnusedVar : public TestFixture {
                               "    goto label;\n"
                               " }\n"
                               " return false;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:5:7]: (style) Variable 'X' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         // #4558
@@ -6956,7 +6956,7 @@ class TestUnusedVar : public TestFixture {
                               " if (i<3)\n"
                               "     goto start;\n"
                               " return i;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -6964,14 +6964,14 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("int foo() {\n"
                               "    auto f = []{return 1};\n"
                               "    return f();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n"
                               "    auto f = []{return 1};\n"
                               "    auto g = []{return 1};\n"
                               "    return f() + g();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo(std::vector<int>& v) {\n"
@@ -6981,7 +6981,7 @@ class TestUnusedVar : public TestFixture {
                               "        n += 2;\n"
                               "        return r;\n"
                               "    });\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int f() {\n" // #8433
@@ -7035,7 +7035,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo() {\n"
                               "    int buf[6];\n"
                               "    Data data(buf);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:14]: (information) --check-library: Provide <type-checks><unusedvar> configuration for Data [checkLibraryCheckType]\n", errout_str());
     }
 
@@ -7044,7 +7044,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void foo() {\n"
                               "    int myNewValue{ 3u };\n"
                               "    myManager.theDummyTable.addRow(UnsignedIndexValue{ myNewValue }, DummyRowData{ false });\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n"
@@ -7063,7 +7063,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void reset() {\n"
                               "    for (auto & e : array)\n"
                               "        e = 0;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7073,13 +7073,13 @@ class TestUnusedVar : public TestFixture {
                               "  do {\n"
                               "    dostuff(a);\n"
                               "  } while((a += x) < 30);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n"
                               "    int var = 1;\n"
                               "    while (var = var >> 1) { }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7088,13 +7088,13 @@ class TestUnusedVar : public TestFixture {
                               "void foo() {\n"
                               "  const int x = 0;\n"
                               "  f<x>();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "  constexpr std::size_t ArraySize(5);\n"
                               "  std::array<int, ArraySize> X; X.dostuff();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n" // #10686
@@ -7144,31 +7144,31 @@ class TestUnusedVar : public TestFixture {
     void localvarFuncPtr() {
         functionVariableUsage("int main() {\n"
                               "    void(*funcPtr)(void)(x);\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'funcPtr' is assigned a value never used.\n", "", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    void(*funcPtr)(void);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:2:11]: (style) Unused variable: funcPtr [unusedVariable]\n", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    void(*funcPtr)(void)(x);\n"
                               "    funcPtr();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    void(*funcPtr)(void) = x;\n"
                               "    funcPtr();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #14661
         functionVariableUsage("int main() {\n"
                               "    void (*const funcPtr[])(void) = {x};\n"
                               "    funcPtr[0]();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7177,14 +7177,14 @@ class TestUnusedVar : public TestFixture {
                               "  int x = 0;\n"
                               "  dostuff(&x);\n"
                               "  x = 1;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "  int x = 0;\n"
                               "  dostuff(std::ref(x));\n"
                               "  x = 1;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7198,7 +7198,7 @@ class TestUnusedVar : public TestFixture {
                               "    buf = tmp;"
                               ""
                               "    delete [] buf;"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7208,7 +7208,7 @@ class TestUnusedVar : public TestFixture {
                               "    double sum = 0.0;\n"
                               "    for (int i = 0; i<n; ++i)\n"
                               "        pdD[i] = (sum += pdD[i]);\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7216,7 +7216,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("SAL_WNODEPRECATED_DECLARATIONS_PUSH\n"
                               "void convertToTokenArray() {\n"
                               "}\n"
-                              "SAL_WNODEPRECATED_DECLARATIONS_POP"); // #4033
+                              "SAL_WNODEPRECATED_DECLARATIONS_POP\n"); // #4033
     }
 
     void crash2() {
@@ -7226,7 +7226,7 @@ class TestUnusedVar : public TestFixture {
                               "struct Y<0> {};\n"
                               "void f() {\n"
                               "    Y y;\n"
-                              "}"); // #4695
+                              "}\n"); // #4695
         ASSERT_EQUALS("[test.cpp:6:7]: (style) Unused variable: y [unusedVariable]\n", errout_str());
     }
 
@@ -7250,7 +7250,7 @@ class TestUnusedVar : public TestFixture {
                               "          }\n"
                               "   }\n"
                               "   return j;\n"
-                              "}"); // #4585
+                              "}\n"); // #4585
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7268,7 +7268,7 @@ class TestUnusedVar : public TestFixture {
                               "  };\n"
                               "  do_something();\n"
                               "  do_something();\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
 
@@ -7276,20 +7276,20 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage("void f(std::vector<int> ints) {\n"
                               "  int x = 0;\n"
                               "  std::for_each(ints.begin(), ints.end(), [&x](int i){ dostuff(x); x = i; });\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(std::vector<int> ints) {\n"
                               "  int x = 0;\n"
                               "  std::for_each(ints.begin(), ints.end(), [&x](int i){ x += i; });\n"
-                              "}");
+                              "}\n");
         TODO_ASSERT_EQUALS("[test.cpp:3:5]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", "", errout_str());
 
         functionVariableUsage("int f(const std::vector<int>& v) {\n"
                               "    auto it = std::find_if(v.begin(), v.end(), [&](int i) { return i > 0 && i < 7; });\n"
                               "    std::unordered_map<std::string, std::vector<int*>> exprs;\n"
                               "    return *it;\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("[test.cpp:3:56]: (style) Unused variable: exprs [unusedVariable]\n", errout_str());
     }
 
@@ -7307,7 +7307,7 @@ class TestUnusedVar : public TestFixture {
                               "     }\n"
                               "     return value;\n"
                               "  }\n"
-                              "}");
+                              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7317,7 +7317,7 @@ class TestUnusedVar : public TestFixture {
             " static int fpUnread{0};\n"
             " const int var{fpUnread++};\n"
             " return var;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7325,19 +7325,19 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage(
             "void fun(Value value) {\n"
             " value[10] = 123;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
             "void fun(std::string s) {\n"
             " s[10] = 123;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("[test.cpp:2:8]: (style) Variable 's[10]' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage(
             "void fun(short data[2]) {\n"
             "  data[2] = 1;\n"
-            "}"
+            "}\n"
             );
         ASSERT_EQUALS("", errout_str());
 
@@ -7345,7 +7345,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage(
             "void A::b(Date& result) {"
             "  result = 12;\n"
-            "}"
+            "}\n"
             );
         ASSERT_EQUALS("", errout_str());
 
@@ -7354,14 +7354,14 @@ class TestUnusedVar : public TestFixture {
             functionVariableUsage( // assume unknown argument type is reference
                 "void fun(Date result) {"
                 "  result.x = 12;\n"
-                "}"
+                "}\n"
                 );
             ASSERT_EQUALS("", errout_str());
 
             functionVariableUsage( // there is no reference type in C
                 "void fun(Date result) {"
                 "  result.x = 12;\n"
-                "}",
+                "}\n",
                 dinit(FunctionVariableUsageOptions, $.cpp = false)
                 );
             ASSERT_EQUALS("[test.c:1:35]: (style) Variable 'result.x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
@@ -7370,7 +7370,7 @@ class TestUnusedVar : public TestFixture {
                 "struct Date { int x; };\n"
                 "void fun(Date result) {"
                 "  result.x = 12;\n"
-                "}"
+                "}\n"
                 );
             ASSERT_EQUALS("[test.cpp:2:35]: (style) Variable 'result.x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
         }
@@ -7380,7 +7380,7 @@ class TestUnusedVar : public TestFixture {
             "void fun() {"
             "  struct FOO foo;\n"
             "  foo.x = 123;\n"
-            "}"
+            "}\n"
             );
         ASSERT_EQUALS("[test.cpp:2:9]: (style) Variable 'foo.x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
@@ -7389,7 +7389,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage(
             "void foo(std::insert_iterator<C> it) {\n"
             "  it = 123;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7404,7 +7404,7 @@ class TestUnusedVar : public TestFixture {
             "        else\n"
             "            (*pos).second = number;\n"
             "    }\n"
-            "};");
+            "};\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7413,7 +7413,7 @@ class TestUnusedVar : public TestFixture {
             "struct Data { unsigned int n; };\n"
             "int main() {\n"
             "  (*(volatile struct Data*)0x4200).n = 1;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -7422,7 +7422,7 @@ class TestUnusedVar : public TestFixture {
         functionVariableUsage(
             "void f(void) {\n"
             "    ((uint8_t *) (uint16_t)0x1000)[0] = 0x42;\n"
-            "}");
+            "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
diff --git a/test/testvaarg.cpp b/test/testvaarg.cpp
index 826438fe355..4b08c2316d3 100644
--- a/test/testvaarg.cpp
+++ b/test/testvaarg.cpp
@@ -57,21 +57,21 @@ class TestVaarg : public TestFixture {
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr, szFormat);\n"
               "    va_end(arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) 'szFormat' given to va_start() is not last named argument of the function. Did you intend to pass 'nSize'? [va_start_wrongParameter]\n", errout_str());
 
         check("void Format(char* szFormat, char* szBuffer, size_t nSize, ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (warning) 'szBuffer' given to va_start() is not last named argument of the function. Did you intend to pass 'nSize'? [va_start_wrongParameter]\n", errout_str());
 
         check("void Format(char* szFormat, char* szBuffer, size_t nSize, ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr, nSize);\n"
               "    va_end(arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("int main(int argc, char *argv[]) {\n"
@@ -80,14 +80,14 @@ class TestVaarg : public TestFixture {
               "        va_start(argp, format);\n"
               "        c = va_arg(argp, int);\n"
               "    };\n"
-              "}"); // Don't crash (#6032)
+              "}\n"); // Don't crash (#6032)
         ASSERT_EQUALS("[test.cpp:6:5]: (error) va_list 'argp' was opened but not closed by va_end(). [va_end_missing]\n", errout_str());
 
         check("void Format(char* szFormat, char* szBuffer, size_t nSize, ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr);\n"
               "    va_end(arg_ptr);\n"
-              "}"); // Don't crash if less than expected arguments are given.
+              "}\n"); // Don't crash if less than expected arguments are given.
         ASSERT_EQUALS("", errout_str());
 
         check("void assertf_fail(const char *assertion, const char *file, int line, const char *func, const char* msg, ...) {\n"
@@ -99,7 +99,7 @@ class TestVaarg : public TestFixture {
               "                va_end(args);\n"
               "        }\n"
               "    };\n"
-              "}"); // Inner class (#6453)
+              "}\n"); // Inner class (#6453)
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -108,14 +108,14 @@ class TestVaarg : public TestFixture {
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:23]: (error) Using reference 'szBuffer' as parameter for va_start() results in undefined behaviour. [va_start_referencePassed]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -124,7 +124,7 @@ class TestVaarg : public TestFixture {
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6186
@@ -136,13 +136,13 @@ class TestVaarg : public TestFixture {
               "    } catch(...) {\n"
               "        va_end(arg_ptr);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr, szBuffer);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:1]: (error) va_list 'arg_ptr' was opened but not closed by va_end(). [va_end_missing]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
@@ -150,7 +150,7 @@ class TestVaarg : public TestFixture {
               "    va_start(arg_ptr, szBuffer);\n"
               "    if(sth) return;\n"
               "    va_end(arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:19]: (error) va_list 'arg_ptr' was opened but not closed by va_end(). [va_end_missing]\n", errout_str());
 
         // #8124
@@ -164,7 +164,7 @@ class TestVaarg : public TestFixture {
               "        return va_arg(ap, const char*);\n"
               "    });\n"
               "    va_end(ap);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void f(int n, ...)\n"
@@ -176,7 +176,7 @@ class TestVaarg : public TestFixture {
               "    {\n"
               "        return va_arg(ap, const char*);\n"
               "    });\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:10:1]: (error) va_list 'ap' was opened but not closed by va_end(). [va_end_missing]\n", errout_str());
     }
 
@@ -184,19 +184,19 @@ class TestVaarg : public TestFixture {
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
               "    return va_arg(arg_ptr, float);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:19]: (error) va_list 'arg_ptr' used before va_start() was called. [va_list_usedBeforeStarted]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
               "    foo(arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:9]: (error) va_list 'arg_ptr' used before va_start() was called. [va_list_usedBeforeStarted]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_copy(f, arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) va_list 'arg_ptr' used before va_start() was called. [va_list_usedBeforeStarted]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
@@ -204,13 +204,13 @@ class TestVaarg : public TestFixture {
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
               "    return va_arg(arg_ptr, float);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:5:19]: (error) va_list 'arg_ptr' used before va_start() was called. [va_list_usedBeforeStarted]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_end(arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:3:5]: (error) va_list 'arg_ptr' used before va_start() was called. [va_list_usedBeforeStarted]\n", errout_str());
 
 
@@ -221,7 +221,7 @@ class TestVaarg : public TestFixture {
               "    va_start(arg_ptr, szBuffer);\n"
               "    foo(va_arg(arg_ptr, float));\n"
               "    va_end(arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #6066
@@ -230,7 +230,7 @@ class TestVaarg : public TestFixture {
               "    va_copy(v2, v1);\n"
               "    foo(va_arg(v1, float));\n"
               "    va_end(v2);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7527
@@ -246,7 +246,7 @@ class TestVaarg : public TestFixture {
               "        int data = va_arg(vargs, int);\n"
               "        va_end(vargs);\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7533
@@ -262,7 +262,7 @@ class TestVaarg : public TestFixture {
               "        break;\n"
               "    }\n"
               "    va_end(args);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void action_push(int type, ...) {\n"
@@ -278,7 +278,7 @@ class TestVaarg : public TestFixture {
               "        va_end(args);\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         check("void action_push(int type, ...) {\n"
@@ -293,7 +293,7 @@ class TestVaarg : public TestFixture {
               "        va_end(args);\n"
               "        break;\n"
               "    }\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:13:1]: (error) va_list 'args' was opened but not closed by va_end(). [va_end_missing]\n", errout_str());
 
         // #8043
@@ -308,7 +308,7 @@ class TestVaarg : public TestFixture {
               "    sdscatvprintf(curarg, _format, _cpy);\n"
               "    va_end(_cpy);\n"
               "format_err:\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -318,7 +318,7 @@ class TestVaarg : public TestFixture {
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) va_start() or va_copy() called subsequently on 'arg_ptr' without va_end() in between. [va_start_subsequentCalls]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
@@ -326,7 +326,7 @@ class TestVaarg : public TestFixture {
               "    va_start(vl1, szBuffer);\n"
               "    va_copy(vl1, vl1);\n"
               "    va_end(vl1);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("[test.cpp:4:5]: (error) va_start() or va_copy() called subsequently on 'vl1' without va_end() in between. [va_start_subsequentCalls]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
@@ -335,7 +335,7 @@ class TestVaarg : public TestFixture {
               "    va_end(arg_ptr);\n"
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
     }
 
@@ -344,7 +344,7 @@ class TestVaarg : public TestFixture {
               "  BG_TChar * f;\n"
               "  va_start(args,f);\n"
               "  BG_TString result(f);\n"
-              "}");
+              "}\n");
         ASSERT_EQUALS("", errout_str());
 
         // #7559
@@ -356,7 +356,7 @@ class TestVaarg : public TestFixture {
               "  }\n"
               "  va_start(va, name);\n"
               "  va_end(va);\n"
-              "}");
+              "}\n");
     }
 };
 
diff --git a/test/testvalueflow.cpp b/test/testvalueflow.cpp
index 98c4271f509..56bd0e26ce2 100644
--- a/test/testvalueflow.cpp
+++ b/test/testvalueflow.cpp
@@ -580,35 +580,35 @@ class TestValueFlow : public TestFixture {
     }
 
     void valueFlowNumber() {
-        ASSERT_EQUALS(123, valueOfTok("x=123;", "123").intvalue);
-        ASSERT_EQUALS_DOUBLE(192.0, valueOfTok("x=0x0.3p10;", "0x0.3p10").floatValue, 1e-5); // 3 * 16^-1 * 2^10 = 192
-        ASSERT(std::fabs(valueOfTok("x=0.5;", "0.5").floatValue - 0.5) < 0.1);
-        ASSERT_EQUALS(10, valueOfTok("enum {A=10,B=15}; x=A+0;", "+").intvalue);
-        ASSERT_EQUALS(0, valueOfTok("x=false;", "false").intvalue);
-        ASSERT_EQUALS(1, valueOfTok("x=true;", "true").intvalue);
-        ASSERT_EQUALS(0, valueOfTok("x(NULL);", "NULL").intvalue);
-        ASSERT_EQUALS(static_cast<int>('a'), valueOfTok("x='a';", "'a'").intvalue);
-        ASSERT_EQUALS(static_cast<int>('\n'), valueOfTok("x='\\n';", "'\\n'").intvalue);
-        TODO_ASSERT_EQUALS(0xFFFFFFFF00000000, 0, valueOfTok("x=0xFFFFFFFF00000000;", "0xFFFFFFFF00000000").intvalue); // #7701
-        ASSERT_EQUALS_DOUBLE(16, valueOfTok("x=(double)16;", "(").floatValue, 1e-5);
-        ASSERT_EQUALS_DOUBLE(0.0625, valueOfTok("x=1/(double)16;", "/").floatValue, 1e-5);
+        ASSERT_EQUALS(123, valueOfTok("x=123;\n", "123").intvalue);
+        ASSERT_EQUALS_DOUBLE(192.0, valueOfTok("x=0x0.3p10;\n", "0x0.3p10").floatValue, 1e-5); // 3 * 16^-1 * 2^10 = 192
+        ASSERT(std::fabs(valueOfTok("x=0.5;\n", "0.5").floatValue - 0.5) < 0.1);
+        ASSERT_EQUALS(10, valueOfTok("enum {A=10,B=15}; x=A+0;\n", "+").intvalue);
+        ASSERT_EQUALS(0, valueOfTok("x=false;\n", "false").intvalue);
+        ASSERT_EQUALS(1, valueOfTok("x=true;\n", "true").intvalue);
+        ASSERT_EQUALS(0, valueOfTok("x(NULL);\n", "NULL").intvalue);
+        ASSERT_EQUALS(static_cast<int>('a'), valueOfTok("x='a';\n", "'a'").intvalue);
+        ASSERT_EQUALS(static_cast<int>('\n'), valueOfTok("x='\\n';\n", "'\\n'").intvalue);
+        TODO_ASSERT_EQUALS(0xFFFFFFFF00000000, 0, valueOfTok("x=0xFFFFFFFF00000000;\n", "0xFFFFFFFF00000000").intvalue); // #7701
+        ASSERT_EQUALS_DOUBLE(16, valueOfTok("x=(double)16;\n", "(").floatValue, 1e-5);
+        ASSERT_EQUALS_DOUBLE(0.0625, valueOfTok("x=1/(double)16;\n", "/").floatValue, 1e-5);
 
         const Settings settingsC23 = settingsBuilder().c(Standards::C23).build();
-        ASSERT_EQUALS(1, valueOfTok("x=true;", "true", &settingsC23, false).intvalue);
-        ASSERT_EQUALS(0, valueOfTok("x=false;", "false", &settingsC23, false).intvalue);
+        ASSERT_EQUALS(1, valueOfTok("x=true;\n", "true", &settingsC23, false).intvalue);
+        ASSERT_EQUALS(0, valueOfTok("x=false;\n", "false", &settingsC23, false).intvalue);
 
         const Settings settingsC17 = settingsBuilder().c(Standards::C17).build();
-        ASSERT(!valueOfTok("x=true;", "true", &settingsC17, false).isKnown());
-        ASSERT(!valueOfTok("x=false;", "false", &settingsC17, false).isKnown());
+        ASSERT(!valueOfTok("x=true;\n", "true", &settingsC17, false).isKnown());
+        ASSERT(!valueOfTok("x=false;\n", "false", &settingsC17, false).isKnown());
 
         // scope
         {
             const char code[] = "namespace N { enum E {e0,e1}; }\n"
-                                "void foo() { x = N::e1; }";
+                                "void foo() { x = N::e1; }\n";
             ASSERT_EQUALS(1, valueOfTok(code, "::").intvalue);
         }
 
-        ASSERT_EQUALS(63, valueOfTok("x = 3 * uint32_t{21};", "*").intvalue);
+        ASSERT_EQUALS(63, valueOfTok("x = 3 * uint32_t{21};\n", "*").intvalue);
     }
 
     void valueFlowString() {
@@ -619,7 +619,7 @@ class TestValueFlow : public TestFixture {
                 "    static const char *x;\n"
                 "    if (a) x = \"123\";\n"
                 "    return x;\n"
-                "}";
+                "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4, "\"123\"", ValueFlow::Value::ValueType::TOK));
 
         // valueFlowSubFunction
@@ -627,85 +627,85 @@ class TestValueFlow : public TestFixture {
                 "  f(x);\n"
                 "}\n"
                 "\n"
-                "void test() { dostuff(\"abc\"); }";
+                "void test() { dostuff(\"abc\"); }\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2, "\"abc\"", ValueFlow::Value::ValueType::TOK));
     }
 
     void valueFlowTypeTraits()
     {
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<void>{};", "{", 1));
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<void>::value;", ":: value", 1));
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void_v<void>;", "::", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<void>{};\n", "{", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<void>::value;\n", ":: value", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void_v<void>;\n", "::", 1));
 
         // is_void
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<int>{};", "{", 0));
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<void*>{};", "{", 0));
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<const void>{};", "{", 1));
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<volatile void>{};", "{", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<int>{};\n", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<void*>{};\n", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<const void>{};\n", "{", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<volatile void>{};\n", "{", 1));
 
         // is_lvalue_reference
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_lvalue_reference<int>{};", "{", 0));
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_lvalue_reference<int&>{};", "{", 1));
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_lvalue_reference<int&&>{};", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_lvalue_reference<int>{};\n", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_lvalue_reference<int&>{};\n", "{", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_lvalue_reference<int&&>{};\n", "{", 0));
 
         // is_rvalue_reference
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_rvalue_reference<int>{};", "{", 0));
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_rvalue_reference<int&>{};", "{", 0));
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_rvalue_reference<int&&>{};", "{", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_rvalue_reference<int>{};\n", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_rvalue_reference<int&>{};\n", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_rvalue_reference<int&&>{};\n", "{", 1));
 
         // is_reference
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_reference<int>{};", "{", 0));
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_reference<int&>{};", "{", 1));
-        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_reference<int&&>{};", "{", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_reference<int>{};\n", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_reference<int&>{};\n", "{", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_reference<int&&>{};\n", "{", 1));
 
         {
             const char* code;
             code = "void bar();\n"
-                   "void foo() { std::is_void<decltype(bar())>::value; }";
+                   "void foo() { std::is_void<decltype(bar())>::value; }\n";
             ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
 
             code = "int bar();\n"
-                   "void foo() { std::is_void<decltype(bar())>::value; }";
+                   "void foo() { std::is_void<decltype(bar())>::value; }\n";
             ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
 
             code = "void bar();\n"
-                   "void foo() { std::is_void<decltype(bar)>::value; }";
+                   "void foo() { std::is_void<decltype(bar)>::value; }\n";
             ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
 
             code = "class A;\n"
-                   "void foo() { std::is_lvalue_reference<A>::value; }";
+                   "void foo() { std::is_lvalue_reference<A>::value; }\n";
             ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
 
             code = "class A;\n"
-                   "void foo() { std::is_lvalue_reference<A&>::value; }";
+                   "void foo() { std::is_lvalue_reference<A&>::value; }\n";
             ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
 
             code = "class A;\n"
-                   "void foo() { std::is_lvalue_reference<A&&>::value; }";
+                   "void foo() { std::is_lvalue_reference<A&&>::value; }\n";
             ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
 
             code = "class A;\n"
-                   "void foo() { std::is_rvalue_reference<A>::value; }";
+                   "void foo() { std::is_rvalue_reference<A>::value; }\n";
             ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
 
             code = "class A;\n"
-                   "void foo() { std::is_rvalue_reference<A&>::value; }";
+                   "void foo() { std::is_rvalue_reference<A&>::value; }\n";
             ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
 
             code = "class A;\n"
-                   "void foo() { std::is_rvalue_reference<A&&>::value; }";
+                   "void foo() { std::is_rvalue_reference<A&&>::value; }\n";
             ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
 
             code = "class A;\n"
-                   "void foo() { std::is_reference<A>::value; }";
+                   "void foo() { std::is_reference<A>::value; }\n";
             ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
 
             code = "class A;\n"
-                   "void foo() { std::is_reference<A&>::value; }";
+                   "void foo() { std::is_reference<A&>::value; }\n";
             ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
 
             code = "class A;\n"
-                   "void foo() { std::is_reference<A&&>::value; }";
+                   "void foo() { std::is_reference<A&&>::value; }\n";
             ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
 
             code = "void foo() {\n"
@@ -770,7 +770,7 @@ class TestValueFlow : public TestFixture {
                 "    static char ret[10];\n"
                 "    if (a) x = &ret[0];\n"
                 "    return x;\n"
-                "}";
+                "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 5, "& ret [ 0 ]", ValueFlow::Value::ValueType::TOK));
 
         // dead pointer
@@ -778,13 +778,13 @@ class TestValueFlow : public TestFixture {
                 "  int *x;\n"
                 "  if (cond) { int i; x = &i; }\n"
                 "  *x = 0;\n"  // <- x can point at i
-                "}";
+                "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4, "& i", ValueFlow::Value::ValueType::TOK));
 
         code  = "void f() {\n"
                 "  struct X *x;\n"
                 "  x = &x[1];\n"
-                "}";
+                "}\n";
         values = tokenValues(code, "&");
         values.remove_if(&isNotTokValue);
         ASSERT_EQUALS(true, values.empty());
@@ -940,38 +940,38 @@ class TestValueFlow : public TestFixture {
         code  = "void f() {\n"
                 "    const int x[] = {43,23,12};\n"
                 "    return x;\n"
-                "}";
+                "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, "{ 43 , 23 , 12 }", ValueFlow::Value::ValueType::TOK));
 
         code  = "void f() {\n"
                 "    const char x[] = \"abcd\";\n"
                 "    return x;\n"
-                "}";
+                "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, "\"abcd\"", ValueFlow::Value::ValueType::TOK));
 
         code  = "void f() {\n"
                 "    char x[32] = \"abcd\";\n"
                 "    return x;\n"
-                "}";
+                "}\n";
         TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 3U, "\"abcd\"", ValueFlow::Value::ValueType::TOK));
 
         code = "void f() {\n"
                "  int a[10];\n"
                "  int *x = a;\n" // <- a value is a
                "  *x = 0;\n"     // .. => x value is a
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4, "a", ValueFlow::Value::ValueType::TOK));
 
         code  = "char f() {\n"
                 "    const char *x = \"abcd\";\n"
                 "    return x[0];\n"
-                "}";
+                "}\n";
         ASSERT_EQUALS(static_cast<int>('a'), valueOfTok(code, "[").intvalue);
 
         code  = "char f() {\n"
                 "    const char *x = \"\";\n"
                 "    return x[0];\n"
-                "}";
+                "}\n";
         ASSERT_EQUALS(0, valueOfTok(code, "[").intvalue);
 
         code = "int g() { return 3; }\n"
@@ -996,28 +996,28 @@ class TestValueFlow : public TestFixture {
                "   X x;\n"
                "   g(std::move(x));\n"
                "   y=x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, ValueFlow::Value::MoveKind::MovedVariable));
 
         code = "void f() {\n"
                "   X x;\n"
                "   g(std::forward<X>(x));\n"
                "   y=x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, ValueFlow::Value::MoveKind::ForwardedVariable));
 
         code = "void f() {\n"
                "   X x;\n"
                "   g(std::move(x).getA());\n"   // Only parts of x might be moved out
                "   y=x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, ValueFlow::Value::MoveKind::MovedVariable));
 
         code = "void f() {\n"
                "   X x;\n"
                "   g(std::forward<X>(x).getA());\n" // Only parts of x might be moved out
                "   y=x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, ValueFlow::Value::MoveKind::ForwardedVariable));
 
         code = "void f() {\n"
@@ -1025,7 +1025,7 @@ class TestValueFlow : public TestFixture {
                "   g(std::move(x));\n"
                "   x.clear();\n"
                "   y=x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, ValueFlow::Value::MoveKind::MovedVariable));
 
         code = "void f() {\n"
@@ -1033,28 +1033,28 @@ class TestValueFlow : public TestFixture {
                "   g(std::move(x));\n"
                "   y=x->y;\n"
                "   z=x->z;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 5U, ValueFlow::Value::MoveKind::MovedVariable));
 
         code = "void f(int i) {\n"
                "    X x;\n"
                "    z = g(std::move(x));\n"
                "    y = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, ValueFlow::Value::MoveKind::MovedVariable));
 
         code = "void f(int i) {\n"
                "    X x;\n"
                "    y = g(std::move(x),\n"
                "          x.size());\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, ValueFlow::Value::MoveKind::MovedVariable));
 
         code = "void f(int i) {\n"
                "    X x;\n"
                "    x = g(std::move(x));\n"
                "    y = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, ValueFlow::Value::MoveKind::MovedVariable));
 
         code = "A f(int i) {\n"
@@ -1062,7 +1062,7 @@ class TestValueFlow : public TestFixture {
                "    if (i)"
                "        return g(std::move(x));\n"
                "    return h(std::move(x));\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, ValueFlow::Value::MoveKind::MovedVariable));
 
         code = "struct X {\n"
@@ -1076,13 +1076,13 @@ class TestValueFlow : public TestFixture {
                "   X x;\n"
                "   g(std::move(x)).foo([=](int value) mutable {;});\n"
                "   X y=x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 11U, ValueFlow::Value::MoveKind::MovedVariable));
 
         code = "void f(int x) {\n"
                "   g(std::move(x));\n"
                "   y=x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, ValueFlow::Value::MoveKind::MovedVariable));
 
         code = "void g(std::string);\n"
@@ -1115,57 +1115,57 @@ class TestValueFlow : public TestFixture {
         const char *code;
 
         // Different operators
-        ASSERT_EQUALS(5, valueOfTok("3 +  (a ? b : 2);", "+").intvalue);
-        ASSERT_EQUALS(1, valueOfTok("3 -  (a ? b : 2);", "-").intvalue);
-        ASSERT_EQUALS(6, valueOfTok("3 *  (a ? b : 2);", "*").intvalue);
-        ASSERT_EQUALS(6, valueOfTok("13 / (a ? b : 2);", "/").intvalue);
-        ASSERT_EQUALS(1, valueOfTok("13 % (a ? b : 2);", "%").intvalue);
-        ASSERT_EQUALS(0, valueOfTok("3 == (a ? b : 2);", "==").intvalue);
-        ASSERT_EQUALS(1, valueOfTok("3 != (a ? b : 2);", "!=").intvalue);
-        ASSERT_EQUALS(1, valueOfTok("3 >  (a ? b : 2);", ">").intvalue);
-        ASSERT_EQUALS(1, valueOfTok("3 >= (a ? b : 2);", ">=").intvalue);
-        ASSERT_EQUALS(0, valueOfTok("3 <  (a ? b : 2);", "<").intvalue);
-        ASSERT_EQUALS(0, valueOfTok("3 <= (a ? b : 2);", "<=").intvalue);
-
-        ASSERT_EQUALS(1, valueOfTok("(UNKNOWN_TYPE)1;","(").intvalue);
-        ASSERT(tokenValues("(UNKNOWN_TYPE)1000;","(").empty()); // don't know if there is truncation, sign extension
-        ASSERT_EQUALS(255, valueOfTok("(unsigned char)~0;", "(").intvalue);
-        ASSERT_EQUALS(0, valueOfTok("(int)0;", "(").intvalue);
-        ASSERT_EQUALS(3, valueOfTok("(int)(1+2);", "(").intvalue);
-        ASSERT_EQUALS(0, valueOfTok("(UNKNOWN_TYPE*)0;","(").intvalue);
-        ASSERT_EQUALS(100, valueOfTok("(int)100.0;", "(").intvalue);
-        ASSERT_EQUALS(10, valueOfTok("x = static_cast<int>(10);", "( 10 )").intvalue);
-        ASSERT_EQUALS(0, valueOfTok("x = sizeof (struct {int a;}) * 0;", "*").intvalue);
+        ASSERT_EQUALS(5, valueOfTok("3 +  (a ? b : 2);\n", "+").intvalue);
+        ASSERT_EQUALS(1, valueOfTok("3 -  (a ? b : 2);\n", "-").intvalue);
+        ASSERT_EQUALS(6, valueOfTok("3 *  (a ? b : 2);\n", "*").intvalue);
+        ASSERT_EQUALS(6, valueOfTok("13 / (a ? b : 2);\n", "/").intvalue);
+        ASSERT_EQUALS(1, valueOfTok("13 % (a ? b : 2);\n", "%").intvalue);
+        ASSERT_EQUALS(0, valueOfTok("3 == (a ? b : 2);\n", "==").intvalue);
+        ASSERT_EQUALS(1, valueOfTok("3 != (a ? b : 2);\n", "!=").intvalue);
+        ASSERT_EQUALS(1, valueOfTok("3 >  (a ? b : 2);\n", ">").intvalue);
+        ASSERT_EQUALS(1, valueOfTok("3 >= (a ? b : 2);\n", ">=").intvalue);
+        ASSERT_EQUALS(0, valueOfTok("3 <  (a ? b : 2);\n", "<").intvalue);
+        ASSERT_EQUALS(0, valueOfTok("3 <= (a ? b : 2);\n", "<=").intvalue);
+
+        ASSERT_EQUALS(1, valueOfTok("(UNKNOWN_TYPE)1;\n","(").intvalue);
+        ASSERT(tokenValues("(UNKNOWN_TYPE)1000;\n","(").empty()); // don't know if there is truncation, sign extension
+        ASSERT_EQUALS(255, valueOfTok("(unsigned char)~0;\n", "(").intvalue);
+        ASSERT_EQUALS(0, valueOfTok("(int)0;\n", "(").intvalue);
+        ASSERT_EQUALS(3, valueOfTok("(int)(1+2);\n", "(").intvalue);
+        ASSERT_EQUALS(0, valueOfTok("(UNKNOWN_TYPE*)0;\n","(").intvalue);
+        ASSERT_EQUALS(100, valueOfTok("(int)100.0;\n", "(").intvalue);
+        ASSERT_EQUALS(10, valueOfTok("x = static_cast<int>(10);\n", "( 10 )").intvalue);
+        ASSERT_EQUALS(0, valueOfTok("x = sizeof (struct {int a;}) * 0;\n", "*").intvalue);
 
         // Don't calculate or crash if there is UB or invalid operations
-        ASSERT(tokenValues(";-1<<10;","<<").empty());
-        ASSERT(tokenValues(";10<<-1;","<<").empty());
-        ASSERT(tokenValues(";10<<64;","<<").empty());
-        ASSERT(tokenValues(";-1>>10;",">>").empty());
-        ASSERT(tokenValues(";10>>-1;",">>").empty());
-        ASSERT(tokenValues(";10>>64;",">>").empty());
-        ASSERT_EQUALS(tokenValues(";1%-1;","%").size(), 1);
-        ASSERT_EQUALS(tokenValues(";1%-10;","%").size(), 1);
-        ASSERT_EQUALS(tokenValues(";1.5%-1;","%").size(), 1);
-        ASSERT_EQUALS(tokenValues(";1.5%-10;","%").size(), 1);
-        ASSERT(tokenValues(";1%-1.5;","%").empty());
-        ASSERT(tokenValues(";1%-10.5;","%").empty());
-        ASSERT(tokenValues(";1.5%-1.5;","%").empty());
-        ASSERT(tokenValues(";1.5%-10.5;","%").empty());
-        ASSERT(tokenValues(";1/-1;","/").empty());
-        ASSERT(tokenValues(";1/-10;","/").empty());
-        ASSERT(tokenValues(";1.5/-1;","/").empty());
-        ASSERT(tokenValues(";1.5/-10;","/").empty());
-        ASSERT(tokenValues(";1/-1.5;","/").empty());
-        ASSERT(tokenValues(";1/-10.5;","/").empty());
-        ASSERT(tokenValues(";1.5/-1.5;","/").empty());
-        ASSERT(tokenValues(";1.5/-10.5;","/").empty());
-        ASSERT(tokenValues(";1/0;","/").empty());
-        ASSERT(tokenValues(";1/0;","/").empty());
-        ASSERT(tokenValues(";1.5/0;","/").empty());
-        ASSERT(tokenValues(";1.5/0;","/").empty());
-        ASSERT(tokenValues(";((-1) * 9223372036854775807LL - 1) / (-1);", "/").empty()); // #12109
-        ASSERT_EQUALS(tokenValues(";((-1) * 9223372036854775807LL - 1) % (-1);", "%").size(), 1); // #12109
+        ASSERT(tokenValues(";-1<<10;\n","<<").empty());
+        ASSERT(tokenValues(";10<<-1;\n","<<").empty());
+        ASSERT(tokenValues(";10<<64;\n","<<").empty());
+        ASSERT(tokenValues(";-1>>10;\n",">>").empty());
+        ASSERT(tokenValues(";10>>-1;\n",">>").empty());
+        ASSERT(tokenValues(";10>>64;\n",">>").empty());
+        ASSERT_EQUALS(tokenValues(";1%-1;\n","%").size(), 1);
+        ASSERT_EQUALS(tokenValues(";1%-10;\n","%").size(), 1);
+        ASSERT_EQUALS(tokenValues(";1.5%-1;\n","%").size(), 1);
+        ASSERT_EQUALS(tokenValues(";1.5%-10;\n","%").size(), 1);
+        ASSERT(tokenValues(";1%-1.5;\n","%").empty());
+        ASSERT(tokenValues(";1%-10.5;\n","%").empty());
+        ASSERT(tokenValues(";1.5%-1.5;\n","%").empty());
+        ASSERT(tokenValues(";1.5%-10.5;\n","%").empty());
+        ASSERT(tokenValues(";1/-1;\n","/").empty());
+        ASSERT(tokenValues(";1/-10;\n","/").empty());
+        ASSERT(tokenValues(";1.5/-1;\n","/").empty());
+        ASSERT(tokenValues(";1.5/-10;\n","/").empty());
+        ASSERT(tokenValues(";1/-1.5;\n","/").empty());
+        ASSERT(tokenValues(";1/-10.5;\n","/").empty());
+        ASSERT(tokenValues(";1.5/-1.5;\n","/").empty());
+        ASSERT(tokenValues(";1.5/-10.5;\n","/").empty());
+        ASSERT(tokenValues(";1/0;\n","/").empty());
+        ASSERT(tokenValues(";1/0;\n","/").empty());
+        ASSERT(tokenValues(";1.5/0;\n","/").empty());
+        ASSERT(tokenValues(";1.5/0;\n","/").empty());
+        ASSERT(tokenValues(";((-1) * 9223372036854775807LL - 1) / (-1);\n", "/").empty()); // #12109
+        ASSERT_EQUALS(tokenValues(";((-1) * 9223372036854775807LL - 1) % (-1);\n", "%").size(), 1); // #12109
 
         code = "float f(const uint16_t& value) {\n"
                "    const uint16_t uVal = value; \n"
@@ -1176,27 +1176,27 @@ class TestValueFlow : public TestFixture {
         // calculation using 1,2 variables/values
         code  = "void f(int x) {\n"
                 "    a = x+456;\n"
-                "    if (x==123) {}"
-                "}";
+                "    if (x==123) {}\n"
+                "}\n";
         ASSERT_EQUALS(579, valueOfTok(code, "+").intvalue);
 
         code  = "void f(int x, int y) {\n"
                 "    a = x+y;\n"
-                "    if (x==123 || y==456) {}"
-                "}";
+                "    if (x==123 || y==456) {}\n"
+                "}\n";
         ASSERT_EQUALS(0, valueOfTok(code, "+").intvalue);
 
         code  = "void f(int x) {\n"
                 "    a = x+x;\n"
-                "    if (x==123) {}"
-                "}";
+                "    if (x==123) {}\n"
+                "}\n";
         ASSERT_EQUALS(246, valueOfTok(code, "+").intvalue);
 
         code  = "void f(int x, int y) {\n"
                 "    a = x*x;\n"
                 "    if (x==2) {}\n"
                 "    if (x==4) {}\n"
-                "}";
+                "}\n";
         std::list<ValueFlow::Value> values = tokenValues(code,"*");
         ASSERT_EQUALS(2U, values.size());
         ASSERT_EQUALS(4, values.front().intvalue);
@@ -1205,7 +1205,7 @@ class TestValueFlow : public TestFixture {
         code  = "void f(int x) {\n"
                 "    if (x == 3) {}\n"
                 "    a = x * (1 - x - 1);\n"
-                "}";
+                "}\n";
         ASSERT_EQUALS(-9, valueOfTok(code, "*").intvalue);
 
         // addition of different variables with known values
@@ -1253,11 +1253,11 @@ class TestValueFlow : public TestFixture {
                 "    const int i = 1;\n"
                 "    int x = i < 0 ? 0 : 1;\n"
                 "    return x;\n"
-                "}";
+                "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 1));
 
         // ~
-        code  = "x = ~0U;";
+        code  = "x = ~0U;\n";
         values = tokenValues(code,"~");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(~0U, values.back().intvalue);
@@ -1266,7 +1266,7 @@ class TestValueFlow : public TestFixture {
         code  = "void f(int x) {\n"
                 "    a = !x;\n"
                 "    if (x==0) {}\n"
-                "}";
+                "}\n";
         values = removeImpossible(tokenValues(code, "!"));
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(1, values.back().intvalue);
@@ -1275,7 +1275,7 @@ class TestValueFlow : public TestFixture {
         code  = "void f(int x) {\n"
                 "    a = -x;\n"
                 "    if (x==10) {}\n"
-                "}";
+                "}\n";
         values = tokenValues(code,"-");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(-10, values.back().intvalue);
@@ -1283,57 +1283,57 @@ class TestValueFlow : public TestFixture {
         code = "bool f(unsigned a) {\n" // #14848
                "    bool x = -a < 1;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, 1));
 
         // Logical and
         code = "void f(bool b) {\n"
                "   bool x = false && b;\n"
                "   bool a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
 
         code = "void f(bool b) {\n"
                "   bool x = b && false;\n"
                "   bool a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
 
         code = "void f(bool b) {\n"
                "   bool x = true && b;\n"
                "   bool a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 1));
 
         code = "void f(bool b) {\n"
                "   bool x = b && true;\n"
                "   bool a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 1));
 
         // Logical or
         code = "void f(bool b) {\n"
                "   bool x = true || b;\n"
                "   bool a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 1));
 
         code = "void f(bool b) {\n"
                "   bool x = b || true;\n"
                "   bool a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 1));
 
         code = "void f(bool b) {\n"
                "   bool x = false || b;\n"
                "   bool a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
 
         code = "void f(bool b) {\n"
                "   bool x = b || false;\n"
                "   bool a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
 
         code = "void f(int i) {\n"
@@ -1369,7 +1369,7 @@ class TestValueFlow : public TestFixture {
                 "void callf() {\n"
                 "    f(1,1);\n"
                 "    f(10,10);\n"
-                "}";
+                "}\n";
         values = tokenValues(code, "+");
         ASSERT_EQUALS(true, values.empty());
         if (!values.empty()) {
@@ -1387,22 +1387,22 @@ class TestValueFlow : public TestFixture {
         ASSERT_NO_THROW(tokenValues(code, "<=>"));
 
         // Comparison of string
-        values = removeImpossible(tokenValues("f(\"xyz\" == \"xyz\");", "==")); // implementation defined
+        values = removeImpossible(tokenValues("f(\"xyz\" == \"xyz\");\n", "==")); // implementation defined
         ASSERT_EQUALS(0U, values.size()); // <- no value
 
-        values = removeImpossible(tokenValues("f(\"xyz\" == 0);", "=="));
+        values = removeImpossible(tokenValues("f(\"xyz\" == 0);\n", "=="));
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(0, values.front().intvalue);
 
-        values = removeImpossible(tokenValues("f(0 == \"xyz\");", "=="));
+        values = removeImpossible(tokenValues("f(0 == \"xyz\");\n", "=="));
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(0, values.front().intvalue);
 
-        values = removeImpossible(tokenValues("f(\"xyz\" != 0);", "!="));
+        values = removeImpossible(tokenValues("f(\"xyz\" != 0);\n", "!="));
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(1, values.front().intvalue);
 
-        values = removeImpossible(tokenValues("f(0 != \"xyz\");", "!="));
+        values = removeImpossible(tokenValues("f(0 != \"xyz\");\n", "!="));
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(1, values.front().intvalue);
     }
@@ -1415,7 +1415,7 @@ class TestValueFlow : public TestFixture {
         code  = "void f() {\n"
                 "    char a[10];"
                 "    x = sizeof(*a);\n"
-                "}";
+                "}\n";
         values = tokenValues(code,"( *");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(1, values.back().intvalue);
@@ -1423,31 +1423,31 @@ class TestValueFlow : public TestFixture {
         code  = "void f() {\n"
                 "    char a[10];"
                 "    x = sizeof(a[0]);\n"
-                "}";
+                "}\n";
         values = tokenValues(code,"( a");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(1, values.back().intvalue);
 
         code = "enum testEnum : uint32_t { a };\n"
-               "sizeof(testEnum);";
+               "sizeof(testEnum);\n";
         values = tokenValues(code,"( testEnum");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(4, values.back().intvalue);
 
         code = "char& r = i;\n"
-               "sizeof(r);";
+               "sizeof(r);\n";
         values = tokenValues(code, "( r");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(1, values.back().intvalue);
 
         code = "char* p;\n"
-               "sizeof(p);";
+               "sizeof(p);\n";
         values = tokenValues(code, "( p");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(settings.platform.sizeof_pointer, values.back().intvalue);
 
         code = "char*& pr = p;\n"
-               "sizeof(pr);";
+               "sizeof(pr);\n";
         values = tokenValues(code, "( pr");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(settings.platform.sizeof_pointer, values.back().intvalue);
@@ -1462,7 +1462,7 @@ class TestValueFlow : public TestFixture {
     do {                                     \
         code = "void f() {\n"                    \
                "    x = sizeof(" A ");\n"        \
-               "}";                              \
+               "}\n";                              \
         values = tokenValues(code,"( " C " )");  \
         ASSERT_EQUALS(1U, values.size());        \
         ASSERT_EQUALS(B, values.back().intvalue); \
@@ -1500,7 +1500,7 @@ class TestValueFlow : public TestFixture {
         code  = "void f() {\n"
                 "    struct S *a[10];"
                 "    x = sizeof(a) / sizeof(a[0]);\n"
-                "}";
+                "}\n";
         values = tokenValues(code,"/");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(10, values.back().intvalue);
@@ -1509,7 +1509,7 @@ class TestValueFlow : public TestFixture {
                 "    struct S { int i; };\n"
                 "    const S a[] = { 1, 2 };\n"
                 "    x = sizeof(a) / ( sizeof(a[0]) );\n"
-                "}";
+                "}\n";
         values = tokenValues(code, "/");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(2, values.back().intvalue);
@@ -1519,7 +1519,7 @@ class TestValueFlow : public TestFixture {
         code = "enum " A " E " B " { E0, E1 };\n" \
                "void f() {\n"                     \
                "    x = sizeof(" C ");\n"         \
-               "}";                               \
+               "}\n";                               \
         values = tokenValues(code,"( " C " )");   \
         ASSERT_EQUALS(1U, values.size());         \
         ASSERT_EQUALS(D, values.back().intvalue); \
@@ -1545,7 +1545,7 @@ class TestValueFlow : public TestFixture {
         CHECK("", ": signed long long", "E", settings.platform.sizeof_long_long);
         CHECK("", ": unsigned long long", "E", settings.platform.sizeof_long_long);
         CHECK("", ": wchar_t", "E", settings.platform.sizeof_wchar_t);
-        CHECK("", ": size_t", "E", settings.platform.sizeof_size_t);
+        CHECK("", ": size_t\n", "E", settings.platform.sizeof_size_t);
 
         // enumerators
         CHECK("", "", "E0", settings.platform.sizeof_int);
@@ -1567,7 +1567,7 @@ class TestValueFlow : public TestFixture {
         CHECK("", ": signed long long", "E0", settings.platform.sizeof_long_long);
         CHECK("", ": unsigned long long", "E0", settings.platform.sizeof_long_long);
         CHECK("", ": wchar_t", "E0", settings.platform.sizeof_wchar_t);
-        CHECK("", ": size_t", "E0", settings.platform.sizeof_size_t);
+        CHECK("", ": size_t\n", "E0", settings.platform.sizeof_size_t);
 
         // class typed enumerators
         CHECK("class", ": char", "E :: E0", 1U);
@@ -1586,7 +1586,7 @@ class TestValueFlow : public TestFixture {
         CHECK("class", ": signed long long", "E :: E0", settings.platform.sizeof_long_long);
         CHECK("class", ": unsigned long long", "E :: E0", settings.platform.sizeof_long_long);
         CHECK("class", ": wchar_t", "E :: E0", settings.platform.sizeof_wchar_t);
-        CHECK("class", ": size_t", "E :: E0", settings.platform.sizeof_size_t);
+        CHECK("class", ": size_t\n", "E :: E0", settings.platform.sizeof_size_t);
 #undef CHECK
 
 #define CHECK(A, B)                                   \
@@ -1595,7 +1595,7 @@ class TestValueFlow : public TestFixture {
                "void f() {\n"                         \
                "    E arrE[] = { E0, E1 };\n"         \
                "    x = sizeof(arrE);\n"              \
-               "}";                                   \
+               "}\n";                                   \
         values = tokenValues(code,"( arrE )");        \
         ASSERT_EQUALS(1U, values.size());             \
         ASSERT_EQUALS(B * 2ULL, values.back().intvalue); \
@@ -1621,7 +1621,7 @@ class TestValueFlow : public TestFixture {
         CHECK(": signed long long", settings.platform.sizeof_long_long);
         CHECK(": unsigned long long", settings.platform.sizeof_long_long);
         CHECK(": wchar_t", settings.platform.sizeof_wchar_t);
-        CHECK(": size_t", settings.platform.sizeof_size_t);
+        CHECK(": size_t\n", settings.platform.sizeof_size_t);
 #undef CHECK
 
 #define CHECK(A, B)                                   \
@@ -1630,7 +1630,7 @@ class TestValueFlow : public TestFixture {
                "void f() {\n"                         \
                "    E arrE[] = { E::E0, E::E1 };\n"   \
                "    x = sizeof(arrE);\n"              \
-               "}";                                   \
+               "}\n";                                   \
         values = tokenValues(code,"( arrE )");        \
         ASSERT_EQUALS(1U, values.size());             \
         ASSERT_EQUALS(B * 2ULL, values.back().intvalue); \
@@ -1656,16 +1656,16 @@ class TestValueFlow : public TestFixture {
         CHECK(": signed long long", settings.platform.sizeof_long_long);
         CHECK(": unsigned long long", settings.platform.sizeof_long_long);
         CHECK(": wchar_t", settings.platform.sizeof_wchar_t);
-        CHECK(": size_t", settings.platform.sizeof_size_t);
+        CHECK(": size_t\n", settings.platform.sizeof_size_t);
 #undef CHECK
 
         code = "uint16_t arr[10];\n"
-               "x = sizeof(arr);";
+               "x = sizeof(arr);\n";
         values = tokenValues(code,"( arr )");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(10 * sizeof(std::uint16_t), values.back().intvalue);
 
-        code = "int sz = sizeof(int32_t[10][20]);";
+        code = "int sz = sizeof(int32_t[10][20]);\n";
         values = tokenValues(code, "=");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(sizeof(std::int32_t) * 10 * 20, values.back().intvalue);
@@ -1673,7 +1673,7 @@ class TestValueFlow : public TestFixture {
         code = "struct X { float a; float b; };\n"
                "void f() {\n"
                "    x = sizeof(X);\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "( X )");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(8, values.back().intvalue);
@@ -1681,7 +1681,7 @@ class TestValueFlow : public TestFixture {
         code = "struct X { char a; char b; };\n"
                "void f() {\n"
                "    x = sizeof(X);\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "( X )");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(2, values.back().intvalue);
@@ -1689,7 +1689,7 @@ class TestValueFlow : public TestFixture {
         code = "struct X { char a; float b; };\n"
                "void f() {\n"
                "    x = sizeof(X);\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "( X )");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(8, values.back().intvalue);
@@ -1697,7 +1697,7 @@ class TestValueFlow : public TestFixture {
         code = "struct X { char a; char b; float c; };\n"
                "void f() {\n"
                "    x = sizeof(X);\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "( X )");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(8, values.back().intvalue);
@@ -1705,7 +1705,7 @@ class TestValueFlow : public TestFixture {
         code = "struct X { float a; char b; };\n"
                "void f() {\n"
                "    x = sizeof(X);\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "( X )");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(8, values.back().intvalue);
@@ -1713,7 +1713,7 @@ class TestValueFlow : public TestFixture {
         code = "struct X { float a; char b; char c; };\n"
                "void f() {\n"
                "    x = sizeof(X);\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "( X )");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(8, values.back().intvalue);
@@ -1722,7 +1722,7 @@ class TestValueFlow : public TestFixture {
                "struct X { A a; char b; };\n"
                "void f() {\n"
                "    x = sizeof(X);\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "( X )");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(12, values.back().intvalue);
@@ -1730,7 +1730,7 @@ class TestValueFlow : public TestFixture {
         code = "struct X { A a; int b; A c; };\n"
                "void f() {\n"
                "    x = sizeof(X);\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "( X )");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(-1, values.back().intvalue);
@@ -1740,7 +1740,7 @@ class TestValueFlow : public TestFixture {
                "void f() {\n"
                "    x = sizeof(X);\n"
                "    subx = sizeof(SubX);\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "( X )");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(1, values.back().intvalue);
@@ -1793,7 +1793,7 @@ class TestValueFlow : public TestFixture {
         code = "void f() {\n"
                "    int a[N + 1];"
                "    x = sizeof(a) / sizeof(a[0]);\n"
-               "}";
+               "}\n";
         values = tokenValues(code,"/");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(-1, values.back().intvalue);
@@ -1810,7 +1810,7 @@ class TestValueFlow : public TestFixture {
                "};\n"
                "int f() {\n"
                "    return sizeof(D);\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "( D )");
         ASSERT_EQUALS(1U, values.size());
         TODO_ASSERT_EQUALS(2 * settings.platform.sizeof_pointer, 1, values.back().intvalue);
@@ -1818,7 +1818,7 @@ class TestValueFlow : public TestFixture {
         code = "int f() {\n" // #11335
                "    int* a[2];"
                "    return sizeof(a);\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "( a");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(2 * settings.platform.sizeof_pointer, values.back().intvalue);
@@ -1878,7 +1878,7 @@ class TestValueFlow : public TestFixture {
                "  int x = y;\n"
                "  a = x;\n"
                "  y += 12;\n"
-               "  if (y == 32) {}"
+               "  if (y == 32) {}\n"
                "}\n";
         ASSERT_EQUALS("2,x is assigned 'y' here.\n"
                       "5,Assuming that condition 'y==32' is not redundant\n"
@@ -1913,45 +1913,45 @@ class TestValueFlow : public TestFixture {
         code = "void f(int x) {\n"
                "    int a = x;\n"
                "    if (x == 123) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 123));
 
         code = "void f(unsigned int x) {\n"
                "    int a = x;\n"
                "    if (x >= 1) {}\n"
-               "}";
+               "}\n";
         TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 2U, 1));
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));
 
         code = "void f(unsigned int x) {\n"
                "    int a = x;\n"
                "    if (x > 0) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));
 
         code = "void f(unsigned int x) {\n"
                "    int a = x;\n"
                "    if (x > 1) {}\n" // not zero => don't consider > condition
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 1));
 
         code = "void f(int x) {\n" // not unsigned => don't consider > condition
                "    int a = x;\n"
                "    if (x > 0) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 0));
 
         code = "void f(int *x) {\n"
                "    *x = 100;\n"
                "    if (x) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));
 
         code = "extern const int x;\n"
                "void f() {\n"
                "    int a = x;\n"
                "    if (x == 123) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
 
         // after loop
@@ -1973,26 +1973,26 @@ class TestValueFlow : public TestFixture {
         code = "void f(int x) {\n"
                "   x = 2 + x;\n"
                "   if (x == 65);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 65));
 
         code = "void f(int x) {\n"
                "   x = y = 2 + x;\n"
                "   if (x == 65);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 65));
 
         code = "void f(int x) {\n"
                "   a[x++] = 0;\n"
                "   if (x == 5);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 5));
 
         code = "void f(int x) {\n"
                "   a = x;\n"
                "   x++;\n"
                "   if (x == 4);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 3));
 
         // compound assignment += , -= , ...
@@ -2000,7 +2000,7 @@ class TestValueFlow : public TestFixture {
                "   a = x;\n"
                "   x += 2;\n"
                "   if (x == 4);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 2));
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 2));
 
@@ -2008,7 +2008,7 @@ class TestValueFlow : public TestFixture {
                "   a = x;\n"
                "   x -= 2;\n"
                "   if (x == 4);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 6));
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 6));
 
@@ -2016,7 +2016,7 @@ class TestValueFlow : public TestFixture {
                "   a = x;\n"
                "   x *= 2;\n"
                "   if (x == 42);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 21));
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 21));
 
@@ -2024,7 +2024,7 @@ class TestValueFlow : public TestFixture {
                "   a = x;\n"
                "   x /= 5;\n"
                "   if (x == 42);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 210));
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 210));
 
@@ -2032,7 +2032,7 @@ class TestValueFlow : public TestFixture {
         bailout("void f(int x) {\n"
                 "    x = y;\n"
                 "    if (x == 123) {}\n"
-                "}");
+                "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:9]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable y [valueFlowBailoutIncompleteVar]\n",
             errout_str());
@@ -2045,7 +2045,7 @@ class TestValueFlow : public TestFixture {
                "    if (!x || \n"  // <- x can be 0
                "        a/x) {}\n" // <- x can't be 0
                "    if (x==0) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
 
@@ -2053,14 +2053,14 @@ class TestValueFlow : public TestFixture {
                "  ((x=ret())&&\n"
                "   (*x==0));\n"  // <- x is not 0
                "  if (x==0) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
 
         code = "void f(int *x) {\n"
                "  int a = (x && *x == '1');\n"
                "  int b = a ? atoi(x) : 0;\n"  // <- x is not 0
                "  if (x==0) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
     }
 
@@ -2071,7 +2071,7 @@ class TestValueFlow : public TestFixture {
                "  a = x;\n"
                "  setx(x);\n"
                "  if (x == 1) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX((std::string("void setx(int x);")+code).c_str(), 2U, 1));
         ASSERT_EQUALS(false, testValueOfX((std::string("void setx(int &x);")+code).c_str(), 2U, 1));
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 1));
@@ -2079,7 +2079,7 @@ class TestValueFlow : public TestFixture {
         code = "void f(char* x) {\n"
                "  strcpy(x,\"abc\");\n"
                "  if (x) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));
 
         code = "void addNewFunction(Scope**scope, const Token**tok);\n"
@@ -2087,14 +2087,14 @@ class TestValueFlow : public TestFixture {
                "  x->functionList.back();\n"
                "  addNewFunction(&x,&tok);\n" // address-of, x can be changed by subfunction
                "  if (x) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
 
         code = "void g(int&);"
                "void f(int x) {\n"
                "   g(x);\n"
                "   if (x == 5);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 5));
     }
 
@@ -2104,25 +2104,25 @@ class TestValueFlow : public TestFixture {
         code = "void f(int x) {\n" // loop condition, x is not assigned inside loop => use condition
                "  a = x;\n"  // x can be 37
                "  while (x == 37) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 37));
 
         code = "void f(int x) {\n" // loop condition, x is assigned inside loop => don't use condition
                "  a = x;\n"  // don't assume that x can be 37
                "  while (x != 37) { x++; }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 37));
 
         code = "void f(int x) {\n"
                "  a = x;\n"
                "  for (; x!=1; x++) { }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 1));
 
         code = "void f(menu *x) {\n"
                "  a = x->parent;\n"
                "  for (i=0;(i<10) && (x!=0); i++) { x = x->next; }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 0));
 
         code = "void f(int x) {\n"  // condition inside loop, x is NOT assigned inside loop => use condition
@@ -2130,7 +2130,7 @@ class TestValueFlow : public TestFixture {
                "    do {\n"
                "        if (x==76) {}\n"
                "    } while (1);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 76));
 
         code = "void f(int x) {\n"  // conditions inside loop, x is assigned inside do-while => don't use condition
@@ -2138,7 +2138,7 @@ class TestValueFlow : public TestFixture {
                "    do {\n"
                "        if (x!=76) { x=do_something(); }\n"
                "    } while (1);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 76));
 
         code = "void f(X x) {\n"  // conditions inside loop, x is assigned inside do-while => don't use condition
@@ -2147,7 +2147,7 @@ class TestValueFlow : public TestFixture {
                "        BUGON(x==0)\n"
                "        x = x.next;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 0));
 
         code = "struct S {\n" // #12848
@@ -2173,7 +2173,7 @@ class TestValueFlow : public TestFixture {
 
         bailout("void f(int x) {\n"
                 "    y = ((x<0) ? x : ((x==2)?3:4));\n"
-                "}");
+                "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:5]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable y [valueFlowBailoutIncompleteVar]\n",
             errout_str());
@@ -2181,26 +2181,26 @@ class TestValueFlow : public TestFixture {
         bailout("int f(int x) {\n"
                 "  int r = x ? 1 / x : 0;\n"
                 "  if (x == 0) {}\n"
-                "}");
+                "}\n");
 
         code = "void f(int x) {\n"
                "    int a =v x;\n"
                "    a = b ? x/2 : 20/x;\n"
                "    if (x == 123) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 123));
 
         code = "void f(const s *x) {\n"
                "  x->a = 0;\n"
                "  if (x ? x->a : 0) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));
 
         code = "void f(int x, int y) {\n"
                "    a = x;\n"
                "    if (y){}\n"
                "    if (x==123){}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 123));
     }
 
@@ -2210,13 +2210,13 @@ class TestValueFlow : public TestFixture {
         code = "void f(int *x) {\n"
                "    sizeof(x[0]);\n"
                "    if (x==63){}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 63));
 
         code = "void f(int *x) {\n"
                "    char a[sizeof x.y];\n"
                "    if (x==0){}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 0));
     }
 
@@ -2229,7 +2229,7 @@ class TestValueFlow : public TestFixture {
                "      (a(x->name, html)) &&\n"
                "      (a(x->name, body))) {}\n"
                "  if (x != NULL) { }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
@@ -2238,7 +2238,7 @@ class TestValueFlow : public TestFixture {
         bailout("void f(int x) {\n"
                 "    if (x != 123) { b = x; }\n"
                 "    if (x == 123) {}\n"
-                "}");
+                "}\n");
         ASSERT_EQUALS(
             "[test.cpp:2:21]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable b [valueFlowBailoutIncompleteVar]\n",
             errout_str());
@@ -2247,14 +2247,14 @@ class TestValueFlow : public TestFixture {
                "  a = x;\n"
                "  if (abc) { x = 1; }\n" // <- condition must be false if x is 7 in next line
                "  if (x == 7) { }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 7));
 
         code = "void f(int x, bool abc) {\n"
                "  a = x;\n"
                "  if (abc) { x = 7; }\n" // <- condition is probably true
                "  if (x == 7) { }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 7));
     }
 
@@ -2266,7 +2266,7 @@ class TestValueFlow : public TestFixture {
                "void f() {\n"
                "    int a = x;\n"
                "    if (x == 123) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code,3,123));
 
         // bailout when there is function call
@@ -2275,7 +2275,7 @@ class TestValueFlow : public TestFixture {
                "    int a = x;\n"
                "    clear();\n"  // <- x might be assigned
                "    if (x == 234) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code,3,234));
     }
 
@@ -2287,7 +2287,7 @@ class TestValueFlow : public TestFixture {
                 "    case 1: a=x; break;\n"
                 "    case 2: if (x==5) {} break;\n"
                 "    };\n"
-                "}");
+                "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:13]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a [valueFlowBailoutIncompleteVar]\n",
             errout_str());
@@ -2297,7 +2297,7 @@ class TestValueFlow : public TestFixture {
                 "    case 1: a=x; return 1;\n"
                 "    case 2: if (x==5) {} break;\n"
                 "    };\n"
-                "}");
+                "}\n");
         ASSERT_EQUALS(
             "[test.cpp:3:13]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a [valueFlowBailoutIncompleteVar]\n",
             errout_str());
@@ -2309,7 +2309,7 @@ class TestValueFlow : public TestFixture {
                 "void f(int x) {\n"
                 "    a = x;\n"
                 "    M;\n"
-                "}");
+                "}\n");
         ASSERT_EQUALS_WITHOUT_LINENUMBERS(
             "[test.cpp:3]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a\n"
             "[test.cpp:4]: (debug) valueflow.cpp:1260:(valueFlow) bailout: variable 'x', condition is defined in macro\n"
@@ -2320,7 +2320,7 @@ class TestValueFlow : public TestFixture {
                 "void f(int *x) {\n"
                 "    a = x;\n"
                 "    FREE(x);\n"
-                "}");
+                "}\n");
         ASSERT_EQUALS_WITHOUT_LINENUMBERS(
             "[test.cpp:3]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a\n"
             "[test.cpp:4]: (debug) valueflow.cpp:1260:(valueFlow) bailout: variable 'x', condition is defined in macro\n"
@@ -2335,7 +2335,7 @@ class TestValueFlow : public TestFixture {
                 "    a=x;\n"   // <- x is not 123
                 "out:"
                 "    if (x==123){}\n"
-                "}");
+                "}\n");
         ASSERT_EQUALS_WITHOUT_LINENUMBERS(
             "[test.cpp:3]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a\n"
             "[test.cpp:2]: (debug) valueflow.cpp::(valueFlow) bailout: valueFlowAfterCondition: bailing in conditional block\n"
@@ -2352,7 +2352,7 @@ class TestValueFlow : public TestFixture {
                 "\n"
                 "out:\n"
                 "    if (abc) {}\n"
-                "}");
+                "}\n");
         ASSERT_EQUALS_WITHOUT_LINENUMBERS(
             "[test.cpp:3]: (debug) valueflow.cpp:6730:(valueFlow) bailout: valueFlowAfterCondition: bailing in conditional block\n"
             "[test.cpp:3]: (debug) valueflow.cpp:6730:(valueFlow) bailout: valueFlowAfterCondition: bailing in conditional block\n", // duplicate
@@ -2366,14 +2366,14 @@ class TestValueFlow : public TestFixture {
                "    int x = a;\n"
                "    if (a == 123) {}\n"
                "    int b = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
 
         code = "void f(int a) {\n"
                "    int x = a;\n"
                "    if (a != 123) {}\n"
                "    int b = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
     }
 
@@ -2407,38 +2407,38 @@ class TestValueFlow : public TestFixture {
         code = "void f() {\n"
                "    int x = 123;\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
 
         code = "void f() {\n"
                "    bool x = 32;\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 1));
 
         code = "void f() {\n"
                "    int x = 123;\n"
                "    a = sizeof(x);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
 
         code = "void f() {\n"
                "    int x = 123;\n"
                "    a = 2 + x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
 
         code = "void f() {\n"
                "    const int x(321);\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 321));
 
         code = "void f() {\n"
                "    int x = 9;\n"
                "    --x;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 9));
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 8));
         ASSERT_EQUALS("2,Assignment 'x=9', assigned value is 9\n"
@@ -2449,54 +2449,54 @@ class TestValueFlow : public TestFixture {
                "    int x = value ? 6 : 0;\n"
                "    x =\n"
                "        1 + x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 7));
 
         code = "void f() {\n"
                "    int x = 0;\n"
                "    y = x += z;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
         code = "void f() {\n"
                "    static int x = 2;\n"
                "    x++;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 2));
 
         code = "void f() {\n"
                "    static int x = 2;\n"
                "    a >> x;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 2));
 
         code = "void f() {\n"
                "    static int x = 0;\n"
                "    if (x==0) x = getX();\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
         // truncation
         code = "int f() {\n"
                "  int x = 1.5;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 1));
 
         code = "int f() {\n"
                "  unsigned char x = 0x123;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0x23));
 
         code = "int f() {\n"
                "  signed char x = 0xfe;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, -2));
 
         // function
@@ -2504,14 +2504,14 @@ class TestValueFlow : public TestFixture {
                "    char *x = 0;\n"
                "    int success = getx((char**)&x);\n"
                "    if (success) x[0] = 0;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
         code = "void f() {\n"
                "    char *x = 0;\n"
                "    getx(reinterpret_cast<void **>(&x));\n"
                "    *x = 0;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
         // lambda
@@ -2549,14 +2549,14 @@ class TestValueFlow : public TestFixture {
                "    int x = 8;\n"
                "    a = ((x > 10) ?\n"
                "        x : 0);\n" // <- x is not 8
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 8));
 
         code = "void f() {\n" // #6973
                "    char *x = \"\";\n"
                "    a = ((x[0] == 'U') ?\n"
                "        x[1] : 0);\n" // <- x is not ""
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, "\"\"", ValueFlow::Value::ValueType::TOK));
 
         code = "void f() {\n" // #6973
@@ -2579,7 +2579,7 @@ class TestValueFlow : public TestFixture {
                "  t *x = 0;\n"
                "  y = (a ? 1 : x\n" // <- x is 0
                "       && x->y ? 1 : 2);" // <- x is not 0
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
@@ -2587,7 +2587,7 @@ class TestValueFlow : public TestFixture {
                "  t *x = 0;\n"
                "  y = (a ? 1 : !x\n" // <- x is 0
                "       || x->y ? 1 : 2);" // <- x is not 0
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
@@ -2596,14 +2596,14 @@ class TestValueFlow : public TestFixture {
                "    int x = 123;\n"
                "    if (condition) return;\n"
                "    a = 2 + x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
 
         code = "void f() {\n"
                "    int x = 1;\n"
                "    if (condition) x = 2;\n"
                "    a = 2 + x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 1));
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 2));
 
@@ -2612,7 +2612,7 @@ class TestValueFlow : public TestFixture {
                "    if (condition1) x = 456;\n"
                "    if (condition2) x = 789;\n"
                "    a = 2 + x;\n" // <- either assignment "x=123" is redundant or x can be 123 here.
-               "}";
+               "}\n";
         TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 5U, 123));
 
         code = "void f(int a) {\n"
@@ -2622,7 +2622,7 @@ class TestValueFlow : public TestFixture {
                "    else\n"
                "        ++x;\n"
                "    return 2 + x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
 
         code = "void f() {\n"
@@ -2630,7 +2630,7 @@ class TestValueFlow : public TestFixture {
                "    if (condition1) x = 2;\n"
                "    else return;\n"
                "    a = 2 + x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 1));
 
         code = "void f(){\n"
@@ -2645,21 +2645,21 @@ class TestValueFlow : public TestFixture {
                "  X *x = getx();\n"
                "  if(0) { x = 0; }\n"
                "  else { x->y = 1; }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
         code = "void f() {\n" // #6239
                "  int x = 4;\n"
                "  if(1) { x = 0; }\n"
                "  a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 4));
 
         code = "void f() {\n"
                "    int x = 32;\n"
                "    if (x>=32) return;\n"
                "    a[x]=0;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 32));
 
         code = "void f() {\n"
@@ -2668,7 +2668,7 @@ class TestValueFlow : public TestFixture {
                "        a[x] = 0;\n"  // <- should have possible value 32
                "        return;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 32));
 
         code = "void f() {\n"
@@ -2676,7 +2676,7 @@ class TestValueFlow : public TestFixture {
                "    if (x==33) goto fail;\n"
                "    a[x]=0;\n"
                "fail:\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 33));
 
         code = "void f() {\n"
@@ -2684,7 +2684,7 @@ class TestValueFlow : public TestFixture {
                "    if (a==1) { z=x+12; }\n"
                "    if (a==2) { z=x+32; }\n"
                "    z = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 32));
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 32));
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 32));
@@ -2695,14 +2695,14 @@ class TestValueFlow : public TestFixture {
                "        x = getx();\n"
                "    }\n"
                "    y = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 6U, 0));
 
         code = "void f(int y) {\n" // alias
                "  int x = y;\n"
                "  if (y == 54) {}\n"
                "  else { a = x; }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 54));
 
         code = "void f () {\n"
@@ -2712,7 +2712,7 @@ class TestValueFlow : public TestFixture {
                "        return 1;\n"
                "    }\n"
                "    a = x->y;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 7U, 0));
 
         code = "void f () {\n"
@@ -2723,7 +2723,7 @@ class TestValueFlow : public TestFixture {
                "    }\n"
                "    a = x->y;\n"
                "label:\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 7U, 0));
 
         code = "void f() {\n" // #5752 - FP
@@ -2731,14 +2731,14 @@ class TestValueFlow : public TestFixture {
                "    if (x && *x == 123) {\n"
                "        getx(*x);\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
         code = "void f() {\n"
                "    int x = 0;\n"
                "    if (!x) {}\n"
                "    else { y = x; }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
         code = "void f() {\n" // #6118 - FP
@@ -2746,7 +2746,7 @@ class TestValueFlow : public TestFixture {
                "    x = x & 0x1;\n"
                "    if (x == 0) { x = 2; }\n"
                "    y = 42 / x;\n" // <- x is 2
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 0));
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 2));
 
@@ -2755,7 +2755,7 @@ class TestValueFlow : public TestFixture {
                "    x = x & 0x1;\n"
                "    if (x == 0) { x += 2; }\n"
                "    y = 42 / x;\n" // <- x is 2
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 0));
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 2));
 
@@ -2768,7 +2768,7 @@ class TestValueFlow : public TestFixture {
                "    if (!x) exit(1);\n"
                "\n"
                "    a = x->a;\n" // <- x can't be 0
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 9U, 0));
 
         code = "void f(int i) {\n"
@@ -2792,14 +2792,14 @@ class TestValueFlow : public TestFixture {
         code = "void f(int a) {\n"
                "    int x = a;\n"
                "    if (a!=132) { b = x; }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 132));
 
         code = "void f(int a) {\n"
                "    int x = a;\n"
                "    b = x;\n" // <- line 3
                "    if (a!=132) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 132));
 
         code = "void f() {\n"
@@ -2808,7 +2808,7 @@ class TestValueFlow : public TestFixture {
                "    else { a = 0; }\n"
                "    int x = a;\n"
                "    if (a > 0) { a = b / x; }\n" // <- line 6
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 6U, 0)); // x is not 0 at line 6
 
         code = "void f(int x1) {\n" // #6086
@@ -2817,7 +2817,7 @@ class TestValueFlow : public TestFixture {
                "    return;\n"
                "  }\n"
                "  a = x;\n"  // <- x is not 3
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 6U, 3));
 
         code = "int f(int *x) {\n" // #5980
@@ -2828,13 +2828,13 @@ class TestValueFlow : public TestFixture {
                "    };\n"
                "  }\n"
                "  return *x;\n"  // <- x is not 0
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 8U, 0));
 
         code = "void f(int a) {\n" // #6826
                "    int x = a ? a : 87;\n"
                "    if (a && x) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 87));
 
         code = "void f() {\n"
@@ -2843,7 +2843,7 @@ class TestValueFlow : public TestFixture {
                "    if (first >= 0) { a = x; }\n" // <- x is not 0
                "    first++; x=3;\n"
                "  } while (1);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 3));
 
@@ -2855,7 +2855,7 @@ class TestValueFlow : public TestFixture {
                "    *px = 1;\n"
                "  }\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 7U, 2));
 
         code = "int f(void) {\n"
@@ -2865,7 +2865,7 @@ class TestValueFlow : public TestFixture {
                "    rx = 1;\n"
                "  }\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 7U, 5));
 
         // break
@@ -2888,7 +2888,7 @@ class TestValueFlow : public TestFixture {
                "    case B: x = 34; break;\n"
                "  }\n"
                "  v = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 7U, 12));
         ASSERT_EQUALS(true, testValueOfX(code, 7U, 34));
 
@@ -2901,7 +2901,7 @@ class TestValueFlow : public TestFixture {
                "  switch (ab) {\n"
                "    case A: v = x; break;\n" // <- x is not 34
                "  }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 8U, 34));
 
         // while/for
@@ -3136,7 +3136,7 @@ class TestValueFlow : public TestFixture {
                "  if (y)\n"
                "    x = 10;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 10));
 
         code = "namespace A { int x; }\n"
@@ -3144,7 +3144,7 @@ class TestValueFlow : public TestFixture {
                "  if (y)\n"
                "    A::x = 10;\n"
                "  return A::x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 10));
 
         // member variable
@@ -3155,7 +3155,7 @@ class TestValueFlow : public TestFixture {
                "      x = 10;\n"
                "    return x;\n"
                "  }\n"
-               "};";
+               "};\n";
         ASSERT_EQUALS(true, testValueOfX(code, 6U, 10));
 
         code = "void f(int i) {\n"
@@ -3179,21 +3179,21 @@ class TestValueFlow : public TestFixture {
                "    constexpr int x(123);\n"
                "    constexpr int y(x*x);\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 123));
 
         code = "void f() {\n"
                "    static const int x(123);\n"
                "    static const int y(x*x);\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 123));
 
         code = "void f() {\n"
                "    static int x(123);\n"
                "    static int y(x*x);\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
 
         code = "bool f() {\n" // #13208
@@ -3269,7 +3269,7 @@ class TestValueFlow : public TestFixture {
                "    std::swap(a, b);\n"
                "    int x = a;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfXKnown(code, 6U, 2));
         ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, 1));
 
@@ -3279,7 +3279,7 @@ class TestValueFlow : public TestFixture {
                "    std::swap(a, b);\n"
                "    int x = b;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfXKnown(code, 6U, 1));
         ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, 2));
 
@@ -3311,21 +3311,21 @@ class TestValueFlow : public TestFixture {
                "    if (x == 123) {\n"
                "        a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
 
         code = "void f(int x) {\n"
                "    if (x != 123) {\n"
                "        a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
 
         code = "void f(int x) {\n"
                "    if (x > 123) {\n"
                "        a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 124));
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
 
@@ -3333,7 +3333,7 @@ class TestValueFlow : public TestFixture {
                "    if (x < 123) {\n"
                "        a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 122));
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
 
@@ -3343,7 +3343,7 @@ class TestValueFlow : public TestFixture {
                "    if (123 < x) {\n"
                "        a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 124));
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
 
@@ -3351,7 +3351,7 @@ class TestValueFlow : public TestFixture {
                "    if (123 > x) {\n"
                "        a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 122));
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
 
@@ -3359,13 +3359,13 @@ class TestValueFlow : public TestFixture {
         code = "void f(int x) {\n"
                "    if (x == 123) {}\n"
                "    else a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
 
         code = "void f(int x) {\n"
                "    if (x != 123) {}\n"
                "    else a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
 
         // after if
@@ -3374,7 +3374,7 @@ class TestValueFlow : public TestFixture {
                "        x++;\n"
                "    }\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 10));
         TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 5U, 11));
 
@@ -3382,78 +3382,78 @@ class TestValueFlow : public TestFixture {
         code = "void f(int x) {\n"
                "    if (!x) { a = x; }\n"
                "    else a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));
 
         code = "void f(int x, int y) {\n"
                "    if (!(x&&y)) { return; }\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
 
         code = "void f(int x) {\n"
                "    if (!x) { { throw new string(); }; }\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
 
         code = "void f(int x) {\n"
                "    if (x != 123) { throw " "; }\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
 
         code = "void f(int x) {\n"
                "    if (x != 123) { }\n"
                "    else { throw " "; }\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 123));
         code = "void f(int x) {\n"
                "    if (x == 123) { }\n"
                "    else { throw " "; }\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
 
 
         code = "void f(int x) {\n"
                "    if (x < 123) { }\n"
                "    else { a = x; }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
 
         code = "void f(int x) {\n"
                "    if (x < 123) { throw \"\"; }\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
 
         code = "void f(int x) {\n"
                "    if (x < 123) { }\n"
                "    else { throw \"\"; }\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 122));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 123));
 
         code = "void f(int x) {\n"
                "    if (x > 123) { }\n"
                "    else { a = x; }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
 
         code = "void f(int x) {\n"
                "    if (x > 123) { throw \"\"; }\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
 
         code = "void f(int x) {\n"
                "    if (x > 123) { }\n"
                "    else { throw \"\"; }\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 124));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 123));
 
@@ -3461,7 +3461,7 @@ class TestValueFlow : public TestFixture {
                "    if (x < 123) { return; }\n"
                "    else { return; }\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 124));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 123));
 
@@ -3470,7 +3470,7 @@ class TestValueFlow : public TestFixture {
                "    if (x) { a = x; }\n"  // <- x is not 0
                "    else { b = x; }\n"    // <- x is 0
                "    c = x;\n"             // <- x might be 0
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 0));
         ASSERT_EQUALS(true,  testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(true,  testValueOfX(code, 4U, 0));
@@ -3479,32 +3479,32 @@ class TestValueFlow : public TestFixture {
         code = "void f(int x) {\n"
                "    while (x != 3) {}\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 3));
 
         code = "void f(int x) {\n"
                "    while (11 != (x = dostuff())) {}\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 11));
 
         code = "void f(int x) {\n"
                "    while (11 != (x = dostuff()) && y) {}\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 11));
 
         code = "void f(int x) {\n"
                "    while (x = dostuff()) {}\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
 
         code = "void f(const Token *x) {\n" // #5866
                "    x = x->next();\n"
                "    while (x) { x = x->next(); }\n"
                "    if (x->str()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 0));
 
         code = "void f(const Token *x) {\n"
@@ -3528,7 +3528,7 @@ class TestValueFlow : public TestFixture {
                "    a = x;\n"  // <- TODO, x can be 2
                "  else\n"
                "    b = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 2));
         ASSERT_EQUALS(false, testValueOfX(code, 6U, 2));
 
@@ -3538,7 +3538,7 @@ class TestValueFlow : public TestFixture {
                "  if (x == 7) { y = 1; }\n"
                "  if (!y)\n"
                "    a = x;\n" // <- x can not be 7 here
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 7));
 
         code = "void f(struct X *x) {\n"
@@ -3555,13 +3555,13 @@ class TestValueFlow : public TestFixture {
         code = "void f(int x) {\n"
                "  a = (x != 3 ||\n"
                "       x);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 3));
 
         code = "void f(int x) {\n"
                "  a = (x == 4 &&\n"
                "       x);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 4));
 
         // protected usage with &&
@@ -3569,7 +3569,7 @@ class TestValueFlow : public TestFixture {
                "    if (x) {}\n"
                "    for (; x &&\n"
                "         x->str() != y; x = x->next()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
@@ -3577,7 +3577,7 @@ class TestValueFlow : public TestFixture {
                "    if (x) {}\n"
                "    if (x &&\n"
                "        x->str() != y) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
@@ -3587,7 +3587,7 @@ class TestValueFlow : public TestFixture {
                "    if (z) return; else return;\n"
                "  }\n"
                "  a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 5));
 
         code = "void f(int x) {\n" // #6730
@@ -3595,14 +3595,14 @@ class TestValueFlow : public TestFixture {
                "    if (z) continue; else throw e;\n"
                "  }\n"
                "  a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 5));
 
         // TODO: float
         code = "void f(float x) {\n"
                "  if (x == 0.5) {}\n"
                "  a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
 
         // aliased variable
@@ -3613,7 +3613,7 @@ class TestValueFlow : public TestFixture {
                "    calc(data);\n"
                "    a = x;\n"  // <- x might be changed by calc
                "  }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 6U, 0));
 
         code = "int* g();\n"
@@ -3630,15 +3630,15 @@ class TestValueFlow : public TestFixture {
         code = "void foo(const volatile int &x) {\n"
                "    if (x==1) {\n"
                "        return x;\n"
-               "    }"
-               "}";
+               "    }\n"
+               "}\n";
         ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, 1));
 
         code = "void foo(const std::atomic<int> &x) {\n"
                "    if (x==2) {\n"
                "        return x;\n"
-               "    }"
-               "}";
+               "    }\n"
+               "}\n";
         ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, 2));
 
         code = "int f(int i, int j) {\n"
@@ -3973,7 +3973,7 @@ class TestValueFlow : public TestFixture {
                "        int x = p[0];\n"
                "        int a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
 
         code = "void f(int y) {\n"
@@ -3981,7 +3981,7 @@ class TestValueFlow : public TestFixture {
                "        int x = y+1;\n"
                "        int a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
 
         code = "void f(int y) {\n"
@@ -3989,7 +3989,7 @@ class TestValueFlow : public TestFixture {
                "        int x = y+2;\n"
                "        int a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 124));
 
         code = "void f(int y, int z) {\n"
@@ -3997,7 +3997,7 @@ class TestValueFlow : public TestFixture {
                "        int x = y+z;\n"
                "        int a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
 
         code = "void f(int y, int z) {\n"
@@ -4006,7 +4006,7 @@ class TestValueFlow : public TestFixture {
                "        int x = y+z;\n"
                "        int a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 123));
 
         code = "void f(int y) {\n"
@@ -4014,7 +4014,7 @@ class TestValueFlow : public TestFixture {
                "        int x = y++;\n"
                "        int a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 123));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 124));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 125));
@@ -4069,28 +4069,28 @@ class TestValueFlow : public TestFixture {
         code = "int f(int x, int y) {\n"
                "    if (x!=0) {}\n"
                "      return y/x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
 
         code = "int f(int x, int y) {\n"
                "    if (!!(x != 0)) {\n"
                "      return y/x;\n"
                "}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
 
         code = "int f(int x, int y) {\n"
                "    if (!!!(x != 0)) {\n"
                "      return y/x;\n"
                "}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
 
         code = "int f(int x, int y) {\n"
                "    if (!!!!(x != 0)) {\n"
                "      return y/x;\n"
                "}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
     }
 
@@ -4101,7 +4101,7 @@ class TestValueFlow : public TestFixture {
                "    int x = 123;\n"
                "    x += 43;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 166));
         ASSERT_EQUALS("2,Assignment 'x=123', assigned value is 123\n"
                       "3,Compound assignment '+=', assigned value is 166\n",
@@ -4111,35 +4111,35 @@ class TestValueFlow : public TestFixture {
                "    int x = 123;\n"
                "    x /= 0;\n" // don't crash when evaluating x/=0
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 123));
 
         code = "float f() {\n"
                "    float x = 123.45f;\n"
                "    x += 67;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, static_cast<double>(123.45f) + 67, 0.01));
 
         code = "double f() {\n"
                "    double x = 123.45;\n"
                "    x += 67;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 123.45 + 67, 0.01));
 
         code = "void f() {\n"
                "    int x = 123;\n"
                "    x >>= 1;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 61));
 
         code = "int f() {\n"
                "    int x = 123;\n"
                "    x <<= 1;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 246));
 
         code = "int64_t f() {\n"
@@ -4147,7 +4147,7 @@ class TestValueFlow : public TestFixture {
                "    int64_t x = val;\n"
                "    x += val;\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 1LL << 34));
     }
 
@@ -4158,7 +4158,7 @@ class TestValueFlow : public TestFixture {
                "  bool zero(x==0);\n"
                "  if (zero) a = x;\n"  // <- x is 0
                "  else b = x;\n"  // <- x is not 0
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
@@ -4184,7 +4184,7 @@ class TestValueFlow : public TestFixture {
                "  int x = 0;\n"
                "  if (b) x = 1;\n"
                "  else b = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 0));
 
         code = "void f(int i) {\n"
@@ -4209,7 +4209,7 @@ class TestValueFlow : public TestFixture {
                "  int x=1;\n"
                "  C c(x);\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 8U, 1));
 
         code = "class C {\n"
@@ -4220,7 +4220,7 @@ class TestValueFlow : public TestFixture {
                "  int x=1;\n"
                "  C c(x);\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 8U, 1));
 
         code = "int f(int *);\n"
@@ -4229,7 +4229,7 @@ class TestValueFlow : public TestFixture {
                "  int x = 11;\n"
                "  c = (a && f(&x));\n"
                "  if (x == 42) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 6U, 11));
 
         code = "void f() {\n"
@@ -4252,21 +4252,21 @@ class TestValueFlow : public TestFixture {
                "  int x=5;\n"
                "  a = b ? init1(&x) : init2(&x);\n"
                "  return 1 + x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 5));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 5));
 
         code = "int f(int *p) {\n" // #9008 - gcc ternary ?:
                "  if (p) return;\n"
                "  x = *p ? : 1;\n" // <- no explicit expr0
-               "}";
+               "}\n";
         (void)testValueOfX(code, 1U, 0); // do not crash
 
         code = "void f(int a) {\n" // #8784
                "    int x = 13;\n"
                "    if (a == 1) x = 26;\n"
                "    return a == 1 ? x : 0;\n"  // <- x is 26
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 13));
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 26));
 
@@ -4296,7 +4296,7 @@ class TestValueFlow : public TestFixture {
                "  auto f = [&](){ a=x; }\n"  // x is not 1
                "  x = 2;\n"
                "  f();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 1));
         TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 3U, 2));
 
@@ -4304,7 +4304,7 @@ class TestValueFlow : public TestFixture {
                "  int x=3;\n"
                "  auto f = [&](){ a=x; }\n"  // todo: x is 3
                "  f();\n"
-               "}";
+               "}\n";
         TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 3U, 3));
 
         code = "void f() {\n"
@@ -4313,7 +4313,7 @@ class TestValueFlow : public TestFixture {
                "  x = 1;\n"
                "  f();\n"
                "  int a = x;\n" // x is actually 2
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 6U, 1));
         ASSERT_EQUALS(false, testValueOfX(code, 6U, 3));
     }
@@ -4358,21 +4358,21 @@ class TestValueFlow : public TestFixture {
         code = "int f(int a) {\n"
                "  int x = a & 0x80;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code,3U,0));
         ASSERT_EQUALS(true, testValueOfX(code,3U,0x80));
 
         code = "int f(int a) {\n"
                "  int x = a & 0x80 ? 1 : 2;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code,3U,0));
         ASSERT_EQUALS(false, testValueOfX(code,3U,0x80));
 
         code = "int f() {\n"
                "  int x = (19 - 3) & 15;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code,3U,0));
         ASSERT_EQUALS(false, testValueOfX(code,3U,16));
     }
@@ -4506,73 +4506,73 @@ class TestValueFlow : public TestFixture {
         code = "int f(int a) {\n"
                "  int x = (a & 0xff) >> 16;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code,3U,0,&s));
 
         code = "int f(unsigned int a) {\n"
                "  int x = (a % 123) >> 16;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code,3U,0,&s));
 
         code = "int f(int y) {\n"
                "  int x = (y & 0xFFFFFFF) >> 31;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3u, 0));
 
         code = "int f(int y) {\n"
                "  int x = (y & 0xFFFFFFF) >> 32;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(short y) {\n"
                "  int x = (y & 0xFFFFFF) >> 31;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(short y) {\n"
                "  int x = (y & 0xFFFFFF) >> 32;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(long y) {\n"
                "  int x = (y & 0xFFFFFF) >> 63;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(long y) {\n"
                "  int x = (y & 0xFFFFFF) >> 64;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(long long y) {\n"
                "  int x = (y & 0xFFFFFF) >> 63;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(long long y) {\n"
                "  int x = (y & 0xFFFFFF) >> 64;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(long long y) {\n"
                "  int x = (y & 0xFFFFFF) >> 121;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(long long y) {\n"
                "  int x = (y & 0xFFFFFF) >> 128;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3u, 0,&s));
     }
 
@@ -4584,7 +4584,7 @@ class TestValueFlow : public TestFixture {
                "  struct Foo foo;\n"
                "  foo.x = 1;\n"
                "  x = 0 + foo.x;\n" // <- foo.x is 1
-               "}";
+               "}\n";
         values = removeSymbolicTok(tokenValues(code, "+"));
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(true, values.front().isKnown());
@@ -4597,7 +4597,7 @@ class TestValueFlow : public TestFixture {
                "  int y = 10;\n"
                "  while (s.x < y)\n" // s.x does not have known value
                "    s.x++;\n"
-               "}";
+               "}\n";
         values = removeImpossible(tokenValues(code, "<"));
         ASSERT_EQUALS(1, values.size());
         ASSERT(values.front().isPossible());
@@ -4609,7 +4609,7 @@ class TestValueFlow : public TestFixture {
                "  int y = 10;\n"
                "  while (s.x < y)\n" // s.x has a known value
                "    y--;\n"
-               "}";
+               "}\n";
         values = tokenValues(code, ". x <");
         ASSERT(values.size() == 1 &&
                values.front().isKnown() &&
@@ -4622,7 +4622,7 @@ class TestValueFlow : public TestFixture {
                "  if (foo)\n"
                "    hints.x = 2;\n"
                "  x = 0 + foo.x;\n" // <- foo.x is possible 1, possible 2
-               "}";
+               "}\n";
         values = removeSymbolicTok(tokenValues(code, "+"));
         TODO_ASSERT_EQUALS(2U, 0U, values.size()); // should be 2
 
@@ -4637,7 +4637,7 @@ class TestValueFlow : public TestFixture {
                "  }\n"
                "  if (*b > 0) {\n" // *b does not have known value
                "  }\n"
-               "}";
+               "}\n";
         values = removeImpossible(tokenValues(code, ">"));
         ASSERT_EQUALS(1, values.size());
         ASSERT(values.front().isPossible());
@@ -4650,7 +4650,7 @@ class TestValueFlow : public TestFixture {
                "        if (pvd.descr_type == 0xff) {}\n"
                "        dostuff(&pvd);\n"
                "    } while (condition);\n"
-               "}";
+               "}\n";
         values = removeImpossible(tokenValues(code, "=="));
         ASSERT_EQUALS(1, values.size());
         ASSERT(values.front().isPossible());
@@ -4660,7 +4660,7 @@ class TestValueFlow : public TestFixture {
         code = "struct S { int x; };\n" // #9036
                "void foo(struct S s) {\n"
                "    for (s.x = 0; s.x < 127; s.x++) {}\n"
-               "}";
+               "}\n";
         values = removeImpossible(tokenValues(code, "<"));
         values.remove_if([&](const ValueFlow::Value& v) {
             return !v.isKnown();
@@ -4675,7 +4675,7 @@ class TestValueFlow : public TestFixture {
                             "    case 14: a=x+2; break;\n"  // <- x is 14
                             "    };\n"
                             "    a = x;\n"  // <- x can be 14
-                            "}";
+                            "}\n";
         ASSERT_EQUALS(true, testConditionalValueOfX(code, 2U, 14));
         TODO_ASSERT_EQUALS(true, false, testConditionalValueOfX(code, 4U, 14));
         TODO_ASSERT_EQUALS(true, false, testConditionalValueOfX(code, 6U, 14));
@@ -4696,7 +4696,7 @@ class TestValueFlow : public TestFixture {
         code = "void f() {\n"
                "    for (int x = 0; x < 10; x++)\n"
                "        a[x] = 0;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 9));
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 10));
@@ -4706,7 +4706,7 @@ class TestValueFlow : public TestFixture {
                "    for (x = 2; x < 1; x++)\n"
                "        a[x] = 0;\n" // <- not 2
                "    b = x;\n" // 2
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 2));
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 2));
 
@@ -4715,7 +4715,7 @@ class TestValueFlow : public TestFixture {
                "    for (x = 2; x < 1; ++x)\n"
                "        a[x] = 0;\n" // <- not 2
                "    b = x;\n" // 2
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 2));
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 2));
 
@@ -4724,26 +4724,26 @@ class TestValueFlow : public TestFixture {
                "    int x;\n"
                "    for (x = 1; x < B; ++x)\n"
                "        a[x] = 0;\n" // <- not 1
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 1));
 
         code = "void f(int a) {\n"
                "    for (int x = a; x < 10; x++)\n"
                "        a[x] = 0;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 9));
 
         code = "void f() {\n"
                "    for (int x = 0; x < 5; x += 2)\n"
                "        a[x] = 0;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 4));
 
         code = "void f() {\n"
                "    for (int x = 0; x < 10; x = x + 2)\n"
                "        a[x] = 0;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 8));
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 10));
@@ -4751,14 +4751,14 @@ class TestValueFlow : public TestFixture {
         code = "void f() {\n"
                "    for (int x = 0; x < 10; x = x / 0)\n"
                "        a[x] = 0;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0)); // don't crash
 
         code = "void f() {\n"
                "    for (int x = 0; x < 10; x++)\n"
                "        x<4 ?\n"
                "        a[x] : 0;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 9));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 9));
@@ -4767,13 +4767,13 @@ class TestValueFlow : public TestFixture {
                "    for (int x = 0; x < 10; x++)\n"
                "        x==0 ?\n"
                "        0 : a[x];\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
         code = "void f() {\n" // #5223
                "    for (int x = 0; x < 300 && x < 18; x++)\n"
                "        x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 17));
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 299));
@@ -4782,7 +4782,7 @@ class TestValueFlow : public TestFixture {
                "    int x;\n"
                "    for (int i = 0; x = bar[i]; i++)\n"
                "        x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
         code = "void f() {\n"
@@ -4790,28 +4790,28 @@ class TestValueFlow : public TestFixture {
                "    int x;\n"
                "    for (x = 0; abc[x] != '\\0'; x++) {}\n"
                "    a[x] = 0;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 3));
 
         code = "void f() {\n" // #5939
                "    int x;\n"
                "    for (int x = 0; (x = do_something()) != 0;)\n"
                "        x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
         code = "void f() {\n"
                "    int x;\n"
                "    for (int x = 0; x < 10 && y = do_something();)\n"
                "        x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 0));
 
         code = "void f() {\n"
                "    int x,y;\n"
                "    for (x = 0, y = 0; x < 10, y < 10; x++, y++)\n" // usage of ,
                "        x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 0));
 
         code = "void foo(double recoveredX) {\n"
@@ -4837,7 +4837,7 @@ class TestValueFlow : public TestFixture {
         code = "void foo() {\n"
                "  for (int x = 0; x < 10; x++) {\n"
                "    if (x > 1\n"
-               "        && x) {}" // <- x is not 0
+               "        && x) {}\n" // <- x is not 0
                "  }\n"
                "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
@@ -4847,7 +4847,7 @@ class TestValueFlow : public TestFixture {
         code = "void foo() {\n"
                "  for (int x = 0; x < 10; x++) {\n"
                "    if (x < value\n"
-               "        && x) {}" // <- maybe x is not 9
+               "        && x) {}\n" // <- maybe x is not 9
                "  }\n"
                "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 9));
@@ -4856,7 +4856,7 @@ class TestValueFlow : public TestFixture {
         code = "void foo() {\n"
                "  for (int x = 0; x < 10; x++) {\n"
                "    if (x == 0\n"
-               "        || x) {}" // <- x is not 0
+               "        || x) {}\n" // <- x is not 0
                "  }\n"
                "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
@@ -4892,7 +4892,7 @@ class TestValueFlow : public TestFixture {
                "    abort();\n"
                "  }\n"
                "  a = x;\n" // <- x can't be 5
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 7U, 5));
 
         code = "void f() {\n"
@@ -4901,7 +4901,7 @@ class TestValueFlow : public TestFixture {
                "  if (x < 5) {}\n"
                "  else return;\n"
                "  a = x;\n" // <- x can't be 5
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 6U, 5));
 
         // assert after for loop..
@@ -4921,7 +4921,7 @@ class TestValueFlow : public TestFixture {
         code = "void f() {\n"
                "  for(int i = 0; i < 20; i++)\n"
                "    n = (int)(i < 10 || abs(negWander) < abs(negTravel));\n"
-               "}";
+               "}\n";
         (void)testValueOfX(code,0,0); // <- don't hang
 
         // crash (daca@home)
@@ -4934,7 +4934,7 @@ class TestValueFlow : public TestFixture {
                "            if (z[n] && strncmp(&z[n+i], \"-->\", 3) == 0) ;\n"
                "        }\n"
                "    }\n"
-               "}";
+               "}\n";
         (void)testValueOfX(code,0,0); // <- don't crash
 
         // conditional code in loop
@@ -4946,7 +4946,7 @@ class TestValueFlow : public TestFixture {
                "      else { a = x; }\n" // <- x is not 10
                "    }\n"
                "  }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 6U, 10));
 
         // #7886 - valueFlowForLoop must be called after valueFlowAfterAssign
@@ -4955,14 +4955,14 @@ class TestValueFlow : public TestFixture {
                "  int x,y;\n"
                "  for(x=0,y=0; x < sz && y < 10; x++)\n"
                "    a = x;\n" // <- max value is 3
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 3));
 
         code = "void f() {\n"
                "    int x;\n"
                "    for (x = 0; x < 10; x++)\n"
                "        x;\n"
-               "}";
+               "}\n";
         std::list<ValueFlow::Value> values = tokenValues(code, "x <");
         ASSERT(std::none_of(values.cbegin(), values.cend(), std::mem_fn(&ValueFlow::Value::isUninitValue)));
 
@@ -5158,7 +5158,7 @@ class TestValueFlow : public TestFixture {
                "}\n"
                "void g(){\n"
                "    f(42);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 17));
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 42));
         ASSERT_EQUALS(true, testValueOfX(code, 7U, 0));
@@ -5276,7 +5276,7 @@ class TestValueFlow : public TestFixture {
                "}\n"
                "void f2() {\n"
                "    x = 10 - f1(2);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(7, valueOfTok(code, "-").intvalue);
         ASSERT_EQUALS(true, valueOfTok(code, "-").isKnown());
 
@@ -5285,12 +5285,12 @@ class TestValueFlow : public TestFixture {
                "}\n"
                "void f2() {\n"
                "    x = 2 * add(10+1,4);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(30, valueOfTok(code, "*").intvalue);
         ASSERT_EQUALS(true, valueOfTok(code, "*").isKnown());
 
         code = "int one() { return 1; }\n"
-               "void f() { x = 2 * one(); }";
+               "void f() { x = 2 * one(); }\n";
         ASSERT_EQUALS(2, valueOfTok(code, "*").intvalue);
         ASSERT_EQUALS(true, valueOfTok(code, "*").isKnown());
 
@@ -5299,7 +5299,7 @@ class TestValueFlow : public TestFixture {
                "}\n"
                "void f2() {\n"
                "    x = 2 * add(1,add(2,3));\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(12, valueOfTok(code, "*").intvalue);
         ASSERT_EQUALS(true, valueOfTok(code, "*").isKnown());
 
@@ -5308,7 +5308,7 @@ class TestValueFlow : public TestFixture {
                "        return g(std::move(x));\n"
                "    g(x);\n"
                "    return 0;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, ValueFlow::Value::MoveKind::MovedVariable));
 
         code = "class A\n"
@@ -5319,7 +5319,7 @@ class TestValueFlow : public TestFixture {
                "    void f2() {\n"
                "        x = 10 - f1(2);\n"
                "    }\n"
-               "};";
+               "};\n";
         ASSERT_EQUALS(7, valueOfTok(code, "-").intvalue);
         ASSERT_EQUALS(true, valueOfTok(code, "-").isKnown());
 
@@ -5331,7 +5331,7 @@ class TestValueFlow : public TestFixture {
                "    void f2() {\n"
                "        x = 10 - f1(2);\n"
                "    }\n"
-               "};";
+               "};\n";
         TODO_ASSERT_EQUALS(7, 0, valueOfTok(code, "-").intvalue);
         ASSERT_EQUALS(false, valueOfTok(code, "-").isKnown());
 
@@ -5463,13 +5463,13 @@ class TestValueFlow : public TestFixture {
 
         code = "class continuous_src_time {\n"
                "    continuous_src_time(std::complex<double> f, double st = 0.0, double et = infinity) {}\n"
-               "};";
+               "};\n";
         (void)testValueOfX(code, 2U, 2); // Don't crash (#6494)
 
         code = "struct S {\n" // #14693
                "    int i;\n"
                "    explicit S(std::string&& s = {}) : i(0) {}\n"
-               "};";
+               "};\n";
         ASSERT_EQUALS(false, testKnownValueOfTok(code, "{ } )", 0));
     }
 
@@ -5484,13 +5484,13 @@ class TestValueFlow : public TestFixture {
         const char *code;
         ValueFlow::Value value;
 
-        ASSERT(valueOfTok("x = 1;", "1").isKnown());
+        ASSERT(valueOfTok("x = 1;\n", "1").isKnown());
 
         // after assignment
         code = "void f() {\n"
                "  int x = 1;\n"
                "  return x + 2;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "+");
         ASSERT_EQUALS(3, value.intvalue);
         ASSERT(value.isKnown());
@@ -5499,7 +5499,7 @@ class TestValueFlow : public TestFixture {
             code = "void f() {\n"
                    "  int x = 15;\n"
                    "  if (x == 15) { x += 7; }\n" // <- condition is true
-                   "}";
+                   "}\n";
             value = valueOfTok(code, "==");
             ASSERT_EQUALS(1, value.intvalue);
             ASSERT(value.isKnown());
@@ -5519,7 +5519,7 @@ class TestValueFlow : public TestFixture {
                "  int x;\n"
                "  if (ab) { x = 7; }\n"
                "  return x + 2;\n" // <- possible value
-               "}";
+               "}\n";
         value = valueOfTok(code, "+");
         ASSERT_EQUALS(9, value.intvalue);
         ASSERT(value.isPossible());
@@ -5528,7 +5528,7 @@ class TestValueFlow : public TestFixture {
                "  int x = 0;\n"
                "  if (c) {} else { x++; }\n"
                "  return x + 2;\n" // <- possible value
-               "}";
+               "}\n";
         ASSERT(isNotKnownValues(code, "+"));
 
         code = "void f() {\n"
@@ -5603,7 +5603,7 @@ class TestValueFlow : public TestFixture {
                "    a = x+2;\n"
                "    dostuff();\n"
                "  }\n"
-               "}";
+               "}\n";
         ASSERT(isNotKnownValues(code, "+"));
 
         code = "void f() {\n"
@@ -5629,7 +5629,7 @@ class TestValueFlow : public TestFixture {
                "    }\n"
                "  }\n"
                "  if (!x) {}\n"  // <- possible value
-               "}";
+               "}\n";
         ASSERT(isNotKnownValues(code, "!"));
 
         code = "void f() {\n" // #8356
@@ -5637,7 +5637,7 @@ class TestValueFlow : public TestFixture {
                "  for(int x = 3; !b && x < 10; x++) {\n" // <- b has known value
                "    for(int y = 4; !b && y < 20; y++) {}\n"
                "  }\n"
-               "}";
+               "}\n";
         value = valueOfTok(code, "!");
         ASSERT_EQUALS(1, value.intvalue);
         ASSERT(value.isKnown());
@@ -5650,7 +5650,7 @@ class TestValueFlow : public TestFixture {
                "    break;\n"
                "  }\n"
                "  if (!x) {}\n"  // <- possible value
-               "}";
+               "}\n";
         ASSERT(isNotKnownValues(code, "!"));
 
         code = "void f() {\n" // #7049
@@ -5661,7 +5661,7 @@ class TestValueFlow : public TestFixture {
                "  case 2:\n"
                "    if (!x) {}\n" // <- possible value
                "  }\n"
-               "}";
+               "}\n";
         ASSERT(isNotKnownValues(code, "!"));
 
         code = "void f() {\n"
@@ -5669,7 +5669,7 @@ class TestValueFlow : public TestFixture {
                "  while (!x) {\n" // <- possible value
                "    scanf(\"%d\", &x);\n"
                "  }\n"
-               "}";
+               "}\n";
         value = valueOfTok(code, "!");
         ASSERT_EQUALS(1, value.intvalue);
         ASSERT(value.isPossible());
@@ -5677,7 +5677,7 @@ class TestValueFlow : public TestFixture {
         code = "void f() {\n"
                "  int x = 0;\n"
                "  do { } while (++x < 12);\n" // <- possible value
-               "}";
+               "}\n";
         ASSERT(isNotKnownValues(code, "<"));
 
         code = "void f() {\n"
@@ -5692,7 +5692,7 @@ class TestValueFlow : public TestFixture {
                "  int x = 0;\n"
                "a:\n"
                "  a = x + 1;\n" // <- possible value
-               "}";
+               "}\n";
         value = valueOfTok(code, "+");
         ASSERT_EQUALS(1, value.intvalue);
         ASSERT(value.isPossible());
@@ -5702,7 +5702,7 @@ class TestValueFlow : public TestFixture {
                "  if (!x) {\n"
                "    a = x+1;\n" // <- known value
                "  }\n"
-               "}";
+               "}\n";
         value = valueOfTok(code, "+");
         ASSERT_EQUALS(1, value.intvalue);
         ASSERT(value.isKnown());
@@ -5711,7 +5711,7 @@ class TestValueFlow : public TestFixture {
                "  if (a && 4==x && y) {\n"
                "    a = x+12;\n" // <- known value
                "  }\n"
-               "}";
+               "}\n";
         value = valueOfTok(code, "+");
         ASSERT_EQUALS(16, value.intvalue);
         ASSERT(value.isKnown());
@@ -5720,7 +5720,7 @@ class TestValueFlow : public TestFixture {
         code = "int f(int x) {\n"
                "  if (x == 4) {}\n"
                "  return x + 1;\n" // <- possible value
-               "}";
+               "}\n";
         value = valueOfTok(code, "+");
         ASSERT_EQUALS(5, value.intvalue);
         ASSERT(value.isPossible());
@@ -5728,7 +5728,7 @@ class TestValueFlow : public TestFixture {
         code = "int f(int x) {\n"
                "  if (x < 2) {}\n"
                "  else if (x >= 2) {}\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, ">=");
         ASSERT_EQUALS(1, value.intvalue);
         ASSERT(value.isKnown());
@@ -5736,7 +5736,7 @@ class TestValueFlow : public TestFixture {
         code = "int f(int x) {\n"
                "  if (x < 2) {}\n"
                "  else if (x > 2) {}\n" // <- possible value
-               "}";
+               "}\n";
         ASSERT(isNotKnownValues(code, ">"));
 
         // known and possible value
@@ -5744,22 +5744,22 @@ class TestValueFlow : public TestFixture {
                "    int x = 1;\n"
                "    int y = 2 + x;\n" // <- known value, don't care about condition
                "    if (x == 2) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true,  testValueOfX(code, 3U, 1)); // value of x can be 1
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 2)); // value of x can't be 2
 
         code = "bool f() {\n"
                "  const int s( 4 );"
                "  return s == 4;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT(value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
 
         code = "bool f() {\n"
-               "  const int s{ 4 };"
+               "  const int s{ 4 };\n"
                "  return s == 4;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT(value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
@@ -5767,7 +5767,7 @@ class TestValueFlow : public TestFixture {
         code = "bool f() {\n"
                "  const int s = int( 4 );"
                "  return s == 4;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT(value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
@@ -5775,7 +5775,7 @@ class TestValueFlow : public TestFixture {
         code = "bool f() {\n"
                "  const int s = int{ 4 };"
                "  return s == 4;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT(value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
@@ -5783,7 +5783,7 @@ class TestValueFlow : public TestFixture {
         code = "bool f() {\n"
                "  const int s = int{};"
                "  return s == 0;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT_EQUALS(true, value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
@@ -5791,7 +5791,7 @@ class TestValueFlow : public TestFixture {
         code = "bool f() {\n"
                "  const int s = int();"
                "  return s == 0;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT_EQUALS(true, value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
@@ -5799,7 +5799,7 @@ class TestValueFlow : public TestFixture {
         code = "bool f() {\n"
                "  const int s{};"
                "  return s == 0;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT_EQUALS(true, value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
@@ -5807,7 +5807,7 @@ class TestValueFlow : public TestFixture {
         code = "bool f() {\n"
                "  int* p{};\n"
                "  return p == nullptr;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT_EQUALS(true, value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
@@ -5815,7 +5815,7 @@ class TestValueFlow : public TestFixture {
         code = "bool f() {\n"
                "  int* p{ nullptr };\n"
                "  return p == nullptr;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT_EQUALS(true, value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
@@ -5823,7 +5823,7 @@ class TestValueFlow : public TestFixture {
         code = "bool f() {\n"
                "  int* p{ 0 };\n"
                "  return p == nullptr;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT_EQUALS(true, value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
@@ -5831,7 +5831,7 @@ class TestValueFlow : public TestFixture {
         code = "bool f() {\n"
                "  int* p = {};\n"
                "  return p == nullptr;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT_EQUALS(true, value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
@@ -5839,7 +5839,7 @@ class TestValueFlow : public TestFixture {
         code = "bool f() {\n"
                "  int i = {};\n"
                "  return i == 0;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT_EQUALS(true, value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
@@ -5847,7 +5847,7 @@ class TestValueFlow : public TestFixture {
         code = "bool f() {\n"
                "  int* p = { 0 };\n"
                "  return p == nullptr;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT_EQUALS(true, value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
@@ -5855,20 +5855,20 @@ class TestValueFlow : public TestFixture {
         code = "bool f() {\n"
                "  int i = { 1 };\n"
                "  return i == 1;\n" // <- known value
-               "}";
+               "}\n";
         value = valueOfTok(code, "==");
         ASSERT_EQUALS(true, value.isKnown());
         ASSERT_EQUALS(1, value.intvalue);
 
         // calculation with known result
-        code = "int f(int x) { a = x & 0; }"; // <- & is 0
+        code = "int f(int x) { a = x & 0; }\n"; // <- & is 0
         value = valueOfTok(code, "&");
         ASSERT_EQUALS(0, value.intvalue);
         ASSERT(value.isKnown());
 
         // template parameters are not known
         code = "template <int X> void f() { a = X; }\n"
-               "f<1>();";
+               "f<1>();\n";
         value = valueOfTok(code, "1");
         ASSERT_EQUALS(1, value.intvalue);
         ASSERT_EQUALS(false, value.isKnown());
@@ -5897,7 +5897,7 @@ class TestValueFlow : public TestFixture {
     }
 
     void valueFlowSizeofForwardDeclaredEnum() {
-        const char *code = "enum E; sz=sizeof(E);";
+        const char *code = "enum E; sz=sizeof(E);\n";
         (void)valueOfTok(code, "="); // Don't crash (#7775)
     }
 
@@ -5908,14 +5908,14 @@ class TestValueFlow : public TestFixture {
                "void f() {\n"
                "    x = 4;\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 4));
 
         code = "int x;\n"
                "void f() {\n"
                "    if (x == 4) {}\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 4));
 
         code = "int x;\n"
@@ -5923,7 +5923,7 @@ class TestValueFlow : public TestFixture {
                "    x = 42;\n"
                "    unknownFunction();\n"
                "    a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 42));
     }
 
@@ -5933,7 +5933,7 @@ class TestValueFlow : public TestFixture {
         code = "const int x = 321;\n"
                "void f() {\n"
                "  a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 321));
 
         code = "void f(const int x = 1) {\n"
@@ -5956,41 +5956,41 @@ class TestValueFlow : public TestFixture {
         code = "static int x = 321;\n"
                "void f() {\n"
                "  a = x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 321));
 
         code = "static int x = 321;\n"
                "void f() {\n"
                "  a = x;\n"
-               "}"
+               "}\n"
                "void other() { x=a; }\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 321));
 
         code = "static int x = 321;\n"
                "void f() {\n"
                "  a = x;\n"
-               "}"
+               "}\n"
                "void other() { p = &x; }\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 321));
 
         code = "static int x = 321;\n"
                "void f() {\n"
                "  a = x;\n"
-               "}"
+               "}\n"
                "void other() { x++; }\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 321));
 
         code = "static int x = 321;\n"
                "void f() {\n"
                "  a = x;\n"
-               "}"
+               "}\n"
                "void other() { foo(x); }\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 321));
 
         code = "static int x = 1;\n" // compound assignment
                "void f() {\n"
                "  a = x;\n"
-               "}"
+               "}\n"
                "void other() { x += b; }\n";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 1));
     }
@@ -6000,7 +6000,7 @@ class TestValueFlow : public TestFixture {
                            "    int x = 42;\n"
                            "    asm(\"\");\n"
                            "    a = x;\n"
-                           "}";
+                           "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 42));
     }
 
@@ -6069,21 +6069,21 @@ class TestValueFlow : public TestFixture {
         code = "void f() {\n"
                "    int x;\n"
                "    switch (x) {}\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "x )");
         ASSERT_EQUALS(true, values.size()==1U && values.front().isUninitValue());
 
         code = "void f() {\n"
                "    const C *c;\n"
                "    if (c->x() == 4) {}\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "c .");
         ASSERT_EQUALS(true, values.size()==1U && values.front().isUninitValue());
 
         code = "void f() {\n"
                "    C *c;\n"
                "    if (c->x() == 4) {}\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "c .");
         ASSERT_EQUALS(true, values.size()==1U && values.front().isUninitValue());
 
@@ -6091,7 +6091,7 @@ class TestValueFlow : public TestFixture {
                "    int **x;\n"
                "    y += 10;\n"
                "    x = dostuff(sizeof(*x)*y);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(0U, tokenValues(code, "x )").size());
 
         // initialization
@@ -6099,7 +6099,7 @@ class TestValueFlow : public TestFixture {
                "  int x;\n"
                "  *((int *)(&x)) = 12;\n"
                "  a = x + 1;\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "x +");
         ASSERT_EQUALS(true, values.empty());
         // ASSERT_EQUALS(1U, values.size());
@@ -6122,7 +6122,7 @@ class TestValueFlow : public TestFixture {
         code = "void foo() {\n"
                "    int x;\n"
                "    f(x=3), return x+3;\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "x +");
         ASSERT_EQUALS(true, values.empty());
         // ASSERT_EQUALS(1U, values.size());
@@ -6135,15 +6135,15 @@ class TestValueFlow : public TestFixture {
                "  if (is >> x) {\n"
                "    a = x;\n"
                "  }\n"
-               "}";
-        values = tokenValues(code, "x ; }");
+               "}\n";
+        values = tokenValues(code, "x ; }\n");
         ASSERT_EQUALS(true, values.empty());
 
         // return (#8173)
         code = "int repeat() {\n"
                "  const char *n;\n"
                "  return((n=42) && *n == 'A');\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "n ==");
         values.remove_if(&isNotUninitValue);
         ASSERT_EQUALS(true, values.empty());
@@ -6157,7 +6157,7 @@ class TestValueFlow : public TestFixture {
                "  else\n"
                "    x = 1;\n"
                "  if (x>1) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfXKnown(code, 8U, 1));
 
         // #8348 - noreturn else
@@ -6177,8 +6177,8 @@ class TestValueFlow : public TestFixture {
         code = "void f() {\n"
                "    int x;\n"
                "    a & x;\n"
-               "}";
-        values = tokenValues(code, "x ; }");
+               "}\n";
+        values = tokenValues(code, "x ; }\n");
         ASSERT_EQUALS(true, values.empty());
 
         code = "void b(bool d, bool e) {\n"
@@ -6189,7 +6189,7 @@ class TestValueFlow : public TestFixture {
                "    goto;\n"
                "  c++;\n"
                "}\n";
-        values = tokenValues(code, "c ++ ; }");
+        values = tokenValues(code, "c ++ ; }\n");
         ASSERT_EQUALS(true, values.empty());
 
         code = "void b(bool d, bool e) {\n"
@@ -6200,7 +6200,7 @@ class TestValueFlow : public TestFixture {
                "    return;\n"
                "  c++;\n"
                "}\n";
-        values = tokenValues(code, "c ++ ; }");
+        values = tokenValues(code, "c ++ ; }\n");
         ASSERT_EQUALS(true, values.empty());
 
         code = "void b(bool d, bool e) {\n"
@@ -6211,7 +6211,7 @@ class TestValueFlow : public TestFixture {
                "    exit();\n"
                "  c++;\n"
                "}\n";
-        values = tokenValues(code, "c ++ ; }");
+        values = tokenValues(code, "c ++ ; }\n");
         ASSERT_EQUALS(true, values.empty());
 
         code = "void b(bool d, bool e) {\n"
@@ -6246,7 +6246,7 @@ class TestValueFlow : public TestFixture {
                "  int szHdr;\n"
                "  idx = (A<0x80) ? (szHdr = 0) : dostuff(A, (int *)&(szHdr));\n"
                "  d = szHdr;\n" // szHdr can be 0.
-               "}";
+               "}\n";
         values = tokenValues(code, "szHdr ; }");
         TODO_ASSERT_EQUALS(1, 0, values.size());
         if (values.size() == 1) {
@@ -6257,7 +6257,7 @@ class TestValueFlow : public TestFixture {
                "  int szHdr;\n"
                "  idx = ((aKey<0x80) ? ((szHdr)=aKey), 1 : sqlite3GetVarint32(&(szHdr)));\n"
                "  d = szHdr;\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "szHdr ; }");
         ASSERT_EQUALS(0, values.size());
 
@@ -6268,7 +6268,7 @@ class TestValueFlow : public TestFixture {
                "    MyStruct x;\n"
                "    fread(((char *)&x) + 0, sizeof(x), f);\n"
                "    if (x.value < 432) {}\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "x . value");
         ASSERT_EQUALS(0, values.size());
 
@@ -6342,7 +6342,7 @@ class TestValueFlow : public TestFixture {
                "    int n;\n"
                "    for (int i = 0; i < 4; i = n)\n" // <- n is initialized in the loop body
                "        n = 10;\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "n )", ValueFlow::Value::ValueType::UNINIT);
         ASSERT_EQUALS(0, values.size());
 
@@ -6364,7 +6364,7 @@ class TestValueFlow : public TestFixture {
                "  int x;\n"
                "  if (false || init(&x)) {}\n"
                "  int b = x+1;\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "x + 1", ValueFlow::Value::ValueType::UNINIT);
         ASSERT_EQUALS(0, values.size());
 
@@ -6448,7 +6448,7 @@ class TestValueFlow : public TestFixture {
                "    size_t bytesCopied;\n"
                "    bool copied_all = true;\n"
                "    g(&copied_all, &bytesCopied);\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "buflen >=", ValueFlow::Value::ValueType::UNINIT);
         ASSERT_EQUALS(1, values.size());
 
@@ -6613,7 +6613,7 @@ class TestValueFlow : public TestFixture {
                "\n"
                "    this->FileIndex = 1 ;\n"
                "    if ( this->FileIndex < 0 ) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, valueOfTok(code, "<").intvalue == 1);
 
         code = "int f(int p) {\n"
@@ -6798,33 +6798,33 @@ class TestValueFlow : public TestFixture {
         code = "void f(const std::list<int> &ints) {\n"
                "  if (!static_cast<bool>(ints.empty()))\n"
                "    ints.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints . front"), 0));
 
         // valueFlowContainerReverse
         code = "void f(const std::list<int> &ints) {\n"
                "  ints.front();\n" // <- container can be empty
                "  if (ints.empty()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 0));
 
         code = "void f(const std::list<int> &ints) {\n"
                "  ints.front();\n" // <- container can be empty
                "  if (ints.size()==0) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 0));
 
         code = "void f(std::list<int> ints) {\n"
                "  ints.front();\n" // <- no container size
                "  ints.pop_back();\n"
                "  if (ints.empty()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 1));
 
         code = "void f(std::vector<int> v) {\n"
                "  v[10] = 0;\n" // <- container size can be 10
                "  if (v.size() == 10) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "v ["), 10));
 
         code = "void f(std::vector<std::string> params) {\n"
@@ -6837,7 +6837,7 @@ class TestValueFlow : public TestFixture {
                "    if (params.size() < 2) { }\n" // <- condition
                "    break;\n"
                "  }\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "params [ 2 ]").empty());
 
         // valueFlowAfterCondition
@@ -6873,40 +6873,40 @@ class TestValueFlow : public TestFixture {
         code = "void f(const std::list<int> &ints) {\n"
                "  if (ints.empty()) {}\n"
                "  ints.front();\n" // <- container can be empty
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 0));
 
         code = "void f(const std::list<int> &ints) {\n"
                "  if (ints.empty()) { continue; }\n"
                "  ints.front();\n" // <- no container size
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints . front"), 0));
 
         code = "void f(const std::list<int> &ints) {\n"
                "  if (ints.empty()) { ints.push_back(0); }\n"
                "  ints.front();\n" // <- container is not empty
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "ints . front").empty());
 
         code = "void f(const std::list<int> &ints) {\n"
                "  if (ints.empty()) {\n"
                "    ints.front();\n" // <- container is empty
                "  }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "ints . front"), 0));
 
         code = "void f(const std::list<int> &ints) {\n"
                "  if (ints.size() == 3) {\n"
                "    ints.front();\n" // <- container size is 3
                "  }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "ints . front"), 3));
 
         code = "void f(const std::list<int> &ints) {\n"
                "  if (ints.size() <= 3) {\n"
                "    ints.front();\n" // <- container size is 3
                "  }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 3, false));
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints . front"), 4, false));
 
@@ -6914,7 +6914,7 @@ class TestValueFlow : public TestFixture {
                "  if (ints.size() >= 3) {\n"
                "    ints.front();\n" // <- container size is 3
                "  }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 3, false));
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints . front"), 2, false));
 
@@ -6922,7 +6922,7 @@ class TestValueFlow : public TestFixture {
                "  if (ints.size() < 3) {\n"
                "    ints.front();\n" // <- container size is 2
                "  }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 2, false));
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints . front"), 3, false));
 
@@ -6930,7 +6930,7 @@ class TestValueFlow : public TestFixture {
                "  if (ints.size() > 3) {\n"
                "    ints.front();\n" // <- container size is 4
                "  }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 4, false));
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints . front"), 3, false));
 
@@ -6938,103 +6938,103 @@ class TestValueFlow : public TestFixture {
                "  if (ints.empty() == false) {\n"
                "    ints.front();\n" // <- container is not empty
                "  }\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "ints . front").empty());
 
         code = "void f(const std::vector<int> &v) {\n"
                "  if (v.empty()) {}\n"
                "  if (!v.empty() && v[10]==0) {}\n" // <- no container size for 'v[10]'
-               "}";
+               "}\n";
         ASSERT(removeImpossible(tokenValues(code, "v [")).empty());
 
         code = "void f() {\n"
                "  std::list<int> ints;\n"  // No value => ints is empty
                "  ints.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "ints . front"), 0));
 
         code = "void f() {\n"
                "  std::array<int,10> ints;\n" // Array size is 10
                "  ints.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("values.size():2", isKnownContainerSizeValue(tokenValues(code, "ints . front"), 10)); // uninit value
 
         code = "void f() {\n"
                "  std::string s;\n"
                "  cin >> s;\n"
                "  s[0];\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "s [").empty());
 
         code = "void f() {\n"
                "  std::string s = \"abc\";\n" // size of s is 3
                "  s.size();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "s . size"), 3));
 
         code = "void f(const char* p) {\n"
                "  if (p == nullptr) return;\n"
                "  std::string s { p };\n" // size of s is unknown
                "  s.front();\n"
-               "}";
+               "}\n";
         ASSERT(removeSymbolicTok(tokenValues(code, "s . front")).empty());
 
         code = "void f() {\n"
                "  std::string s = { 'a', 'b', 'c' };\n" // size of s is 3
                "  s.size();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "s . size"), 3));
 
         code = "void f() {\n"
                "  std::string s=\"abc\";\n" // size of s is 3
                "  s += unknown;\n"
                "  s.size();\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "s . size").empty());
 
         code = "void f() {\n"
                "  std::string s=\"abc\";\n" // size of s is 3
                "  s += \"def\";\n" // size of s => 6
                "  s.size();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "s . size"), 6));
 
         code = "void f(std::string s) {\n"
                "    if (s == \"hello\")\n"
                "        s[40] = c;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "s ["), 5));
 
         code = "void f(std::string s) {\n"
                "    s[40] = c;\n"
                "    if (s == \"hello\") {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "s ["), 5));
 
         code = "void f(std::string s) {\n"
                "    if (s != \"hello\") {}\n"
                "    s[40] = c;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "s ["), 5));
 
         code = "void f(std::string s) {\n"
                "    if (s != \"hello\")\n"
                "        s[40] = c;\n"
-               "}";
+               "}\n";
         ASSERT(!isImpossibleContainerSizeValue(tokenValues(code, "s ["), 5).empty());
 
         code = "void f() {\n"
                "    static std::string s;\n"
                "    if (s.size() == 0)\n"
                "        s = x;\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "s . size").empty());
 
         code = "void f() {\n"
                "    const uint8_t data[] = { 1, 2, 3 };\n"
                "    std::vector<uint8_t> v{ data, data + sizeof(data) };\n"
                "    v.size();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "v . size"), 3, false));
 
         // valueFlowContainerForward, loop
@@ -7042,7 +7042,7 @@ class TestValueFlow : public TestFixture {
                "    std::stack<Token *> links;\n"
                "    while (!links.empty() || indentlevel)\n"
                "        links.push(tok);\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "links . empty"), 0));
 
         // valueFlowContainerForward, function call
@@ -7050,14 +7050,14 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  f(x);\n"
                "  x.front();\n" // <- unknown container size
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "x . front").empty());
 
         code = "void f() {\n" // #8689
                "  std::list<int> x;\n"
                "  f<ns::a>(x);\n"
                "  x.front();\n" // <- unknown container size
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "x . front").empty());
 
         code = "void g(std::list<int>&);\n"
@@ -7065,7 +7065,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(x);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "x . front").empty());
 
         code = "void g(std::list<int>*);\n"
@@ -7073,7 +7073,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(&x);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "x . front").empty());
 
         code = "void g(std::list<int>* const);\n" // #9434
@@ -7081,7 +7081,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(&x);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "x . front").empty());
 
         code = "void g(const std::list<int>&);\n"
@@ -7089,7 +7089,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(x);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "x . front"), 0));
 
         code = "void g(std::list<int>);\n"
@@ -7097,7 +7097,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(x);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "x . front"), 0));
 
         code = "void g(int&);\n"
@@ -7105,7 +7105,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(x[0]);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "x . front"), 0));
 
         code = "void g(int&);\n"
@@ -7113,7 +7113,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(x.back());\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "x . front"), 0));
 
         code = "void g(std::list<int>&) {}\n"
@@ -7121,7 +7121,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(x);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "x . front"), 0));
 
         code = "void g(std::list<int>& y) { y.push_back(1); }\n"
@@ -7129,7 +7129,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(x);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "x . front").empty());
 
         code = "void g(std::list<int>*) {}\n"
@@ -7137,7 +7137,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(&x);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "x . front"), 0));
 
         code = "void g(std::list<int>* y) { y->push_back(1); }\n"
@@ -7145,7 +7145,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(&x);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "x . front").empty());
 
         code = "void h(std::list<int>&);\n"
@@ -7154,7 +7154,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(x);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "x . front").empty());
 
         code = "void h(const std::list<int>&);\n"
@@ -7163,7 +7163,7 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(x);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "x . front"), 0));
 
         code = "void h(const std::list<int>&);\n"
@@ -7172,14 +7172,14 @@ class TestValueFlow : public TestFixture {
                "  std::list<int> x;\n"
                "  g(x);\n"
                "  x.front();\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "x . front").empty());
 
         code = "void f(std::vector<int> ints) {\n" // #8697
                "  if (ints.empty())\n"
                "    abort() << 123;\n"
                "  ints[0] = 0;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints ["), 0));
 
         code = "struct A {\n"  // forward, nested function call, #9424
@@ -7195,7 +7195,7 @@ class TestValueFlow : public TestFixture {
                "    std::vector<unsigned char> v;\n"
                "    ptr->getMessage (&v);\n"
                "    if (v.size () > 0) {}\n" // <- v has unknown size!
-               "}";
+               "}\n";
         ASSERT_EQUALS(0U, tokenValues(code, "v . size ( )").size());
 
         // if
@@ -7214,46 +7214,46 @@ class TestValueFlow : public TestFixture {
         code = "void f() {\n"
                "  std::string s = \"abcd\";\n"
                "  s.size();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(4, tokenValues(code, "( ) ;").front().intvalue);
 
         code = "void f() {\n"
                "  std::string s;\n"
                "  s.empty();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(1, tokenValues(code, "( ) ;").front().intvalue);
 
         // Calculations
         code = "void f() {\n"
                "  std::string s = \"abcd\";\n"
                "  x = s + s;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "+"), 8));
 
         code = "void f(const std::vector<int> &ints) {\n"
                "  ints.clear();\n"
                "  ints.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
 
         code = "void f(const std::vector<int> &ints) {\n"
                "  ints.resize(3);\n"
                "  ints.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 3));
 
         code = "void f(const std::vector<int> &ints) {\n"
                "  ints.resize(3);\n"
                "  ints.push_back(3);\n"
                "  ints.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 4));
 
         code = "void f(const std::vector<int> &ints) {\n"
                "  ints.resize(3);\n"
                "  ints.pop_back();\n"
                "  ints.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 2));
 
         code = "int f(bool b) {\n"
@@ -7282,21 +7282,21 @@ class TestValueFlow : public TestFixture {
         code = "void f() {\n"
                "  std::vector<int> ints{};\n"
                "  ints.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("",
                       isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
 
         code = "void f() {\n"
                "  std::vector<int> ints{};\n"
                "  ints.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("",
                       isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
 
         code = "void f() {\n"
                "  std::vector<int> ints{1};\n"
                "  ints.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("",
                       isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 1));
 
@@ -7304,14 +7304,14 @@ class TestValueFlow : public TestFixture {
                "  std::vector<int> ints{1};\n"
                "  std::vector<int> ints2{ints.begin(), ints.end()};\n"
                "  ints2.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(
             "", isKnownContainerSizeValue(tokenValues(code, "ints2 . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 1));
 
         code = "void f() {\n"
                "  std::vector<int> ints = {};\n"
                "  ints.front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("",
                       isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
 
@@ -7476,7 +7476,7 @@ class TestValueFlow : public TestFixture {
                "}\n";
         ASSERT_EQUALS(
             true,
-            removeImpossible(tokenValues(code, "v [ 0 ] != 0 ) { }", ValueFlow::Value::ValueType::CONTAINER_SIZE)).empty());
+            removeImpossible(tokenValues(code, "v [ 0 ] != 0 ) { }\n", ValueFlow::Value::ValueType::CONTAINER_SIZE)).empty());
 
         code = "std::vector<int> f() {\n"
                "    std::vector<int> v;\n"
@@ -7490,13 +7490,13 @@ class TestValueFlow : public TestFixture {
         code = "void f() {\n"
                "  std::vector<int> v(3);\n"
                "  v.size();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "v . size"), 3));
 
         code = "void f() {\n"
                "  std::vector<int> v({ 1, 2, 3 });\n"
                "  v.size();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "v . size"), 3));
 
         code = "int f() {\n"
@@ -7537,16 +7537,16 @@ class TestValueFlow : public TestFixture {
                "}\n";
         ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 0));
 
-        code = "std::vector<int> f() { return std::vector<int>(); }";
+        code = "std::vector<int> f() { return std::vector<int>(); }\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "( ) ;"), 0));
 
-        code = "std::vector<int> f() { return std::vector<int>{}; }";
+        code = "std::vector<int> f() { return std::vector<int>{}; }\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "{ } ;"), 0));
 
-        code = "std::vector<int> f() { return {}; }";
+        code = "std::vector<int> f() { return {}; }\n";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "{ } ;"), 0));
 
-        code = "int f() { auto a = std::array<int, 2>{}; return a[1]; }";
+        code = "int f() { auto a = std::array<int, 2>{}; return a[1]; }\n";
         ASSERT_EQUALS("values.size():0", isKnownContainerSizeValue(tokenValues(code, "a ["), 0));
 
         code = "void g(std::vector<int>* w) {\n"
@@ -7615,44 +7615,44 @@ class TestValueFlow : public TestFixture {
         code = "void f(const std::string& a) {\n" // #12994
                "    std::string b = a + \"123\";\n"
                "    if (b.empty()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "b ."), 2));
 
         code = "void f(const std::string& a) {\n"
                "    std::string b = \"123\" + a;\n"
                "    if (b.empty()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "b ."), 2));
 
         code = "void f(const std::string& a, const std::string& b) {\n"
                "    std::string c = a + b + \"123\";\n"
                "    if (c.empty()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "c ."), 2));
 
         code = "void f(const std::string& a) {\n"
                "    std::string b = a + \"123\" + \"456\";\n"
                "    if (b.empty()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "b ."), 5));
 
         code = "void f(const std::string& a) {\n"
                "    std::string b = \"123\" + a + \"456\";\n"
                "    if (b.empty()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "b ."), 5));
 
         code = "void f(const std::string& a, const std::string& b) {\n"
                "    std::string c = \"123\" + a + b;\n"
                "    if (c.empty()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "c ."), 2));
 
         code = "void f(const std::string& a) {\n"
                "    std::string s;\n"
                "    s.append(a);\n"
                "    if (s.empty()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "s . empty"), 0));
 
         code = "int f(const std::string& str) {\n"
@@ -7660,25 +7660,25 @@ class TestValueFlow : public TestFixture {
                "    std::vector<std::string> v{ std::istream_iterator<std::string>(iss), {} };\n"
                "    auto x = v.size();\n"
                "    return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(false, testValueOfXKnown(code, 5U, 2));
 
         code = "auto f() {\n" // #13450
                "    auto v = std::vector<std::vector<S*>>(3, std::vector<S*>());\n"
                "    return v[2];\n"
-               "}";
+               "}\n";
         ASSERT(isKnownContainerSizeValue(tokenValues(code, "v ["), 3).empty());
 
         code = "auto f() {\n" // #13654
                "    std::array<uint8_t, 6 * sizeof(uint16_t)> a{};\n"
                "    return a[0];\n"
-               "}";
+               "}\n";
         ASSERT(!isKnownContainerSizeValue(tokenValues(code, "a ["), 6).empty());
 
         code = "void f(const char a[]) {\n" // #14518
                "    std::string s(a);\n"
                "    if (s.empty()) {}\n"
-               "}";
+               "}\n";
         ASSERT(!isKnownContainerSizeValue(tokenValues(code, "s ."), 0).empty());
 
         code = "void g(std::map<int, int>* p) {\n" // #14721
@@ -7696,7 +7696,7 @@ class TestValueFlow : public TestFixture {
                "    std::vector<int> v(3);\n"
                "    int* p = v.data();\n"
                "    return p[1];\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("",
                       isKnownContainerSizeValue(tokenValues(code, "p [", ValueFlow::Value::ValueType::CONTAINER_SIZE), 3));
 
@@ -7706,7 +7706,7 @@ class TestValueFlow : public TestFixture {
                "    int* p = v.data();\n"
                "    v.push_back(1);\n"
                "    return p[1];\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(0U, tokenValues(code, "p [", ValueFlow::Value::ValueType::CONTAINER_SIZE).size());
 
         // the buffer of c_str() includes the null terminator
@@ -7714,14 +7714,14 @@ class TestValueFlow : public TestFixture {
                "    std::string s = \"abc\";\n"
                "    const char* p = s.c_str();\n"
                "    return p + 3;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("",
                       isKnownContainerSizeValue(tokenValues(code, "p +", ValueFlow::Value::ValueType::CONTAINER_SIZE), 4));
 
         code = "const char* f() {\n"
                "    std::string s = \"abc\";\n"
                "    return s.c_str();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(
             "",
             isKnownContainerSizeValue(tokenValues(code, "( ) ;", ValueFlow::Value::ValueType::CONTAINER_SIZE), 4));
@@ -7730,7 +7730,7 @@ class TestValueFlow : public TestFixture {
         code = "int* f() {\n"
                "    std::vector<int> v(3);\n"
                "    return v.data();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS("",
                       isKnownContainerSizeValue(tokenValues(code, "( ) ;", ValueFlow::Value::ValueType::CONTAINER_SIZE),
                                                 3));
@@ -7740,7 +7740,7 @@ class TestValueFlow : public TestFixture {
         code = "void f(const std::string& k) {\n"
                "    std::map<std::string, std::vector<int>> m;\n"
                "    m[k].front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(
             "",
             isKnownContainerSizeValue(tokenValues(code, "[ k ] . front", ValueFlow::Value::ValueType::CONTAINER_SIZE),
@@ -7751,7 +7751,7 @@ class TestValueFlow : public TestFixture {
         code = "void f(int a, int b) {\n"
                "    std::map<int, std::map<int, std::vector<int>>> m;\n"
                "    m[a][b].front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(
             "",
             isKnownContainerSizeValue(tokenValues(code, "[ b ] . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
@@ -7760,14 +7760,14 @@ class TestValueFlow : public TestFixture {
         code = "void f(int i) {\n"
                "    std::vector<std::vector<int>> v;\n"
                "    v[i].front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(0U, tokenValues(code, "[ i ] . front", ValueFlow::Value::ValueType::CONTAINER_SIZE).size());
 
         // ..nor when the container is not empty..
         code = "void f(std::map<std::string, std::vector<int>>& m, const std::string& k) {\n"
                "    if (m.size() == 1)\n"
                "        m[k].front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(0U, tokenValues(code, "[ k ] . front", ValueFlow::Value::ValueType::CONTAINER_SIZE).size());
 
         // ..nor when the container was modified
@@ -7775,7 +7775,7 @@ class TestValueFlow : public TestFixture {
                "    std::map<std::string, std::vector<int>> m;\n"
                "    m[\"a\"].push_back(1);\n"
                "    m[k].front();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(0U, tokenValues(code, "[ k ] . front", ValueFlow::Value::ValueType::CONTAINER_SIZE).size());
     }
 
@@ -7787,7 +7787,7 @@ class TestValueFlow : public TestFixture {
                "    const std::vector<int> v{1, 2, 3};\n"
                "    auto it = v.begin();\n"
                "    if (it != v.end()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(
             "",
             isKnownContainerSizeValue(tokenValues(code, "it !=", ValueFlow::Value::ValueType::CONTAINER_SIZE), 3));
@@ -7796,7 +7796,7 @@ class TestValueFlow : public TestFixture {
         code = "void f() {\n"
                "    const std::deque<int> d{1, 2, 3, 4, 5, 6};\n"
                "    if (std::equal(d.cbegin(), d.cend(), d.cbegin())) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(
             "",
             isKnownContainerSizeValue(tokenValues(code, "( ) ,", ValueFlow::Value::ValueType::CONTAINER_SIZE), 6));
@@ -7806,7 +7806,7 @@ class TestValueFlow : public TestFixture {
                "    std::array<int, 5> a;\n"
                "    auto it = a.begin();\n"
                "    if (it != a.end()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(
             "",
             isKnownContainerSizeValue(tokenValues(code, "it !=", ValueFlow::Value::ValueType::CONTAINER_SIZE), 5));
@@ -7816,14 +7816,14 @@ class TestValueFlow : public TestFixture {
                "    const std::vector<int> v{1, 2, 3};\n"
                "    auto it = w.begin();\n"
                "    if (it != w.end()) {}\n"
-               "}";
+               "}\n";
         ASSERT(tokenValues(code, "it !=", ValueFlow::Value::ValueType::CONTAINER_SIZE).empty());
 
         // iterators created from the container carry the container size
         code = "bool f() {\n"
                "    std::vector<int> v(3);\n"
                "    return v.begin() != v.end();\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(
             "",
             isKnownContainerSizeValue(tokenValues(code, "( ) !=", ValueFlow::Value::ValueType::CONTAINER_SIZE), 3));
@@ -7836,7 +7836,7 @@ class TestValueFlow : public TestFixture {
                "    std::vector<int> v(3);\n"
                "    auto it = v.begin();\n"
                "    if (it != v.end()) {}\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(
             "",
             isKnownContainerSizeValue(tokenValues(code, "it !=", ValueFlow::Value::ValueType::CONTAINER_SIZE), 3));
@@ -7877,48 +7877,48 @@ class TestValueFlow : public TestFixture {
         code = "void* f() {\n"
                "  void* x = malloc(10);\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 10, ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "void* f() {\n"
                "  void* x = calloc(4, 5);\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 20,  ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "void* f() {\n"
                "  const char* y = \"abcd\";\n"
                "  const char* x = strdup(y);\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 5,  ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "void* f() {\n"
                "  void* y = malloc(10);\n"
                "  void* x = realloc(y, 20);\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 20,  ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "void* f() {\n"
                "  void* y = calloc(10, 4);\n"
                "  void* x = reallocarray(y, 20, 5);\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 100,  ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "struct A {};\n" // #14305
                "void* f() {\n"
                "  A* x = new A();\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 1, ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "struct A {};\n"
                "void* f() {\n"
                "  void* x = new A;\n"
                "  return x;\n"
-               "}";
+               "}\n";
         {
             auto values = tokenValues(code, "x ; }", &settingsCfg);
             ASSERT_EQUALS(1, values.size());
@@ -7930,7 +7930,7 @@ class TestValueFlow : public TestFixture {
                "void* f() {\n"
                "  B* x = new B();\n"
                "  return x;\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 4, ValueFlow::Value::ValueType::BUFFER_SIZE, &settingsCfg));
 
         code = "void f()\n"
@@ -7960,7 +7960,7 @@ class TestValueFlow : public TestFixture {
 
         code = "short f(short x) {\n"
                "  return x + 0;\n"
-               "}";
+               "}\n";
         values = removeSymbolicTok(tokenValues(code, "+", &s));
         ASSERT_EQUALS(2, values.size());
         ASSERT_EQUALS(-0x8000, values.front().intvalue);
@@ -7968,7 +7968,7 @@ class TestValueFlow : public TestFixture {
 
         code = "short f(std::string x) {\n"
                "  return x[10];\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "x [", &s);
         ASSERT_EQUALS(2, values.size());
         ASSERT_EQUALS(0, values.front().intvalue);
@@ -7976,7 +7976,7 @@ class TestValueFlow : public TestFixture {
 
         code = "int f(float x) {\n"
                "  return x;\n"
-               "}";
+               "}\n";
         values = tokenValues(code, "x ;", &s);
         ASSERT_EQUALS(2, values.size());
         ASSERT(values.front().floatValue < -1E20);
@@ -7984,7 +7984,7 @@ class TestValueFlow : public TestFixture {
 
         code = "short f(__cppcheck_low__(0) __cppcheck_high__(100) short x) {\n"
                "  return x + 0;\n"
-               "}";
+               "}\n";
         values = removeSymbolicTok(tokenValues(code, "+", &s));
         ASSERT_EQUALS(2, values.size());
         ASSERT_EQUALS(0, values.front().intvalue);
@@ -7992,7 +7992,7 @@ class TestValueFlow : public TestFixture {
 
         code = "unsigned short f(unsigned short x) [[expects: x <= 100]] {\n"
                "  return x + 0;\n"
-               "}";
+               "}\n";
         values = removeSymbolicTok(tokenValues(code, "+", &s));
         values.remove_if([](const ValueFlow::Value& v) {
             return v.isImpossible();
@@ -8017,7 +8017,7 @@ class TestValueFlow : public TestFixture {
         /*const*/ Settings s = settingsBuilder().library("std.cfg").build();
         s.checkUnknownFunctionReturn.insert("rand");
 
-        code = "x = rand();";
+        code = "x = rand();\n";
         values = tokenValues(code, "(", &s);
         ASSERT_EQUALS(2, values.size());
         ASSERT_EQUALS(INT_MIN, values.front().intvalue);
@@ -8027,7 +8027,7 @@ class TestValueFlow : public TestFixture {
     void valueFlowUnknownFunctionReturnMalloc() { // #4626
         const char *code;
 
-        code = "ptr = malloc(10);";
+        code = "ptr = malloc(10);\n";
         const auto& values = tokenValues(code, "(");
         ASSERT_EQUALS(1, values.size());
         ASSERT_EQUALS(true, values.front().isIntValue());
@@ -8230,7 +8230,7 @@ class TestValueFlow : public TestFixture {
                "  std::tuple<float, float, float, float> t4(5.2f, 3.1f, 2.4f, 9.1f), t5(4, 6, 9, 27);\n"
                "  t4 = t5;\n"
                "  ASSERT(!(t4 < t5) && t4 <= t5);\n"
-               "}";
+               "}\n";
         (void)valueOfTok(code, "<=");
 
         code = "void f() {\n"
@@ -8810,7 +8810,7 @@ class TestValueFlow : public TestFixture {
                "    if (path != standard)\n"
                "    {\n"
                "    }\n"
-               "}";
+               "}\n";
         (void)valueOfTok(code, "path");
 
         code = "void Error()\n"
@@ -8822,7 +8822,7 @@ class TestValueFlow : public TestFixture {
                "    if (path != standard)\n"
                "    {\n"
                "    }\n"
-               "}";
+               "}\n";
         (void)valueOfTok(code, "path");
 
         code = "struct S {\n"
@@ -8856,7 +8856,7 @@ class TestValueFlow : public TestFixture {
                           "  }\n"
                           "\n"
                           "  return 0;\n"
-                          "}";
+                          "}\n";
 
         ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, 1));
     }
@@ -9221,21 +9221,21 @@ class TestValueFlow : public TestFixture {
                "    if (x == y) {\n"
                "        int a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, "y", 0));
 
         code = "void f(int x, int y) {\n"
                "    if (x != y) {\n"
                "        int a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "y", 0));
 
         code = "void f(int x, int y) {\n"
                "    if (x < y) {\n"
                "        int a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, "y", -1));
         ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "y", 0));
 
@@ -9243,7 +9243,7 @@ class TestValueFlow : public TestFixture {
                "    if (x <= y) {\n"
                "        int a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, "y", 0));
         ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "y", 1));
 
@@ -9251,7 +9251,7 @@ class TestValueFlow : public TestFixture {
                "    if (x > y) {\n"
                "        int a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, "y", 1));
         ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "y", 0));
 
@@ -9259,7 +9259,7 @@ class TestValueFlow : public TestFixture {
                "    if (x >= y) {\n"
                "        int a = x;\n"
                "    }\n"
-               "}";
+               "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, "y", 0));
         ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "y", -1));
 
@@ -9740,7 +9740,7 @@ class TestValueFlow : public TestFixture {
 #define testBitfields(...) testBitfields_(__FILE__, __LINE__, __VA_ARGS__)
     void testBitfields_(const char *file, int line, const std::string &structBody, std::size_t expectedSize) {
         const Settings settingsUnix64 = settingsBuilder().platform(Platform::Type::Unix64).build();
-        const std::string code = "struct S { " + structBody + " }; const std::size_t size = sizeof(S);";
+        const std::string code = "struct S { " + structBody + " }; const std::size_t size = sizeof(S);\n";
         const auto values = tokenValues(code.c_str(), "( S", &settingsUnix64);
         ASSERT_LOC(!values.empty(), file, line);
         ASSERT_EQUALS_LOC(expectedSize, values.back().intvalue, file, line);
diff --git a/test/testvarid.cpp b/test/testvarid.cpp
index e30c613c0bc..a554cbe80be 100644
--- a/test/testvarid.cpp
+++ b/test/testvarid.cpp
@@ -545,7 +545,7 @@ class TestVarID : public TestFixture {
             "{\n"
             "    std::string str(\"test\");\n"
             "    str.clear();\n"
-            "}");
+            "}\n");
 
         const char expected[] = "1: void func ( )\n"
                                 "2: {\n"
@@ -571,7 +571,7 @@ class TestVarID : public TestFixture {
             "{\n"
             "    int abc;\n"
             "    struct abc abc1;\n"
-            "}", dinit(TokenizeOptions, $.cpp = false));
+            "}\n", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: void foo ( )\n"
                                 "2: {\n"
@@ -583,7 +583,7 @@ class TestVarID : public TestFixture {
     }
 
     void varid11() {
-        const std::string actual = tokenize("class Foo;");
+        const std::string actual = tokenize("class Foo;\n");
 
         const char expected[] = "1: class Foo ;\n";
 
@@ -595,7 +595,7 @@ class TestVarID : public TestFixture {
             "static void a()\n"
             "{\n"
             "    class Foo *foo;\n"
-            "}");
+            "}\n");
 
         const char expected[] = "1: static void a ( )\n"
                                 "2: {\n"
@@ -630,7 +630,7 @@ class TestVarID : public TestFixture {
             "A a;\n"
             "B b;\n"
             "b * a;\n"
-            "}", dinit(TokenizeOptions, $.cpp = false));
+            "}\n", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: void foo ( )\n"
                                 "2: {\n"
@@ -648,7 +648,7 @@ class TestVarID : public TestFixture {
                 "struct S {\n"
                 "    struct T {\n"
                 "    } t;\n"
-                "} s;", dinit(TokenizeOptions, $.cpp = false));
+                "} s;\n", dinit(TokenizeOptions, $.cpp = false));
 
             const char expected[] = "1: struct S {\n"
                                     "2: struct T {\n"
@@ -663,7 +663,7 @@ class TestVarID : public TestFixture {
                 "struct S {\n"
                 "    struct T {\n"
                 "    } t;\n"
-                "};", dinit(TokenizeOptions, $.cpp = false));
+                "};\n", dinit(TokenizeOptions, $.cpp = false));
 
             const char expected[] = "1: struct S {\n"
                                     "2: struct T {\n"
@@ -889,7 +889,7 @@ class TestVarID : public TestFixture {
         const char code2[] = "void f() {\n"
                              "  int  *p;\n"
                              "  void bar(int *p);\n"
-                             "}";
+                             "}\n";
         const char expected2[] = "1: void f ( ) {\n"
                                  "2: int * p@1 ;\n"
                                  "3: void bar ( int * p ) ;\n"
@@ -915,17 +915,21 @@ class TestVarID : public TestFixture {
 
     void varid37() {
         {
-            const char code[] = "void blah() {"
-                                "    Bar bar(*x);"
-                                "}";
-            ASSERT_EQUALS("1: void blah ( ) { Bar bar@1 ( * x ) ; }\n",
+            const char code[] = "void blah() {\n"
+                                "    Bar bar(*x);\n"
+                                "}\n";
+            ASSERT_EQUALS("1: void blah ( ) {\n"
+                          "2: Bar bar@1 ( * x ) ;\n"
+                          "3: }\n",
                           tokenize(code));
         }
         {
-            const char code[] = "void blah() {"
-                                "    Bar bar(&x);"
-                                "}";
-            ASSERT_EQUALS("1: void blah ( ) { Bar bar@1 ( & x ) ; }\n",
+            const char code[] = "void blah() {\n"
+                                "    Bar bar(&x);\n"
+                                "}\n";
+            ASSERT_EQUALS("1: void blah ( ) {\n"
+                          "2: Bar bar@1 ( & x ) ;\n"
+                          "3: }\n",
                           tokenize(code));
         }
     }
@@ -951,18 +955,18 @@ class TestVarID : public TestFixture {
     }
 
     void varid40() {
-        const char code[] ="extern \"C\" int (*a())();";
+        const char code[] ="extern \"C\" int (*a())();\n";
         ASSERT_EQUALS("1: int * a ( ) ;\n",
                       tokenize(code));
     }
 
     void varid41() {
-        const char code1[] = "union evt; void f(const evt & event);";
+        const char code1[] = "union evt; void f(const evt & event);\n";
         ASSERT_EQUALS("1: union evt ; void f ( const evt & event@1 ) ;\n",
                       tokenize(code1));
         ASSERT_THROW_INTERNAL(tokenize(code1, dinit(TokenizeOptions, $.cpp = false)), SYNTAX);
 
-        const char code2[] = "struct evt; void f(const evt & event);";
+        const char code2[] = "struct evt; void f(const evt & event);\n";
         ASSERT_EQUALS("1: struct evt ; void f ( const evt & event@1 ) ;\n",
                       tokenize(code2));
         ASSERT_THROW_INTERNAL(tokenize(code2, dinit(TokenizeOptions, $.cpp = false)), SYNTAX);
@@ -973,7 +977,7 @@ class TestVarID : public TestFixture {
                             "class Fred {\n"
                             "public:\n"
                             "     struct fruit::banana Bananas[25];\n"
-                            "};";
+                            "};\n";
         ASSERT_EQUALS("1: namespace fruit { struct banana { } ; } ;\n"
                       "2: class Fred {\n"
                       "3: public:\n"
@@ -983,25 +987,25 @@ class TestVarID : public TestFixture {
     }
 
     void varid43() {
-        const char code[] ="int main(int flag) { if(a & flag) { return 1; } }";
+        const char code[] ="int main(int flag) { if(a & flag) { return 1; } }\n";
         ASSERT_EQUALS("1: int main ( int flag@1 ) { if ( a & flag@1 ) { return 1 ; } }\n",
                       tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varid44() {
-        const char code[] ="class A:public B,public C,public D {};";
+        const char code[] ="class A:public B,public C,public D {};\n";
         ASSERT_EQUALS("1: class A : public B , public C , public D { } ;\n",
                       tokenize(code));
     }
 
     void varid45() { // #3466
-        const char code[] ="void foo() { B b(this); A a(this, b); }";
+        const char code[] ="void foo() { B b(this); A a(this, b); }\n";
         ASSERT_EQUALS("1: void foo ( ) { B b@1 ( this ) ; A a@2 ( this , b@1 ) ; }\n",
                       tokenize(code));
     }
 
     void varid46() { // #3756
-        const char code[] ="void foo() { int t; x = (struct t *)malloc(); f(t); }";
+        const char code[] ="void foo() { int t; x = (struct t *)malloc(); f(t); }\n";
         ASSERT_EQUALS("1: void foo ( ) { int t@1 ; x = ( struct t * ) malloc ( ) ; f ( t@1 ) ; }\n",
                       tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
@@ -1009,7 +1013,7 @@ class TestVarID : public TestFixture {
     void varid47() { // function parameters
         // #3768
         {
-            const char code[] ="void f(std::string &string, std::string &len) {}";
+            const char code[] ="void f(std::string &string, std::string &len) {}\n";
             ASSERT_EQUALS("1: void f ( std :: string & string@1 , std :: string & len@2 ) { }\n",
                           tokenize(code));
         }
@@ -1027,25 +1031,25 @@ class TestVarID : public TestFixture {
     }
 
     void varid48() {  // #3785 - return (a*b)
-        const char code[] ="int X::f(int b) const { return(a*b); }";
+        const char code[] ="int X::f(int b) const { return(a*b); }\n";
         ASSERT_EQUALS("1: int X :: f ( int b@1 ) const { return ( a * b@1 ) ; }\n",
                       tokenize(code));
     }
 
     void varid49() {  // #3799 - void f(std::vector<int>)
-        const char code[] ="void f(std::vector<int>)";
+        const char code[] ="void f(std::vector<int>)\n";
         ASSERT_EQUALS("1: void f ( std :: vector < int > )\n",
                       tokenize(code));
     }
 
     void varid50() {  // #3760 - explicit
-        const char code[] ="class A { explicit A(const A&); };";
+        const char code[] ="class A { explicit A(const A&); };\n";
         ASSERT_EQUALS("1: class A { explicit A ( const A & ) ; } ;\n",
                       tokenize(code));
     }
 
     void varid51() {  // don't set varid on template function
-        const char code[] ="T t; t.x<0>();";
+        const char code[] ="T t; t.x<0>();\n";
         ASSERT_EQUALS("1: T t@1 ; t@1 . x < 0 > ( ) ;\n",
                       tokenize(code));
     }
@@ -1053,7 +1057,7 @@ class TestVarID : public TestFixture {
     void varid52() {
         const char code[] ="A<B<C>::D> e;\n"
                             "B< C<> > b[10];\n"
-                            "B<C<>> c[10];";
+                            "B<C<>> c[10];\n";
         ASSERT_EQUALS("1: A < B < C > :: D > e@1 ;\n"
                       "2: B < C < > > b@2 [ 10 ] ;\n"
                       "3: B < C < > > c@3 [ 10 ] ;\n",
@@ -1062,74 +1066,67 @@ class TestVarID : public TestFixture {
 
     void varid53() { // #4172 - Template instantiation: T<&functionName> list[4];
         ASSERT_EQUALS("1: A < & f > list@1 [ 4 ] ;\n",
-                      tokenize("A<&f> list[4];"));
+                      tokenize("A<&f> list[4];\n"));
     }
 
     void varid54() { // hang
         // Original source code: libgc
-        (void)tokenize("STATIC ptr_t GC_approx_sp(void) { word sp; sp = (word)&sp; return((ptr_t)sp); }");
+        (void)tokenize("STATIC ptr_t GC_approx_sp(void) { word sp; sp = (word)&sp; return((ptr_t)sp); }\n");
     }
 
     void varid55() { // Ticket #5868
-        const char code[] =     "typedef struct foo {} foo; "
-                            "void bar1(struct foo foo) {} "
-                            "void baz1(foo foo) {} "
-                            "void bar2(struct foo& foo) {} "
-                            "void baz2(foo& foo) {} "
-                            "void bar3(struct foo* foo) {} "
-                            "void baz3(foo* foo) {}";
-        const char expected[] = "1: "
-                                "struct foo { } ; "
-                                "void bar1 ( struct foo foo@1 ) { } "
-                                "void baz1 ( struct foo foo@2 ) { } "
-                                "void bar2 ( struct foo & foo@3 ) { } "
-                                "void baz2 ( struct foo & foo@4 ) { } "
-                                "void bar3 ( struct foo * foo@5 ) { } "
-                                "void baz3 ( struct foo * foo@6 ) { }\n";
+        const char code[] = "typedef struct foo {} foo;\n"
+                            "void bar1(struct foo foo) {}\n"
+                            "void baz1(foo foo) {}\n"
+                            "void bar2(struct foo& foo) {}\n"
+                            "void baz2(foo& foo) {}\n"
+                            "void bar3(struct foo* foo) {}\n"
+                            "void baz3(foo* foo) {}\n";
+        const char expected[] = "1: struct foo { } ;\n"
+                                "2: void bar1 ( struct foo foo@1 ) { }\n"
+                                "3: void baz1 ( struct foo foo@2 ) { }\n"
+                                "4: void bar2 ( struct foo & foo@3 ) { }\n"
+                                "5: void baz2 ( struct foo & foo@4 ) { }\n"
+                                "6: void bar3 ( struct foo * foo@5 ) { }\n"
+                                "7: void baz3 ( struct foo * foo@6 ) { }\n";
         ASSERT_EQUALS(expected, tokenize(code));
     }
 
     void varid56() { // Ticket #6548 - function with a throw()
-        const char code1[] = "void fred(int x) throw() {}"
-                             "void wilma() { x++; }";
-        const char expected1[] = "1: "
-                                 "void fred ( int x@1 ) throw ( ) { } "
-                                 "void wilma ( ) { x ++ ; }\n";
+        const char code1[] = "void fred(int x) throw() {}\n"
+                             "void wilma() { x++; }\n";
+        const char expected1[] = "1: void fred ( int x@1 ) throw ( ) { }\n"
+                                 "2: void wilma ( ) { x ++ ; }\n";
         ASSERT_EQUALS(expected1, tokenize(code1));
 
-        const char code2[] = "void fred(int x) const throw(EXCEPT) {}"
-                             "void wilma() { x++; }";
-        const char expected2[] = "1: "
-                                 "void fred ( int x@1 ) const throw ( EXCEPT ) { } "
-                                 "void wilma ( ) { x ++ ; }\n";
+        const char code2[] = "void fred(int x) const throw(EXCEPT) {}\n"
+                             "void wilma() { x++; }\n";
+        const char expected2[] = "1: void fred ( int x@1 ) const throw ( EXCEPT ) { }\n"
+                                 "2: void wilma ( ) { x ++ ; }\n";
         ASSERT_EQUALS(expected2, tokenize(code2));
 
-        const char code3[] = "void fred(int x) throw() ABCD {}"
-                             "void wilma() { x++; }";
-        const char expected3[] = "1: "
-                                 "void fred ( int x@1 ) throw ( ) { } "
-                                 "void wilma ( ) { x ++ ; }\n";
+        const char code3[] = "void fred(int x) throw() ABCD {}\n"
+                             "void wilma() { x++; }\n";
+        const char expected3[] = "1: void fred ( int x@1 ) throw ( ) { }\n"
+                                 "2: void wilma ( ) { x ++ ; }\n";
         ASSERT_EQUALS(expected3, tokenize(code3));
 
-        const char code4[] = "void fred(int x) noexcept() {}"
-                             "void wilma() { x++; }";
-        const char expected4[] = "1: "
-                                 "void fred ( int x@1 ) noexcept ( ) { } "
-                                 "void wilma ( ) { x ++ ; }\n";
+        const char code4[] = "void fred(int x) noexcept() {}\n"
+                             "void wilma() { x++; }\n";
+        const char expected4[] = "1: void fred ( int x@1 ) noexcept ( ) { }\n"
+                                 "2: void wilma ( ) { x ++ ; }\n";
         ASSERT_EQUALS(expected4, tokenize(code4));
 
-        const char code5[] = "void fred(int x) noexcept {}"
-                             "void wilma() { x++; }";
-        const char expected5[] = "1: "
-                                 "void fred ( int x@1 ) noexcept ( true ) { } "
-                                 "void wilma ( ) { x ++ ; }\n";
+        const char code5[] = "void fred(int x) noexcept {}\n"
+                             "void wilma() { x++; }\n";
+        const char expected5[] = "1: void fred ( int x@1 ) noexcept ( true ) { }\n"
+                                 "2: void wilma ( ) { x ++ ; }\n";
         ASSERT_EQUALS(expected5, tokenize(code5));
 
-        const char code6[] = "void fred(int x) noexcept ( false ) {}"
-                             "void wilma() { x++; }";
-        const char expected6[] = "1: "
-                                 "void fred ( int x@1 ) noexcept ( false ) { } "
-                                 "void wilma ( ) { x ++ ; }\n";
+        const char code6[] = "void fred(int x) noexcept ( false ) {}\n"
+                             "void wilma() { x++; }\n";
+        const char expected6[] = "1: void fred ( int x@1 ) noexcept ( false ) { }\n"
+                                 "2: void wilma ( ) { x ++ ; }\n";
         ASSERT_EQUALS(expected6, tokenize(code6));
     }
 
@@ -1185,7 +1182,7 @@ class TestVarID : public TestFixture {
         const char code[] = "class DLLSYM B;\n"
                             "struct B {\n"
                             "    ~B() {}\n"
-                            "};";
+                            "};\n";
         const char expected[] = "1: class DLLSYM B@1 ;\n" // In this line, we cannot really do better...
                                 "2: struct B {\n"
                                 "3: ~ B@1 ( ) { }\n" // ...but here we could
@@ -1199,13 +1196,13 @@ class TestVarID : public TestFixture {
 
     void varid60() { // #7267 - cast
         ASSERT_EQUALS("1: a = ( x y ) 10 ;\n",
-                      tokenize("a=(x y)10;"));
+                      tokenize("a=(x y)10;\n"));
     }
 
     void varid61() {
         const char code[] = "void foo(int b) {\n"
                             "  void bar(int a, int b) {}\n"
-                            "}";
+                            "}\n";
         const char expected[] = "1: void foo ( int b@1 ) {\n"
                                 "2: void bar ( int a@2 , int b@3 ) { }\n"
                                 "3: }\n";
@@ -1219,41 +1216,41 @@ class TestVarID : public TestFixture {
                             "        int x;\n"
                             "        bar(r, r * x);\n"
                             "    }\n"
-                            "}";
+                            "}\n";
         // Ensure that there is only one variable id for "x"
         ASSERT_EQUALS("same varid", compareVaridsForVariable(code, "x"));
     }
 
     void varid63() {
-        const char code[] = "void f(boost::optional<int> const& x) {}";
+        const char code[] = "void f(boost::optional<int> const& x) {}\n";
         const char expected[] = "1: void f ( const boost :: optional < int > & x@1 ) { }\n";
         ASSERT_EQUALS(expected, tokenize(code));
     }
 
     void varid64() {
-        const char code[] = "extern const char (*x[256]);";
+        const char code[] = "extern const char (*x[256]);\n";
         const char expected[] = "1: extern const char ( * x@1 [ 256 ] ) ;\n";
         ASSERT_EQUALS(expected, tokenize(code));
     }
 
     void varid65() { // #10936
         {
-            const char code[] = "extern int (*p);";
+            const char code[] = "extern int (*p);\n";
             const char expected[] = "1: extern int ( * p@1 ) ;\n";
             ASSERT_EQUALS(expected, tokenize(code));
         }
         {
-            const char code[] = "extern int (i);";
+            const char code[] = "extern int (i);\n";
             const char expected[] = "1: extern int ( i@1 ) ;\n";
             ASSERT_EQUALS(expected, tokenize(code));
         }
         {
-            const char code[] = "int (*p);";
+            const char code[] = "int (*p);\n";
             const char expected[] = "1: int ( * p@1 ) ;\n";
             ASSERT_EQUALS(expected, tokenize(code));
         }
         {
-            const char code[] = "int (i);";
+            const char code[] = "int (i);\n";
             const char expected[] = "1: int ( i@1 ) ;\n";
             ASSERT_EQUALS(expected, tokenize(code));
         }
@@ -1280,7 +1277,7 @@ class TestVarID : public TestFixture {
 
     void varid67() { // #11711
         const char code1[] = "int *x;\n"
-                             "_Generic(*x, int: foo, default: bar)();";
+                             "_Generic(*x, int: foo, default: bar)();\n";
         const char expected1[] = "1: int * x@1 ;\n"
                                  "2: _Generic ( * x@1 , int : foo , default : bar ) ( ) ;\n";
         ASSERT_EQUALS(expected1, tokenize(code1, dinit(TokenizeOptions, $.cpp = false)));
@@ -1291,7 +1288,7 @@ class TestVarID : public TestFixture {
                              "char* str_chars(struct S* s);\n"
                              "void f(struct S strOut) {\n"
                              "	 switch (str_chars(&strOut)[0])  {}\n"
-                             "}";
+                             "}\n";
         const char expected1[] = "1: struct S { } ;\n"
                                  "2: char * str_chars ( struct S * s@1 ) ;\n"
                                  "3: void f ( struct S strOut@2 ) {\n"
@@ -1304,7 +1301,7 @@ class TestVarID : public TestFixture {
     void varid69() {
         const char code1[] = "void f() {\n"
                              "    auto g = [](int&, int& r, int i) {};\n"
-                             "}";
+                             "}\n";
         const char expected1[] = "1: void f ( ) {\n"
                                  "2: auto g@1 ; g@1 = [ ] ( int & , int & r@2 , int i@3 ) { } ;\n"
                                  "3: }\n";
@@ -1421,7 +1418,7 @@ class TestVarID : public TestFixture {
     void varid_for_1() {
         const char code[] = "void foo(int a, int b) {\n"
                             "  for (int a=1,b=2;;) {}\n"
-                            "}";
+                            "}\n";
         const char expected[] = "1: void foo ( int a@1 , int b@2 ) {\n"
                                 "2: for ( int a@3 = 1 , b@4 = 2 ; ; ) { }\n"
                                 "3: }\n";
@@ -1431,7 +1428,7 @@ class TestVarID : public TestFixture {
     void varid_for_2() {
         const char code[] = "void foo(int a, int b) {\n"
                             "  for (int a=f(x,y,z),b=2;;) {}\n"
-                            "}";
+                            "}\n";
         const char expected[] = "1: void foo ( int a@1 , int b@2 ) {\n"
                                 "2: for ( int a@3 = f ( x , y , z ) , b@4 = 2 ; ; ) { }\n"
                                 "3: }\n";
@@ -1464,7 +1461,7 @@ class TestVarID : public TestFixture {
         const char code[] = "void f() {\n"
                             "    delete d;\n"
                             "    throw t;\n"
-                            "}";
+                            "}\n";
 
         const char expected[] = "1: void f ( ) {\n"
                                 "2: delete d@1 ;\n"
@@ -1479,27 +1476,27 @@ class TestVarID : public TestFixture {
                             "unsigned long bits, int wake, int delete, struct extent_state **cached_state, "
                             "gfp_t mask) {\n"
                             "  struct extent_state *state;\n"
-                            "}"
+                            "}\n"
                             "int clear_extent_dirty() {\n"
                             "  return clear_extent_bit(tree, start, end, EXTENT_DIRTY | EXTENT_DELALLOC | "
                             "                          EXTENT_DO_ACCOUNTING, 0, 0, NULL, mask);\n"
-                            "}";
+                            "}\n";
         ASSERT_NO_THROW(tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varid_cpp_keywords_in_c_code3() { // #12120
-        const char code[] = "const struct class *p;";
+        const char code[] = "const struct class *p;\n";
         const char expected[] = "1: const struct class * p@1 ;\n";
         ASSERT_EQUALS(expected, tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varid_cpp_keywords_in_c_code4() { // #12120
         {
-            const char code[] = "int false = 0;";
+            const char code[] = "int false = 0;\n";
             ASSERT_THROW_INTERNAL_EQUALS(tokenize(code, dinit(TokenizeOptions, $.cpp = true)), INTERNAL, "Internal error. VarId set for bool literal.");
         }
         {
-            const char code[] = "int false = 0;";
+            const char code[] = "int false = 0;\n";
             ASSERT_EQUALS("1: int false@1 ; false@1 = 0 ;\n", tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
         }
     }
@@ -1508,7 +1505,7 @@ class TestVarID : public TestFixture {
         const char code[] ="void f() {\n"
                             "    int x;\n"
                             "    x = a(y*x,10);\n"
-                            "}";
+                            "}\n";
         const char expected[] = "1: void f ( ) {\n"
                                 "2: int x@1 ;\n"
                                 "3: x@1 = a ( y * x@1 , 10 ) ;\n"
@@ -1520,7 +1517,7 @@ class TestVarID : public TestFixture {
         // #2491
         const char code[] ="void f(int b) {\n"
                             "    x(a*b,10);\n"
-                            "}";
+                            "}\n";
         const std::string expected1("1: void f ( int b@1 ) {\n"
                                     "2: x ( a * b");
         const std::string expected2(" , 10 ) ;\n"
@@ -1533,7 +1530,7 @@ class TestVarID : public TestFixture {
         const char code[] ="void f() {\n"
                             "    int a = 0;\n"
                             "    int b = c - (foo::bar * a);\n"
-                            "}";
+                            "}\n";
 
         const char expected[] = "1: void f ( ) {\n"
                                 "2: int a@1 ; a@1 = 0 ;\n"
@@ -1545,16 +1542,16 @@ class TestVarID : public TestFixture {
 
     void varidFunctionCall4() {
         // Ticket #3280
-        const char code1[] = "void f() { int x; fun(a,b*x); }";
+        const char code1[] = "void f() { int x; fun(a,b*x); }\n";
         ASSERT_EQUALS("1: void f ( ) { int x@1 ; fun ( a , b * x@1 ) ; }\n",
                       tokenize(code1, dinit(TokenizeOptions, $.cpp = false)));
-        const char code2[] = "void f(int a) { int x; fun(a,b*x); }";
+        const char code2[] = "void f(int a) { int x; fun(a,b*x); }\n";
         ASSERT_EQUALS("1: void f ( int a@1 ) { int x@2 ; fun ( a@1 , b * x@2 ) ; }\n",
                       tokenize(code2, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varidFunctionCall5() {
-        const char code[] = "void foo() { (f(x[2]))(x[2]); }";
+        const char code[] = "void foo() { (f(x[2]))(x[2]); }\n";
         ASSERT_EQUALS("1: void foo ( ) { f ( x [ 2 ] ) ( x [ 2 ] ) ; }\n",
                       tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
@@ -1569,7 +1566,7 @@ class TestVarID : public TestFixture {
             "std::list<boost::wave::token_id> tokens;\n"
             "static std::vector<CvsProcess*> ex1;\n"
             "extern std::vector<CvsProcess*> ex2;\n"
-            "std::map<int, 1> m;");
+            "std::map<int, 1> m;\n");
 
         const char expected[] = "1: list < int > ints@1 ;\n"
                                 "2: list < int > :: iterator it@2 ;\n"
@@ -1585,7 +1582,7 @@ class TestVarID : public TestFixture {
     }
 
     void varidStl2() {
-        const std::string actual = tokenize("std::bitset<static_cast<int>(2)> x;");
+        const std::string actual = tokenize("std::bitset<static_cast<int>(2)> x;\n");
 
         const char expected[] = "1: std :: bitset < static_cast < int > ( 2 ) > x@1 ;\n";
 
@@ -1594,7 +1591,7 @@ class TestVarID : public TestFixture {
 
     void varid_newauto() {
         ASSERT_EQUALS("1: void f ( ) { const new auto ( 0 ) ; }\n",
-                      tokenize("void f(){new const auto(0);}"));
+                      tokenize("void f(){new const auto(0);}\n"));
     }
 
     void varid_delete() {
@@ -1603,7 +1600,7 @@ class TestVarID : public TestFixture {
             "{\n"
             "  int *a;\n"
             "  delete a;\n"
-            "}");
+            "}\n");
 
         const char expected[] = "1: void f ( )\n"
                                 "2: {\n"
@@ -1654,7 +1651,7 @@ class TestVarID : public TestFixture {
                 "void f3(const std::string &s)\n"
                 "{\n"
                 "    s.size();\n"
-                "}");
+                "}\n");
 
             const char expected[] = "1: void f1 ( int & p@1 )\n"
                                     "2: {\n"
@@ -1673,13 +1670,13 @@ class TestVarID : public TestFixture {
         }
 
         {
-            const std::string actual = tokenize("void f(struct foobar);", dinit(TokenizeOptions, $.cpp = false));
+            const std::string actual = tokenize("void f(struct foobar);\n", dinit(TokenizeOptions, $.cpp = false));
             const char expected[] = "1: void f ( struct foobar ) ;\n";
             ASSERT_EQUALS(expected, actual);
         }
 
         {
-            const std::string actual = tokenize("bool f(X x, int=3);");
+            const std::string actual = tokenize("bool f(X x, int=3);\n");
             const char expected[] = "1: bool f ( X x@1 , int = 3 ) ;\n";
             ASSERT_EQUALS(expected, actual);
         }
@@ -1716,7 +1713,7 @@ class TestVarID : public TestFixture {
     }
 
     void varid_sizeof() {
-        const char code[] = "x = sizeof(a*b);";
+        const char code[] = "x = sizeof(a*b);\n";
         const char expected[] = "1: x = sizeof ( a * b ) ;\n";
         ASSERT_EQUALS(expected, tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
@@ -1728,7 +1725,7 @@ class TestVarID : public TestFixture {
             "    std::vector<int> b;\n"
             "    std::vector<int> &a = b;\n"
             "    std::vector<int> *c = &b;\n"
-            "}");
+            "}\n");
 
         const char expected[] = "1: void f ( )\n"
                                 "2: {\n"
@@ -1748,7 +1745,7 @@ class TestVarID : public TestFixture {
                 "public:\n"
                 "    std::string name1;\n"
                 "    std::string name2;\n"
-                "};");
+                "};\n");
 
             const char expected[] = "1: class Foo\n"
                                     "2: {\n"
@@ -1774,7 +1771,7 @@ class TestVarID : public TestFixture {
                 "    POINT pOutput = { 0 , 0 };\n"
                 "    int x = pOutput.x;\n"
                 "    int y = pOutput.y;\n"
-                "}");
+                "}\n");
 
             const char expected[] = "1: class foo\n"
                                     "2: {\n"
@@ -1809,7 +1806,7 @@ class TestVarID : public TestFixture {
             "void Bar::f()\n"
             "{\n"
             "    foo.x = x;\n"
-            "}");
+            "}\n");
         const char expected[] = "1: struct Foo {\n"
                                 "2: int x@1 ;\n"
                                 "3: } ;\n"
@@ -1833,7 +1830,7 @@ class TestVarID : public TestFixture {
                             "        Bar x(*this);\n"  // <- ..
                             "    }\n"
                             "    int x;\n"   // <- .. don't assign same varid
-                            "};";
+                            "};\n";
         ASSERT_EQUALS("1: class Foo {\n"
                       "2: void blah ( ) {\n"
                       "3: Bar x@1 ( * this ) ;\n"
@@ -1845,7 +1842,7 @@ class TestVarID : public TestFixture {
     void varid_in_class4() {
         const char code[] = "class Foo {\n"
                             "public: class C;\n"
-                            "};";
+                            "};\n";
         ASSERT_EQUALS("1: class Foo {\n"
                       "2: public: class C ;\n"
                       "3: } ;\n",
@@ -1855,7 +1852,7 @@ class TestVarID : public TestFixture {
     void varid_in_class5() {
         const char code[] = "struct Foo {\n"
                             "    std::vector<::X> v;\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("1: struct Foo {\n"
                       "2: std :: vector < :: X > v@1 ;\n"
                       "3: }\n",
@@ -1868,7 +1865,7 @@ class TestVarID : public TestFixture {
                             "        std::stringstream sst;\n"
                             "        sst.str();\n"
                             "    }\n"
-                            "};";
+                            "};\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: void f ( const char * str@1 ) const {\n"
                       "3: std :: stringstream sst@2 ;\n"
@@ -1884,7 +1881,7 @@ class TestVarID : public TestFixture {
                             "        abc.a = 0;\n"
                             "    }\n"
                             "    struct ABC abc;\n"
-                            "};";
+                            "};\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: void f ( ) {\n"
                       "3: abc@1 . a@2 = 0 ;\n"
@@ -1899,7 +1896,7 @@ class TestVarID : public TestFixture {
                             "  UNKNOWN_MACRO(A)\n"
                             "private:\n"
                             "  int x;\n"
-                            "};";
+                            "};\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: UNKNOWN_MACRO ( A )\n"
                       "3: private:\n"
@@ -1916,7 +1913,7 @@ class TestVarID : public TestFixture {
                              "};\n"
                              "void A::setVar() {\n"
                              "  this->var = var;\n"
-                             "}";
+                             "}\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: int var@1 ;\n"
                       "3: public:\n"
@@ -1933,7 +1930,7 @@ class TestVarID : public TestFixture {
                              "};\n"
                              "void Foo::Clone(FooBase& g) {\n"
                              "    g->m_bar = m_bar;\n"
-                             "}";
+                             "}\n";
         ASSERT_EQUALS("1: class Foo : public FooBase {\n"
                       "2: void Clone ( FooBase & g@1 ) ;\n"
                       "3: short m_bar@2 ;\n"
@@ -1951,7 +1948,7 @@ class TestVarID : public TestFixture {
                             "};\n"
                             "void Foo::Clone(FooBase& g) {\n"
                             "    ((FooBase)g)->m_bar = m_bar;\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("1: class Foo : public FooBase {\n"
                       "2: void Clone ( FooBase & g@1 ) ;\n"
                       "3: short m_bar@2 ;\n"
@@ -1966,7 +1963,7 @@ class TestVarID : public TestFixture {
         const char code1[] = "class Foo {\n"
                              "    union { float a; int b; };\n"
                              "    void f() { a=0; }\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class Foo {\n"
                       "2: union { float a@1 ; int b@2 ; } ;\n"
                       "3: void f ( ) { a@1 = 0 ; }\n"
@@ -1976,7 +1973,7 @@ class TestVarID : public TestFixture {
         const char code2[] = "class Foo {\n"
                              "    void f() { a=0; }\n"
                              "    union { float a; int b; };\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class Foo {\n"
                       "2: void f ( ) { a@1 = 0 ; }\n"
                       "3: union { float a@1 ; int b@2 ; } ;\n"
@@ -1992,7 +1989,7 @@ class TestVarID : public TestFixture {
                              "    };\n"
                              "    g(abcd);\n"
                              "    h(a, b, c, d);\n"
-                             "}";
+                             "}\n";
         ASSERT_EQUALS("1: void f ( ) {\n"
                       "2: union {\n"
                       "3: struct {\n"
@@ -2009,7 +2006,7 @@ class TestVarID : public TestFixture {
         const char code4[] = "class Foo {\n"
                              "    void f(float a) { this->a = a; }\n"
                              "    union { float a; int b; };\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class Foo {\n"
                       "2: void f ( float a@1 ) { this . a@2 = a@1 ; }\n"
                       "3: union { float a@2 ; int b@3 ; } ;\n"
@@ -2021,7 +2018,7 @@ class TestVarID : public TestFixture {
         const char code[] = "class Foo {\n"
                             "private:\n"
                             "    void f(void);\n"
-                            "};";
+                            "};\n";
         ASSERT_EQUALS("1: class Foo {\n"
                       "2: private:\n"
                       "3: void f ( ) ;\n"
@@ -2030,13 +2027,13 @@ class TestVarID : public TestFixture {
     }
 
     void varid_in_class13() {
-        const char code1[] = "struct a { char typename; };";
+        const char code1[] = "struct a { char typename; };\n";
         ASSERT_EQUALS("1: struct a { char typename@1 ; } ;\n",
                       tokenize(code1, dinit(TokenizeOptions, $.cpp = false)));
         ASSERT_EQUALS("1: struct a { char typename ; } ;\n",  // not valid C++ code
                       tokenize(code1));
 
-        const char code2[] = "struct a { char typename[2]; };";
+        const char code2[] = "struct a { char typename[2]; };\n";
         ASSERT_EQUALS("1: struct a { char typename@1 [ 2 ] ; } ;\n",
                       tokenize(code2, dinit(TokenizeOptions, $.cpp = false)));
         ASSERT_EQUALS("1: struct a { char typename [ 2 ] ; } ;\n",  // not valid C++ code
@@ -2116,7 +2113,7 @@ class TestVarID : public TestFixture {
                              "    FOO Set(BAR);\n"
                              "    int method_with_class(B<B> b);\n"
                              "    bool function(std::map<int, int, MYless> & m);\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class Fred {\n"
                       "2: int method_with_internal ( X & ) ;\n"
                       "3: int method_with_internal ( X * ) ;\n"
@@ -2134,7 +2131,7 @@ class TestVarID : public TestFixture {
                              "SomeType someVar1(i, i);\n"
                              "SomeType someVar2(j, j);\n"
                              "SomeType someVar3(j, 1);\n"
-                             "SomeType someVar4(new bar);";
+                             "SomeType someVar4(new bar);\n";
         ASSERT_EQUALS("1: int i@1 ;\n"
                       "2: SomeType someVar1@2 ( i@1 , i@1 ) ;\n"
                       "3: SomeType someVar2 ( j , j ) ;\n" // This one could be a function
@@ -2152,7 +2149,7 @@ class TestVarID : public TestFixture {
                             "};\n"
                             "A::B::B() :\n"
                             "    i(0)\n"
-                            "{}";
+                            "{}\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: class B ;\n"
                       "3: } ;\n"
@@ -2172,7 +2169,7 @@ class TestVarID : public TestFixture {
                             "};\n"
                             "Fred::~Fred() {\n"
                             "    free(str1);\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("1: class Fred {\n"
                       "2: char * str1@1 ;\n"
                       "3: ~ Fred ( ) ;\n"
@@ -2190,7 +2187,7 @@ class TestVarID : public TestFixture {
                             "    cacheEntry();\n"
                             "};\n"
                             "\n"
-                            "template<class C> cacheEntry<C>::cacheEntry() : m_key() {}";
+                            "template<class C> cacheEntry<C>::cacheEntry() : m_key() {}\n";
 
         ASSERT_EQUALS("1: template < class C > class cacheEntry {\n"
                       "2: protected:\n"
@@ -2210,7 +2207,7 @@ class TestVarID : public TestFixture {
                             "};\n"
                             "\n"
                             "template <typename t1,typename t2>\n"
-                            "A::B<t1,t2>::B() : x(9) {}";
+                            "A::B<t1,t2>::B() : x(9) {}\n";
 
         const char expected[] = "1: template < typename t1 , typename t2 >\n"
                                 "2: class A :: B {\n"
@@ -2433,7 +2430,7 @@ class TestVarID : public TestFixture {
                             "    int x;\n"
                             "    union { char y; };\n"
                             "  };\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("1: namespace Blah {\n"
                       "2: struct foo { int x@1 ; } ;\n"
                       "3: struct bar {\n"
@@ -2455,7 +2452,7 @@ class TestVarID : public TestFixture {
                             "\n"
                             "void C::dostuff() {\n"
                             "   X = 0;\n"  // X@2
-                            "}";
+                            "}\n";
 
         const std::string actual = tokenize(code);
 
@@ -2486,7 +2483,7 @@ class TestVarID : public TestFixture {
                             "void Bar::f() {\n"
                             "  type = 0;\n"  // <- ... and here
                             "}\n"
-                            "}";
+                            "}\n";
 
         const std::string actual = tokenize(code);
 
@@ -2501,7 +2498,7 @@ class TestVarID : public TestFixture {
                             "    void dostuff();\n"
                             "  };\n"
                             "  void bar::dostuff() { int x2 = x * 2; }\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("1: namespace X {\n"
                       "2: struct foo { int x@1 ; } ;\n"
                       "3: struct bar : public foo {\n"
@@ -2520,7 +2517,7 @@ class TestVarID : public TestFixture {
                             "    };\n"
                             "    void bar::dostuff() { int x2 = x * 2; }\n"
                             "  }\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("1: namespace X {\n"
                       "2: struct foo { int x@1 ; } ;\n"
                       "3: namespace Y {\n"
@@ -2542,7 +2539,7 @@ class TestVarID : public TestFixture {
                             "            std::map<Vec2i, int>::iterator iter;\n"
                             "        }\n"
                             "    }\n"
-                            "}";
+                            "}\n";
         ASSERT_EQUALS("1: namespace N {\n"
                       "2: namespace O {\n"
                       "3: U :: U ( int * map@1 ) : id ( 0 ) {\n"
@@ -2559,7 +2556,7 @@ class TestVarID : public TestFixture {
         const char code1[] = "class A {\n"
                              "  A() : x(0) {}\n"
                              "  int x;\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: A ( ) : x@1 ( 0 ) { }\n"
                       "3: int x@1 ;\n"
@@ -2569,7 +2566,7 @@ class TestVarID : public TestFixture {
         const char code2[] = "class A {\n"
                              "  A(int x) : x(x) {}\n"
                              "  int x;\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: A ( int x@1 ) : x@2 ( x@1 ) { }\n"
                       "3: int x@2 ;\n"
@@ -2580,7 +2577,7 @@ class TestVarID : public TestFixture {
                              "  A(int x);\n"
                              "  int x;\n"
                              "};\n"
-                             "A::A(int x) : x(x) {}";
+                             "A::A(int x) : x(x) {}\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: A ( int x@1 ) ;\n"
                       "3: int x@2 ;\n"
@@ -2601,7 +2598,7 @@ class TestVarID : public TestFixture {
         const char code5[] = "class A {\n"
                              "  A(int x) noexcept : x(x) {}\n"
                              "  int x;\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: A ( int x@1 ) noexcept ( true ) : x@2 ( x@1 ) { }\n"
                       "3: int x@2 ;\n"
@@ -2611,7 +2608,7 @@ class TestVarID : public TestFixture {
         const char code6[] = "class A {\n"
                              "  A(int x) noexcept(true) : x(x) {}\n"
                              "  int x;\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: A ( int x@1 ) noexcept ( true ) : x@2 ( x@1 ) { }\n"
                       "3: int x@2 ;\n"
@@ -2621,7 +2618,7 @@ class TestVarID : public TestFixture {
         const char code7[] = "class A {\n"
                              "  A(int x) noexcept(false) : x(x) {}\n"
                              "  int x;\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: A ( int x@1 ) noexcept ( false ) : x@2 ( x@1 ) { }\n"
                       "3: int x@2 ;\n"
@@ -2631,7 +2628,7 @@ class TestVarID : public TestFixture {
         const char code8[] = "class Foo : public Bar {\n"
                              "  explicit Foo(int i) : Bar(mi = i) { }\n"
                              "  int mi;\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class Foo : public Bar {\n"
                       "2: explicit Foo ( int i@1 ) : Bar ( mi@2 = i@1 ) { }\n"
                       "3: int mi@2 ;\n"
@@ -2642,7 +2639,7 @@ class TestVarID : public TestFixture {
         const char code9[] = "class A {\n"
                              "  A(int x) : y(a?0:1), x(x) {}\n"
                              "  int x, y;\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: A ( int x@1 ) : y@3 ( a ? 0 : 1 ) , x@2 ( x@1 ) { }\n"
                       "3: int x@2 ; int y@3 ;\n"
@@ -2655,7 +2652,7 @@ class TestVarID : public TestFixture {
                               "  A(const Matrix &m) throw (e);\n"
                               "};\n"
                               "A::A(const Matrix &m) throw (e) : work(0)\n"
-                              "{}";
+                              "{}\n";
         ASSERT_EQUALS("1: class A {\n"
                       "2: double * work@1 ;\n"
                       "3: A ( const Matrix & m@2 ) throw ( e ) ;\n"
@@ -2667,7 +2664,7 @@ class TestVarID : public TestFixture {
         const char code11[] = "struct S {\n" // #12733
                               "    explicit S(int& r) : a{ int{ 1 } }, b{ r } {}\n"
                               "    int a, &b;\n"
-                              "};";
+                              "};\n";
         ASSERT_EQUALS("1: struct S {\n"
                       "2: explicit S ( int & r@1 ) : a@2 { int { 1 } } , b@3 { r@1 } { }\n"
                       "3: int a@2 ; int & b@3 ;\n"
@@ -2723,7 +2720,7 @@ class TestVarID : public TestFixture {
         const char code1[] = "class A : B<C,D> {\n"
                              "  A() : B<C,D>(), x(0) {}\n"
                              "  int x;\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class A : B < C , D > {\n"
                       "2: A ( ) : B < C , D > ( ) , x@1 ( 0 ) { }\n"
                       "3: int x@1 ;\n"
@@ -2733,7 +2730,7 @@ class TestVarID : public TestFixture {
         const char code2[] = "class A : B<C,D> {\n"
                              "  A(int x) : x(x) {}\n"
                              "  int x;\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class A : B < C , D > {\n"
                       "2: A ( int x@1 ) : x@2 ( x@1 ) { }\n"
                       "3: int x@2 ;\n"
@@ -2744,7 +2741,7 @@ class TestVarID : public TestFixture {
                              "  A(int x);\n"
                              "  int x;\n"
                              "};\n"
-                             "A::A(int x) : x(x) {}";
+                             "A::A(int x) : x(x) {}\n";
         ASSERT_EQUALS("1: class A : B < C , D > {\n"
                       "2: A ( int x@1 ) ;\n"
                       "3: int x@2 ;\n"
@@ -2768,7 +2765,7 @@ class TestVarID : public TestFixture {
                              "};\n"
                              "BCLass::BCLass() : Ticket<void>() {\n"
                              "  member = 0;\n"
-                             "}";
+                             "}\n";
         ASSERT_EQUALS("1: class BCLass : public Ticket < void > {\n"
                       "2: BCLass ( ) ;\n"
                       "3: PClass * member@1 ;\n"
@@ -2783,7 +2780,7 @@ class TestVarID : public TestFixture {
         const char code1[] = "class A : public B::C {\n"
                              "  A() : B::C(), x(0) {}\n"
                              "  int x;\n"
-                             "};";
+                             "};\n";
         ASSERT_EQUALS("1: class A : public B :: C {\n"
                       "2: A ( ) : B :: C ( ) , x@1 ( 0 ) { }\n"
                       "3: int x@1 ;\n"
@@ -2798,7 +2795,7 @@ class TestVarID : public TestFixture {
                 "{\n"
                 "public:\n"
                 "    void operator=(const Foo &);\n"
-                "};");
+                "};\n");
 
             const char expected[] = "1: class Foo\n"
                                     "2: {\n"
@@ -2812,7 +2809,7 @@ class TestVarID : public TestFixture {
             const std::string actual = tokenize(
                 "struct Foo {\n"
                 "    void * operator new [](int);\n"
-                "};");
+                "};\n");
             const char expected[] = "1: struct Foo {\n"
                                     "2: void * operatornew[] ( int ) ;\n"
                                     "3: } ;\n";
@@ -2824,7 +2821,7 @@ class TestVarID : public TestFixture {
     void varid_throw() {  // ticket #1723
         const std::string actual = tokenize(
             "UserDefinedException* pe = new UserDefinedException();\n"
-            "throw pe;");
+            "throw pe;\n");
 
         const char expected[] = "1: UserDefinedException * pe@1 ; pe@1 = new UserDefinedException ( ) ;\n"
                                 "2: throw pe@1 ;\n";
@@ -2838,7 +2835,7 @@ class TestVarID : public TestFixture {
                             "    int a[10];\n"
                             "    AAA\n"
                             "    a[0] = 0;\n"
-                            "}";
+                            "}\n";
         const char expected[] = "1: void f ( ) {\n"
                                 "2: int a@1 [ 10 ] ;\n"
                                 "3: AAA\n"
@@ -2849,7 +2846,7 @@ class TestVarID : public TestFixture {
 
     void varid_using() {
         // #3648
-        const char code[] = "using std::size_t;";
+        const char code[] = "using std::size_t;\n";
         const char expected[] = "1: ;\n";
         ASSERT_EQUALS(expected, tokenize(code));
     }
@@ -2858,7 +2855,7 @@ class TestVarID : public TestFixture {
         const char code[] = "void f() {\n"
                             "    try { dostuff(); }\n"
                             "    catch (exception &e) { }\n"
-                            "}";
+                            "}\n";
         const char expected[] = "1: void f ( ) {\n"
                                 "2: try { dostuff ( ) ; }\n"
                                 "3: catch ( exception & e@1 ) { }\n"
@@ -2867,20 +2864,20 @@ class TestVarID : public TestFixture {
     }
 
     void varid_functionPrototypeTemplate() {
-        ASSERT_EQUALS("1: function < void ( ) > fptr@1 ;\n", tokenize("function<void(void)> fptr;"));
+        ASSERT_EQUALS("1: function < void ( ) > fptr@1 ;\n", tokenize("function<void(void)> fptr;\n"));
     }
 
     void varid_templatePtr() {
-        ASSERT_EQUALS("1: std :: map < int , FooTemplate < int > * > dummy_member@1 [ 1 ] ;\n", tokenize("std::map<int, FooTemplate<int>*> dummy_member[1];"));
+        ASSERT_EQUALS("1: std :: map < int , FooTemplate < int > * > dummy_member@1 [ 1 ] ;\n", tokenize("std::map<int, FooTemplate<int>*> dummy_member[1];\n"));
     }
 
     void varid_templateNamespaceFuncPtr() {
-        ASSERT_EQUALS("1: KeyListT < float , & NIFFile :: getFloat > mKeyList@1 [ 4 ] ;\n", tokenize("KeyListT<float, &NIFFile::getFloat> mKeyList[4];"));
+        ASSERT_EQUALS("1: KeyListT < float , & NIFFile :: getFloat > mKeyList@1 [ 4 ] ;\n", tokenize("KeyListT<float, &NIFFile::getFloat> mKeyList[4];\n"));
     }
 
     void varid_templateArray() {
         ASSERT_EQUALS("1: VertexArrayIterator < float [ 2 ] > attrPos@1 ; attrPos@1 = m_AttributePos . GetIterator < float [ 2 ] > ( ) ;\n",
-                      tokenize("VertexArrayIterator<float[2]> attrPos = m_AttributePos.GetIterator<float[2]>();"));
+                      tokenize("VertexArrayIterator<float[2]> attrPos = m_AttributePos.GetIterator<float[2]>();\n"));
     }
 
     void varid_templateParameter() {
@@ -2913,7 +2910,7 @@ class TestVarID : public TestFixture {
 
     void varid_templateUsing() { // #5781 #7273
         const char code[] = "template<class T> using X = Y<T,4>;\n"
-                            "X<int> x;";
+                            "X<int> x;\n";
         ASSERT_EQUALS("2: Y < int , 4 > x@1 ;\n",
                       tokenize(code));
     }
@@ -2932,62 +2929,62 @@ class TestVarID : public TestFixture {
     }
 
     void varid_not_template_in_condition() {
-        const char code1[] = "void f() { if (x<a||x>b); }";
+        const char code1[] = "void f() { if (x<a||x>b); }\n";
         ASSERT_EQUALS("1: void f ( ) { if ( x < a || x > b ) { ; } }\n", tokenize(code1));
 
-        const char code2[] = "void f() { if (1+x<a||x>b); }";
+        const char code2[] = "void f() { if (1+x<a||x>b); }\n";
         ASSERT_EQUALS("1: void f ( ) { if ( 1 + x < a || x > b ) { ; } }\n", tokenize(code2));
 
-        const char code3[] = "void f() { if (x<a||x>b+1); }";
+        const char code3[] = "void f() { if (x<a||x>b+1); }\n";
         ASSERT_EQUALS("1: void f ( ) { if ( x < a || x > b + 1 ) { ; } }\n", tokenize(code3));
 
-        const char code4[] = "void f() { if ((x==13) && (x<a||x>b)); }";
+        const char code4[] = "void f() { if ((x==13) && (x<a||x>b)); }\n";
         ASSERT_EQUALS("1: void f ( ) { if ( ( x == 13 ) && ( x < a || x > b ) ) { ; } }\n", tokenize(code4));
     }
 
     void varid_cppcast() {
         ASSERT_EQUALS("1: const_cast < int * > ( code ) [ 0 ] = 0 ;\n",
-                      tokenize("const_cast<int *>(code)[0] = 0;"));
+                      tokenize("const_cast<int *>(code)[0] = 0;\n"));
 
         ASSERT_EQUALS("1: dynamic_cast < int * > ( code ) [ 0 ] = 0 ;\n",
-                      tokenize("dynamic_cast<int *>(code)[0] = 0;"));
+                      tokenize("dynamic_cast<int *>(code)[0] = 0;\n"));
 
         ASSERT_EQUALS("1: reinterpret_cast < int * > ( code ) [ 0 ] = 0 ;\n",
-                      tokenize("reinterpret_cast<int *>(code)[0] = 0;"));
+                      tokenize("reinterpret_cast<int *>(code)[0] = 0;\n"));
 
         ASSERT_EQUALS("1: static_cast < int * > ( code ) [ 0 ] = 0 ;\n",
-                      tokenize("static_cast<int *>(code)[0] = 0;"));
+                      tokenize("static_cast<int *>(code)[0] = 0;\n"));
     }
 
     void varid_variadicFunc() {
-        ASSERT_EQUALS("1: int foo ( ... ) ;\n", tokenize("int foo(...);"));
+        ASSERT_EQUALS("1: int foo ( ... ) ;\n", tokenize("int foo(...);\n"));
     }
 
     void varid_typename() {
-        ASSERT_EQUALS("1: template < int d , class A , class B > struct S { } ;\n", tokenize("template<int d, class A, class B> struct S {};"));
+        ASSERT_EQUALS("1: template < int d , class A , class B > struct S { } ;\n", tokenize("template<int d, class A, class B> struct S {};\n"));
 
-        ASSERT_EQUALS("1: template < int d , typename A , typename B > struct S { } ;\n", tokenize("template<int d, typename A, typename B> struct S {};"));
+        ASSERT_EQUALS("1: template < int d , typename A , typename B > struct S { } ;\n", tokenize("template<int d, typename A, typename B> struct S {};\n"));
 
-        ASSERT_EQUALS("1: A a@1 ;\n", tokenize("typename A a;"));
+        ASSERT_EQUALS("1: A a@1 ;\n", tokenize("typename A a;\n"));
     }
 
     void varid_rvalueref() {
-        ASSERT_EQUALS("1: int && a@1 ;\n", tokenize("int&& a;"));
+        ASSERT_EQUALS("1: int && a@1 ;\n", tokenize("int&& a;\n"));
 
-        ASSERT_EQUALS("1: void foo ( int && a@1 ) { }\n", tokenize("void foo(int&& a) {}"));
+        ASSERT_EQUALS("1: void foo ( int && a@1 ) { }\n", tokenize("void foo(int&& a) {}\n"));
 
         ASSERT_EQUALS("1: class C {\n"
                       "2: C ( int && a@1 ) ;\n"
                       "3: } ;\n",
                       tokenize("class C {\n"
                                "    C(int&& a);\n"
-                               "};"));
+                               "};\n"));
 
-        ASSERT_EQUALS("1: void foo ( int && ) ;\n", tokenize("void foo(int&&);"));
+        ASSERT_EQUALS("1: void foo ( int && ) ;\n", tokenize("void foo(int&&);\n"));
     }
 
     void varid_arrayFuncPar() {
-        ASSERT_EQUALS("1: void check ( const char fname@1 [ ] = 0 ) { }\n", tokenize("void check( const char fname[] = 0) { }"));
+        ASSERT_EQUALS("1: void check ( const char fname@1 [ ] = 0 ) { }\n", tokenize("void check( const char fname[] = 0) { }\n"));
     }
 
     void varid_sizeofPassed() {
@@ -3000,7 +2997,7 @@ class TestVarID : public TestFixture {
                                "    const char* argv[] = { \"./test_runner\", \"TestClass\" };\n"
                                "    options args(sizeof argv / sizeof argv[0], argv);\n"
                                "    args.which_test();\n"
-                               "}"));
+                               "}\n"));
     }
 
     void varid_classInFunction() {
@@ -3015,7 +3012,7 @@ class TestVarID : public TestFixture {
                                "        void reportErr(ErrorLogger::ErrorMessage &msg) {\n"
                                "        }\n"
                                "    };\n"
-                               "}"));
+                               "}\n"));
     }
 
     void varid_pointerToArray() {
@@ -3040,7 +3037,7 @@ class TestVarID : public TestFixture {
                                "    int f2(int i) { return a4[i]; }\n"
                                "    int f3(int(&a5)[10], int i) { return a5[i]; }\n"
                                "};\n"
-                               "int f4(int(&a6)[10], int i) { return a6[i]; }"));
+                               "int f4(int(&a6)[10], int i) { return a6[i]; }\n"));
     }
 
     void varid_cpp11initialization() {
@@ -3053,15 +3050,15 @@ class TestVarID : public TestFixture {
                                "std::vector<int> vec{1, 2, 3};\n"
                                "namespace n { int z; };\n"
                                "int& j{i};\n"
-                               "int k{1}, l{2};"));
+                               "int k{1}, l{2};\n"));
 
         // #6030
         ASSERT_EQUALS("1: struct S3 : public S1 , public S2 { } ;\n",
-                      tokenize("struct S3 : public S1, public S2 { };"));
+                      tokenize("struct S3 : public S1, public S2 { };\n"));
 
         // #6058
         ASSERT_EQUALS("1: class Scope { } ;\n",
-                      tokenize("class CPPCHECKLIB Scope { };"));
+                      tokenize("class CPPCHECKLIB Scope { };\n"));
 
         // #6073 #6253
         ASSERT_EQUALS("1: class A : public B , public C :: D , public E < F > :: G < H > {\n"
@@ -3075,7 +3072,7 @@ class TestVarID : public TestFixture {
                                "    A(int i): B{i}, C::D{i}, E<F>::G<H>{i} ,i{i} {\n"
                                "        int j{i};\n"
                                "    }\n"
-                               "};"));
+                               "};\n"));
 
         ASSERT_EQUALS("1: struct Sx { int i@1 ; } ;\n" // #14733
                       "2: struct Sx sx@2 { 0 } ;\n",
@@ -3101,7 +3098,7 @@ class TestVarID : public TestFixture {
                                "};\n"
                                "void B::f() {\n"
                                "    a = 0;\n"
-                               "}"));
+                               "}\n"));
 
         ASSERT_EQUALS("1: class A {\n"
                       "2: int a@1 ;\n"
@@ -3120,7 +3117,7 @@ class TestVarID : public TestFixture {
                                "};\n"
                                "void B::f() {\n"
                                "    a = 0;\n"
-                               "}"));
+                               "}\n"));
 
         ASSERT_EQUALS("1: class A {\n"
                       "2: int a@1 ;\n"
@@ -3139,7 +3136,7 @@ class TestVarID : public TestFixture {
                                "};\n"
                                "void B::f() {\n"
                                "    a = 0;\n"
-                               "}"));
+                               "}\n"));
 
         ASSERT_EQUALS("1: class A {\n"
                       "2: int a@1 ;\n"
@@ -3156,7 +3153,7 @@ class TestVarID : public TestFixture {
                                "    void f() {\n"
                                "        a = 0;\n"
                                "    }\n"
-                               "};"));
+                               "};\n"));
     }
 
     void varid_header() {
@@ -3167,7 +3164,7 @@ class TestVarID : public TestFixture {
                       tokenizeHeader("class A;\n"
                                      "struct B {\n"
                                      "    void setData(const A & a);\n"
-                                     "}; ", "test.h"));
+                                     "}; \n", "test.h"));
         ASSERT_EQUALS("1: class A ;\n"
                       "2: struct B {\n"
                       "3: void setData ( const A & a@1 ) ;\n"
@@ -3175,7 +3172,7 @@ class TestVarID : public TestFixture {
                       tokenizeHeader("class A;\n"
                                      "struct B {\n"
                                      "    void setData(const A & a);\n"
-                                     "}; ", "test.hpp"));
+                                     "}; \n", "test.hpp"));
         ASSERT_EQUALS("1: void f ( )\n"
                       "2: {\n"
                       "3: int class@1 ;\n"
@@ -3183,7 +3180,7 @@ class TestVarID : public TestFixture {
                       tokenizeHeader("void f()\n"
                                      "{\n"
                                      "    int class;\n"
-                                     "}", "test.h"));
+                                     "}\n", "test.h"));
     }
 
     void varid_rangeBasedFor() {
@@ -3194,7 +3191,7 @@ class TestVarID : public TestFixture {
                       tokenize("void reset(Foo array) {\n"
                                "    for (auto& e : array)\n"
                                "        foo(e);\n"
-                               "};"));
+                               "};\n"));
 
         ASSERT_EQUALS("1: void reset ( Foo array@1 ) {\n"
                       "2: for ( auto e@2 : array@1 ) {\n"
@@ -3203,7 +3200,7 @@ class TestVarID : public TestFixture {
                       tokenize("void reset(Foo array) {\n"
                                "    for (auto e : array)\n"
                                "        foo(e);\n"
-                               "};"));
+                               "};\n"));
 
         // Labels are no variables
         ASSERT_EQUALS("1: void foo ( ) {\n"
@@ -3223,7 +3220,7 @@ class TestVarID : public TestFixture {
                                "        delta = 1;\n"
                                "        break;\n"
                                "    }\n"
-                               "}", dinit(TokenizeOptions, $.cpp = false)));
+                               "}\n", dinit(TokenizeOptions, $.cpp = false)));
 
         ASSERT_EQUALS("1: int * f ( ) {\n" // #11838
                       "2: int * label@1 ; label@1 = 0 ;\n"
@@ -3234,7 +3231,7 @@ class TestVarID : public TestFixture {
                                "    int* label = 0;\n"
                                "label:\n"
                                "    return label;\n"
-                               "}"));
+                               "}\n"));
     }
 
     void varid_structinit() { // #6406
@@ -3243,21 +3240,21 @@ class TestVarID : public TestFixture {
                       "3: }\n",
                       tokenize("void foo() {\n"
                                "  struct ABC abc = {.a=0,.b=1};\n"
-                               "}"));
+                               "}\n"));
 
         ASSERT_EQUALS("1: void foo ( ) {\n"
                       "2: struct ABC abc@1 ; abc@1 = { . a@2 = abc@1 . a@2 , . b@3 = abc@1 . b@3 } ;\n"
                       "3: }\n",
                       tokenize("void foo() {\n"
                                "  struct ABC abc = {.a=abc.a,.b=abc.b};\n"
-                               "}"));
+                               "}\n"));
 
         ASSERT_EQUALS("1: void foo ( ) {\n"
                       "2: struct ABC abc@1 ; abc@1 = { . a@2 { abc@1 . a@2 } , . b@3 = { abc@1 . b@3 } } ;\n"
                       "3: }\n",
                       tokenize("void foo() {\n"
                                "  struct ABC abc = {.a { abc.a },.b= { abc.b } };\n"
-                               "}"));
+                               "}\n"));
 
         ASSERT_EQUALS("1: struct T { int a@1 ; } ;\n" // #13123
                       "2: void f ( int a@2 ) {\n"
@@ -3286,10 +3283,10 @@ class TestVarID : public TestFixture {
 
     void varid_arrayinit() {
         // #7579 - no variable declaration in rhs
-        ASSERT_EQUALS("1: void foo ( int * a@1 ) { int b@2 [ 1 ] = { x * a@1 [ 0 ] } ; }\n", tokenize("void foo(int*a) { int b[] = { x*a[0] }; }"));
+        ASSERT_EQUALS("1: void foo ( int * a@1 ) { int b@2 [ 1 ] = { x * a@1 [ 0 ] } ; }\n", tokenize("void foo(int*a) { int b[] = { x*a[0] }; }\n"));
 
         // #12402
-        ASSERT_EQUALS("1: void f ( ) { void ( * p@1 [ 1 ] ) ( int ) = { [ ] ( int i@2 ) { } } ; }\n", tokenize("void f() { void (*p[1])(int) = { [](int i) {} }; }"));
+        ASSERT_EQUALS("1: void f ( ) { void ( * p@1 [ 1 ] ) ( int ) = { [ ] ( int i@2 ) { } } ; }\n", tokenize("void f() { void (*p[1])(int) = { [](int i) {} }; }\n"));
     }
 
     void varid_lambda_arg() {
@@ -3297,7 +3294,7 @@ class TestVarID : public TestFixture {
         {
             const char code[] = "static void func(int ec) {\n"
                                 "    func2([](const std::error_code& ec) { return ec; });\n"
-                                "}";
+                                "}\n";
             const char exp[] = "1: static void func ( int ec@1 ) {\n"
                                "2: func2 ( [ ] ( const std :: error_code & ec@2 ) { return ec@2 ; } ) ;\n"
                                "3: }\n";
@@ -3306,7 +3303,7 @@ class TestVarID : public TestFixture {
         {
             const char code[] = "static void func(int ec) {\n"
                                 "    func2([](int x, const std::error_code& ec) { return x + ec; });\n"
-                                "}";
+                                "}\n";
             const char exp[] = "1: static void func ( int ec@1 ) {\n"
                                "2: func2 ( [ ] ( int x@2 , const std :: error_code & ec@3 ) { return x@2 + ec@3 ; } ) ;\n"
                                "3: }\n";
@@ -3355,7 +3352,7 @@ class TestVarID : public TestFixture {
             const char code[] = "static void func() {\n"
                                 "    auto x = []() mutable {};\n"
                                 "    dostuff(x);\n"
-                                "}";
+                                "}\n";
             const char exp[] = "1: static void func ( ) {\n"
                                "2: auto x@1 ; x@1 = [ ] ( ) mutable { } ;\n"
                                "3: dostuff ( x@1 ) ;\n"
@@ -3379,7 +3376,7 @@ class TestVarID : public TestFixture {
                             "};\n"
                             "auto Fred::foo(const Fred & other) -> Fred & {\n"
                             "    return *this;\n"
-                            "}";
+                            "}\n";
         const char exp[] = "1: struct Fred {\n"
                            "2: auto foo ( const Fred & other@1 ) . Fred & ;\n"
                            "3: auto bar ( const Fred & other@2 ) . Fred & {\n"
@@ -3393,7 +3390,7 @@ class TestVarID : public TestFixture {
     }
 
     void varid_trailing_return2() { // #9066
-        const char code[] = "auto func(int arg) -> bar::quux {}";
+        const char code[] = "auto func(int arg) -> bar::quux {}\n";
         const char exp[] = "1: auto func ( int arg@1 ) . bar :: quux { }\n";
         ASSERT_EQUALS(exp, tokenize(code));
     }
@@ -3428,7 +3425,7 @@ class TestVarID : public TestFixture {
                             "    x+y+z;\n"
                             "  }\n"
                             "  x+y+z;\n"
-                            "}";
+                            "}\n";
         const char exp[] = "1: void f ( ) {\n"
                            "2: for ( auto [ x@1 , y@2 , z@3 ] : xyz ) {\n"
                            "3: x@1 + y@2 + z@3 ;\n"
@@ -3441,7 +3438,7 @@ class TestVarID : public TestFixture {
     void varid_not() { // #9689 'not x'
         const char code[] = "void foo(int x) const {\n"
                             "  if (not x) {}\n"
-                            "}";
+                            "}\n";
         const char exp[] = "1: void foo ( int x@1 ) const {\n"
                            "2: if ( ! x@1 ) { }\n"
                            "3: }\n";
@@ -3457,7 +3454,7 @@ class TestVarID : public TestFixture {
                       tokenize("void f(int x) {\n"
                                "  if (int x = 0) { x; }\n"
                                "  x;\n"
-                               "}"));
+                               "}\n"));
         // if, else
         ASSERT_EQUALS("1: void f ( int x@1 ) {\n"
                       "2: if ( int x@2 = 0 ) { x@2 ; }\n"
@@ -3468,7 +3465,7 @@ class TestVarID : public TestFixture {
                                "  if (int x = 0) { x; }\n"
                                "  else { x; }\n"
                                "  x;\n"
-                               "}"));
+                               "}\n"));
         // if, else if
         ASSERT_EQUALS("1: void f ( int x@1 ) {\n"
                       "2: if ( int x@2 = 0 ) { x@2 ; }\n"
@@ -3479,7 +3476,7 @@ class TestVarID : public TestFixture {
                                "  if (int x = 0) x;\n"
                                "  else if (void* x = &x) x;\n"
                                "  x;\n"
-                               "}"));
+                               "}\n"));
         // if, else if, else
         ASSERT_EQUALS("1: void f ( int x@1 ) {\n"
                       "2: if ( int x@2 = 0 ) { x@2 ; }\n"
@@ -3492,7 +3489,7 @@ class TestVarID : public TestFixture {
                                "  else if (void* x = &x) x;\n"
                                "  else x;\n"
                                "  x;\n"
-                               "}"));
+                               "}\n"));
 
         ASSERT_EQUALS("1: const char * f ( int * ) ;\n" // #12924
                       "2: void g ( int i@1 ) {\n"
@@ -3513,7 +3510,7 @@ class TestVarID : public TestFixture {
                             "  memset(::a, 123, 5);\n"
                             "  memset(Z::b.a, 123, 5);\n"
                             "  memset(::Z::b.a, 123, 5);\n"
-                            "}";
+                            "}\n";
 
         const char exp[] = "1: int a@1 [ 5 ] ;\n"
                            "2: namespace Z { struct B { int a@2 [ 5 ] ; } ; struct B b@3 ; }\n"
@@ -3568,7 +3565,7 @@ class TestVarID : public TestFixture {
 
     void varid_alignas() {
         const char code[] = "extern alignas(16) int x;\n"
-                            "alignas(16) int x;";
+                            "alignas(16) int x;\n";
         const char expected[] = "1: extern alignas ( 16 ) int x@1 ;\n"
                                 "2: alignas ( 16 ) int x@2 ;\n";
         ASSERT_EQUALS(expected, tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
@@ -3591,7 +3588,7 @@ class TestVarID : public TestFixture {
             "Fred::foo1()\n"
             "{\n"
             "    i = 0;\n"
-            "}");
+            "}\n");
 
         const char expected[] = "1: class Fred\n"
                                 "2: {\n"
@@ -3627,7 +3624,7 @@ class TestVarID : public TestFixture {
             "void Fred::f()\n"
             "{\n"
             "    i = 0;\n"
-            "}");
+            "}\n");
 
         const char expected[] = "1: class Fred\n"
                                 "2: { void f ( ) ; } ;\n"
@@ -3659,7 +3656,7 @@ class TestVarID : public TestFixture {
             "void A::f()\n"
             "{\n"
             "    i = 0;\n"
-            "}");
+            "}\n");
 
         const char expected[] = "1: class Fred\n"
                                 "2: { int i@1 ; void f ( ) ; } ;\n"
@@ -3687,7 +3684,7 @@ class TestVarID : public TestFixture {
             "{\n"
             "    if (i) { }\n"
             "    i = 0;\n"
-            "}");
+            "}\n");
 
         const char expected[] = "1: class Fred\n"
                                 "2: { int i@1 ; void f ( ) ; } ;\n"
@@ -3709,7 +3706,7 @@ class TestVarID : public TestFixture {
             "    A *a;\n"
             "    B() : a(new A)\n"
             "    { }\n"
-            "};");
+            "};\n");
 
         const char expected[] = "1: class A { } ;\n"
                                 "2: class B\n"
@@ -3734,7 +3731,7 @@ class TestVarID : public TestFixture {
             "{\n"
             "  char buf[2];\n"
             "  A::buf[10] = 0;\n"
-            "}");
+            "}\n");
 
         const char expected[] = "1: class A\n"
                                 "2: {\n"
@@ -3757,7 +3754,7 @@ class TestVarID : public TestFixture {
             "{\n"
             "  char buf[2];\n"
             "  A::buf[10] = 0;\n"
-            "}");
+            "}\n");
 
         const char expected[] = "1: int main ( )\n"
                                 "2: {\n"
@@ -3797,7 +3794,7 @@ class TestVarID : public TestFixture {
                             "}\n"
                             "void Fred::f(Str &cl) {\n"
                             "    sizeof(cl);\n"
-                            "}";
+                            "}\n";
 
         const char expected[] = "1: class A {\n"
                                 "2: public:\n"
@@ -3887,7 +3884,7 @@ class TestVarID : public TestFixture {
         {
             const char code[] ="class A {\n"
                                 "friend class B;\n"
-                                "}";
+                                "}\n";
 
             const char expected[] = "1: class A {\n"
                                     "2: friend class B ;\n"
@@ -3899,7 +3896,7 @@ class TestVarID : public TestFixture {
         {
             const char code[] ="class A {\n"
                                 "private: friend class B;\n"
-                                "}";
+                                "}\n";
 
             const char expected[] = "1: class A {\n"
                                     "2: private: friend class B ;\n"
@@ -3915,7 +3912,7 @@ class TestVarID : public TestFixture {
                             "    int b;\n"
                             "    A();\n"
                             "};\n"
-                            "A::A() : a(0) { b = 1; }";
+                            "A::A() : a(0) { b = 1; }\n";
         const char expected[] = "1: class A {\n"
                                 "2: int a@1 ;\n"
                                 "3: int b@2 ;\n"
@@ -3935,7 +3932,7 @@ class TestVarID : public TestFixture {
                             "};\n"
                             "void A::setPFun(int mode) {\n"
                             "    pFun = &A::funcNorm;\n"
-                            "}";
+                            "}\n";
         const char expected[] = "1: struct A ;\n"
                                 "2:\n"
                                 "3: struct A {\n"
@@ -3955,7 +3952,7 @@ class TestVarID : public TestFixture {
                             "    A(int i): B(i), C::D(i), i(i) {\n"
                             "        int j(i);\n"
                             "    }\n"
-                            "};";
+                            "};\n";
         const char expected[] = "1: class A : public B , public C :: D {\n"
                                 "2: int i@1 ;\n"
                                 "3: A ( int i@2 ) : B ( i@2 ) , C :: D ( i@2 ) , i@1 ( i@2 ) {\n"
@@ -3968,7 +3965,7 @@ class TestVarID : public TestFixture {
                              "    std::vector<int> v;\n"
                              "    int i;\n"
                              "    S(int i) : v({ 0 }), i(i) {}\n"
-                             "};";
+                             "};\n";
         const char expected2[] = "1: struct S {\n"
                                  "2: std :: vector < int > v@1 ;\n"
                                  "3: int i@2 ;\n"
@@ -3983,7 +3980,7 @@ class TestVarID : public TestFixture {
                             "    int b;\n"
                             "    A();\n"
                             "};\n"
-                            "A::A() : a{0} { b = 1; }";
+                            "A::A() : a{0} { b = 1; }\n";
         const char expected[] = "1: class A {\n"
                                 "2: int a@1 ;\n"
                                 "3: int b@2 ;\n"
@@ -3998,7 +3995,7 @@ class TestVarID : public TestFixture {
                             "  int a;\n"
                             "  A();\n"
                             "};\n"
-                            "A::A() : ::B(), a(0) {}";
+                            "A::A() : ::B(), a(0) {}\n";
         const char expected[] = "1: class A : public :: B {\n"
                                 "2: int a@1 ;\n"
                                 "3: A ( ) ;\n"
@@ -4012,7 +4009,7 @@ class TestVarID : public TestFixture {
                             "  int (*p)[2];\n"
                             "  S();\n"
                             "};\n"
-                            "S::S() { p[0] = 0; }";
+                            "S::S() { p[0] = 0; }\n";
         const char expected[] = "1: struct S {\n"
                                 "2: int ( * p@1 ) [ 2 ] ;\n"
                                 "3: S ( ) ;\n"
@@ -4159,7 +4156,7 @@ class TestVarID : public TestFixture {
                             "}\n"
                             "int main() {\n"
                             "    return foo(A::buf);\n"
-                            "}";
+                            "}\n";
 
         const char expected[] = "1: namespace A {\n"
                                 "2: char buf@1 [ 20 ] ;\n"
@@ -4179,7 +4176,7 @@ class TestVarID : public TestFixture {
                             "}\n"
                             "int main() {\n"
                             "  return foo(A::B::buf);\n"
-                            "}";
+                            "}\n";
 
         const char expected[] = "1: namespace A {\n"
                                 "2: namespace B {\n"
@@ -4227,7 +4224,7 @@ class TestVarID : public TestFixture {
                             "    }\n"
                             "}\n"
                             "using namespace A::B;\n"
-                            "C::C() : m(42) {}";
+                            "C::C() : m(42) {}\n";
 
         const char expected[] = "1: namespace A {\n"
                                 "2: namespace B {\n"
@@ -4248,7 +4245,7 @@ class TestVarID : public TestFixture {
                             "{\n"
                             "    foo.size = 0;\n"
                             "    return ((uint8_t)(foo).size);\n"
-                            "}";
+                            "}\n";
         const char expected[] = "1: void f ( Foo foo@1 )\n"
                                 "2: {\n"
                                 "3: foo@1 . size@2 = 0 ;\n"
@@ -4258,37 +4255,37 @@ class TestVarID : public TestFixture {
     }
 
     void decltype1() {
-        const char code[] = "void foo(int x, decltype(A::b) *p);";
+        const char code[] = "void foo(int x, decltype(A::b) *p);\n";
         const char expected[] = "1: void foo ( int x@1 , decltype ( A :: b ) * p@2 ) ;\n";
         ASSERT_EQUALS(expected, tokenize(code));
     }
 
     void decltype2() {
-        const char code[] = "int x; decltype(x) y;";
+        const char code[] = "int x; decltype(x) y;\n";
         const char expected[] = "1: int x@1 ; decltype ( x@1 ) y@2 ;\n";
         ASSERT_EQUALS(expected, tokenize(code));
     }
 
     void typeof1() {
-        const char code[] = "int x; typeof(x) y;";
+        const char code[] = "int x; typeof(x) y;\n";
         const char expected[] = "1: int x@1 ; typeof ( x@1 ) y@2 ;\n";
         ASSERT_EQUALS(expected, tokenize(code));
     }
 
     void typeof2() {
-        const char code[] = "int x; typeof(x) *y;";
+        const char code[] = "int x; typeof(x) *y;\n";
         const char expected[] = "1: int x@1 ; typeof ( x@1 ) * y@2 ;\n";
         ASSERT_EQUALS(expected, tokenize(code));
     }
 
     void typeof3() {
-        const char code[] = "int x; const typeof(x) *const y;";
+        const char code[] = "int x; const typeof(x) *const y;\n";
         const char expected[] = "1: int x@1 ; const typeof ( x@1 ) * const y@2 ;\n";
         ASSERT_EQUALS(expected, tokenize(code));
     }
 
     void typeof4() {
-        const char code[] = "int x; __typeof(x) y;";
+        const char code[] = "int x; __typeof(x) y;\n";
         const char expected[] = "1: int x@1 ; __typeof ( x@1 ) y@2 ;\n";
         TokenizeOptions options;
         options.cpp = false;
@@ -4413,7 +4410,7 @@ class TestVarID : public TestFixture {
         ASSERT_EQUALS(expected, tokenizeExpr(code));
 
         const char code2[] = "struct S { std::function<void()>* p; };\n"
-                             "S f() { return S{ std::make_unique<std::function<void()>>([]() {}).release()}; }";
+                             "S f() { return S{ std::make_unique<std::function<void()>>([]() {}).release()}; }\n";
         const char expected2[] = "1: struct S { std :: function < void ( ) > * p ; } ;\n"
                                  "2: S f ( ) { return S@UNIQUE {@UNIQUE std ::@UNIQUE make_unique < std :: function < void ( ) > > (@UNIQUE [ ] ( ) { } ) .@UNIQUE release (@UNIQUE ) } ; }\n";
         ASSERT_EQUALS(expected2, tokenizeExpr(code2));
@@ -4558,7 +4555,7 @@ class TestVarID : public TestFixture {
     }
 
     void structuredBindings() {
-        const char code[] = "int foo() { auto [x,y] = xy(); return x+y; }";
+        const char code[] = "int foo() { auto [x,y] = xy(); return x+y; }\n";
         ASSERT_EQUALS("1: int foo ( ) { auto [ x@1 , y@2 ] = xy ( ) ; return x@1 + y@2 ; }\n",
                       tokenize(code));
     }

From fd79f15b563a069c223adb8d6ac48c3a5dc8e92b Mon Sep 17 00:00:00 2001
From: Daschle Newberry <dash.q.n@gmail.com>
Date: Wed, 26 Aug 2026 10:53:12 -0700
Subject: [PATCH 58/59] Fixed Qt config macro declaration (#8796)

The macro definition of `Q_ASSERT_X` results in false positives.

### Example
```cpp
#include <QDebug>

void test()
{
    const char *where = "test";
    const char *what = "assertion failed";

    Q_ASSERT_X(false, where, what);
}
 ````

 This code block results in:
```commandline
style: Variable 'where' is assigned a value that is never used.
[unreadVariable]
style: Variable 'what' is assigned a value that is never used.
[unreadVariable]
```

 The existing definition discards `where` and `what` arguments when modeling `Q_ASSERT_X`. The fix preserves these arguments using `(void) (what)` and `(void) (where)`

---------

Co-authored-by: Daschle Newberry <dnewberry@deltamotion.com>
Co-authored-by: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
---
 AUTHORS         | 1 +
 cfg/qt.cfg      | 2 +-
 test/cfg/qt.cpp | 7 +++++++
 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/AUTHORS b/AUTHORS
index cda29aa6ef8..e804ab53e16 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -101,6 +101,7 @@ daisuke-chiba
 Daniel Friedrich
 David Korczynski
 Daniel Marjamäki
+Daschle Newberry
 David Hallas
 David Korth
 Dávid Slivka
diff --git a/cfg/qt.cfg b/cfg/qt.cfg
index c7bf3d8779b..95dc022cf57 100644
--- a/cfg/qt.cfg
+++ b/cfg/qt.cfg
@@ -5520,7 +5520,7 @@
   <define name="Q_OVERRIDE(x)" value=""/>
   <define name="Q_PLUGIN_METADATA(x)" value=""/>
   <define name="Q_ASSERT(condition)" value="assert(condition)"/>
-  <define name="Q_ASSERT_X(condition, where, what)" value="assert(condition)"/>
+  <define name="Q_ASSERT_X(condition, where, what)" value="assert(condition); (void)(where); (void)(what)"/>
   <define name="QTC_ASSERT_STRINGIFY_HELPER(x)" value="#x"/>
   <define name="QTC_ASSERT_STRINGIFY(x)" value="QTC_ASSERT_STRINGIFY_HELPER(x)"/>
   <define name="QTC_ASSERT_STRING(cond)" value="::Utils::writeAssertLocation( &quot;\&quot;&quot; cond&quot;\&quot; in file &quot; __FILE__ &quot;, line &quot; QTC_ASSERT_STRINGIFY(__LINE__))"/>
diff --git a/test/cfg/qt.cpp b/test/cfg/qt.cpp
index 2b683648dcd..34f6cc8c957 100644
--- a/test/cfg/qt.cpp
+++ b/test/cfg/qt.cpp
@@ -894,6 +894,13 @@ int qdateIsValid()
     return qd.month(); 
 }
 
+void qAssertX()
+{
+    const char *where = "test";
+    const char *what = "assertion failed";
+    Q_ASSERT_X(false, where, what);
+}
+
 struct S_QTimer_connect : QObject { // #13846
     S_QTimer_connect() {
         // cppcheck-suppress checkLibraryFunction - timeout() is a signal from QTimer

From ab753cd4b6b79e1062c3cde092f21b62c96aedb2 Mon Sep 17 00:00:00 2001
From: chrchr-github <78114321+chrchr-github@users.noreply.github.com>
Date: Wed, 26 Aug 2026 20:07:47 +0200
Subject: [PATCH 59/59] Fix  #14967 internalAstError with function pointer in
 if (#8782)

Co-authored-by: chrchr-github <noreply@github.com>
---
 lib/tokenlist.cpp     | 2 +-
 test/testtokenize.cpp | 9 +++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/lib/tokenlist.cpp b/lib/tokenlist.cpp
index 384c45e406b..bad4f4df6f4 100644
--- a/lib/tokenlist.cpp
+++ b/lib/tokenlist.cpp
@@ -463,7 +463,7 @@ static Token* skipDecl(Token* tok, std::vector<Token*>* inner = nullptr)
         return Token::Match(tok, "%name%| ,|)");
     };
 
-    if (!Token::Match(tok->previous(), "( %name%"))
+    if (tok->varId() || !Token::Match(tok->previous(), "( %name%"))
         return tok;
     Token *vartok = tok;
     while (Token::Match(vartok, "%name%|*|&|&&|::|<")) {
diff --git a/test/testtokenize.cpp b/test/testtokenize.cpp
index e8dd4a32806..a44492de433 100644
--- a/test/testtokenize.cpp
+++ b/test/testtokenize.cpp
@@ -446,6 +446,7 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(astfuncdecl);
         TEST_CASE(astarrayinit);
         TEST_CASE(astbracedinit);
+        TEST_CASE(astif);
 
         TEST_CASE(startOfExecutableScope);
 
@@ -7728,6 +7729,14 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("anullptr{", testAst("int *a { nullptr };\n", AstStyle::Simple, ListSimplification::Full));
     }
 
+    void astif() {
+        ASSERT_EQUALS( // #14967
+            "ifxx(&&(",
+            testAst("void f(int (*x)()) {\n"
+                    "    if (x && x()) {}\n"
+                    "}\n", AstStyle::Simple, ListSimplification::Full));
+    }
+
 #define isStartOfExecutableScope(offset, code) isStartOfExecutableScope_(offset, code, __FILE__, __LINE__)
     template<size_t size>
     bool isStartOfExecutableScope_(int offset, const char (&code)[size], const char* file, int line) {