TestOther() : TestFixture("TestOther") {

}

Settings _settings;

void run() {

LOAD_LIB_2(_settings.library, "std.cfg");

TEST_CASE(emptyBrackets);

TEST_CASE(zeroDiv1);

TEST_CASE(zeroDiv2);

TEST_CASE(zeroDiv3);

TEST_CASE(zeroDiv4);

TEST_CASE(zeroDiv5);

TEST_CASE(zeroDiv6);

TEST_CASE(zeroDiv7); // #4930

TEST_CASE(zeroDiv8);

TEST_CASE(zeroDiv9);

TEST_CASE(zeroDiv10);

TEST_CASE(zeroDiv11);

TEST_CASE(zeroDivCond); // division by zero / useless condition

TEST_CASE(nanInArithmeticExpression);

TEST_CASE(varScope1);

TEST_CASE(varScope2);

TEST_CASE(varScope3);

TEST_CASE(varScope4);

TEST_CASE(varScope5);

TEST_CASE(varScope6);

TEST_CASE(varScope7);

TEST_CASE(varScope8);

TEST_CASE(varScope9); // classes may have extra side-effects

TEST_CASE(varScope10); // Undefined macro FOR

TEST_CASE(varScope11); // #2475 - struct initialization is not inner scope

TEST_CASE(varScope12);

TEST_CASE(varScope13); // variable usage in inner loop

TEST_CASE(varScope14);

TEST_CASE(varScope15); // #4573 if-else-if

TEST_CASE(varScope16);

TEST_CASE(varScope17);

TEST_CASE(varScope18);

TEST_CASE(varScope20); // Ticket #5103

TEST_CASE(varScope21); // Ticket #5382

TEST_CASE(varScope22); // Ticket #5684

TEST_CASE(varScope23); // Ticket #6154

TEST_CASE(oldStylePointerCast);

TEST_CASE(invalidPointerCast);

TEST_CASE(passedByValue);

TEST_CASE(switchRedundantAssignmentTest);

TEST_CASE(switchRedundantOperationTest);

TEST_CASE(switchRedundantBitwiseOperationTest);

TEST_CASE(switchFallThroughCase);

TEST_CASE(unreachableCode);

TEST_CASE(suspiciousCase);

TEST_CASE(suspiciousEqualityComparison);

TEST_CASE(selfAssignment);

TEST_CASE(trac1132);

TEST_CASE(testMisusedScopeObjectDoesNotPickFunction1);

TEST_CASE(testMisusedScopeObjectDoesNotPickFunction2);

TEST_CASE(testMisusedScopeObjectPicksClass);

TEST_CASE(testMisusedScopeObjectPicksStruct);

TEST_CASE(testMisusedScopeObjectDoesNotPickIf);

TEST_CASE(testMisusedScopeObjectDoesNotPickConstructorDeclaration);

TEST_CASE(testMisusedScopeObjectDoesNotPickFunctor);

TEST_CASE(testMisusedScopeObjectDoesNotPickLocalClassConstructors);

TEST_CASE(testMisusedScopeObjectDoesNotPickUsedObject);

TEST_CASE(testMisusedScopeObjectDoesNotPickPureC);

TEST_CASE(testMisusedScopeObjectDoesNotPickNestedClass);

TEST_CASE(testMisusedScopeObjectInConstructor);

TEST_CASE(testMisusedScopeObjectNoCodeAfter);

TEST_CASE(trac2071);

TEST_CASE(trac2084);

TEST_CASE(trac3693);

TEST_CASE(memsetZeroBytes);

TEST_CASE(memsetInvalid2ndParam);

TEST_CASE(clarifyCalculation);

TEST_CASE(clarifyStatement);

TEST_CASE(duplicateBranch);

TEST_CASE(duplicateBranch1); // tests extracted by http://www.viva64.com/en/b/0149/ ( Comparison between PVS-Studio and cppcheck ): Errors detected in Quake 3: Arena by PVS-Studio: Fragement 2

TEST_CASE(duplicateBranch2); // empty macro

TEST_CASE(duplicateExpression1);

TEST_CASE(duplicateExpression2); // ticket #2730

TEST_CASE(duplicateExpression3); // ticket #3317

TEST_CASE(duplicateExpression4); // ticket #3354 (++)

TEST_CASE(duplicateExpression5); // ticket #3749 (macros with same values)

TEST_CASE(duplicateExpression6); // ticket #4639

TEST_CASE(duplicateExpressionTernary); // #6391

TEST_CASE(checkSignOfUnsignedVariable);

TEST_CASE(checkSignOfPointer);

TEST_CASE(checkForSuspiciousSemicolon1);

TEST_CASE(checkForSuspiciousSemicolon2);

TEST_CASE(checkInvalidFree);

TEST_CASE(checkRedundantCopy);

TEST_CASE(checkNegativeShift);

TEST_CASE(incompleteArrayFill);

TEST_CASE(redundantVarAssignment);

TEST_CASE(redundantVarAssignment_7133);

TEST_CASE(redundantMemWrite);

TEST_CASE(varFuncNullUB);

TEST_CASE(checkPipeParameterSize); // ticket #3521

TEST_CASE(checkCastIntToCharAndBack); // ticket #160

TEST_CASE(checkCommaSeparatedReturn);

TEST_CASE(checkComparisonFunctionIsAlwaysTrueOrFalse);

TEST_CASE(integerOverflow); // #5895

TEST_CASE(redundantPointerOp);

TEST_CASE(test_isSameExpression);

TEST_CASE(raceAfterInterlockedDecrement);

TEST_CASE(testUnusedLabel);

TEST_CASE(testEvaluationOrder);

TEST_CASE(testEvaluationOrderSelfAssignment);

TEST_CASE(testEvaluationOrderMacro);

TEST_CASE(testEvaluationOrderSequencePointsFunctionCall);

TEST_CASE(testEvaluationOrderSequencePointsComma);

TEST_CASE(testEvaluationOrderSizeof);

}

