{

std::stringstream ss;

ss << "[test.cpp:" << lno << ":" << cno << "]: (portability) ";

ss << "Zero initializing union '" << varName << "' ";

ss << "does not guarantee its complete storage to be zero initialized as its largest member is not declared as the first member. ";

ss << "Consider making " << largestMemberName << " the first member or favor memset(). [UnionZeroInit]";

ss << std::endl;

return ss.str();

public:

TestOther() : TestFixture("TestOther") {}

private:

const Settings settings0 = settingsBuilder().library("std.cfg").build();

/*const*/ Settings settings1 = settingsBuilder().library("std.cfg").severity(Severity::style).severity(Severity::warning).severity(Severity::portability).severity(Severity::performance).build();

const Settings settings2 = settingsBuilder(settings1).certainty(Certainty::inconclusive).build();

void run() override {

mNewTemplate = true;

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

TEST_CASE(zeroDiv13);

TEST_CASE(zeroDiv14); // #1169

TEST_CASE(zeroDiv15); // #8319

TEST_CASE(zeroDiv16); // #11158

TEST_CASE(zeroDiv17); // #9931

TEST_CASE(zeroDiv18);

TEST_CASE(zeroDiv19);

TEST_CASE(zeroDiv20); // #11175

TEST_CASE(zeroDiv21);

TEST_CASE(zeroDiv22);

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(varScope24); // pointer / reference

TEST_CASE(varScope25); // time_t

TEST_CASE(varScope26); // range for loop, map

TEST_CASE(varScope27); // #7733 - #if

TEST_CASE(varScope28); // #10527

TEST_CASE(varScope29); // #10888

TEST_CASE(varScope30); // #8541

TEST_CASE(varScope31); // #11099

TEST_CASE(varScope32); // #11441

TEST_CASE(varScope33);

TEST_CASE(varScope34);

TEST_CASE(varScope35);

TEST_CASE(varScope36); // #12158

TEST_CASE(varScope37); // #12158

TEST_CASE(varScope38);

TEST_CASE(varScope39);

TEST_CASE(varScope40);

TEST_CASE(varScope41); // #11845

TEST_CASE(varScope42);

TEST_CASE(varScope43);

TEST_CASE(oldStylePointerCast);

TEST_CASE(intToPointerCast);

TEST_CASE(invalidPointerCast);

TEST_CASE(passedByValue);

TEST_CASE(passedByValue_nonConst);

TEST_CASE(passedByValue_externC);

TEST_CASE(constVariable);

TEST_CASE(constParameterCallback);

TEST_CASE(constPointer);

TEST_CASE(constArray);

TEST_CASE(switchRedundantAssignmentTest);

TEST_CASE(switchRedundantOperationTest);

TEST_CASE(switchRedundantBitwiseOperationTest);

TEST_CASE(unreachableCode);

TEST_CASE(redundantContinue);

TEST_CASE(suspiciousCase);

TEST_CASE(suspiciousEqualityComparison);

TEST_CASE(suspiciousUnaryPlusMinus); // #8004

TEST_CASE(suspiciousFloatingPointCast);

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

TEST_CASE(testMisusedScopeObjectNamespace);

TEST_CASE(testMisusedScopeObjectAssignment); // #11371

TEST_CASE(trac2071);

TEST_CASE(trac2084);

TEST_CASE(trac3693);

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: Fragment 2

TEST_CASE(duplicateBranch2); // empty macro

TEST_CASE(duplicateBranch3);

TEST_CASE(duplicateBranch4);

TEST_CASE(duplicateBranch5); // make sure the Token attributes are compared

TEST_CASE(duplicateBranch6);

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

TEST_CASE(duplicateExpression8);

TEST_CASE(duplicateExpression9); // #9320

TEST_CASE(duplicateExpression10); // #9485

TEST_CASE(duplicateExpression11); // #8916 (function call)

TEST_CASE(duplicateExpression12); // #10026

TEST_CASE(duplicateExpression13); // #7899

TEST_CASE(duplicateExpression14); // #9871

TEST_CASE(duplicateExpression15); // #10650

TEST_CASE(duplicateExpression16); // #10569

TEST_CASE(duplicateExpression17); // #12036

TEST_CASE(duplicateExpression18);

TEST_CASE(duplicateExpression19);

TEST_CASE(duplicateExpression20);

TEST_CASE(duplicateExpressionLoop);

TEST_CASE(duplicateValueTernary);

TEST_CASE(duplicateValueTernarySizeof); // #13773

TEST_CASE(duplicateExpressionTernary); // #6391

TEST_CASE(duplicateExpressionTemplate); // #6930

TEST_CASE(duplicateExpressionCompareWithZero);

TEST_CASE(oppositeExpression);

TEST_CASE(duplicateVarExpression);

TEST_CASE(duplicateVarExpressionUnique);

TEST_CASE(duplicateVarExpressionAssign);

TEST_CASE(duplicateVarExpressionCrash);

TEST_CASE(multiConditionSameExpression);

TEST_CASE(checkSignOfUnsignedVariable);

TEST_CASE(checkSignOfPointer);

TEST_CASE(checkSuspiciousSemicolon1);

TEST_CASE(checkSuspiciousSemicolon2);

TEST_CASE(checkSuspiciousSemicolon3);

TEST_CASE(checkSuspiciousComparison);

TEST_CASE(checkInvalidFree);

TEST_CASE(checkRedundantCopy);

TEST_CASE(checkNegativeShift);

TEST_CASE(incompleteArrayFill);

TEST_CASE(redundantVarAssignment);

TEST_CASE(redundantVarAssignment_trivial);

TEST_CASE(redundantVarAssignment_struct);

TEST_CASE(redundantVarAssignment_union);

TEST_CASE(redundantVarAssignment_7133);

TEST_CASE(redundantVarAssignment_stackoverflow);

TEST_CASE(redundantVarAssignment_lambda);

TEST_CASE(redundantVarAssignment_loop);

TEST_CASE(redundantVarAssignment_after_switch);

TEST_CASE(redundantVarAssignment_pointer);

TEST_CASE(redundantVarAssignment_pointer_parameter);

TEST_CASE(redundantVarAssignment_array);

TEST_CASE(redundantVarAssignment_switch_break);

TEST_CASE(redundantInitialization);

//TEST_CASE(redundantMemWrite); // FIXME: temporary hack

TEST_CASE(redundantAssignmentSameValue);

TEST_CASE(varFuncNullUB);

TEST_CASE(checkCastIntToCharAndBack); // ticket #160

TEST_CASE(checkCommaSeparatedReturn);

TEST_CASE(checkPassByReference);

TEST_CASE(checkComparisonFunctionIsAlwaysTrueOrFalse);

TEST_CASE(integerOverflow); // #5895

TEST_CASE(redundantPointerOp);

TEST_CASE(test_isSameExpression);

TEST_CASE(raceAfterInterlockedDecrement);

TEST_CASE(testUnusedLabel);

TEST_CASE(testUnusedLabelConfiguration);

TEST_CASE(testUnusedLabelSwitchConfiguration);

TEST_CASE(testEvaluationOrder);

TEST_CASE(testEvaluationOrderSelfAssignment);

TEST_CASE(testEvaluationOrderMacro);

TEST_CASE(testEvaluationOrderSequencePointsFunctionCall);

TEST_CASE(testEvaluationOrderSequencePointsComma);

TEST_CASE(testEvaluationOrderSizeof);

TEST_CASE(testUnsignedLessThanZero);

TEST_CASE(doubleMove1);

TEST_CASE(doubleMoveMemberInitialization1);

TEST_CASE(doubleMoveMemberInitialization2);

TEST_CASE(doubleMoveMemberInitialization3); // #9974

TEST_CASE(doubleMoveMemberInitialization4);

TEST_CASE(moveAndAssign1);

TEST_CASE(moveAndAssign2);

TEST_CASE(moveAssignMoveAssign);

TEST_CASE(moveAndReset1);

TEST_CASE(moveAndReset2);

TEST_CASE(moveResetMoveReset);

TEST_CASE(moveAndFunctionParameter);

TEST_CASE(moveAndFunctionParameterReference);

TEST_CASE(moveAndFunctionParameterConstReference);

TEST_CASE(moveAndFunctionParameterUnknown);

TEST_CASE(moveAndReturn);

TEST_CASE(moveAndClear);

TEST_CASE(movedPointer);

TEST_CASE(moveAndAddressOf);

TEST_CASE(partiallyMoved);

TEST_CASE(moveAndLambda);

TEST_CASE(moveInLoop);

TEST_CASE(moveCallback);

TEST_CASE(moveClassVariable);

TEST_CASE(forwardAndUsed);

TEST_CASE(moveAndReference);

TEST_CASE(moveForRange);

TEST_CASE(moveTernary);

TEST_CASE(movePointerAlias);

TEST_CASE(funcArgNamesDifferent);

TEST_CASE(funcArgOrderDifferent);

TEST_CASE(cpp11FunctionArgInit); // #7846 - "void foo(int declaration = {}) {"

TEST_CASE(shadowVariables);

TEST_CASE(knownArgument);

TEST_CASE(knownArgumentHiddenVariableExpression);

TEST_CASE(knownArgumentTernaryOperator);

TEST_CASE(checkComparePointers);

TEST_CASE(unusedVariableValueTemplate); // #8994

TEST_CASE(moduloOfOne);

TEST_CASE(sameExpressionPointers);

TEST_CASE(checkOverlappingWrite);

TEST_CASE(constVariableArrayMember); // #10371

TEST_CASE(knownPointerToBool);

TEST_CASE(iterateByValue);

TEST_CASE(knownConditionFloating);

TEST_CASE(knownConditionPrefixed);

TEST_CASE(unionZeroInitBasic);

TEST_CASE(unionZeroInitArrayMember);

TEST_CASE(unionZeroInitStructMember);

TEST_CASE(unionZeroInitUnknownType);

TEST_CASE(unionZeroInitBitfields);

}

struct CheckOptions

{

bool cpp = true;

bool inconclusive = true;

bool verbose = false;

Settings* settings = nullptr; // TODO: split from this

};

#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

void check_(const char* file, int line, const char (&code)[size], const CheckOptions& opt = make_default_obj{}) {

// TODO: do not modify object passed into

Settings* settings;

if (!opt.settings) {

settings = &settings1;

}

else {

settings = opt.settings;

settings->severity.enable(Severity::style);

settings->severity.enable(Severity::warning);

settings->severity.enable(Severity::portability);

settings->severity.enable(Severity::performance);

}

settings->certainty.setEnabled(Certainty::inconclusive, opt.inconclusive);

settings->verbose = opt.verbose;

// Tokenize..

SimpleTokenizer tokenizer(*settings, *this, opt.cpp);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

// Check..

runChecks<CheckOther>(tokenizer, this);

}

struct CheckPOptions

{

bool cpp = true;

};

#define checkP(...) checkP_(__FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

void checkP_(const char* file, int line, const char (&code)[size], const CheckPOptions& options = make_default_obj()) {

SimpleTokenizer2 tokenizer(settings2, *this, code, options.cpp ? "test.cpp" : "test.c");

// Tokenizer..

ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);

// Check..

runChecks<CheckOther>(tokenizer, this);

}

