TestOther() : TestFixture("TestOther") {

}

void run() {

TEST_CASE(oppositeInnerCondition);

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(zeroDivCond); // division by zero / useless condition

TEST_CASE(nanInArithmeticExpression);

TEST_CASE(invalidFunctionUsage1);

TEST_CASE(sprintf1); // Dangerous usage of sprintf

TEST_CASE(sprintf2);

TEST_CASE(sprintf3);

TEST_CASE(sprintf4); // struct member

TEST_CASE(strPlusChar1); // "/usr" + '/'

TEST_CASE(strPlusChar2); // "/usr" + ch

TEST_CASE(strPlusChar3); // ok: path + "/sub" + '/'

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(varScope19); // Ticket #4994

TEST_CASE(varScope20); // Ticket #5103

TEST_CASE(oldStylePointerCast);

TEST_CASE(invalidPointerCast);

TEST_CASE(passedByValue);

TEST_CASE(mathfunctionCall_fmod);

TEST_CASE(mathfunctionCall_sqrt);

TEST_CASE(mathfunctionCall_log);

TEST_CASE(mathfunctionCall_acos);

TEST_CASE(mathfunctionCall_asin);

TEST_CASE(mathfunctionCall_pow);

TEST_CASE(mathfunctionCall_atan2);

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(modulo);

TEST_CASE(incorrectLogicOperator1);

TEST_CASE(incorrectLogicOperator2);

TEST_CASE(incorrectLogicOperator3);

TEST_CASE(incorrectLogicOperator4);

TEST_CASE(incorrectLogicOperator5); // complex expressions

TEST_CASE(incorrectLogicOperator6); // char literals

TEST_CASE(secondAlwaysTrueFalseWhenFirstTrueError);

TEST_CASE(incorrectLogicOp_condSwapping);

TEST_CASE(sameExpression);

TEST_CASE(memsetZeroBytes);

TEST_CASE(redundantGetAndSetUserId);

TEST_CASE(clarifyCalculation);

TEST_CASE(clarifyStatement);

TEST_CASE(clarifyCondition1); // if (a = b() < 0)

TEST_CASE(clarifyCondition2); // if (a & b == c)

TEST_CASE(clarifyCondition3); // if (! a & b)

TEST_CASE(clarifyCondition4); // ticket #3110

TEST_CASE(clarifyCondition5); // #3609 CWinTraits<WS_CHILD|WS_VISIBLE>..

TEST_CASE(clarifyCondition6); // #3818

TEST_CASE(incorrectStringCompare);

TEST_CASE(duplicateIf);

TEST_CASE(duplicateIf1); // ticket 3689

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(alwaysTrueFalseStringCompare);

TEST_CASE(suspiciousStringCompare);

TEST_CASE(checkSignOfUnsignedVariable);

TEST_CASE(checkSignOfPointer);

TEST_CASE(checkForSuspiciousSemicolon1);

TEST_CASE(checkForSuspiciousSemicolon2);

TEST_CASE(checkDoubleFree);

TEST_CASE(checkInvalidFree);

TEST_CASE(checkRedundantCopy);

TEST_CASE(checkNegativeShift);

TEST_CASE(incompleteArrayFill);

TEST_CASE(redundantVarAssignment);

TEST_CASE(redundantMemWrite);

TEST_CASE(varFuncNullUB);

TEST_CASE(checkPipeParameterSize); // ticket #3521

TEST_CASE(checkCastIntToCharAndBack); // ticket #160

TEST_CASE(checkSleepTimeIntervall)

TEST_CASE(checkCommaSeparatedReturn);

TEST_CASE(checkComparisonFunctionIsAlwaysTrueOrFalse);

}

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

// Clear the error buffer..

errout.str("");

if (!settings) {

static Settings _settings;

settings = &_settings;

}

settings->addEnabled("style");

settings->addEnabled("warning");

settings->addEnabled("portability");

settings->addEnabled("performance");

settings->inconclusive = inconclusive;

settings->experimental = experimental;

settings->standards.posix = posix;

if (posix) {

const char cfg[] = "<?xml version=\"1.0\"?>\n"

"<def>\n"

" <function name=\"usleep\"> <arg nr=\"1\"><valid>0-999999</valid></arg> </function>\n"

"</def>";

tinyxml2::XMLDocument xmldoc;

xmldoc.Parse(cfg, sizeof(cfg));

settings->library.load(xmldoc);

}

// 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) {

const std::string str1(tokenizer.tokens()->stringifyList(0,true));

tokenizer.simplifyTokenList2();

const std::string str2(tokenizer.tokens()->stringifyList(0,true));

if (str1 != str2)