void check(const char code[], const char *filename = nullptr, bool experimental = false, bool inconclusive = true, bool runSimpleChecks=true, Settings* settings = 0) {

// Clear the error buffer..

errout.str("");

if (!settings) {

settings = &_settings;

}

settings->addEnabled("style");

settings->addEnabled("warning");

settings->addEnabled("portability");

settings->addEnabled("performance");

settings->inconclusive = inconclusive;

settings->experimental = experimental;

// Tokenize..

Tokenizer tokenizer(settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, filename ? filename : "test.cpp");

// Check..

CheckOther checkOther(&tokenizer, settings, this);

checkOther.runChecks(&tokenizer, settings, this);

if (runSimpleChecks) {

tokenizer.simplifyTokenList2();

checkOther.runSimplifiedChecks(&tokenizer, settings, this);

}

}

void checkposix(const char code[]) {

static Settings settings;

settings.addEnabled("warning");

settings.standards.posix = true;

check(code,

nullptr, // filename

false, // experimental

false, // inconclusive

true, // runSimpleChecks

&settings);

}

void checkInterlockedDecrement(const char code[]) {

static Settings settings;

settings.platformType = Settings::Win32A;

check(code, nullptr, false, false, true, &settings);

}

void check_preprocess_suppress(const char precode[], const char *filename = nullptr) {

// Clear the error buffer..

errout.str("");

if (filename == nullptr)

filename = "test.cpp";

Settings settings;

settings.addEnabled("warning");

settings.addEnabled("style");

settings.addEnabled("performance");

settings.experimental = true;

// Preprocess file..

SimpleSuppressor logger(settings, this);

Preprocessor preprocessor(settings, &logger);

std::list<std::string> configurations;

std::string filedata = "";

std::istringstream fin(precode);

preprocessor.preprocess(fin, filedata, configurations, filename, settings.includePaths);

const std::string code = preprocessor.getcode(filedata, "", filename);

// Tokenize..

Tokenizer tokenizer(&settings, &logger);

std::istringstream istr(code);

tokenizer.tokenize(istr, filename);

// Check..

CheckOther checkOther(&tokenizer, &settings, &logger);

checkOther.checkSwitchCaseFallThrough();

logger.reportUnmatchedSuppressions(settings.nomsg.getUnmatchedLocalSuppressions(filename, false));

}