template<size_t size>

void checkInterlockedDecrement(const char (&code)[size]) {

/*const*/ Settings settings = settingsBuilder().platform(Platform::Type::Win32A).build();

check(code, dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));

}

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:16]: (error) Division by zero. [zerodiv]\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:14]: (error) Division by zero. [zerodiv]\n", errout_str());

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

" return i % 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2:14]: (error) Division by zero. [zerodiv]\n", errout_str());

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

" i /= 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2:7]: (error) Division by zero. [zerodiv]\n", errout_str());

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

" i %= 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2:7]: (error) Division by zero. [zerodiv]\n", errout_str());

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

" return i / 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2:14]: (error) Division by zero. [zerodiv]\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:15]: (error) Division by zero. [zerodiv]\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:15]: (error) Division by zero. [zerodiv]\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:15]: (error) Division by zero. [zerodiv]\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:15]: (error) Division by zero. [zerodiv]\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:14]: (error) Division by zero. [zerodiv]\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:16]: (error) Division by zero. [zerodiv]\n"

"[test.cpp:3:16]: (error) Division by zero. [zerodiv]\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:12]: (error, inconclusive) Division by zero. [zerodiv]\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 = 1;\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:18]: (error) Division by zero. [zerodiv]\n"

"[test.cpp:3:18]: (error) Division by zero. [zerodiv]\n", errout_str());

