testrunner: removed more std::istringstream usage

firewave · firewave · commit fd22ba3544cc · 2025-08-22T15:42:21.000+02:00
diff --git a/test/helpers.cpp b/test/helpers.cpp
@@ -117,25 +117,24 @@ ScopedFile::~ScopedFile() {
 // TODO: we should be using the actual Preprocessor implementation
 std::string PreprocessorHelper::getcode(const Settings& settings, ErrorLogger& errorlogger, const std::string &filedata, const std::string &cfg, const std::string &filename, SuppressionList *inlineSuppression)
 {
-    std::map<std::string, std::string> cfgcode = getcode(settings, errorlogger, filedata.c_str(), std::set<std::string>{cfg}, filename, inlineSuppression);
+    std::map<std::string, std::string> cfgcode = getcode(settings, errorlogger, filedata.c_str(), filedata.size(), std::set<std::string>{cfg}, filename, inlineSuppression);
     const auto it = cfgcode.find(cfg);
     if (it == cfgcode.end())
         return "";
     return it->second;
 }
 
-std::map<std::string, std::string> PreprocessorHelper::getcode(const Settings& settings, ErrorLogger& errorlogger, const char code[], const std::string &filename, SuppressionList *inlineSuppression)
+std::map<std::string, std::string> PreprocessorHelper::getcode(const Settings& settings, ErrorLogger& errorlogger, const char code[], std::size_t size, const std::string &filename, SuppressionList *inlineSuppression)
 {
-    return getcode(settings, errorlogger, code, {}, filename, inlineSuppression);
+    return getcode(settings, errorlogger, code, size, {}, filename, inlineSuppression);
 }
 
-std::map<std::string, std::string> PreprocessorHelper::getcode(const Settings& settings, ErrorLogger& errorlogger, const char code[], std::set<std::string> cfgs, const std::string &filename, SuppressionList *inlineSuppression)
+std::map<std::string, std::string> PreprocessorHelper::getcode(const Settings& settings, ErrorLogger& errorlogger, const char code[], std::size_t size, std::set<std::string> cfgs, const std::string &filename, SuppressionList *inlineSuppression)
 {
     simplecpp::OutputList outputList;
     std::vector<std::string> files;
 
-    std::istringstream istr(code);
-    simplecpp::TokenList tokens(istr, files, Path::simplifyPath(filename), &outputList);
+    simplecpp::TokenList tokens(code, size, files, Path::simplifyPath(filename), &outputList);
     Preprocessor preprocessor(settings, errorlogger, Path::identify(tokens.getFiles()[0], false));
     if (inlineSuppression)
         preprocessor.inlineSuppressions(tokens, *inlineSuppression);
@@ -162,11 +161,9 @@ std::map<std::string, std::string> PreprocessorHelper::getcode(const Settings& s
     return cfgcode;
 }
 
-void SimpleTokenizer2::preprocess(const char code[], std::vector<std::string> &files, const std::string& file0, Tokenizer& tokenizer, ErrorLogger& errorlogger)
+void SimpleTokenizer2::preprocess(const char* code, std::size_t size, std::vector<std::string> &files, const std::string& file0, Tokenizer& tokenizer, ErrorLogger& errorlogger)
 {
-    // TODO: get rid of stream
-    std::istringstream istr(code);
-    const simplecpp::TokenList tokens1(istr, files, file0);
+    const simplecpp::TokenList tokens1(code, size, files, file0);
 
     Preprocessor preprocessor(tokenizer.getSettings(), errorlogger, Path::identify(tokens1.getFiles()[0], false));
     simplecpp::TokenList tokens2 = preprocessor.preprocess(tokens1, "", files, true);
diff --git a/test/helpers.h b/test/helpers.h
@@ -177,10 +177,15 @@ class PreprocessorHelper
      * @param inlineSuppression the inline suppressions
      */
     static std::string getcode(const Settings& settings, ErrorLogger& errorlogger, const std::string &filedata, const std::string &cfg, const std::string &filename, SuppressionList *inlineSuppression = nullptr);
-    static std::map<std::string, std::string> getcode(const Settings& settings, ErrorLogger& errorlogger, const char code[], const std::string &filename = "file.c", SuppressionList *inlineSuppression = nullptr);
+    template<size_t size>
+    static std::map<std::string, std::string> getcode(const Settings& settings, ErrorLogger& errorlogger, const char (&code)[size], const std::string &filename = "file.c", SuppressionList *inlineSuppression = nullptr)
+    {
+        return getcode(settings, errorlogger, code, size-1, filename, inlineSuppression);
+    }
 
 private:
-    static std::map<std::string, std::string> getcode(const Settings& settings, ErrorLogger& errorlogger, const char code[], std::set<std::string> cfgs, const std::string &filename = "file.c", SuppressionList *inlineSuppression = nullptr);
+    static std::map<std::string, std::string> getcode(const Settings& settings, ErrorLogger& errorlogger, const char code[], std::size_t size, const std::string &filename = "file.c", SuppressionList *inlineSuppression = nullptr);
+    static std::map<std::string, std::string> getcode(const Settings& settings, ErrorLogger& errorlogger, const char code[], std::size_t size, std::set<std::string> cfgs, const std::string &filename = "file.c", SuppressionList *inlineSuppression = nullptr);
 };
 
 namespace cppcheck {
@@ -254,18 +259,18 @@ class SimpleTokenizer2 : public Tokenizer {
     SimpleTokenizer2(const Settings &settings, ErrorLogger &errorlogger, const char (&code)[size], const std::string& file0)
         : Tokenizer{TokenList{settings, Path::identify(file0, false)}, errorlogger}
     {
-        preprocess(code, mFiles, file0, *this, errorlogger);
+        preprocess(code, size-1, mFiles, file0, *this, errorlogger);
     }
 
     // TODO: get rid of this
-    SimpleTokenizer2(const Settings &settings, ErrorLogger &errorlogger, const char code[], const std::string& file0)
+    SimpleTokenizer2(const Settings &settings, ErrorLogger &errorlogger, const char* code, std::size_t size, const std::string& file0)
         : Tokenizer{TokenList{settings, Path::identify(file0, false)}, errorlogger}
     {
-        preprocess(code, mFiles, file0, *this, errorlogger);
+        preprocess(code, size, mFiles, file0, *this, errorlogger);
     }
 
 private:
-    static void preprocess(const char code[], std::vector<std::string> &files, const std::string& file0, Tokenizer& tokenizer, ErrorLogger& errorlogger);
+    static void preprocess(const char* code, std::size_t size, std::vector<std::string> &files, const std::string& file0, Tokenizer& tokenizer, ErrorLogger& errorlogger);
 
     std::vector<std::string> mFiles;
 };
diff --git a/test/testbufferoverrun.cpp b/test/testbufferoverrun.cpp
@@ -70,7 +70,8 @@ class TestBufferOverrun : public TestFixture {
     }
 
 #define checkP(...) checkP_(__FILE__, __LINE__, __VA_ARGS__)
-    void checkP_(const char* file, int line, const char code[])
+    template<size_t size>
+    void checkP_(const char* file, int line, const char (&code)[size])
     {
         const Settings settings = settingsBuilder(settings0).severity(Severity::performance).certainty(Certainty::inconclusive).build();
 
diff --git a/test/testclass.cpp b/test/testclass.cpp
@@ -8778,7 +8778,8 @@ class TestClass : public TestFixture {
     }
 
     #define checkUselessOverride(...) checkUselessOverride_(__FILE__, __LINE__, __VA_ARGS__)
-    void checkUselessOverride_(const char* file, int line, const char code[]) {
+    template<size_t size>
+    void checkUselessOverride_(const char* file, int line, const char (&code)[size]) {
         const Settings settings = settingsBuilder().severity(Severity::style).build();
 
         SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
diff --git a/test/testcondition.cpp b/test/testcondition.cpp
@@ -136,7 +136,8 @@ class TestCondition : public TestFixture {
     };
 
 #define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
-    void check_(const char* file, int line, const char code[], const CheckOptions& options = make_default_obj()) {
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
         const Settings settings = settingsBuilder(options.s ? *options.s : settings0).certainty(Certainty::inconclusive, options.inconclusive).build();
 
         SimpleTokenizer2 tokenizer(settings, *this, code, options.cpp ? "test.cpp" : "test.c");
@@ -149,7 +150,8 @@ class TestCondition : public TestFixture {
     }
 
 #define checkP(...) checkP_(__FILE__, __LINE__, __VA_ARGS__)
-    void checkP_(const char* file, int line, const char code[])
+    template<size_t size>
+    void checkP_(const char* file, int line, const char (&code)[size])
     {
         const Settings settings = settingsBuilder(settings0).severity(Severity::performance).certainty(Certainty::inconclusive).build();
 
diff --git a/test/testincompletestatement.cpp b/test/testincompletestatement.cpp
@@ -39,7 +39,8 @@ class TestIncompleteStatement : public TestFixture {
     };
 
 #define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
-    void check_(const char* file, int line, const char code[], const CheckOptions& options = make_default_obj()) {
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
         const Settings settings1 = settingsBuilder(settings).certainty(Certainty::inconclusive, options.inconclusive).build();
 
         SimpleTokenizer2 tokenizer(settings1, *this, code, options.cpp ? "test.cpp" : "test.c");
diff --git a/test/testleakautovar.cpp b/test/testleakautovar.cpp
@@ -3229,7 +3229,8 @@ class TestLeakAutoVarRecursiveCountLimit : public TestFixture {
     const Settings settings = settingsBuilder().library("std.cfg").checkLibrary().build();
 
 #define checkP(...) checkP_(__FILE__, __LINE__, __VA_ARGS__)
-    void checkP_(const char* file, int line, const char code[], bool cpp = false) {
+    template<size_t size>
+    void checkP_(const char* file, int line, const char (&code)[size], bool cpp = false) {
         SimpleTokenizer2 tokenizer(settings, *this, code, cpp?"test.cpp":"test.c");
 
         // Tokenizer..
diff --git a/test/testpreprocessor.cpp b/test/testpreprocessor.cpp
@@ -309,7 +309,7 @@ class TestPreprocessor : public TestFixture {
             settings.userUndefs.insert(arg+2);
         std::vector<std::string> files;
         // TODO: this adds an empty filename
-        simplecpp::TokenList tokens(code, size-1,files);
+        simplecpp::TokenList tokens(code,size-1,files);
         tokens.removeComments();
         Preprocessor preprocessor(settings, *this, Standards::Language::C); // TODO: do we need to consider #file?
         const std::set<std::string> configs = preprocessor.getConfigs(tokens);
@@ -813,35 +813,35 @@ class TestPreprocessor : public TestFixture {
     }
 
     void ticket_3675() {
-        const char* code = "#ifdef YYSTACKSIZE\n"
-                           "#define YYMAXDEPTH YYSTACKSIZE\n"
-                           "#else\n"
-                           "#define YYSTACKSIZE YYMAXDEPTH\n"
-                           "#endif\n"
-                           "#if YYDEBUG\n"
-                           "#endif\n";
+        const char code[] = "#ifdef YYSTACKSIZE\n"
+                            "#define YYMAXDEPTH YYSTACKSIZE\n"
+                            "#else\n"
+                            "#define YYSTACKSIZE YYMAXDEPTH\n"
+                            "#endif\n"
+                            "#if YYDEBUG\n"
+                            "#endif\n";
         (void)PreprocessorHelper::getcode(settings0, *this, code);
 
         // There's nothing to assert. It just needs to not hang.
     }
 
     void ticket_3699() {
-        const char* code = "#define INLINE __forceinline\n"
-                           "#define inline __forceinline\n"
-                           "#define __forceinline inline\n"
-                           "#if !defined(_WIN32)\n"
-                           "#endif\n"
-                           "INLINE inline __forceinline\n";
+        const char code[] = "#define INLINE __forceinline\n"
+                            "#define inline __forceinline\n"
+                            "#define __forceinline inline\n"
+                            "#if !defined(_WIN32)\n"
+                            "#endif\n"
+                            "INLINE inline __forceinline\n";
         const std::map<std::string, std::string> actual = PreprocessorHelper::getcode(settings0, *this, code);
 
         // First, it must not hang. Second, inline must becomes inline, and __forceinline must become __forceinline.
         ASSERT_EQUALS("\n\n\n\n\n$__forceinline $inline $__forceinline", actual.at(""));
     }
 
     void ticket_4922() { // #4922
-        const char* code = "__asm__ \n"
-                           "{ int extern __value) 0; (double return (\"\" } extern\n"
-                           "__typeof __finite (__finite) __finite __inline \"__GI___finite\");";
+        const char code[] = "__asm__ \n"
+                            "{ int extern __value) 0; (double return (\"\" } extern\n"
+                            "__typeof __finite (__finite) __finite __inline \"__GI___finite\");";
         (void)PreprocessorHelper::getcode(settings0, *this, code);
     }
 
@@ -2284,12 +2284,12 @@ class TestPreprocessor : public TestFixture {
     }
 
     void if_sizeof() { // #4071
-        static const char* code = "#if sizeof(unsigned short) == 2\n"
-                                  "Fred & Wilma\n"
-                                  "#elif sizeof(unsigned short) == 4\n"
-                                  "Fred & Wilma\n"
-                                  "#else\n"
-                                  "#endif";
+        const char code[] = "#if sizeof(unsigned short) == 2\n"
+                            "Fred & Wilma\n"
+                            "#elif sizeof(unsigned short) == 4\n"
+                            "Fred & Wilma\n"
+                            "#else\n"
+                            "#endif";
 
         const std::map<std::string, std::string> actual = PreprocessorHelper::getcode(settings0, *this, code);
         ASSERT_EQUALS("\nFred & Wilma", actual.at(""));
diff --git a/test/testsimplifytypedef.cpp b/test/testsimplifytypedef.cpp
@@ -26,7 +26,6 @@
 #include "tokenlist.h"
 
 #include <cstddef>
-#include <sstream>
 #include <string>
 #include <utility>
 
@@ -289,8 +288,8 @@ class TestSimplifyTypedef : public TestFixture {
         return tokenizer.tokens()->stringifyList(nullptr, false);
     }
 
-
-    std::string simplifyTypedefP(const char code[]) {
+    template<size_t size>
+    std::string simplifyTypedefP(const char (&code)[size]) {
         SimpleTokenizer2 tokenizer(settings0, *this, code, "test.cpp");
 
         // Tokenize..
@@ -331,7 +330,7 @@ class TestSimplifyTypedef : public TestFixture {
     template<size_t size>
     std::string dumpTypedefInfo(const char (&code)[size]) {
         TokenList tokenlist{settings1, Standards::Language::C};
-        if (!TokenListHelper::createTokens(tokenlist, code, "file.c"))
+        if (!TokenListHelper::createTokens(tokenlist, code, size-1, "file.c"))
             return {};
         Tokenizer tokenizer(std::move(tokenlist), *this);
         tokenizer.createLinks();
diff --git a/test/teststring.cpp b/test/teststring.cpp
@@ -67,7 +67,8 @@ class TestString : public TestFixture {
     };
 
 #define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
-    void check_(const char* file, int line, const char code[], const CheckOptions& options = make_default_obj()) {
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
         SimpleTokenizer2 tokenizer(settings, *this, code, options.cpp ? "test.cpp" : "test.c");
 
         // Tokenize..
diff --git a/test/testtokenize.cpp b/test/testtokenize.cpp
@@ -560,15 +560,16 @@ class TestTokenizer : public TestFixture {
         return tokenizer.tokens()->stringifyList(true,true,true,true,false);
     }
 
-    void directiveDump(const char filedata[], std::ostream& ostr) {
-        directiveDump(filedata, "test.c", settingsDefault, ostr);
+    template<size_t size>
+    void directiveDump(const char (&code)[size], std::ostream& ostr) {
+        directiveDump(code, "test.c", settingsDefault, ostr);
     }
 
-    void directiveDump(const char filedata[], const char filename[], const Settings& settings, std::ostream& ostr) {
-        std::istringstream istr(filedata);
+    template<size_t size>
+    void directiveDump(const char (&code)[size], const char filename[], const Settings& settings, std::ostream& ostr) {
         simplecpp::OutputList outputList;
         std::vector<std::string> files;
-        const simplecpp::TokenList tokens1(istr, files, filename, &outputList);
+        const simplecpp::TokenList tokens1(code, size-1, files, filename, &outputList);
         Preprocessor preprocessor(settings, *this, Path::identify(tokens1.getFiles()[0], false));
         std::list<Directive> directives = preprocessor.createDirectives(tokens1);
 
@@ -8046,7 +8047,8 @@ class TestTokenizer : public TestFixture {
     }
 
 #define checkHdrs(...) checkHdrs_(__FILE__, __LINE__, __VA_ARGS__)
-    std::string checkHdrs_(const char* file, int line, const char code[], bool checkHeadersFlag) {
+    template<size_t size>
+    std::string checkHdrs_(const char* file, int line, const char (&code)[size], bool checkHeadersFlag) {
         const Settings settings = settingsBuilder().checkHeaders(checkHeadersFlag).build();
 
         SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
@@ -8695,10 +8697,9 @@ class TestTokenizerCompileLimits : public TestFixture
                                 "int PTR4 q4_var RBR4 = 0;\n";
 
         // Preprocess file..
-        std::istringstream fin(raw_code);
         simplecpp::OutputList outputList;
         std::vector<std::string> files;
-        const simplecpp::TokenList tokens1(fin, files, "", &outputList);
+        const simplecpp::TokenList tokens1(raw_code, sizeof(raw_code), files, "", &outputList);
         const std::string filedata = tokens1.stringify();
         const std::string code = PreprocessorHelper::getcode(settingsDefault, *this, filedata, "", "test.c");
 
diff --git a/test/testtokenlist.cpp b/test/testtokenlist.cpp
@@ -155,9 +155,8 @@ class TestTokenList : public TestFixture {
         // 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>";
-        std::istringstream istr(code);
         std::vector<std::string> files;
-        simplecpp::TokenList tokens1(istr, files, "poll.h", nullptr);
+        simplecpp::TokenList tokens1(code, sizeof(code), files, "poll.h", nullptr);
         Preprocessor preprocessor(settingsDefault, *this, Path::identify(tokens1.getFiles()[0], false));
         simplecpp::TokenList tokensP = preprocessor.preprocess(tokens1, "", files, true);
         TokenList tokenlist(settingsDefault, Standards::Language::C); // headers are treated as C files
diff --git a/test/testunusedprivfunc.cpp b/test/testunusedprivfunc.cpp
@@ -93,7 +93,8 @@ class TestUnusedPrivateFunction : public TestFixture {
     };
 
 #define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
-    void check_(const char* file, int line, const char code[], const CheckOptions& options = make_default_obj()) {
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
         const Settings settings1 = settingsBuilder(settings).platform(options.platform).build();
 
         SimpleTokenizer2 tokenizer(settings1, *this, code, "test.cpp");
diff --git a/test/testunusedvar.cpp b/test/testunusedvar.cpp
@@ -302,7 +302,8 @@ class TestUnusedVar : public TestFixture {
     }
 
 #define checkStructMemberUsageP(...) checkStructMemberUsageP_(__FILE__, __LINE__, __VA_ARGS__)
-    void checkStructMemberUsageP_(const char* file, int line, const char code[]) {
+    template<size_t size>
+    void checkStructMemberUsageP_(const char* file, int line, const char (&code)[size]) {
         SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
 
         // Tokenizer..
@@ -314,7 +315,8 @@ class TestUnusedVar : public TestFixture {
     }
 
 #define checkFunctionVariableUsageP(...) checkFunctionVariableUsageP_(__FILE__, __LINE__, __VA_ARGS__)
-    void checkFunctionVariableUsageP_(const char* file, int line, const char code[]) {
+    template<size_t size>
+    void checkFunctionVariableUsageP_(const char* file, int line, const char (&code)[size]) {
         SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
 
         // Tokenizer..

Original file line number	Diff line number	Diff line change
`@@ -117,25 +117,24 @@ ScopedFile::~ScopedFile() {`
`117`	`117`	`// TODO: we should be using the actual Preprocessor implementation`
`118`	`118`	`std::string PreprocessorHelper::getcode(const Settings& settings, ErrorLogger& errorlogger, const std::string &filedata, const std::string &cfg, const std::string &filename, SuppressionList *inlineSuppression)`
`119`	`119`	`{`
`120`		`- std::map<std::string, std::string> cfgcode = getcode(settings, errorlogger, filedata.c_str(), std::set<std::string>{cfg}, filename, inlineSuppression);`
	`120`	`+ std::map<std::string, std::string> cfgcode = getcode(settings, errorlogger, filedata.c_str(), filedata.size(), std::set<std::string>{cfg}, filename, inlineSuppression);`
`121`	`121`	`const auto it = cfgcode.find(cfg);`
`122`	`122`	`if (it == cfgcode.end())`
`123`	`123`	`return "";`
`124`	`124`	`return it->second;`
`125`	`125`	`}`
`126`	`126`
`127`		`-std::map<std::string, std::string> PreprocessorHelper::getcode(const Settings& settings, ErrorLogger& errorlogger, const char code[], const std::string &filename, SuppressionList *inlineSuppression)`
	`127`	`+std::map<std::string, std::string> PreprocessorHelper::getcode(const Settings& settings, ErrorLogger& errorlogger, const char code[], std::size_t size, const std::string &filename, SuppressionList *inlineSuppression)`
`128`	`128`	`{`
`129`		`- return getcode(settings, errorlogger, code, {}, filename, inlineSuppression);`
	`129`	`+ return getcode(settings, errorlogger, code, size, {}, filename, inlineSuppression);`
`130`	`130`	`}`
`131`	`131`
`132`		`-std::map<std::string, std::string> PreprocessorHelper::getcode(const Settings& settings, ErrorLogger& errorlogger, const char code[], std::set<std::string> cfgs, const std::string &filename, SuppressionList *inlineSuppression)`
	`132`	`+std::map<std::string, std::string> PreprocessorHelper::getcode(const Settings& settings, ErrorLogger& errorlogger, const char code[], std::size_t size, std::set<std::string> cfgs, const std::string &filename, SuppressionList *inlineSuppression)`
`133`	`133`	`{`
`134`	`134`	`simplecpp::OutputList outputList;`
`135`	`135`	`std::vector<std::string> files;`
`136`	`136`
`137`		`- std::istringstream istr(code);`
`138`		`- simplecpp::TokenList tokens(istr, files, Path::simplifyPath(filename), &outputList);`
	`137`	`+ simplecpp::TokenList tokens(code, size, files, Path::simplifyPath(filename), &outputList);`
`139`	`138`	`Preprocessor preprocessor(settings, errorlogger, Path::identify(tokens.getFiles()[0], false));`
`140`	`139`	`if (inlineSuppression)`
`141`	`140`	`preprocessor.inlineSuppressions(tokens, *inlineSuppression);`
`@@ -162,11 +161,9 @@ std::map<std::string, std::string> PreprocessorHelper::getcode(const Settings& s`
`162`	`161`	`return cfgcode;`
`163`	`162`	`}`
`164`	`163`
`165`		`-void SimpleTokenizer2::preprocess(const char code[], std::vector<std::string> &files, const std::string& file0, Tokenizer& tokenizer, ErrorLogger& errorlogger)`
	`164`	`+void SimpleTokenizer2::preprocess(const char* code, std::size_t size, std::vector<std::string> &files, const std::string& file0, Tokenizer& tokenizer, ErrorLogger& errorlogger)`
`166`	`165`	`{`
`167`		`- // TODO: get rid of stream`
`168`		`- std::istringstream istr(code);`
`169`		`- const simplecpp::TokenList tokens1(istr, files, file0);`
	`166`	`+ const simplecpp::TokenList tokens1(code, size, files, file0);`
`170`	`167`
`171`	`168`	`Preprocessor preprocessor(tokenizer.getSettings(), errorlogger, Path::identify(tokens1.getFiles()[0], false));`
`172`	`169`	`simplecpp::TokenList tokens2 = preprocessor.preprocess(tokens1, "", files, true);`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,8 @@ class TestBufferOverrun : public TestFixture {`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`#define checkP(...) checkP_(__FILE__, __LINE__, __VA_ARGS__)`
`73`		`- void checkP_(const char* file, int line, const char code[])`
	`73`	`+ template<size_t size>`
	`74`	`+ void checkP_(const char* file, int line, const char (&code)[size])`
`74`	`75`	`{`
`75`	`76`	`const Settings settings = settingsBuilder(settings0).severity(Severity::performance).certainty(Certainty::inconclusive).build();`
`76`	`77`
Original file line number	Diff line number	Diff line change
`@@ -8778,7 +8778,8 @@ class TestClass : public TestFixture {`
`8778`	`8778`	`}`
`8779`	`8779`
`8780`	`8780`	`#define checkUselessOverride(...) checkUselessOverride_(__FILE__, __LINE__, __VA_ARGS__)`
`8781`		`- void checkUselessOverride_(const char* file, int line, const char code[]) {`
	`8781`	`+ template<size_t size>`
	`8782`	`+ void checkUselessOverride_(const char* file, int line, const char (&code)[size]) {`
`8782`	`8783`	`const Settings settings = settingsBuilder().severity(Severity::style).build();`
`8783`	`8784`
`8784`	`8785`	`SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");`