void emptyBrackets() {

check("{\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void zeroDiv1() { // floating point division by zero => no error

check("void foo() {\n"

" cout << 1. / 0;\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void foo() {\n"

" cout << 42 / (double)0;\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void foo() {\n"

" cout << 42 / (float)0;\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void foo() {\n"

" cout << 42 / (int)0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());

}

void zeroDiv2() {

check("void foo()\n"

"{\n"

" int sum = 0;\n"

" for(int i = 0; i < n; i ++)\n"

" {\n"

" sum += i;\n"

" }\n"

" cout<<b/sum;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void zeroDiv3() {

check("int foo(int i) {\n"

" return i / 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());

check("int foo(int i) {\n"

" return i % 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());

check("void foo(int& i) {\n"

" i /= 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());

check("void foo(int& i) {\n"

" i %= 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());

check("uint8_t foo(uint8_t i) {\n"

" return i / 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());

}

void zeroDiv4() {

check("void f()\n"

"{\n"

" long a = b / 0x6;\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f()\n"

"{\n"

" long a = b / 0x0;\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f(long b)\n"

"{\n"

" long a = b / 0x0;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (error) Division by zero.\n", errout.str());

check("void f()\n"

"{\n"

" long a = b / 0L;\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f(long b)\n"

"{\n"

" long a = b / 0L;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (error) Division by zero.\n", errout.str());

check("void f()\n"

"{\n"

" long a = b / 0ul;\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f(long b)\n"

"{\n"

" long a = b / 0ul;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (error) Division by zero.\n", errout.str());

// Don't warn about floating points (gcc doesn't warn either)

// and floating points are handled differently than integers.

check("void f()\n"

"{\n"

" long a = b / 0.0;\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f()\n"

"{\n"

" long a = b / 0.5;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void zeroDiv5() {

check("void f()\n"

"{ { {\n"

" long a = b / 0;\n"

"} } }");

ASSERT_EQUALS("", errout.str());

check("void f(long b)\n"

"{ { {\n"

" long a = b / 0;\n"

"} } }");

ASSERT_EQUALS("[test.cpp:3]: (error) Division by zero.\n", errout.str());

}

void zeroDiv6() {

check("void f()\n"

"{ { {\n"

" int a = b % 0;\n"

"} } }");

ASSERT_EQUALS("", errout.str());

check("void f(int b)\n"

"{ { {\n"

" int a = b % 0;\n"

"} } }");

ASSERT_EQUALS("[test.cpp:3]: (error) Division by zero.\n", errout.str());

}

void zeroDiv7() {

// unknown types for x and y --> do not warn

check("void f() {\n"

" int a = x/2*3/0;\n"

" int b = y/2*3%0;\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"

"}");

ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n"

"[test.cpp:3]: (error) Division by zero.\n", errout.str());

}

void zeroDiv8() {

// #5584 - FP when function is unknown

check("void f() {\n"

" int a = 0;\n"

" do_something(a);\n"

" return 4 / a;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error, inconclusive) Division by zero.\n", errout.str());

}

void zeroDiv9() {

// #6403 FP zerodiv - inside protecting if-clause

check("void foo() {\n"

" double fStepHelp = 0;\n"

" if( (rOuterValue >>= fStepHelp) ) {\n"

" if( fStepHelp != 0.0) {\n"

" double fStepMain = 0;\n"

" sal_Int32 nIntervalCount = static_cast< sal_Int32 >(fStepMain / fStepHelp);\n"

" }\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void zeroDiv10() {

// #5402 false positive: (error) Division by zero -- with boost::format

check("int main() {\n"

" std::cout\n"

" << boost::format(\" %d :: %s <> %s\") % 0 % \"a\" % \"b\"\n"

" << std::endl;\n"

" return 0;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void zeroDiv11() {

check("void f(int a) {\n"

" int res = (a+2)/0;\n"

" int res = (a*2)/0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n"

"[test.cpp:3]: (error) Division by zero.\n", errout.str());

check("void f() {\n"

" int res = (a+2)/0;\n"

" int res = (a*2)/0;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void zeroDivCond() {

check("void f(unsigned int x) {\n"

" int y = 17 / x;\n"

" if (x > 0) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Either the condition 'x>0' is redundant or there is division by zero at line 2.\n", errout.str());

check("void f(unsigned int x) {\n"

" int y = 17 / x;\n"

" if (x >= 1) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Either the condition 'x>=1' is redundant or there is division by zero at line 2.\n", errout.str());

check("void f(int x) {\n"

" int y = 17 / x;\n"

" if (x == 0) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Either the condition 'x==0' is redundant or there is division by zero at line 2.\n", errout.str());

check("void f(unsigned int x) {\n"

" int y = 17 / x;\n"

" if (x != 0) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Either the condition 'x!=0' is redundant or there is division by zero at line 2.\n", errout.str());

// function call

check("void f1(int x, int y) { c=x/y; }\n"

"void f2(unsigned int y) {\n"

" f1(123,y);\n"

" if (y>0){}\n"

"}");

ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:1]: (warning) Either the condition 'y>0' is redundant or there is division by zero at line 1.\n", errout.str());

// avoid false positives when variable is changed after division

check("void f() {\n"

" unsigned int x = do_something();\n"

" int y = 17 / x;\n"

" x = some+calculation;\n"

" if (x != 0) {}\n"

"}");

ASSERT_EQUALS("", errout.str());

{

// function is called that might modify global variable

check("void do_something();\n"

"int x;\n"

"void f() {\n"

" int y = 17 / x;\n"

" do_something();\n"

" if (x != 0) {}\n"

"}");

ASSERT_EQUALS("", errout.str());

// function is called. but don't care, variable is local

check("void do_something();\n"

"void f() {\n"

" int x = some + calculation;\n"

" int y = 17 / x;\n"

" do_something();\n"

" if (x != 0) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:4]: (warning) Either the condition 'x!=0' is redundant or there is division by zero at line 4.\n", errout.str());

}

check("void do_something(int value);\n"

"void f(int x) {\n"

" int y = 17 / x;\n"

" do_something(x);\n"

"}");

ASSERT_EQUALS("", errout.str());

check("int x;\n"

"void f() {\n"

" int y = 17 / x;\n"

" while (y || x == 0) { x--; }\n"

"}");

ASSERT_EQUALS("", errout.str());

// ticket 5033 segmentation fault (valid code) in CheckOther::checkZeroDivisionOrUselessCondition

check("void f() {\n"

"double* p1= new double[1];\n"

"double* p2= new double[1];\n"

"double* p3= new double[1];\n"

"double* pp[3] = {p1,p2,p3};\n"

"}");

ASSERT_EQUALS("", errout.str());

// #5105 - FP

check("int f(int a, int b) {\n"

" int r = a / b;\n"

" if (func(b)) {}\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"

"}");

ASSERT_EQUALS("", errout.str());

check("int f(int a) {\n"

" int r = a ? 1 / a : 0;\n"

" if (a == 0) {}\n"

"}");

ASSERT_EQUALS("", errout.str());

check("int f(int a) {\n"

" int r = (a == 0) ? 0 : 1 / a;\n"

" if (a == 0) {}\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void nanInArithmeticExpression() {

check("void f()\n"

"{\n"

" double x = 3.0 / 0.0 + 1.0\n"

" printf(\"%f\n\", x);\n"

"}");

ASSERT_EQUALS(

"[test.cpp:3]: (style) Using NaN/Inf in a computation.\n", errout.str());

check("void f()\n"

"{\n"

" double x = 3.0 / 0.0 - 1.0\n"

" printf(\"%f\n\", x);\n"

"}");

ASSERT_EQUALS(

"[test.cpp:3]: (style) Using NaN/Inf in a computation.\n", errout.str());

check("void f()\n"

"{\n"

" double x = 1.0 + 3.0 / 0.0\n"

" printf(\"%f\n\", x);\n"

"}");

ASSERT_EQUALS(

"[test.cpp:3]: (style) Using NaN/Inf in a computation.\n", errout.str());

check("void f()\n"

"{\n"

" double x = 1.0 - 3.0 / 0.0\n"

" printf(\"%f\n\", x);\n"

"}");

ASSERT_EQUALS(

"[test.cpp:3]: (style) Using NaN/Inf in a computation.\n", errout.str());

check("void f()\n"

"{\n"

" double x = 3.0 / 0.0\n"

" printf(\"%f\n\", x);\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope1() {

check("unsigned short foo()\n"

"{\n"

" test_client CClient;\n"

" try\n"

" {\n"

" if (CClient.Open())\n"

" {\n"

" return 0;\n"

" }\n"

" }\n"

" catch (...)\n"

" {\n"

" return 2;\n"

" }\n"

"\n"

" try\n"

" {\n"

" CClient.Close();\n"

" }\n"

" catch (...)\n"

" {\n"

" return 2;\n"

" }\n"

"\n"

" return 1;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope2() {

check("int foo()\n"

"{\n"

" Error e;\n"

" e.SetValue(12);\n"

" throw e;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope3() {

check("void foo()\n"

"{\n"

" int i;\n"

" int *p = 0;\n"

" if (abc)\n"

" {\n"

" p = &i;\n"

" }\n"

" *p = 1;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope4() {

check("void foo()\n"

"{\n"

" int i;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope5() {

check("void f(int x)\n"

"{\n"

" int i = 0;\n"

" if (x) {\n"

" for ( ; i < 10; ++i) ;\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) The scope of the variable 'i' can be reduced.\n", errout.str());

check("void f(int x) {\n"

" const unsigned char i = 0;\n"

" if (x) {\n"

" for ( ; i < 10; ++i) ;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f(int x)\n"

"{\n"

" int i = 0;\n"

" if (x) {b()}\n"

" else {\n"

" for ( ; i < 10; ++i) ;\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) The scope of the variable 'i' can be reduced.\n", errout.str());

}

void varScope6() {

check("void f(int x)\n"

"{\n"

" int i = x;\n"

" if (a) {\n"

" x++;\n"

" }\n"

" if (b) {\n"

" c(i);\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f()\n"

"{\n"

"int foo = 0;\n"

"std::vector<int> vec(10);\n"

"BOOST_FOREACH(int& i, vec)\n"

"{\n"

" foo += 1;\n"

" if(foo == 10)\n"

" {\n"

" return 0;\n"

" }\n"

"}\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f(int &x)\n"

"{\n"

" int n = 1;\n"

" do\n"

" {\n"

" ++n;\n"

" ++x;\n"

" } while (x);\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope7() {

check("void f(int x)\n"

"{\n"

" int y = 0;\n"

" b(y);\n"

" if (x) {\n"

" y++;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope8() {

check("void test() {\n"

" float edgeResistance=1;\n"

" std::vector<int> edges;\n"

" BOOST_FOREACH(int edge, edges) {\n"

" edgeResistance = (edge+1) / 2.0;\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'edgeResistance' can be reduced.\n", errout.str());

}

void varScope9() {

// classes may have extra side effects

check("class fred {\n"

"public:\n"

" void x();\n"

"};\n"

"void test(int a) {\n"

" fred f;\n"

" if (a == 2) {\n"

" f.x();\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope10() {

check("int f()\n"

"{\n"

" int x = 0;\n"

" FOR {\n"

" foo(x++);\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope11() {

check("int f() {\n"

" int x = 0;\n"

" AB ab = { x, 0 };\n"

"}");

ASSERT_EQUALS("", errout.str());

check("int f() {\n"

" int x = 0;\n"

" if (a == 0) { ++x; }\n"

" AB ab = { x, 0 };\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"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope12() {

check("void f(int x) {\n"

" int i[5];\n"

" int* j = y;\n"

" if (x)\n"

" foo(i);\n"

" foo(j);\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'i' can be reduced.\n", errout.str());

check("void f(int x) {\n"

" int i[5];\n"

" int* j;\n"

" if (x)\n"

" j = i;\n"

" foo(j);\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f(int x) {\n"

" const bool b = true;\n"

" x++;\n"

" if (x == 5)\n"

" foo(b);\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f(int x) {\n"

" const bool b = x;\n"

" x++;\n"

" if (x == 5)\n"

" foo(b);\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope13() {

// #2770

check("void f() {\n"

" int i = 0;\n"

" forever {\n"

" if (i++ == 42) { break; }\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope14() {

// #3941

check("void f() {\n"

" const int i( foo());\n"

" if(a) {\n"

" for ( ; i < 10; ++i) ;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void varScope15() {

// #4573

check("void f() {\n"

" int a,b,c;\n"

" if (a);\n"

" else if(b);\n"

" else if(c);\n"

" else;\n"

"}", nullptr, false, false);

ASSERT_EQUALS("", errout.str());

}

void varScope16() {

check("void f() {\n"

" int a = 0;\n"

" while((++a) < 56) {\n"

" foo();\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f() {\n"

" int a = 0;\n"

" do {\n"

" foo();\n"

" } while((++a) < 56);\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f() {\n"

" int a = 0;\n"

" do {\n"

" a = 64;\n"

" foo(a);\n"

" } while((++a) < 56);\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f() {\n"

" int a = 0;\n"

" do {\n"

" a = 64;\n"

" foo(a);\n"

" } while(z());\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'a' can be reduced.\n", errout.str());

}

void varScope17() {

check("void f() {\n"

" int x;\n"

" if (a) {\n"

" x = stuff(x);\n"

" morestuff(x);\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'x' can be reduced.\n", errout.str());

check("void f() {\n"

" int x;\n"

" if (a) {\n"

" x = stuff(x);\n"

" morestuff(x);\n"

" }\n"

" if (b) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'x' can be reduced.\n", errout.str());

}

void varScope18() {

check("void f() {\n"

" short x;\n"

"\n"

" switch (ab) {\n"

" case A:\n"

" break;\n"

" case B:\n"

" default:\n"

" break;\n"

" }\n"

"\n"

" if (c) {\n"

" x = foo();\n"

" do_something(x);\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'x' can be reduced.\n", errout.str());

check("void f() {\n"

" short x;\n"

"\n"

" switch (ab) {\n"

" case A:\n"

" x = 10;\n"

" break;\n"

" case B:\n"

" default:\n"

" break;\n"

" }\n"

"\n"

" if (c) {\n"

" x = foo();\n"

" do_something(x);\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

check("void f() {\n"

" short x;\n"

"\n"

" switch (ab) {\n"

" case A:\n"