/*

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

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

#include "fixture.h"

#include "helpers.h"

#include "platform.h"

#include "settings.h"

#include <cstddef>

#include <string>

class TestCondition : public TestFixture {

public:

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

private:

const Settings settings0 = settingsBuilder().library("qt.cfg").library("std.cfg").severity(Severity::style).severity(Severity::warning).build();

/*const*/ Settings settings1 = settingsBuilder().severity(Severity::style).severity(Severity::warning).build();

const Settings settings2 = settingsBuilder(settings0).severity(Severity::performance).certainty(Certainty::inconclusive).build();

void run() override {

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

"<def>\n"

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

"</def>";

settings1 = settingsBuilder(settings1).libraryxml(cfg).build();

mNewTemplate = true;

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

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

TEST_CASE(oppositeInnerConditionEmpty);

TEST_CASE(oppositeInnerConditionFollowVar);

TEST_CASE(oppositeInnerConditionLambda);

TEST_CASE(identicalInnerCondition);

TEST_CASE(identicalConditionAfterEarlyExit);

TEST_CASE(innerConditionModified);

TEST_CASE(overlappingInnerCondition);

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

TEST_CASE(alwaysTrueLoop);

TEST_CASE(alwaysTrueTryCatch);

TEST_CASE(alwaysTrueSideEffect);

TEST_CASE(alwaysTruePremiumMisra);

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

TEST_CASE(knownConditionAfterBailout); // #12526

TEST_CASE(knownConditionIncDecOperator);

TEST_CASE(knownConditionFloating);

}

struct CheckOptions

{

bool cpp = true;

};

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

template<size_t size>

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

check_(file, line, code, settings0, options.cpp);

}

template<size_t size>

void check_(const char* file, int line, const char (&code)[size], const Settings& settings, bool cpp = true) {

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

// Tokenizer..

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

CheckCondition check;

runChecks(check, tokenizer, *this);

}

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

template<size_t size>

void checkP_(const char* file, int line, const char (&code)[size])

{

SimpleTokenizer2 tokenizer(settings2, *this, code, "test.cpp");

// Tokenizer..

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

CheckCondition check;

runChecks(check, tokenizer, *this);

}

void assignAndCompare() {

// &

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

"{\n"

" int y = x & 4;\n"

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

"}\n");

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

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

"{\n"

" int y = x & 4;\n"

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

"}\n");

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

// |

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

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

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

"}\n");

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

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

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

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

"}\n");

ASSERT_EQUALS("", errout_str());

// various simple assignments

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

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

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

"}\n");

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

check("void foo() {\n"

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

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

"}\n");

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

// multiple conditions

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

" int y = x & 4;\n"

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

"}\n");

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

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

" int y = x & 4;\n"

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

"}\n");

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

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

" int y = x & 7;\n"

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

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

"}\n");

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

// while

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

" int y = x & 7;\n"

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

"}\n");

ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:11]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false. [assignIfError]\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

"}\n");

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"

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

"}\n");

ASSERT_EQUALS(

"[test.cpp:5:15] -> [test.cpp:6:15]: (style) Mismatching assignment and comparison, comparison 'y!=0' is always true. [assignIfError]\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"

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

"}\n");

ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:4:8]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false. [assignIfError]\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"

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

"}\n");

ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:5:8]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false. [assignIfError]\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

"}\n");

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"

"}\n");

ASSERT_EQUALS("", errout_str());

// #4735

check("void f() {\n"

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

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

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

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

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

"}\n");

ASSERT_EQUALS("", errout_str());

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

// #11610

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

" if (&rHitObject) {}\n"

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

"}\n");

ASSERT_EQUALS("[test.cpp:2:9]: (style) Condition '&rHitObject' is always true [knownConditionTrueFalse]\n"

"[test.cpp:3:42]: (style) Condition '!&rHitObject' is always false [knownConditionTrueFalse]\n",

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"

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

"}\n");

ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:8]: (style) Mismatching assignment and comparison, comparison 'x!=5' is always true. [assignIfError]\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"

"}\n");

ASSERT_EQUALS("", errout_str());

check("void f() {\n"

" int x = 100;\n"

" while (x) {\n"

" g(x);\n"

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

"}\n");

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

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

"void f() {\n"

" int x = 100;\n"

" while (x) {\n"

" g(x);\n"

" }\n"

"}\n");

ASSERT_EQUALS("", errout_str());

}

void mismatchingBitAnd() {

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

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

" b &= 1;\n"

"}\n");

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

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

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

" int c = b & 1;\n"

