/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2023 Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include "checkother.h"

#include "errortypes.h"

#include "library.h"

#include "platform.h"

#include "preprocessor.h"

#include "settings.h"

#include "standards.h"

#include "fixture.h"

#include "tokenize.h"

#include <map>

#include <sstream> // IWYU pragma: keep

#include <string>

#include <unordered_map>

#include <utility>

#include <vector>

#include <simplecpp.h>

class TestOther : public TestFixture {

public:

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

private:

Settings _settings;

void run() override {

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

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

TEST_CASE(duplicateValueTernary);

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

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

}

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

void check_(const char* file, int line, const char code[], const char *filename = nullptr, bool inconclusive = true, bool runSimpleChecks=true, bool verbose=false, Settings* settings = nullptr) {

// Clear the error buffer..

errout.str("");

if (!settings) {

settings = &_settings;

}

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

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

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

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

settings->standards.c = Standards::CLatest;

settings->standards.cpp = Standards::CPPLatest;

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

settings->verbose = verbose;

Preprocessor preprocessor(*settings);

// Tokenize..

Tokenizer tokenizer(settings, this, &preprocessor);

std::istringstream istr(code);

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

// Check..

runChecks<CheckOther>(tokenizer, this);

(void)runSimpleChecks; // TODO Remove this

}

void check_(const char* file, int line, const char code[], Settings *s) {

check_(file, line, code, "test.cpp", true, true, false, s);

}

void checkP(const char code[], const char *filename = "test.cpp") {

// Clear the error buffer..

errout.str("");

Settings* settings = &_settings;

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

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

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

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

settings->standards.c = Standards::CLatest;

settings->standards.cpp = Standards::CPPLatest;

settings->certainty.enable(Certainty::inconclusive);

// Raw tokens..

std::vector<std::string> files(1, filename);

std::istringstream istr(code);

const simplecpp::TokenList tokens1(istr, files, files[0]);

// Preprocess..

simplecpp::TokenList tokens2(files);

std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI());

Preprocessor preprocessor(*settings);

preprocessor.setDirectives(tokens1);

// Tokenizer..

Tokenizer tokenizer(settings, this, &preprocessor);

tokenizer.createTokens(std::move(tokens2));

tokenizer.simplifyTokens1("");

// Check..

runChecks<CheckOther>(tokenizer, this);

}

void checkInterlockedDecrement(const char code[]) {

Settings settings;

settings.platform.type = cppcheck::Platform::Type::Win32A;

check(code, nullptr, false, true, false, &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]: (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 = 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]: (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 zeroDiv12() {

// #8141

check("intmax_t f() {\n"

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

"}");

ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\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]: (error) Division by zero.\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]: (error) Division by zero.\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]: (error) Division by zero.\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] -> [test.cpp:3]: (warning) Either the condition 'x==y' is redundant or there is division by zero at line 3.\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 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());

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]: (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\", 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\", 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\", 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\", 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" // #5398

" bool success = false;\n"

" int notReducable(someClass.getX(&success));\n"

" if (success) {\n"

" foo(notReducable);\n"

" }\n"

"}");

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

check("void foo(Test &test) {\n"

" int& x = test.getData();\n"

" if (test.process())\n"

" x = 0;\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"