TestOther() : TestFixture("TestOther")

{ }

void run() {

TEST_CASE(assignBoolToPointer);

TEST_CASE(zeroDiv1);

TEST_CASE(zeroDiv2);

TEST_CASE(zeroDiv3);

TEST_CASE(zeroDiv4);

TEST_CASE(zeroDiv5);

TEST_CASE(zeroDiv6);

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

TEST_CASE(invalidPointerCast);

TEST_CASE(dangerousStrolUsage);

TEST_CASE(passedByValue);

TEST_CASE(mathfunctionCall1);

TEST_CASE(cctypefunctionCall);

TEST_CASE(sizeofsizeof);

TEST_CASE(sizeofCalculation);

TEST_CASE(switchRedundantAssignmentTest);

TEST_CASE(switchRedundantBitwiseOperationTest);

TEST_CASE(switchFallThroughCase);

TEST_CASE(unreachableCode);

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

TEST_CASE(trac2084);

TEST_CASE(trac3693);

TEST_CASE(assignmentInAssert);

TEST_CASE(modulo);

TEST_CASE(incorrectLogicOperator1);

TEST_CASE(incorrectLogicOperator2);

TEST_CASE(incorrectLogicOperator3);

TEST_CASE(secondAlwaysTrueFalseWhenFirstTrueError);

TEST_CASE(incorrectLogicOp_condSwapping);

TEST_CASE(sameExpression);

TEST_CASE(memsetZeroBytes);

TEST_CASE(sizeofForArrayParameter);

TEST_CASE(sizeofForNumericParameter);

TEST_CASE(clarifyCalculation);

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(bitwiseOnBoolean); // if (bool & bool)

TEST_CASE(comparisonOfBoolExpressionWithInt1);

TEST_CASE(comparisonOfBoolExpressionWithInt2);

TEST_CASE(comparisonOfBoolExpressionWithInt3);

TEST_CASE(incorrectStringCompare);

TEST_CASE(incrementBoolean);

TEST_CASE(comparisonOfBoolWithInt1);

TEST_CASE(comparisonOfBoolWithInt2);

TEST_CASE(comparisonOfBoolWithInt3);

TEST_CASE(comparisonOfBoolWithInt4);

TEST_CASE(comparisonOfBoolWithInt5);

TEST_CASE(duplicateIf);

TEST_CASE(duplicateIf1); // ticket 3689

TEST_CASE(duplicateBranch);

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

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

TEST_CASE(checkPointerSizeof);

TEST_CASE(checkSignOfUnsignedVariable);

TEST_CASE(checkForSuspiciousSemicolon1);

TEST_CASE(checkForSuspiciousSemicolon2);

TEST_CASE(checkDoubleFree);

TEST_CASE(checkRedundantCopy);

}

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

// Clear the error buffer..

errout.str("");

Settings settings;

settings.addEnabled("style");

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

// Simplify token list..

tokenizer.simplifyTokenList();

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

check("void foo(bool *p) {\n"

" p = false;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (error) Assigning bool value to pointer (converting bool value to address)\n", errout.str());

}

void zeroDiv1() {

check("void foo()\n"

"{\n"

" int a = 0;\n"

" double b = 1.;\n"

" cout<<b/a;\n"

"}");

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

}

void zeroDiv2() {

check("void foo()\n"

"{\n"

" int sum = 0;\n"

" int n = 100;\n"

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

" {\n"

" sum += i; \n"

" }\n"

" cout<<b/sum;\n"

"}\n");

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

check("void foo()\n"

"{\n"

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

"}\n");

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

}

void zeroDiv3() {

check("void f()\n"

"{\n"

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

"}\n");

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

}

void zeroDiv4() {

check("void f()\n"

"{\n"

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

"}\n");

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

check("void f()\n"

"{\n"

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

"}\n");

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

check("void f()\n"

"{\n"

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

"}\n");

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

check("void f()\n"

"{\n"

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

"}\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"

"}\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"

"}\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"

"}\n");

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

check("void f()\n"

"{\n"

" long a = b / 0.5;\n"

"}\n");

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

// Don't warn about 0.0

check("void f()\n"

"{\n"

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

"}\n");

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

check("void f()\n"

"{\n"

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

"}\n");

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

}

void zeroDiv5() {

check("void f()\n"

"{ { {\n"

" long a = b / 0;\n"

"} } }\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"

"} } }\n");

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

}

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

//tokenizer.tokens()->printOut( "tokens" );

// Check for redundant code..

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

checkOther.invalidFunctionUsage();

}

void sprintf1() {

sprintfUsage("void foo()\n"

"{\n"

" char buf[100];\n"

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

"}\n");

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

}