warn(("Unsimplified code in test case\nstr1="+str1+"\nstr2="+str2).c_str());

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

}

}

class SimpleSuppressor: public ErrorLogger {

public:

SimpleSuppressor(Settings &settings, ErrorLogger *next)

: _settings(settings), _next(next) {

}

virtual void reportOut(const std::string &outmsg) {

_next->reportOut(outmsg);

}

virtual void reportErr(const ErrorLogger::ErrorMessage &msg) {

if (!msg._callStack.empty() && !_settings.nomsg.isSuppressed(msg._id, msg._callStack.begin()->getfile(), msg._callStack.begin()->line))

_next->reportErr(msg);

}

private:

Settings &_settings;

ErrorLogger *_next;

};

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

// Clear the error buffer..

errout.str("");

if (filename == NULL)

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);

tokenizer.simplifyGoto();

// Check..

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

checkOther.checkSwitchCaseFallThrough();

checkOther.checkAlwaysTrueOrFalseStringCompare();

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

}

void oppositeInnerCondition() {

check("void foo(int a, int b)\n"

"{\n"

" if(a==b)\n"

" if(a!=b)\n"

" cout << a;\n"

"}", "test.cpp", true, true);

ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Opposite conditions in nested 'if' blocks lead to a dead code block.\n", errout.str());

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

"{\n"

" if(i > 5) {\n"

" i = bar();\n"

" if(i < 5) {\n"

" cout << a;\n"

" }\n"

" }\n"

"}", "test.cpp", true, true);

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

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

"{\n"

" i=6;\n"

"}\n"

"void bar(int i)\n"

"{\n"

" if(i>5){\n"

" foo(i);\n"

" if(i<5){\n"

" }\n"

" }\n"

"}", "test.cpp", true, true);

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

}

void emptyBrackets() {

check("{\n"

"}");

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

}

void zeroDiv1() {

check("void foo() {\n"

" cout << 1. / 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("void f()\n"

"{\n"

" div_t divresult = div (1,0);\n"

"}");

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

// #4929 - if there is a user function with the name "div" don't warn

check("void div(int a, int b);\n"

"void f() {\n"

" div (1,0);\n"

"}");

ASSERT_EQUALS("", 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("[test.cpp:3]: (error) Division by zero.\n", errout.str());

check("void f()\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("[test.cpp:3]: (error) Division by zero.\n", errout.str());

check("void f()\n"

"{\n"

" div_t divresult = div (1,0L);\n"

"}");

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

check("void f()\n"

"{\n"

" div_t divresult = div (1,0x5);\n"

"}");

ASSERT_EQUALS("", 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());

// Don't warn about 0.0

check("void f()\n"

"{\n"

" div_t divresult = div (1,0.0);\n"

"}");

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

check("void f()\n"

"{\n"

" div_t divresult = div (1,0.5);\n"

"}");

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

}

void zeroDiv5() {

check("void f()\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("[test.cpp:3]: (error) Division by zero.\n", errout.str());

}

void zeroDiv7() {

check("void f() {\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 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 useless 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 useless 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 useless 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 useless 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 useless 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 useless 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());

// ticket #5045 segmentation fault when SymbolDatabase is corrupt

{

// We don't use the "check" function because we need to

// make sure the symboldatabase is inconsistent..

const char code[] = "namespace {\n"

" void get() { source = create(context); }\n"

" void create( something const & context)\n"

" SAL_THROW((css::uno::Exception))\n"

" { return new Server(context); }\n"

"}\n"

"void component_getFactory()\n"

"{ component_getFactoryHelper(); }";

Settings settings;

settings.addEnabled("warning");

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr,"test.cpp");

tokenizer.simplifyTokenList2();

// Assert that the symboldatabase is inconsistent..

const SymbolDatabase *symbolDatabase = tokenizer.getSymbolDatabase();

ASSERT_EQUALS(2U, symbolDatabase->getVariableListSize());

const Variable *var = symbolDatabase->getVariableFromVarId(1U);

ASSERT(!!var->typeStartToken());

bool invalid = true;

for (const Token *tok = var->typeStartToken(); tok; tok = tok->next()) {

invalid = true;

if (tok == var->typeEndToken()) {

invalid = false;

break;

}

}

ASSERT_EQUALS(true, invalid);

// Make sure there is no crash with inconsistent symboldatabase..

// typeStartToken() is not before typeEndToken()

errout.str("");

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

checkOther.checkZeroDivisionOrUselessCondition(); // don't crash

}

// #5105 - FP

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

" int r = a / b;\n"

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

"}");

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

// ?:

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

" int r = (a?b:c) / d;\n"

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

"}");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Either the condition 'd==0' is useless or there is division by zero at line 2.\n", 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 invalidFunctionUsage(const char code[]) {

// Clear the error buffer..

errout.str("");

const char cfg[] = "<?xml version=\"1.0\"?>\n"

"<def>\n"

" <function name=\"memset\"> <arg nr=\"3\"><not-bool/></arg> </function>\n"

" <function name=\"strtol\"> <arg nr=\"3\"><valid>0,2-36</valid></arg> </function>\n"

"</def>";

tinyxml2::XMLDocument xmldoc;

xmldoc.Parse(cfg, sizeof(cfg));

Settings settings;

settings.library.load(xmldoc);

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, "test.cpp");

// Check for redundant code..

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

checkOther.invalidFunctionUsage();

}