check("void f() {\n"

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

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

"}");

ASSERT_EQUALS("", errout_str());

}

void zeroDiv12() {

// #8141

check("intmax_t f() {\n"

" return 1 / imaxabs(0);\n"

"}");

ASSERT_EQUALS("[test.cpp:2:12]: (error) Division by zero. [zerodiv]\n", errout_str());

}

void zeroDiv13() {

// #7324

check("int f () {\n"

" int dividend = 10;\n"

" int divisor = 1;\n"

" dividend = dividend / (--divisor);\n"

" return dividend;\n"

"}\n");

ASSERT_EQUALS("[test.cpp:4:25]: (error) Division by zero. [zerodiv]\n", errout_str());

}

void zeroDiv14() {

check("void f() {\n" // #1169

" double dx = 1.;\n"

" int ix = 1;\n"

" int i = 1;\n"

" std::cout << ix / (i >> 1) << std::endl;\n"

" std::cout << dx / (i >> 1) << std::endl;\n"

"}\n");

ASSERT_EQUALS("[test.cpp:5:21]: (error) Division by zero. [zerodiv]\n", errout_str());

}

void zeroDiv15() { // #8319

check("int f(int i) { return i - 1; }\n"

"int f() {\n"

" const int d = 1;\n"

" const int r = 1 / f(d);\n"

" return r;\n"

"}\n");

ASSERT_EQUALS("[test.cpp:4:21]: (error) Division by zero. [zerodiv]\n", errout_str());

}