void sprintf2() {

sprintfUsage("void foo()\n"

"{\n"

" char buf[100];\n"

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

"}\n");

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

}

void sprintf3() {

sprintfUsage("void foo()\n"

"{\n"

" char buf[100];\n"

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

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

"}\n");

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

}

void sprintf4() {

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

"}\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"

"}\n");

ASSERT_EQUALS("[test.cpp:3]: (error) Unusual pointer arithmetic\n", errout.str());

}

void strPlusChar2() {

// Strange looking pointer arithmetic..

strPlusChar("void foo()\n"

"{\n"

" char ch = 1;\n"

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

"}\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"

"}\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"

"}\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"

"}\n");

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

}

void varScope2() {

varScope("int foo()\n"

"{\n"

" Error e;\n"

" e.SetValue(12);\n"

" throw e;\n"

"}\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"

"}\n");

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

}

void varScope4() {

varScope("void foo()\n"

"{\n"

" int i;\n"

"}\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"

"}\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("[test.cpp:2]: (style) The scope of the variable 'i' can be reduced\n", 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"

"}\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"

"}\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"

"}\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"

"}\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"

"}\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"

"}\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"

"}\n");

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

}

void varScope10() {

// classes may have extra side effects

varScope("int f()\n"

"{\n"

" int x = 0;\n"

" FOR {\n"

" foo(x++);\n"

" }\n"

"}\n");

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

}

void varScope11() {

varScope("int f() {\n"

" int x = 0;\n"

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

"}\n");

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

varScope("int f() {\n"

" int x = 0;\n"

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

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

"}\n");

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

varScope("int f() {\n"

" int x = 0;\n"

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

" if (a == 1) { AB ab = { x, 0 }; }\n"

"}\n");

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

}

void varScope12() {

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

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

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

" const bool b = true;\n"

" x++;\n"

" if (x == 5)\n"

" foo(b);\n"

"}");

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

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

varScope("void f() {\n"

" int i = 0;\n"

" forever {\n"

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

" }\n"

"}");

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

}

void checkOldStylePointerCast(const char code[]) {

// Clear the error buffer..

errout.str("");

Settings settings;

settings.addEnabled("style");

// Tokenize..

Tokenizer tokenizerCpp(&settings, this);

std::istringstream istr(code);

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

Tokenizer tokenizerC(&settings, this);

std::istringstream istr2(code);

tokenizerC.tokenize(istr2, "test.c");

CheckOther checkOtherCpp(&tokenizerCpp, &settings, this);

checkOtherCpp.warningOldStylePointerCast();

CheckOther checkOtherC(&tokenizerC, &settings, this);

checkOtherC.warningOldStylePointerCast();

}

void oldStylePointerCast() {

checkOldStylePointerCast("class Base;\n"

"void foo()\n"

"{\n"

" Base * b = (Base *) derived;\n"

"}\n");

ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());

checkOldStylePointerCast("class Base;\n"

"void foo()\n"

"{\n"

" Base * b = (const Base *) derived;\n"

"}\n");

ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());

checkOldStylePointerCast("class Base;\n"

"void foo()\n"

"{\n"

" Base * b = (const Base *) ( new Derived() );\n"

"}\n");

ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());

checkOldStylePointerCast("class Base;\n"

"void foo()\n"

"{\n"

" Base * b = (const Base *) new Derived();\n"

"}\n");

ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());

checkOldStylePointerCast("class Base;\n"

"void foo()\n"

"{\n"

" Base * b = (const Base *) new short[10];\n"

"}\n");

ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());

checkOldStylePointerCast("class B;\n"

"class A\n"

"{\n"

" virtual void abc(B *) const = 0;\n"

"}\n");

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

checkOldStylePointerCast("class B;\n"

"class A\n"

"{\n"

" virtual void abc(const B *) const = 0;\n"

"}\n");

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

}

void checkInvalidPointerCast(const char code[], bool portability = false, bool inconclusive = false) {

// Clear the error buffer..

errout.str("");

Settings settings;

settings.addEnabled("style");

if (portability)

settings.addEnabled("portability");

settings.inconclusive = inconclusive;

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

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

checkOtherCpp.invalidPointerCast();

}

