removed usage of static Settings object from tests

firewave · firewave · commit 680902c6d3fc · 2023-02-16T12:49:38.000+01:00
diff --git a/test/testclass.cpp b/test/testclass.cpp
@@ -7419,24 +7419,21 @@ class TestClass : public TestFixture {
 
 
 #define checkVirtualFunctionCall(...) checkVirtualFunctionCall_(__FILE__, __LINE__, __VA_ARGS__)
-    void checkVirtualFunctionCall_(const char* file, int line, const char code[], Settings *s = nullptr, bool inconclusive = true) {
+    void checkVirtualFunctionCall_(const char* file, int line, const char code[], bool inconclusive = true) {
         // Clear the error log
         errout.str("");
 
         // Check..
-        if (!s) {
-            static Settings settings_;
-            s = &settings_;
-            s->severity.enable(Severity::warning);
-        }
-        s->certainty.setEnabled(Certainty::inconclusive, inconclusive);
+        Settings settings;
+        settings.severity.enable(Severity::warning);
+        settings.certainty.setEnabled(Certainty::inconclusive, inconclusive);
 
         // Tokenize..
-        Tokenizer tokenizer(s, this);
+        Tokenizer tokenizer(&settings, this);
         std::istringstream istr(code);
         ASSERT_LOC(tokenizer.tokenize(istr, "test.cpp"), file, line);
 
-        CheckClass checkClass(&tokenizer, s, this);
+        CheckClass checkClass(&tokenizer, &settings, this);
         checkClass.checkVirtualFunctionCallInConstructor();
     }
 
diff --git a/test/testother.cpp b/test/testother.cpp
@@ -358,7 +358,7 @@ class TestOther : public TestFixture {
     }
 
     void checkInterlockedDecrement(const char code[]) {
-        static Settings settings;
+        Settings settings;
         settings.platformType = Settings::Win32A;
 
         check(code, nullptr, false, false, true, false, &settings);
@@ -1542,7 +1542,7 @@ class TestOther : public TestFixture {
         // Clear the error buffer..
         errout.str("");
 
-        static Settings settings;
+        Settings settings;
         settings.severity.enable(Severity::style);
         settings.standards.cpp = Standards::CPP03; // #5560
 
diff --git a/test/testpreprocessor.cpp b/test/testpreprocessor.cpp
@@ -64,7 +64,7 @@ class TestPreprocessor : public TestFixture {
             simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI(), &outputList);
 
             if (errorLogger) {
-                static Settings settings;
+                Settings settings;
                 Preprocessor p(settings, errorLogger);
                 p.reportOutput(outputList, true);
             }
diff --git a/test/testtype.cpp b/test/testtype.cpp
@@ -44,14 +44,10 @@ class TestType : public TestFixture {
     }
 
 #define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
-    void check_(const char* file, int line, const char code[], Settings* settings = nullptr, const char filename[] = "test.cpp", const std::string& standard = "c++11") {
+    void check_(const char* file, int line, const char code[], Settings* settings, const char filename[] = "test.cpp", const std::string& standard = "c++11") {
         // Clear the error buffer..
         errout.str("");
 
-        if (!settings) {
-            static Settings _settings;
-            settings = &_settings;
-        }
         settings->severity.enable(Severity::warning);
         settings->severity.enable(Severity::portability);
         settings->standards.setCPP(standard);
@@ -66,6 +62,7 @@ class TestType : public TestFixture {
     }
 
     void checkTooBigShift_Unix32() {
+        Settings settings0;
         Settings settings;
         PLATFORM(settings, Settings::Unix32);
 
@@ -166,7 +163,7 @@ class TestType : public TestFixture {
         // #7266: C++, shift in macro
         check("void f(unsigned int x) {\n"
               "    UINFO(x << 1234);\n"
-              "}");
+              "}", &settings0);
         ASSERT_EQUALS("", errout.str());
 
         // #8640
@@ -176,7 +173,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"
-              "}");
+              "}", &settings0);
         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());
 
@@ -187,7 +184,7 @@ class TestType : public TestFixture {
               "  if (k > 32)\n"
               "    return 0;\n"
               "  return rm>> k;\n"
-              "}");
+              "}", &settings0);
         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());
@@ -199,7 +196,7 @@ class TestType : public TestFixture {
               "    return 0;\n"
               "  else\n"
               "    return rm>> k;\n"
-              "}");
+              "}", &settings0);
         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());
@@ -211,20 +208,20 @@ class TestType : public TestFixture {
               "    return 0;\n"
               "  else\n"
               "    return rm>> k;\n"
-              "}");
+              "}", &settings0);
         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"
