/*

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

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

#include "library.h"

#include "preprocessor.h"

#include "settings.h"

#include "testsuite.h"

#include "tokenize.h"

#include <simplecpp.h>

#include <tinyxml2.h>

#include <map>

#include <vector>

class TestCondition : public TestFixture {

public:

TestCondition() : TestFixture("TestCondition") {}

private:

Settings settings0;

Settings settings1;

void run() OVERRIDE {

// known platform..

settings0.platform(cppcheck::Platform::PlatformType::Native);

settings1.platform(cppcheck::Platform::PlatformType::Native);

LOAD_LIB_2(settings0.library, "qt.cfg");

LOAD_LIB_2(settings0.library, "std.cfg");

settings0.severity.enable(Severity::style);

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

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

"<def>\n"

" <function name=\"bar\"> <pure/> </function>\n"

"</def>";

tinyxml2::XMLDocument xmldoc;

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

settings1.severity.enable(Severity::style);

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

settings1.library.load(xmldoc);

TEST_CASE(assignAndCompare); // assignment and comparison don't match

TEST_CASE(mismatchingBitAnd); // overlapping bitmasks

TEST_CASE(comparison); // CheckCondition::comparison test cases

TEST_CASE(multicompare); // mismatching comparisons

TEST_CASE(overlappingElseIfCondition); // overlapping conditions in if and else-if

TEST_CASE(oppositeElseIfCondition); // opposite conditions in if and else-if

TEST_CASE(checkBadBitmaskCheck);

TEST_CASE(incorrectLogicOperator1);

TEST_CASE(incorrectLogicOperator2);

TEST_CASE(incorrectLogicOperator3);

TEST_CASE(incorrectLogicOperator4);

TEST_CASE(incorrectLogicOperator5); // complex expressions

TEST_CASE(incorrectLogicOperator6); // char literals

TEST_CASE(incorrectLogicOperator7); // opposite expressions: (expr || !expr)

TEST_CASE(incorrectLogicOperator8); // !

TEST_CASE(incorrectLogicOperator9);

TEST_CASE(incorrectLogicOperator10); // enum

TEST_CASE(incorrectLogicOperator11);

TEST_CASE(incorrectLogicOperator12);

TEST_CASE(incorrectLogicOperator13);

TEST_CASE(incorrectLogicOperator14);

TEST_CASE(incorrectLogicOperator15);

TEST_CASE(incorrectLogicOperator16); // #10070

TEST_CASE(secondAlwaysTrueFalseWhenFirstTrueError);

TEST_CASE(incorrectLogicOp_condSwapping);

TEST_CASE(testBug5895);

TEST_CASE(testBug5309);

TEST_CASE(modulo);

TEST_CASE(oppositeInnerCondition);

TEST_CASE(oppositeInnerConditionPointers);

TEST_CASE(oppositeInnerConditionClass);

TEST_CASE(oppositeInnerConditionUndeclaredVariable);

TEST_CASE(oppositeInnerConditionAlias);

TEST_CASE(oppositeInnerCondition2);

TEST_CASE(oppositeInnerCondition3);

TEST_CASE(oppositeInnerConditionAnd);

TEST_CASE(oppositeInnerConditionEmpty);

TEST_CASE(oppositeInnerConditionFollowVar);

TEST_CASE(identicalInnerCondition);

TEST_CASE(identicalConditionAfterEarlyExit);

TEST_CASE(innerConditionModified);

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

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

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

TEST_CASE(clarifyCondition4); // ticket #3110

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

TEST_CASE(clarifyCondition6); // #3818

TEST_CASE(clarifyCondition7);

TEST_CASE(clarifyCondition8);

TEST_CASE(alwaysTrue);

TEST_CASE(alwaysTrueSymbolic);

TEST_CASE(alwaysTrueInfer);

TEST_CASE(multiConditionAlwaysTrue);

TEST_CASE(duplicateCondition);

TEST_CASE(checkInvalidTestForOverflow);

TEST_CASE(checkConditionIsAlwaysTrueOrFalseInsideIfWhile);

TEST_CASE(alwaysTrueFalseInLogicalOperators);

TEST_CASE(pointerAdditionResultNotNull);

TEST_CASE(duplicateConditionalAssign);

TEST_CASE(checkAssignmentInCondition);

TEST_CASE(compareOutOfTypeRange);

TEST_CASE(knownConditionCast); // #9976

TEST_CASE(knownConditionIncrementLoop); // #9808

}

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

// Clear the error buffer..

errout.str("");

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

// Run checks..

CheckCondition checkCondition;

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

}

void check(const char code[], const char* filename = "test.cpp", bool inconclusive = false) {

settings0.certainty.setEnabled(Certainty::inconclusive, inconclusive);

check(code, &settings0, filename);

}

void assignAndCompare() {

// &

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

"{\n"

" int y = x & 4;\n"

" if (y == 3);\n"

"}");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (style) Mismatching assignment and comparison, comparison 'y==3' is always false.\n", errout.str());

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

"{\n"

" int y = x & 4;\n"

" if (y != 3);\n"

"}");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (style) Mismatching assignment and comparison, comparison 'y!=3' is always true.\n", errout.str());

// |

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

" int y = x | 0x14;\n"

" if (y == 0x710);\n"

"}");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching assignment and comparison, comparison 'y==0x710' is always false.\n", errout.str());

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

" int y = x | 0x14;\n"

" if (y == 0x71f);\n"

"}");

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

// various simple assignments

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

" int y = (x+1) | 1;\n"

" if (y == 2);\n"

"}");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching assignment and comparison, comparison 'y==2' is always false.\n", errout.str());

check("void foo() {\n"

" int y = 1 | x();\n"

" if (y == 2);\n"

"}");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching assignment and comparison, comparison 'y==2' is always false.\n", errout.str());

// multiple conditions

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

" int y = x & 4;\n"

" if ((y == 3) && (z == 1));\n"

"}");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching assignment and comparison, comparison 'y==3' is always false.\n", errout.str());

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

" int y = x & 4;\n"

" if ((x==123) || ((y == 3) && (z == 1)));\n"

"}");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching assignment and comparison, comparison 'y==3' is always false.\n", errout.str());

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

" int y = x & 7;\n"

" if (setvalue(&y) && y != 8);\n"

"}");

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

// recursive checking into scopes

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

" int y = x & 7;\n"

" if (z) y=0;\n"

" else { if (y==8); }\n" // always false

"}");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false.\n", errout.str());

// while

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

" int y = x & 7;\n"

" while (y==8);\n" // local variable => always false

"}");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false.\n", errout.str());

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

" extern int y; y = x & 7;\n"

" while (y==8);\n" // non-local variable => no error

"}");

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

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

" int a = 100;\n"

" while (x) {\n"

" int y = 16 | a;\n"

" while (y != 0) y--;\n"

" }\n"

"}");

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

check("void g(int x);\n"

"void f(int x) {\n"

" int a = 100;\n"

" while (x) {\n"

" int y = 16 | a;\n"

" while (y != 0) g(y);\n"

" }\n"

"}");

ASSERT_EQUALS(

"[test.cpp:5] -> [test.cpp:6]: (style) Mismatching assignment and comparison, comparison 'y!=0' is always true.\n",

errout.str());

check("void g(int &x);\n"

"void f(int x) {\n"

" int a = 100;\n"

" while (x) {\n"

" int y = 16 | a;\n"

" while (y != 0) g(y);\n"

" }\n"

"}");

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

// calling function

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

" int y = x & 7;\n"

" do_something();\n"

" if (y==8);\n" // local variable => always false

"}");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false.\n", errout.str());

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

" int y = x & 7;\n"

" do_something(&y);\n" // passing variable => no error

" if (y==8);\n"

"}");

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

check("void do_something(int);\n"

"void f(int x) {\n"

" int y = x & 7;\n"

" do_something(y);\n"

" if (y==8);\n"

"}");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false.\n", errout.str());

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

" extern int y; y = x & 7;\n"

" do_something();\n"

" if (y==8);\n" // non-local variable => no error

"}");

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

// #4434 : false positive: ?:

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

" x = x & 1;\n"

" x = x & 1 ? 1 : -1;\n"

" if(x != -1) { }\n"

"}");

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

// #4735

check("void f() {\n"

" int x = *(char*)&0x12345678;\n"

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

"}");

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

// bailout: no variable info

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

" y = 2 | x;\n" // y not declared => no error

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

"}");

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

// bailout: negative number

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

" int y = -2 | x;\n" // negative number => no error

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

"}");

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

// bailout: pass variable to function

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

" int y = 2 | x;\n"

" bar(&y);\n" // pass variable to function => no error

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

"}");

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

// no crash on unary operator& (#5643)

check("SdrObject* ApplyGraphicToObject() {\n"

" if (&rHitObject) {}\n"

" else if (rHitObject.IsClosedObj() && !&rHitObject) { }\n"

"}");

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

// #5695: increment

check("void f(int a0, int n) {\n"

" int c = a0 & 3;\n"

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

" c++;\n"

" if (c == 4)\n"

" c = 0;\n"

" }\n"

"}");

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

check("void f(int a) {\n" // #6662

" int x = a & 1;\n"

" while (x <= 4) {\n"

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

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (style) Mismatching assignment and comparison, comparison 'x!=5' is always true.\n", errout.str());

check("void f(int a) {\n" // #6662

" int x = a & 1;\n"

" while ((x += 4) < 10) {\n"

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

" }\n"

"}");

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

check("void f() {\n"

" int x = 100;\n"

" while (x) {\n"

" g(x);\n"

" }\n"

"}");

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

check("void g(int x);\n"

"void f() {\n"

" int x = 100;\n"

" while (x) {\n"

" g(x);\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (style) Condition 'x' is always true\n", errout.str());

check("void g(int & x);\n"

"void f() {\n"

" int x = 100;\n"

" while (x) {\n"

" g(x);\n"

" }\n"

"}");

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

}

void mismatchingBitAnd() {

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

" int b = a & 0xf0;\n"

" b &= 1;\n"

"}");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching bitmasks. Result is always 0 (X = Y & 0xf0; Z = X & 0x1; => Z=0).\n", errout.str());

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

" int b = a & 0xf0;\n"

" int c = b & 1;\n"

"}");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching bitmasks. Result is always 0 (X = Y & 0xf0; Z = X & 0x1; => Z=0).\n", errout.str());

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

" int b = a;"

" switch (x) {\n"

" case 1: b &= 1; break;\n"

" case 2: b &= 2; break;\n"

" };\n"

"}");

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

}

void comparison() {

// CheckCondition::comparison test cases

// '=='

check("void f(int a) {\n assert( (a & 0x07) == 8U );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x7) == 0x8' is always false.\n",errout.str());

check("void f(int a) {\n assert( (a & b & 4 & c ) == 3 );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x4) == 0x3' is always false.\n", errout.str());

check("void f(int a) {\n assert( (a | 0x07) == 8U );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X | 0x7) == 0x8' is always false.\n",errout.str());

check("void f(int a) {\n assert( (a & 0x07) == 7U );\n}");

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

check("void f(int a) {\n assert( (a | 0x01) == -15 );\n}");

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

// '!='

check("void f(int a) {\n assert( (a & 0x07) != 8U );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x7) != 0x8' is always true.\n",errout.str());

check("void f(int a) {\n assert( (a | 0x07) != 8U );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X | 0x7) != 0x8' is always true.\n",errout.str());

check("void f(int a) {\n assert( (a & 0x07) != 7U );\n}");

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

check("void f(int a) {\n assert( (a | 0x07) != 7U );\n}");

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

// '>='

check("void f(int a) {\n assert( (a & 0x07) >= 8U );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x7) >= 0x8' is always false.\n",errout.str());

check("void f(unsigned int a) {\n assert( (a | 0x7) >= 7U );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X | 0x7) >= 0x7' is always true.\n",errout.str());

check("void f(int a) {\n assert( (a & 0x07) >= 7U );\n}");

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

check("void f(int a) {\n assert( (a | 0x07) >= 8U );\n}");

ASSERT_EQUALS("",errout.str()); //correct for negative 'a'

// '>'

check("void f(int a) {\n assert( (a & 0x07) > 7U );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x7) > 0x7' is always false.\n",errout.str());

check("void f(unsigned int a) {\n assert( (a | 0x7) > 6U );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X | 0x7) > 0x6' is always true.\n",errout.str());

check("void f(int a) {\n assert( (a & 0x07) > 6U );\n}");

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

check("void f(int a) {\n assert( (a | 0x07) > 7U );\n}");

ASSERT_EQUALS("",errout.str()); //correct for negative 'a'

// '<='

check("void f(int a) {\n assert( (a & 0x07) <= 7U );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x7) <= 0x7' is always true.\n",errout.str());

check("void f(unsigned int a) {\n assert( (a | 0x08) <= 7U );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X | 0x8) <= 0x7' is always false.\n",errout.str());

check("void f(int a) {\n assert( (a & 0x07) <= 6U );\n}");

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

check("void f(int a) {\n assert( (a | 0x08) <= 7U );\n}");

ASSERT_EQUALS("",errout.str()); //correct for negative 'a'

// '<'

check("void f(int a) {\n assert( (a & 0x07) < 8U );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x7) < 0x8' is always true.\n",errout.str());

check("void f(unsigned int a) {\n assert( (a | 0x07) < 7U );\n}");

ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X | 0x7) < 0x7' is always false.\n",errout.str());

check("void f(int a) {\n assert( (a & 0x07) < 3U );\n}");

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

check("void f(int a) {\n assert( (a | 0x07) < 7U );\n}");

ASSERT_EQUALS("",errout.str()); //correct for negative 'a'

}

void multicompare() {

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

"{\n"

" if (x & 7);\n"

" else { if (x == 1); }\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (style) Expression is always false because 'else if' condition matches previous condition at line 3.\n", errout.str());

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

"{\n"

" if (x & 7);\n"

" else { if (x & 1); }\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (style) Expression is always false because 'else if' condition matches previous condition at line 3.\n", errout.str());

check("extern int bar() __attribute__((pure));\n"

"void foo(int x)\n"

"{\n"

" if ( bar() >1 && b) {}\n"

" else if (bar() >1 && b) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (style) Expression is always false because 'else if' condition matches previous condition at line 4.\n", errout.str());

checkPureFunction("extern int bar();\n"

"void foo(int x)\n"

"{\n"

" if ( bar() >1 && b) {}\n"

" else if (bar() >1 && b) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (style) Expression is always false because 'else if' condition matches previous condition at line 4.\n", errout.str());

// 7284

check("void foo() {\n"

" if (a) {}\n"

" else if (!!a) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());

}

void checkPureFunction(const char code[]) {

// Clear the error buffer..

errout.str("");

// Tokenize..

Tokenizer tokenizer(&settings1, this);

std::istringstream istr(code);

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

CheckCondition checkCondition;

checkCondition.runChecks(&tokenizer, &settings1, this);

}

void overlappingElseIfCondition() {

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

" if (a) { b = 1; }\n"

" else { if (a) { b = 2; } }\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());

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

" if (a) { b = 1; }\n"

" else { if (a) { b = 2; } }\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());

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

" if (a == 1) { b = 1; }\n"

" else { if (a == 2) { b = 2; }\n"

" else { if (a == 1) { b = 3; } } }\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());

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

" if (a == 1) { b = 1; }\n"

" else { if (a == 2) { b = 2; }\n"

" else { if (a == 2) { b = 3; } } }\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (style) Expression is always false because 'else if' condition matches previous condition at line 3.\n", errout.str());

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

" if (a++) { b = 1; }\n"

" else { if (a++) { b = 2; }\n"

" else { if (a++) { b = 3; } } }\n"

"}");

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

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

" if (!strtok(NULL, \" \")) { b = 1; }\n"

" else { if (!strtok(NULL, \" \")) { b = 2; } }\n"

"}");

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

{

check("void f(Class &c) {\n"

" if (c.dostuff() == 3) {}\n"

" else { if (c.dostuff() == 3) {} }\n"

"}");

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

check("void f(const Class &c) {\n"

" if (c.dostuff() == 3) {}\n"

" else { if (c.dostuff() == 3) {} }\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());

}

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

" x = x / 2;\n"

" if (x < 100) { b = 1; }\n"

" else { x = x / 2; if (x < 100) { b = 2; } }\n"

"}");

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

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

" if(i == 0x02e2000000 || i == 0xa0c6000000)\n"

" foo(i);\n"

"}");

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

// ticket 3689 ( avoid false positive )

check("int fitInt(long long int nValue){\n"

" if( nValue < 0x7fffffffLL )\n"

" {\n"

" return 32;\n"

" }\n"

" if( nValue < 0x7fffffffffffLL )\n"

" {\n"

" return 48;\n"

" }\n"

" else {\n"

" if( nValue < 0x7fffffffffffffffLL )\n"

" {\n"

" return 64;\n"

" } else\n"

" {\n"

" return -1;\n"

" }\n"

" }\n"

"}");

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

check("void f(WIDGET *widget) {\n"

" if (dynamic_cast<BUTTON*>(widget)){}\n"

" else if (dynamic_cast<LABEL*>(widget)){}\n"

"}");

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

check("void f(int x) {\n" // #6482

" if (x & 1) {}\n"

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

"}");

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

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

" if (x & 15) {}\n"

" else if (x == 40) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());

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

" if (x == sizeof(double)) {}\n"

" else { if (x == sizeof(long double)) {} }"

"}");

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

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

" if (x & 0x08) {}\n"

" else if (x & 0xF8) {}\n"

"}");

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

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

" if (x & 0xF8) {}\n"

" else if (x & 0x08) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());

check("void f(bool a, bool b) {\n"

" if(a && b){}\n"

" else if( !!b && !!a){}\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());

check("void f(bool a, bool b) {\n"

" if(a && b){}\n"

" else if( !!b && a){}\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());

check("void f(bool a, bool b) {\n"

" if(a && b){}\n"

" else if( b && !!a){}\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());

check("void f(bool a, bool b) {\n"

" if(a && b){}\n"

" else if( b && !(!a)){}\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());

check("void f(bool a, bool b) {\n"

" if(a && b){}\n"

" else if( !!b && !(!a)){}\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());

check("void f(bool a, bool b) {\n"

" if(a && b){}\n"

" else if( !!(b) && !!(a+b)){}\n"

"}");

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

// #8168

check("enum MaskValues\n"

"{\n"

" Value1 = 0x00000001,\n"

" Value2 = 0x00000002\n"

"};\n"

"void TestFunction(int value) {\n"

" if ( value & (int)Value1 ) {}\n"

" else if ( value & (int)Value2 ) {}\n"

"}");

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

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

" if (x == sizeof(int)) {}\n"

" else { if (x == sizeof(long))} {}\n"

"}\n");

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

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

" if (x == sizeof(long)) {}\n"

" else { if (x == sizeof(long long))} {}\n"

"}\n");

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

}

void oppositeElseIfCondition() {

setMultiline();

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

" if (x) {}\n"

" else if (!x) {}\n"

"}");

ASSERT_EQUALS("test.cpp:3:style:Expression is always true because 'else if' condition is opposite to previous condition at line 2.\n"

"test.cpp:2:note:first condition\n"

"test.cpp:3:note:else if condition is opposite to first condition\n", errout.str());

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

" int y = x;\n"

" if (x) {}\n"

" else if (!y) {}\n"

"}");

ASSERT_EQUALS("test.cpp:4:style:Expression is always true because 'else if' condition is opposite to previous condition at line 3.\n"

"test.cpp:2:note:'y' is assigned value 'x' here.\n"

"test.cpp:3:note:first condition\n"

"test.cpp:4:note:else if condition is opposite to first condition\n", errout.str());

}

void checkBadBitmaskCheck() {

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

" bool b = x | 0x02;\n"

" return b;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());

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

" bool b = 0x02 | x;\n"

" return b;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());

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

" int b = x | 0x02;\n"

" return b;\n"

"}");

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

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

" bool b = x & 0x02;\n"

" return b;\n"

"}");

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

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

" if(x | 0x02)\n"

" return b;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());

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

" int y = 0x1;\n"

" if(b) y = 0;\n"

" if(x | y)\n"

" return b;\n"

"}");

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

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

" foo(a && (x | 0x02));\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());

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

" return (x | 0x02) ? 0 : 5;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());

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

" return x ? (x | 0x02) : 5;\n"

"}");

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

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

" return x | 0x02;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());

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

" if (x) {\n"

" return x | 0x02;\n"

" }\n"

" return 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());

check("const bool f(int x) {\n"

" return x | 0x02;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());

check("struct F {\n"

" static const bool f(int x) {\n"

" return x | 0x02;\n"

" }\n"

"};");

ASSERT_EQUALS("[test.cpp:3]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());

check("struct F {\n"

" typedef bool b_t;\n"

"};\n"

"F::b_t f(int x) {\n"

" return x | 0x02;\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());

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

" return x | 0x02;\n"

"}");

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

check("void create_rop_masks_4( rop_mask_bits *bits) {\n"

"DWORD mask_offset;\n"

"BYTE *and_bits = bits->and;\n"

"rop_mask *rop_mask;\n"

"and_bits[mask_offset] |= (rop_mask->and & 0x0f);\n"

"}");

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

check("void f(unsigned a, unsigned b) {\n"

" unsigned cmd1 = b & 0x0F;\n"

" if (cmd1 | a) {\n"

" if (b == 0x0C) {}\n"

" }\n"

"}");

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

}

void incorrectLogicOperator1() {

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

" if ((x != 1) || (x != 3))\n"

" a++;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x != 1 || x != 3.\n", errout.str());

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

" if (1 != x || 3 != x)\n"

" a++;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x != 1 || x != 3.\n", errout.str());

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

" if (x<0 && !x) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 0 && !x.\n", errout.str());

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

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

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x == 0 && x.\n", errout.str());

check("void f(int x) {\n" // ast..

" if (y == 1 && x == 1 && x == 7) { }\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x == 1 && x == 7.\n", errout.str());

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

" if (x != 1 || y != 1)\n"

" a++;\n"

"}");

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

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

" if ((y == 1) && (x != 1) || (x != 3))\n"

" a++;\n"

"}");

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

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

" if ((x != 1) || (x != 3) && (y == 1))\n"

" a++;\n"

"}"

);

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:2]: (style) Condition 'x!=3' is always true\n", errout.str());

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

" if ((x != 1) && (x != 3))\n"

" a++;\n"

"}");

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

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

" if ((x == 1) || (x == 3))\n"

" a++;\n"

"}");

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

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

" if ((x != 1) || (y != 3))\n"

" a++;\n"

"}");

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

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

" if ((x != hotdog) || (y != hotdog))\n"

" a++;\n"

"}");

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

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

" if ((x != 5) || (y != 5))\n"

" a++;\n"

"}");

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

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

" if ((x != 5) || (x != 6))\n"

" a++;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x != 5 || x != 6.\n", errout.str());

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

" if((a != b) || (c != b) || (c != a))\n"

" {\n"

" return true;\n"

" }\n"

" return false;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (style) Condition 'c!=a' is always false\n", errout.str());

}

void incorrectLogicOperator2() {

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

" if ((x == 1) && (x == 1.0))\n"

" a++;\n"

"}");

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

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

" if ((x == 1) && (x == 0x00000001))\n"

" a++;\n"

"}");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:2]: (style) Condition 'x==0x00000001' is always true\n", errout.str());

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

" if (x == 1 && x == 3)\n"

" a++;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x == 1 && x == 3.\n", errout.str());

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

" if (x == 1.0 && x == 3.0)\n"

" a++;\n"

"}");

ASSERT_EQUALS("", errout.str()); // float comparisons with == and != are not checked right now - such comparison is a bad idea

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

" if (x == 1 && x == 1.0)\n"

" a++;\n"

"}");

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

check("void bar(float f) {\n" // #5246

" if ((f > 0) && (f < 1)) {}\n"

"}");

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

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

" if (x < 1 && x > 1)\n"

" a++;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 1.\n", errout.str());

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

" if (x < 1.0 && x > 1.0)\n"