diff --git a/test/helpers.h b/test/helpers.h
index 08d3fb0eb5f9..94d0197dcf8d 100644
--- a/test/helpers.h
+++ b/test/helpers.h
@@ -32,13 +32,15 @@
 class Token;
 class Preprocessor;
 class SuppressionList;
+class ErrorLogger;
 namespace simplecpp {
     struct DUI;
 }
 
 class SimpleTokenizer {
 public:
-    explicit SimpleTokenizer(const char sample[], bool cpp = true)
+    SimpleTokenizer(ErrorLogger& errorlogger, const char sample[], bool cpp = true)
+        : tokenizer{settings, &errorlogger}
     {
         std::istringstream iss(sample);
         if (!tokenizer.tokenize(iss, cpp ? "test.cpp" : "test.c"))
@@ -55,7 +57,7 @@ class SimpleTokenizer {
 
 private:
     const Settings settings;
-    Tokenizer tokenizer{settings, nullptr};
+    Tokenizer tokenizer;
 };
 
 class SimpleTokenList
diff --git a/test/testlibrary.cpp b/test/testlibrary.cpp
index e02ed84aa8aa..0d92b793e5d7 100644
--- a/test/testlibrary.cpp
+++ b/test/testlibrary.cpp
@@ -791,7 +791,7 @@ class TestLibrary : public TestFixture {
         }
     }
 
-    void container() const {
+    void container() {
         constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
                                    "<def>\n"
                                    "  <container id=\"A\" startPattern=\"std :: A &lt;\" endPattern=\"&gt; !!::\" itEndPattern=\"&gt; :: iterator\">\n"
@@ -871,7 +871,7 @@ class TestLibrary : public TestFixture {
         ASSERT_EQUALS(C.arrayLike_indexOp, true);
 
         {
-            SimpleTokenizer var("std::A<int> a;");
+            SimpleTokenizer var(*this, "std::A<int> a;");
             ASSERT_EQUALS(&A, library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             bool isIterator;
@@ -880,14 +880,14 @@ class TestLibrary : public TestFixture {
         }
 
         {
-            SimpleTokenizer var("std::A<int>::size_type a_s;");
+            SimpleTokenizer var(*this, "std::A<int>::size_type a_s;");
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             ASSERT(!library.detectContainerOrIterator(var.tokens()));
         }
 
         {
-            SimpleTokenizer var("std::A<int>::iterator a_it;");
+            SimpleTokenizer var(*this, "std::A<int>::iterator a_it;");
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT_EQUALS(&A, library.detectIterator(var.tokens()));
             bool isIterator;
@@ -896,7 +896,7 @@ class TestLibrary : public TestFixture {
         }
 
         {
-            SimpleTokenizer var("std::B<int> b;");
+            SimpleTokenizer var(*this, "std::B<int> b;");
             ASSERT_EQUALS(&B, library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             bool isIterator;
@@ -905,14 +905,14 @@ class TestLibrary : public TestFixture {
         }
 
         {
-            SimpleTokenizer var("std::B<int>::size_type b_s;");
+            SimpleTokenizer var(*this, "std::B<int>::size_type b_s;");
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             ASSERT(!library.detectContainerOrIterator(var.tokens()));
         }
 
         {
-            SimpleTokenizer var("std::B<int>::iterator b_it;");
+            SimpleTokenizer var(*this, "std::B<int>::iterator b_it;");
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT_EQUALS(&B, library.detectIterator(var.tokens()));
             bool isIterator;
@@ -921,14 +921,14 @@ class TestLibrary : public TestFixture {
         }
 
         {
-            SimpleTokenizer var("C c;");
+            SimpleTokenizer var(*this, "C c;");
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             ASSERT(!library.detectContainerOrIterator(var.tokens()));
         }
 
         {
-            SimpleTokenizer var("D d;");
+            SimpleTokenizer var(*this, "D d;");
             ASSERT(!library.detectContainer(var.tokens()));
             ASSERT(!library.detectIterator(var.tokens()));
             ASSERT(!library.detectContainerOrIterator(var.tokens()));
diff --git a/test/testsymboldatabase.cpp b/test/testsymboldatabase.cpp
index bf4f1dcaac10..62456567a360 100644
--- a/test/testsymboldatabase.cpp
+++ b/test/testsymboldatabase.cpp
@@ -816,7 +816,7 @@ class TestSymbolDatabase : public TestFixture {
         }
         {
             reset();
-            SimpleTokenizer constpointer("const int* p;");
+            SimpleTokenizer constpointer(*this, "const int* p;");
             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());
diff --git a/test/testtoken.cpp b/test/testtoken.cpp
index 4256afd5fc63..6f86a6ce15f2 100644
--- a/test/testtoken.cpp
+++ b/test/testtoken.cpp
@@ -290,8 +290,8 @@ class TestToken : public TestFixture {
         ASSERT_EQUALS(true, Token::Match(numparen.tokens(), "(| 100 %bool%|%name%| )|"));
     }
 
-    void multiCompare4() const {
-        SimpleTokenizer var("std :: queue < int > foo ;");
+    void multiCompare4() {
+        SimpleTokenizer var(*this, "std :: queue < int > foo ;");
 
         ASSERT_EQUALS(Token::eBracket, var.tokens()->tokAt(3)->tokType());
         ASSERT_EQUALS(Token::eBracket, var.tokens()->tokAt(5)->tokType());
@@ -546,18 +546,18 @@ class TestToken : public TestFixture {
         ASSERT_EQUALS(true, *tokensFront == &tok);
     }
 
-    void nextArgument() const {
-        SimpleTokenizer example1("foo(1, 2, 3, 4);");
+    void nextArgument() {
+        SimpleTokenizer example1(*this, "foo(1, 2, 3, 4);");
         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("foo();");
+        SimpleTokenizer example2(*this, "foo();");
         ASSERT_EQUALS(true, example2.tokens()->tokAt(2)->nextArgument() == nullptr);
 
-        SimpleTokenizer example3("foo(bar(a, b), 2, 3);");
+        SimpleTokenizer example3(*this, "foo(bar(a, b), 2, 3);");
         ASSERT_EQUALS(true, Token::simpleMatch(example3.tokens()->tokAt(2)->nextArgument(), "2 , 3"));
 
-        SimpleTokenizer example4("foo(x.i[1], \"\", 3);");
+        SimpleTokenizer example4(*this, "foo(x.i[1], \"\", 3);");
         ASSERT_EQUALS(true, Token::simpleMatch(example4.tokens()->tokAt(2)->nextArgument(), "\"\" , 3"));
     }
 
@@ -605,11 +605,11 @@ class TestToken : public TestFixture {
         ASSERT_EQUALS(false, Token::Match(ifSemicolonElse.tokens(), "if ; !!else"));
     }
 
-    void matchType() const {
+    void matchType() {
         SimpleTokenList type("abc");
         ASSERT_EQUALS(true, Token::Match(type.tokens(), "%type%"));
 
-        SimpleTokenizer isVar("int a = 3 ;");
+        SimpleTokenizer isVar(*this, "int a = 3 ;");
         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%"));
@@ -661,8 +661,8 @@ class TestToken : public TestFixture {
         ASSERT_EQUALS(true, Token::Match(emptyStr.tokens(), "%str%"));
     }
 
-    void matchVarid() const {
-        SimpleTokenizer var("int a ; int b ;");
+    void matchVarid() {
+        SimpleTokenizer var(*this, "int a ; int b ;");
 
         // Varid == 0 should throw exception
         ASSERT_THROW((void)Token::Match(var.tokens(), "%type% %varid% ; %type% %name%", 0),InternalError);
@@ -743,7 +743,7 @@ class TestToken : public TestFixture {
         ASSERT_EQUALS(true, Token::Match(negative.tokens(), "%bool%"));
     }
 
-    void matchOr() const {
+    void matchOr() {
         SimpleTokenList bitwiseOr(";|;");
         // cppcheck-suppress simplePatternError - this is intentional
         ASSERT_EQUALS(true,  Token::Match(bitwiseOr.tokens(), "; %or%"));
@@ -751,7 +751,7 @@ class TestToken : public TestFixture {
         // cppcheck-suppress simplePatternError - this is intentional
         ASSERT_EQUALS(false, Token::Match(bitwiseOr.tokens(), "; %oror%"));
 
-        SimpleTokenizer bitwiseOrAssignment(";|=;");
+        SimpleTokenizer bitwiseOrAssignment(*this, ";|=;");
         // cppcheck-suppress simplePatternError - this is intentional
         ASSERT_EQUALS(false,  Token::Match(bitwiseOrAssignment.tokens(), "; %or%"));
         ASSERT_EQUALS(true,  Token::Match(bitwiseOrAssignment.tokens(), "; %op%"));
@@ -1106,39 +1106,39 @@ class TestToken : public TestFixture {
         ASSERT_EQUALS(true, tok.isName());
     }
 
-    void canFindMatchingBracketsNeedsOpen() const {
-        SimpleTokenizer var("std::deque<std::set<int> > intsets;");
+    void canFindMatchingBracketsNeedsOpen() {
+        SimpleTokenizer var(*this, "std::deque<std::set<int> > intsets;");
 
         const Token* const t = var.tokens()->findClosingBracket();
         ASSERT(t == nullptr);
     }
 
-    void canFindMatchingBracketsInnerPair() const {
-        SimpleTokenizer var("std::deque<std::set<int> > intsets;");
+    void canFindMatchingBracketsInnerPair() {
+        SimpleTokenizer var(*this, "std::deque<std::set<int> > intsets;");
 
         const Token * const t = var.tokens()->tokAt(7)->findClosingBracket();
         ASSERT_EQUALS(">", t->str());
         ASSERT(var.tokens()->tokAt(9) == t);
     }
 
-    void canFindMatchingBracketsOuterPair() const {
-        SimpleTokenizer var("std::deque<std::set<int> > intsets;");
+    void canFindMatchingBracketsOuterPair() {
+        SimpleTokenizer var(*this, "std::deque<std::set<int> > intsets;");
 
         const Token* const t = var.tokens()->tokAt(3)->findClosingBracket();
         ASSERT_EQUALS(">", t->str());
         ASSERT(var.tokens()->tokAt(10) == t);
     }
 
-    void canFindMatchingBracketsWithTooManyClosing() const {
-        SimpleTokenizer var("X< 1>2 > x1;");
+    void canFindMatchingBracketsWithTooManyClosing() {
+        SimpleTokenizer var(*this, "X< 1>2 > x1;");
 
         const Token* const t = var.tokens()->next()->findClosingBracket();
         ASSERT_EQUALS(">", t->str());
         ASSERT(var.tokens()->tokAt(3) == t);
     }
 
-    void canFindMatchingBracketsWithTooManyOpening() const {
-        SimpleTokenizer var("X < (2 < 1) > x1;");
+    void canFindMatchingBracketsWithTooManyOpening() {
+        SimpleTokenizer var(*this, "X < (2 < 1) > x1;");
 
         const Token* t = var.tokens()->next()->findClosingBracket();
         ASSERT(t != nullptr && t->str() == ">");
@@ -1147,39 +1147,39 @@ class TestToken : public TestFixture {
         ASSERT(t == nullptr);
     }
 
-    void findClosingBracket() const {
-        SimpleTokenizer var("template<typename X, typename...Y> struct S : public Fred<Wilma<Y...>> {}");
+    void findClosingBracket() {
+        SimpleTokenizer var(*this, "template<typename X, typename...Y> struct S : public Fred<Wilma<Y...>> {}");
 
         const Token* const t = var.tokens()->next()->findClosingBracket();
         ASSERT(Token::simpleMatch(t, "> struct"));
     }
 
-    void findClosingBracket2() const {
-        SimpleTokenizer var("const auto g = []<typename T>() {};\n"); // #11275
+    void findClosingBracket2() {
+        SimpleTokenizer var(*this, "const auto g = []<typename T>() {};\n"); // #11275
 
         const Token* const t = Token::findsimplematch(var.tokens(), "<");
         ASSERT(t && Token::simpleMatch(t->findClosingBracket(), ">"));
     }
 
-    void expressionString() const {
-        SimpleTokenizer var1("void f() { *((unsigned long long *)x) = 0; }");
+    void expressionString() {
+        SimpleTokenizer var1(*this, "void f() { *((unsigned long long *)x) = 0; }");
         const Token *const tok1 = Token::findsimplematch(var1.tokens(), "*");
         ASSERT_EQUALS("*((unsigned long long*)x)", tok1->expressionString());
 
-        SimpleTokenizer var2("typedef unsigned long long u64; void f() { *((u64 *)x) = 0; }");
+        SimpleTokenizer var2(*this, "typedef unsigned long long u64; void f() { *((u64 *)x) = 0; }");
         const Token *const tok2 = Token::findsimplematch(var2.tokens(), "*");
         ASSERT_EQUALS("*((unsigned long long*)x)", tok2->expressionString());
 
-        SimpleTokenizer data3("void f() { return (t){1,2}; }");
+        SimpleTokenizer data3(*this, "void f() { return (t){1,2}; }");
         ASSERT_EQUALS("return(t){1,2}", data3.tokens()->tokAt(5)->expressionString());
 
-        SimpleTokenizer data4("void f() { return L\"a\"; }");
+        SimpleTokenizer data4(*this, "void f() { return L\"a\"; }");
         ASSERT_EQUALS("returnL\"a\"", data4.tokens()->tokAt(5)->expressionString());
 
-        SimpleTokenizer data5("void f() { return U\"a\"; }");
+        SimpleTokenizer data5(*this, "void f() { return U\"a\"; }");
         ASSERT_EQUALS("returnU\"a\"", data5.tokens()->tokAt(5)->expressionString());
 
-        SimpleTokenizer data6("x = \"\\0\\x1\\x2\\x3\\x4\\x5\\x6\\x7\";");
+        SimpleTokenizer data6(*this, "x = \"\\0\\x1\\x2\\x3\\x4\\x5\\x6\\x7\";");
         ASSERT_EQUALS("x=\"\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\"", data6.tokens()->next()->expressionString());
     }