void invalidPointerCast() {

checkInvalidPointerCast("void test() {\n"

" float *f = new float[10];\n"

" delete [] (double*)f;\n"

" delete [] (long double const*)(new float[10]);\n"

"}");

TODO_ASSERT_EQUALS("[test.cpp:3]: (warning) Casting between float* and double* which have an incompatible binary data representation\n"

"[test.cpp:4]: (warning) Casting between float* and long double* which have an incompatible binary data representation\n",

"[test.cpp:3]: (warning) Casting between float* and double* which have an incompatible binary data representation\n"

"[test.cpp:4]: (warning) Casting between float* and double* which have an incompatible binary data representation\n", errout.str());

checkInvalidPointerCast("void test(const float* f) {\n"

" double *d = (double*)f;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Casting between float* and double* which have an incompatible binary data representation\n", errout.str());

checkInvalidPointerCast("void test(double* d1) {\n"

" long double *ld = (long double*)d1;\n"

" double *d2 = (double*)ld;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Casting between double* and long double* which have an incompatible binary data representation\n"

"[test.cpp:3]: (warning) Casting between long double* and double* which have an incompatible binary data representation\n", errout.str());

checkInvalidPointerCast("char* test(int* i) {\n"

" long double *d = (long double*)(i);\n"

" double *d = (double*)(i);\n"

" float *f = reinterpret_cast<float*>(i);\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Casting between integer* and long double* which have an incompatible binary data representation\n"

"[test.cpp:3]: (warning) Casting between integer* and double* which have an incompatible binary data representation\n"

"[test.cpp:4]: (warning) Casting between integer* and float* which have an incompatible binary data representation\n", errout.str());

checkInvalidPointerCast("float* test(unsigned int* i) {\n"

" return (float*)i;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Casting between integer* and float* which have an incompatible binary data representation\n", errout.str());

checkInvalidPointerCast("float* test(unsigned int* i) {\n"

" return (float*)i[0];\n"

"}");

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

checkInvalidPointerCast("float* test(double& d) {\n"

" return (float*)&d;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Casting between double* and float* which have an incompatible binary data representation\n", errout.str());

checkInvalidPointerCast("void test(float* data) {\n"

" f.write((char*)data,sizeof(float));\n"

"}", true, false);

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

checkInvalidPointerCast("void test(float* data) {\n"

" f.write((char*)data,sizeof(float));\n"

"}", true, true); // #3639

ASSERT_EQUALS("[test.cpp:2]: (portability, inconclusive) Casting from float* to char* might be not portable due to different binary data representations on different platforms\n", errout.str());

checkInvalidPointerCast("long long* test(float* f) {\n"

" return (long long*)f;\n"

"}", false);

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

checkInvalidPointerCast("long long* test(float* f, char* c) {\n"

" foo((long long*)f);\n"

" return reinterpret_cast<long long*>(c);\n"

"}", true);

ASSERT_EQUALS("[test.cpp:2]: (portability) Casting from float* to integer* is not portable due to different binary data representations on different platforms\n", errout.str());

}

void dangerousStrolUsage() {

{

sprintfUsage("int f(const char *num)\n"

"{\n"

" return strtol(num, NULL, 1);\n"

"}\n");

ASSERT_EQUALS("[test.cpp:3]: (error) Invalid radix in call to strtol or strtoul. Must be 0 or 2-36\n", errout.str());

}

{

sprintfUsage("int f(const char *num)\n"

"{\n"

" return strtol(num, NULL, 10);\n"

"}\n");

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

}

}

void testPassedByValue(const char code[]) {

// Clear the error buffer..

errout.str("");

Settings settings;

settings.addEnabled("performance");

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

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

checkOther.checkConstantFunctionParameter();

}

void passedByValue() {

testPassedByValue("void f(const std::string str) {}");

ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'str' should be passed by reference.\n", errout.str());

testPassedByValue("class Foo;\nvoid f(const Foo foo) {}");

ASSERT_EQUALS("[test.cpp:2]: (performance) Function parameter 'foo' should be passed by reference.\n", errout.str());

testPassedByValue("void f(const std::string &str) {}");

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

testPassedByValue("void f(const std::vector<int> v) {}");

ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'v' should be passed by reference.\n", errout.str());

testPassedByValue("void f(const std::vector<std::string> v) {}");

ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'v' should be passed by reference.\n", errout.str());

testPassedByValue("void f(const std::vector<int> &v) {}");

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

testPassedByValue("void f(const std::map<int,int> &v) {}");

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

testPassedByValue("void f(const std::map<int,int> v) {}");

ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'v' should be passed by reference.\n", errout.str());

testPassedByValue("void f(const std::map<std::string,std::string> v) {}");

ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'v' should be passed by reference.\n", errout.str());

testPassedByValue("void f(const std::map<int,std::string> v) {}");

ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'v' should be passed by reference.\n", errout.str());

testPassedByValue("void f(const std::map<std::string,int> v) {}");

ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'v' should be passed by reference.\n", errout.str());

testPassedByValue("void f(const std::streamoff pos) {}");

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

}

void mathfunctionCall1() {

// log|log10

check("void foo()\n"

"{\n"

" std::cout << log(-2) << std::endl;\n"

"}");