"}\n");

ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:9]: (style) Mismatching bitmasks. Result is always 0 (X = Y & 0xf0; Z = X & 0x1; => Z=0). [mismatchingBitAnd]\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"

"}\n");

ASSERT_EQUALS("", errout_str());

}

void comparison() {

// CheckCondition::comparison test cases

// '=='

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

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

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

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

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

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

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

ASSERT_EQUALS("", errout_str());

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

ASSERT_EQUALS("", errout_str());

// '!='

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

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

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

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

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

ASSERT_EQUALS("", errout_str());

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

ASSERT_EQUALS("", errout_str());

// '>='

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

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

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

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

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

ASSERT_EQUALS("",errout_str());

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

ASSERT_EQUALS("",errout_str()); //correct for negative 'a'

// '>'

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

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

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

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

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

ASSERT_EQUALS("",errout_str());

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

ASSERT_EQUALS("",errout_str()); //correct for negative 'a'

// '<='

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

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

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

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

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

ASSERT_EQUALS("",errout_str());

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

ASSERT_EQUALS("",errout_str()); //correct for negative 'a'

// '<'

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

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

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

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

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

ASSERT_EQUALS("",errout_str());

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

ASSERT_EQUALS("",errout_str()); //correct for negative 'a'

check("void f(int i) {\n" // #11998

" if ((i & 0x100) == 0x200) {}\n"

" if (0x200 == (i & 0x100)) {}\n"

"}\n");

ASSERT_EQUALS("[test.cpp:2:21] -> [test.cpp:3:15]: (style) The if condition is the same as the previous if condition [duplicateCondition]\n"

"[test.cpp:2:12]: (style) Expression '(X & 0x100) == 0x200' is always false. [comparisonError]\n"

"[test.cpp:3:21]: (style) Expression '(X & 0x100) == 0x200' is always false. [comparisonError]\n",

errout_str());

checkP("#define MACRO1 (0x0010)\n" // #13222

"#define MACRO2 (0x0020)\n"

"#define MACRO_ALL (MACRO1 | MACRO2)\n"

"void f() {\n"

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

"}\n");

ASSERT_EQUALS("", errout_str());

checkP("void f(int i, int j) {\n" // #13360

" int X = 0x10;\n"

" if ((i & 0xff00) == X) {}\n"

" if (X == (j & 0xff00)) {}\n"

"}\n");

ASSERT_EQUALS("[test.cpp:3:12]: (style) Expression '(X & 0xff00) == 0x10' is always false. [comparisonError]\n"

"[test.cpp:4:17]: (style) Expression '(X & 0xff00) == 0x10' is always false. [comparisonError]\n",

errout_str());

}

#define checkPureFunction(...) checkPureFunction_(__FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

void checkPureFunction_(const char* file, int line, const char (&code)[size]) {

// Tokenize..

SimpleTokenizer tokenizer(settings1, *this);

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

CheckCondition check;

runChecks(check, tokenizer, *this);

}

void multicompare() {

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

"{\n"

" if (x & 7);\n"

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

"}\n");

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

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

"{\n"

" if (x & 7);\n"

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

"}\n");

ASSERT_EQUALS("[test.cpp:4:18]: (style) Expression is always false because 'else if' condition matches previous condition at line 3. [multiCondition]\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"

"}\n");

ASSERT_EQUALS("[test.cpp:5:23]: (style) Expression is always false because 'else if' condition matches previous condition at line 4. [multiCondition]\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"

"}\n");

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

// 7284

check("void foo() {\n"

" if (a) {}\n"

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

"}\n");

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

// #11059

check("int f();\n"

"void g() {\n"

" int i = f();\n"

" if (i == 3) {}\n"

" else if ((i = f()) == 5) {}\n"

" else if (i == 3) {}\n"

"}\n");

ASSERT_EQUALS("", errout_str());

check("int f();\n"

"void g() {\n"

" int i = f();\n"

" if (i == 3) {}\n"

" else if ((i = f()) == 5) {}\n"

" else if (i != 3) {}\n"

"}\n");

ASSERT_EQUALS("", errout_str());

}

void overlappingElseIfCondition() {

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

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

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

"}\n");

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

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

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

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

"}\n");

ASSERT_EQUALS("[test.cpp:3:16]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\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"

"}\n");

ASSERT_EQUALS("[test.cpp:4:18]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\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"

"}\n");

ASSERT_EQUALS("[test.cpp:4:18]: (style) Expression is always false because 'else if' condition matches previous condition at line 3. [multiCondition]\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"

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

"}\n");

ASSERT_EQUALS("", errout_str());

{

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

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

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

"}\n");

