/*

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

* Copyright (C) 2007-2022 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 "testsuite.h"

#include "tokenize.h"

#include <iosfwd>

#include <list>

#include <map>

#include <string>

#include <unordered_map>

#include <utility>

#include <vector>

#include <simplecpp.h>

#include <tinyxml2.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(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(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(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(testMisusedScopeObjectNoCodeAfter);

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(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(checkPipeParameterSize); // ticket #3521

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

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

}

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

void check_(const char* file, int line, const char code[], const char *filename = nullptr, bool experimental = false, 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->certainty.setEnabled(Certainty::experimental, experimental);

settings->verbose = verbose;

// Tokenize..

Tokenizer tokenizer(settings, this);

std::istringstream istr(code);

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

// Check..

CheckOther checkOther(&tokenizer, settings, this);

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

(void)runSimpleChecks; // TODO Remove this

}

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

check_(file, line, code, "test.cpp", false, 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);

settings->certainty.disable(Certainty::experimental);

// 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, nullptr);

preprocessor.setDirectives(tokens1);

// Tokenizer..

Tokenizer tokenizer(settings, this);

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

tokenizer.simplifyTokens1("");

tokenizer.setPreprocessor(&preprocessor);

// Check..

CheckOther checkOther(&tokenizer, settings, this);

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

}

void checkposix(const char code[]) {

static Settings settings;

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

settings.libraries.emplace_back("posix");

check(code,

nullptr, // filename

false, // experimental

false, // inconclusive

true, // runSimpleChecks

false, // verbose

&settings);

}

void checkInterlockedDecrement(const char code[]) {

static Settings settings;

settings.platformType = Settings::Win32A;

check(code, nullptr, false, 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 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());

}

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"

" {\n"

" return 0;\n"

" }\n"

"}\n"

"}");

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

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

"{\n"

" int n = 1;\n"

" do\n"

" {\n"

" ++n;\n"

" ++x;\n"

" } while (x);\n"

"}");

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

}

void varScope7() {

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

"{\n"

" int y = 0;\n"

" b(y);\n"

" if (x) {\n"

" y++;\n"

" }\n"

"}");

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

}

void varScope8() {

check("void test() {\n"

" float edgeResistance=1;\n"

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

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

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

" }\n"

"}");

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

}

void varScope9() {

// classes may have extra side effects

check("class fred {\n"

"public:\n"

" void x();\n"

"};\n"

"void test(int a) {\n"

" fred f;\n"

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

" f.x();\n"

" }\n"

"}");

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

}

void varScope10() {

check("int f()\n"

"{\n"

" int x = 0;\n"

" FOR {\n"

" foo(x++);\n"

" }\n"

"}");

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

}

void varScope11() {

check("int f() {\n"

" int x = 0;\n"

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

"}");

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

check("int f() {\n"

" int x = 0;\n"

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

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

"}");

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