void invalidFunctionUsage1() {

invalidFunctionUsage("int f() { memset(a,b,sizeof(a)!=12); }");

ASSERT_EQUALS("[test.cpp:1]: (error) Invalid memset() argument nr 3. A non-boolean value is required.\n", errout.str());

invalidFunctionUsage("int f() { memset(a,b,sizeof(a)!=0); }");

TODO_ASSERT_EQUALS("error", "", errout.str());

invalidFunctionUsage("int f() { strtol(a,b,sizeof(a)!=12); }");

ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strtol() argument nr 3. The value is 0 or 1 (comparison result) but the valid values are '0,2-36'.\n", errout.str());

invalidFunctionUsage("int f() { strtol(a,b,1); }");

ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strtol() argument nr 3. The value is 1 but the valid values are '0,2-36'.\n", errout.str());

invalidFunctionUsage("int f() { strtol(a,b,10); }");

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

}

void sprintf1() {

invalidFunctionUsage("void foo()\n"

"{\n"

" char buf[100];\n"

" sprintf(buf,\"%s\",buf);\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in s[n]printf().\n", errout.str());

}

void sprintf2() {

invalidFunctionUsage("void foo()\n"

"{\n"

" char buf[100];\n"

" sprintf(buf,\"%i\",sizeof(buf));\n"

"}");

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

}

void sprintf3() {

invalidFunctionUsage("void foo()\n"

"{\n"

" char buf[100];\n"

" sprintf(buf,\"%i\",sizeof(buf));\n"

" if (buf[0]);\n"

"}");

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

}

void sprintf4() {

invalidFunctionUsage("struct A\n"

"{\n"

" char filename[128];\n"

"};\n"

"\n"

"void foo()\n"

"{\n"

" const char* filename = \"hello\";\n"

" struct A a;\n"

" snprintf(a.filename, 128, \"%s\", filename);\n"

"}");

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

}

void strPlusChar(const char code[]) {

// Clear the error buffer..

errout.str("");

Settings settings;

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, "test.cpp");

// Check for redundant code..

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

checkOther.strPlusChar();

}

void strPlusChar1() {

// Strange looking pointer arithmetic..

strPlusChar("void foo()\n"

"{\n"

" const char *p = \"/usr\" + '/';\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (error) Unusual pointer arithmetic. A value of type 'char' is added to a string literal.\n", errout.str());

}

void strPlusChar2() {

// Strange looking pointer arithmetic..

strPlusChar("void foo()\n"

"{\n"

" char ch = 1;\n"

" const char *p = ch + \"/usr\";\n"

"}");

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

// Strange looking pointer arithmetic..

strPlusChar("void foo()\n"

"{\n"

" int i = 1;\n"

" const char* psz = \"Bla\";\n"

" const std::string str = i + psz;\n"

"}");

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

}

void strPlusChar3() {

// Strange looking pointer arithmetic..

strPlusChar("void foo()\n"

"{\n"

" std::string temp = \"/tmp\";\n"

" std::string path = temp + '/' + \"sub\" + '/';\n"

"}");

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

}

void varScope(const char code[]) {

// Clear the error buffer..

errout.str("");

Settings settings;

settings.addEnabled("style");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, "test.cpp");

// Check for redundant code..

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

checkOther.checkVariableScope();

}

void varScope1() {

varScope("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() {

varScope("int foo()\n"

"{\n"

" Error e;\n"

" e.SetValue(12);\n"

" throw e;\n"

"}");

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

}

void varScope3() {

varScope("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() {

varScope("void foo()\n"

"{\n"

" int i;\n"

"}");

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

}

void varScope5() {

varScope("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());

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

" const unsigned char i = 0;\n"

" if (x) {\n"

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

" }\n"

"}");

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

varScope("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() {

varScope("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());

varScope("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());

varScope("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() {

varScope("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() {

varScope("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

varScope("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() {

varScope("int f()\n"

"{\n"

" int x = 0;\n"

" FOR {\n"

" foo(x++);\n"