// #11158

void zeroDiv16()

{

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

" int number = 10, a = 0;\n"

" for (int count = 0; count < 2; count++) {\n"

" a += (i / number) % 10;\n"

" number = number / 10;\n"

" }\n"

" return a;\n"

"}\n");

ASSERT_EQUALS("", errout_str());

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

" int number = 10, a = 0;\n"

" for (int count = 0; count < 2; count++) {\n"

" int x = number / 10;\n"

" a += (i / number) % 10;\n"

" number = x;\n"

" }\n"

" return a;\n"

"}\n");

ASSERT_EQUALS("", errout_str());

}

void zeroDiv17() { // #9931

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

" int sz = sizeof(void*[255]) / 255;\n"

" int x = len % sz;\n"

" return x;\n"

"}\n");

ASSERT_EQUALS("", errout_str());

}

void zeroDiv18()

{

check("int f(int x, int y) {\n"

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

" return 1 / (x-y);\n"

"}\n");

ASSERT_EQUALS(

"[test.cpp:2:11] -> [test.cpp:3:14]: (warning) Either the condition 'x==y' is redundant or there is division by zero at line 3. [zerodivcond]\n",

errout_str());

}

void zeroDiv19()

{

check("void f() {\n" // #2456

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

" int j = 10 / i;\n"

"}\n");

ASSERT_EQUALS("[test.cpp:3:20]: (error) Division by zero. [zerodiv]\n", errout_str());

}