-              "}");
+              "}", &settings0);
         ASSERT_EQUALS("", errout.str());
 
         check("bool f() {\n"
               "    std::ofstream outfile;\n"
               "    outfile << vec_points[0](0) << static_cast<int>(d) << ' ';\n"
-              "}");
+              "}", &settings0);
         ASSERT_EQUALS("", errout.str());
 
         check("void f(unsigned b, int len, unsigned char rem) {\n" // #10773
@@ -235,7 +232,7 @@ class TestType : public TestFixture {
               "        if (bits == 512)\n"
               "            len -= 8;\n"
               "    }\n"
-              "}\n");
+              "}\n", &settings0);
         ASSERT_EQUALS("", errout.str());
     }
 
@@ -282,12 +279,13 @@ class TestType : public TestFixture {
     }
 
     void signConversion() {
+        Settings settings0;
         Settings settings;
         PLATFORM(settings, Settings::Unix64);
-        check("x = -4 * (unsigned)y;");
+        check("x = -4 * (unsigned)y;", &settings0);
         ASSERT_EQUALS("[test.cpp:1]: (warning) Expression '-4' has a negative value. That is converted to an unsigned value and used in an unsigned calculation.\n", errout.str());
 
-        check("x = (unsigned)y * -4;");
+        check("x = (unsigned)y * -4;", &settings0);
         ASSERT_EQUALS("[test.cpp:1]: (warning) Expression '-4' has a negative value. That is converted to an unsigned value and used in an unsigned calculation.\n", errout.str());
 
         check("unsigned int dostuff(int x) {\n" // x is signed
@@ -299,35 +297,35 @@ class TestType : public TestFixture {
         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); }", &settings0);
         ASSERT_EQUALS(
             "[test.cpp:1]: (warning) Expression 'x' can have a negative value. That is converted to an unsigned value and used in an unsigned calculation.\n",
             errout.str());
 
         check("unsigned int f1(int x) {"
               "  return x * 5U;\n"
               "}\n"
-              "void f2() { f1(-4); }");
+              "void f2() { f1(-4); }", &settings0);
         ASSERT_EQUALS(
             "[test.cpp:1]: (warning) Expression 'x' can have a negative value. That is converted to an unsigned value and used in an unsigned calculation.\n",
             errout.str());
 
         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); }", &settings0);
         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); }", &settings0);
         ASSERT_EQUALS("", errout.str());
 
         check("size_t foo(size_t x) {\n"
               " return -2 * x;\n"
-              "}");
+              "}", &settings0);
         ASSERT_EQUALS("[test.cpp:2]: (warning) Expression '-2' has a negative value. That is converted to an unsigned value and used in an unsigned calculation.\n", errout.str());
     }
 
@@ -390,42 +388,43 @@ class TestType : public TestFixture {
     }
 
     void checkFloatToIntegerOverflow() {
-        check("x = (int)1E100;");
+        Settings settings;
+        check("x = (int)1E100;", &settings);
         ASSERT_EQUALS("[test.cpp:1]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
 
         check("void f(void) {\n"
               "  return (int)1E100;\n"
-              "}");
+              "}", &settings);
         ASSERT_EQUALS("[test.cpp:2]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
 
         check("void f(void) {\n"
               "  return (int)-1E100;\n"
-              "}");
+              "}", &settings);
         ASSERT_EQUALS("[test.cpp:2]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
 
         check("void f(void) {\n"
               "  return (short)1E6;\n"
-              "}");
+              "}", &settings);
         ASSERT_EQUALS("[test.cpp:2]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
 
         check("void f(void) {\n"
               "  return (unsigned char)256.0;\n"
-              "}");
+              "}", &settings);
         ASSERT_EQUALS("[test.cpp:2]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
 
         check("void f(void) {\n"
               "  return (unsigned char)255.5;\n"
-              "}");
+              "}", &settings);
         ASSERT_EQUALS("", removeFloat(errout.str()));
 
         check("void f(void) {\n"
               "  char c = 1234.5;\n"
-              "}");
+              "}", &settings);
         ASSERT_EQUALS("[test.cpp:2]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
 
         check("char f(void) {\n"
               "  return 1234.5;\n"
-              "}");
+              "}", &settings);
         ASSERT_EQUALS("[test.cpp:2]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
     }
 };

Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ class TestPreprocessor : public TestFixture {`
`64`	`64`	`simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI(), &outputList);`
`65`	`65`
`66`	`66`	`if (errorLogger) {`
`67`		`- static Settings settings;`
	`67`	`+ Settings settings;`
`68`	`68`	`Preprocessor p(settings, errorLogger);`
`69`	`69`	`p.reportOutput(outputList, true);`
`70`	`70`	`}`