ASSERT_EQUALS("", errout_str());

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

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

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

"}\n");

ASSERT_EQUALS("[test.cpp:3:28]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\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"

"}\n");

ASSERT_EQUALS("", errout_str());

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

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

" foo(i);\n"

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

"}\n");

ASSERT_EQUALS("", errout_str());

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

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

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

"}\n");

ASSERT_EQUALS("", errout_str());

check("class B { virtual void v() {} };\n" // #11037

"class D1 : public B {};\n"

"class D2 : public B {};\n"

"void f(const std::shared_ptr<B>&p) {\n"

" const auto d1 = dynamic_cast<D1*>(p.get());\n"

" const auto d2 = dynamic_cast<D2*>(p.get());\n"

" if (d1) {}\n"

" else if (d2) {}\n"

"}\n");

ASSERT_EQUALS("", errout_str());

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

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

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

"}\n");

ASSERT_EQUALS("", errout_str());

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

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

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

"}\n");

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

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

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

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

"}\n");

ASSERT_EQUALS("", errout_str());

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

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

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

"}\n");

ASSERT_EQUALS("", errout_str());

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

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

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

"}\n");

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

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

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

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

"}\n");

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

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

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

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

"}\n");

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

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

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

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

"}\n");

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

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

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

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

"}\n");

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

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

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

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

"}\n");

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

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

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

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

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

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

"}\n");

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

"[test.cpp:2:9]: note: first condition\n"

"[test.cpp:3:14]: 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"

"}\n");

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

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

"[test.cpp:3:9]: note: first condition\n"

"[test.cpp:4:14]: 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"

"}\n");

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

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

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

" return b;\n"

"}\n");

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

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

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

" return b;\n"

"}\n");

ASSERT_EQUALS("", errout_str());

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

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

" return b;\n"

"}\n");

ASSERT_EQUALS("", errout_str());

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

" if(x | 0x02)\n"

" return b;\n"

"}\n");

ASSERT_EQUALS("[test.cpp:2:10]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\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"

"}\n");

ASSERT_EQUALS("", errout_str());

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

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

"}\n");

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

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

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

"}\n");

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

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

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

"}\n");

ASSERT_EQUALS("", errout_str());

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

" return x | 0x02;\n"

"}\n");

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

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

" if (x) {\n"

" return x | 0x02;\n"

" }\n"

" return 0;\n"

"}\n");

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

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

" return x | 0x02;\n"

"}\n");

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

check("struct F {\n"

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

" return x | 0x02;\n"

" }\n"

"};\n");

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

check("struct F {\n"

" typedef bool b_t;\n"

"};\n"

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

" return x | 0x02;\n"

"}\n");

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

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

" return x | 0x02;\n"

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

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

"}\n");

ASSERT_EQUALS("", errout_str());

check("void f(int i) {\n" // #11082

" int j = 0;\n"

" if (i | j) {}\n"

"}\n");

ASSERT_EQUALS("[test.cpp:3:11]: (style) Operator '|' with one operand equal to zero is redundant. [badBitmaskCheck]\n", errout_str());

check("#define EIGHTTOIS(x) (((x) << 8) | (x))\n"

"int f() {\n"

" return EIGHTTOIS(0);\n"

"}\n");

ASSERT_EQUALS("", errout_str());

check("#define O_RDONLY 0\n"

"void f(const char* s, int* pFd) {\n"

" *pFd = open(s, O_RDONLY | O_BINARY, 0);\n"

"}\n");

ASSERT_EQUALS("", errout_str());

check("const int FEATURE_BITS = x |\n"

"#if FOO_ENABLED\n"

" FEATURE_FOO |\n"

"#endif\n"

"#if BAR_ENABLED\n"

" FEATURE_BAR |\n"

"#endif\n"

" 0;\n");

ASSERT_EQUALS("", errout_str());

check("enum precedence { PC0, UNARY };\n"

"int x = PC0 | UNARY;\n"

"int y = UNARY | PC0;\n");

ASSERT_EQUALS("", errout_str());

check("#define MASK 0\n"

"#define SHIFT 1\n"

"int x = 1 | (MASK << SHIFT);\n");

ASSERT_EQUALS("", errout_str());

}

void incorrectLogicOperator1() {

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

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

" a++;\n"

"}\n");

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

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

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

" a++;\n"

"}\n");

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

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

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

"}\n");

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

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

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

"}\n");

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

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

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

"}\n");

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

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

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

" a++;\n"

"}\n");

ASSERT_EQUALS("", errout_str());

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

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

" a++;\n"

"}\n");

ASSERT_EQUALS("", errout_str());

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

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