void zeroDiv20()

{

check("uint16_t f(void)\n" // #11175

"{\n"

" uint16_t x = 0xFFFFU;\n" // UINT16_MAX=0xFFFF

" return 42/(++x);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:14]: (error) Division by zero. [zerodiv]\n", errout_str());

}

void zeroDiv21()

{

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

" return 1 / ((1 / n) - 1);\n"

"}\n"

"int g() {\n"

" return f(1);\n"

"}\n");

ASSERT_EQUALS("[test.cpp:2:14]: (error) Division by zero. [zerodiv]\n", errout_str());

}

void zeroDiv22()

{

check("int main() {\n"

" return _Generic((0), int: (42) / (0), default: 0);\n"

"}\n");

ASSERT_EQUALS("[test.cpp:2:36]: (error) Division by zero. [zerodiv]\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:9] -> [test.cpp:2:14]: (warning) Either the condition 'x>0' is redundant or there is division by zero at line 2. [zerodivcond]\n", errout_str());

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

" int y = 17 / x;\n"

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

"}");

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

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

" int y = 17 / x;\n"

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

"}");

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

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

" int y = 17 / x;\n"

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

"}");

ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:14]: (warning) Either the condition 'x!=0' is redundant or there is division by zero at line 2. [zerodivcond]\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:10] -> [test.cpp:1:28]: (warning) Either the condition 'y>0' is redundant or there is division by zero at line 1. [zerodivcond]\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:9] -> [test.cpp:4:14]: (warning) Either the condition 'x!=0' is redundant or there is division by zero at line 4. [zerodivcond]\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());

check("int g();\n"

"void f(int b) {\n"

" int x = g();\n"

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

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

" else\n"

" a = b / -x;\n"

"}");

ASSERT_EQUALS("", errout_str());

check("struct A {\n"

" int x;\n"

"};\n"

"int f(A* a) {\n"

" if (a->x == 0) \n"

" a->x = 1;\n"

" return 1/a->x;\n"

"}\n");

ASSERT_EQUALS("", errout_str());

// #10049

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

" int quotient, remainder;\n"

" remainder = argc % 2;\n"

" argc = 2;\n"

" quotient = argc;\n"

" if (quotient != 0) \n"

" return quotient;\n"

" return remainder;\n"

"}\n");

ASSERT_EQUALS("", errout_str());

// #11315

checkP("#define STATIC_ASSERT(c) \\\n"

"do { enum { sa = 1/(int)(!!(c)) }; } while (0)\n"

"void f() {\n"

" STATIC_ASSERT(sizeof(int) == sizeof(FOO));\n"

"}\n");

ASSERT_EQUALS("", errout_str());

// #11505

check("void f(uint16_t num, uint8_t radix) {\n"

" int c = num % radix;\n"

" num /= radix;\n"

" if (!num) {}\n"

"}\n");

ASSERT_EQUALS("", errout_str());

}

void nanInArithmeticExpression() {

check("void f()\n"

"{\n"

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

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

"}");

ASSERT_EQUALS("[test.cpp:3:19]: (style) Using NaN/Inf in a computation. [nanInArithmeticExpression]\n", errout_str());

check("void f()\n"

"{\n"

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

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

"}");

ASSERT_EQUALS("[test.cpp:3:19]: (style) Using NaN/Inf in a computation. [nanInArithmeticExpression]\n", errout_str());

check("void f()\n"

"{\n"

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

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

"}");

ASSERT_EQUALS("[test.cpp:3:25]: (style) Using NaN/Inf in a computation. [nanInArithmeticExpression]\n", errout_str());

check("void f()\n"

"{\n"

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

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

"}");

ASSERT_EQUALS("[test.cpp:3:25]: (style) Using NaN/Inf in a computation. [nanInArithmeticExpression]\n", errout_str());

check("void f()\n"

"{\n"

" double x = 3.0 / 0.0;\n"

" printf(\"%f\", 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"