/*

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

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

#include "platform.h"

#include "settings.h"

#include "testsuite.h"

#include "token.h"

#include "tokenize.h"

#include "valueflow.h"

#include <simplecpp.h>

#include <cmath>

#include <list>

#include <map>

#include <ostream>

#include <string>

#include <utility>

#include <vector>

class TestValueFlow : public TestFixture {

public:

TestValueFlow() : TestFixture("TestValueFlow") {

}

private:

Settings settings;

void run() {

// strcpy cfg

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

"<def>\n"

" <function name=\"strcpy\"> <arg nr=\"1\"><not-null/></arg> </function>\n"

"</def>";

settings.library.loadxmldata(cfg, sizeof(cfg));

TEST_CASE(valueFlowNumber);

TEST_CASE(valueFlowString);

TEST_CASE(valueFlowPointerAlias);

TEST_CASE(valueFlowArrayElement);

TEST_CASE(valueFlowMove);

TEST_CASE(valueFlowBitAnd);

TEST_CASE(valueFlowCalculations);

TEST_CASE(valueFlowErrorPath);

TEST_CASE(valueFlowBeforeCondition);

TEST_CASE(valueFlowBeforeConditionAndAndOrOrGuard);

TEST_CASE(valueFlowBeforeConditionAssignIncDec);

TEST_CASE(valueFlowBeforeConditionFunctionCall);

TEST_CASE(valueFlowBeforeConditionGlobalVariables);

TEST_CASE(valueFlowBeforeConditionGoto);

TEST_CASE(valueFlowBeforeConditionIfElse);

TEST_CASE(valueFlowBeforeConditionLoop);

TEST_CASE(valueFlowBeforeConditionMacro);

TEST_CASE(valueFlowBeforeConditionSizeof);

TEST_CASE(valueFlowBeforeConditionSwitch);

TEST_CASE(valueFlowBeforeConditionTernaryOp);

TEST_CASE(valueFlowAfterAssign);

TEST_CASE(valueFlowAfterCondition);

TEST_CASE(valueFlowForwardCompoundAssign);

TEST_CASE(valueFlowForwardCorrelatedVariables);

TEST_CASE(valueFlowForwardFunction);

TEST_CASE(valueFlowForwardLambda);

TEST_CASE(valueFlowSwitchVariable);

TEST_CASE(valueFlowForLoop);

TEST_CASE(valueFlowSubFunction);

TEST_CASE(valueFlowFunctionReturn);

TEST_CASE(valueFlowFunctionDefaultParameter);

TEST_CASE(knownValue);

TEST_CASE(valueFlowSizeofForwardDeclaredEnum);

TEST_CASE(valueFlowGlobalVar);

TEST_CASE(valueFlowGlobalStaticVar);

TEST_CASE(valueFlowInlineAssembly);

TEST_CASE(valueFlowUninit);

}

bool testValueOfX(const char code[], unsigned int linenr, int value) {

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {

if (tok->str() == "x" && tok->linenr() == linenr) {

std::list<ValueFlow::Value>::const_iterator it;

for (it = tok->values().begin(); it != tok->values().end(); ++it) {

if (it->isIntValue() && it->intvalue == value)

return true;

}

}

}

return false;

}

bool testValueOfX(const char code[], unsigned int linenr, float value, float diff) {

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {

if (tok->str() == "x" && tok->linenr() == linenr) {

std::list<ValueFlow::Value>::const_iterator it;

for (it = tok->values().begin(); it != tok->values().end(); ++it) {

if (it->isFloatValue() && it->floatValue >= value - diff && it->floatValue <= value + diff)

return true;

}

}

}

return false;

}

std::string getErrorPathForX(const char code[], unsigned int linenr) {

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {

if (tok->str() != "x" || tok->linenr() != linenr)

continue;

std::ostringstream ostr;

std::list<ValueFlow::Value>::const_iterator it;

for (it = tok->values().begin(); it != tok->values().end(); ++it) {

for (ValueFlow::Value::ErrorPath::const_iterator ep = it->errorPath.begin(); ep != it->errorPath.end(); ++ep) {

const Token *eptok = ep->first;

const std::string &msg = ep->second;

ostr << eptok->linenr() << ',' << msg << '\n';

}

}

return ostr.str();

}

return "";

}

bool testValueOfX(const char code[], unsigned int linenr, const char value[]) {

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {

if (tok->str() == "x" && tok->linenr() == linenr) {

std::list<ValueFlow::Value>::const_iterator it;

for (it = tok->values().begin(); it != tok->values().end(); ++it) {

if (it->isTokValue() && Token::simpleMatch(it->tokvalue, value))

return true;

}

}

}

return false;

}

bool testValueOfX(const char code[], unsigned int linenr, ValueFlow::Value::MoveKind moveKind) {

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {

if (tok->str() == "x" && tok->linenr() == linenr) {

std::list<ValueFlow::Value>::const_iterator it;

for (it = tok->values().begin(); it != tok->values().end(); ++it) {

if (it->isMovedValue() && it->moveKind == moveKind)

return true;

}

}

}

return false;

}

bool testConditionalValueOfX(const char code[], unsigned int linenr, int value) {

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {

if (tok->str() == "x" && tok->linenr() == linenr) {

std::list<ValueFlow::Value>::const_iterator it;

for (it = tok->values().begin(); it != tok->values().end(); ++it) {

if (it->isIntValue() && it->intvalue == value && it->condition)

return true;

}

}

}

return false;

}

void bailout(const char code[]) {

settings.debugwarnings = true;

errout.str("");

std::vector<std::string> files;

files.push_back("test.cpp");

std::istringstream istr(code);

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

simplecpp::TokenList tokens2(files);

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

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

// Tokenize..

Tokenizer tokenizer(&settings, this);

tokenizer.createTokens(&tokens2);

tokenizer.simplifyTokens1("");

settings.debugwarnings = false;

}

std::list<ValueFlow::Value> tokenValues(const char code[], const char tokstr[]) {

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

errout.str("");

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

const Token *tok = Token::findmatch(tokenizer.tokens(), tokstr);

return tok ? tok->values() : std::list<ValueFlow::Value>();

}

ValueFlow::Value valueOfTok(const char code[], const char tokstr[]) {

std::list<ValueFlow::Value> values = tokenValues(code, tokstr);

return values.size() == 1U && !values.front().isTokValue() ? values.front() : ValueFlow::Value();

}

void valueFlowNumber() {

ASSERT_EQUALS(123, valueOfTok("x=123;", "123").intvalue);

ASSERT(std::fabs(valueOfTok("x=0.5;", "0.5").floatValue - 0.5f) < 0.1f);

ASSERT_EQUALS(10, valueOfTok("enum {A=10,B=15}; x=A+0;", "+").intvalue);

ASSERT_EQUALS(0, valueOfTok("x=false;", "false").intvalue);

ASSERT_EQUALS(1, valueOfTok("x=true;", "true").intvalue);

ASSERT_EQUALS(0, valueOfTok("x(NULL);", "NULL").intvalue);

ASSERT_EQUALS((int)('a'), valueOfTok("x='a';", "'a'").intvalue);

ASSERT_EQUALS((int)('\n'), valueOfTok("x='\\n';", "'\\n'").intvalue);

ASSERT_EQUALS(0xFFFFFFFF00000000, valueOfTok("x=0xFFFFFFFF00000000;","18446744069414584320U").intvalue); // #7701

}

void valueFlowString() {

const char *code;

// valueFlowAfterAssign

code = "const char * f() {\n"

" static const char *x;\n"

" if (a) x = \"123\";\n"

" return x;\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 4, "\"123\""));

// valueFlowSubFunction

code = "void dostuff(const char *x) {\n"

" f(x);\n"

"}\n"

"\n"

"void test() { dostuff(\"abc\"); }";

ASSERT_EQUALS(true, testValueOfX(code, 2, "\"abc\""));

}

void valueFlowPointerAlias() {

const char *code;

code = "const char * f() {\n"

" static const char *x;\n"

" static char ret[10];\n"

" if (a) x = &ret[0];\n"

" return x;\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 5, "& ret [ 0 ]"));

// dead pointer

code = "void f() {\n"

" int *x;\n"

" if (cond) { int i; x = &i; }\n"

" *x = 0;\n" // <- x can point at i

"}";

ASSERT_EQUALS(true, testValueOfX(code, 4, "& i"));

code = "void f() {\n"

" struct X *x;\n"

" x = &x[1];\n"

"}";

ASSERT_EQUALS(true, tokenValues(code, "&").empty());

ASSERT_EQUALS(true, tokenValues(code, "x [").empty());

}

void valueFlowArrayElement() {

const char *code;

code = "void f() {\n"

" const int x[] = {43,23,12};\n"

" return x;\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 3U, "{ 43 , 23 , 12 }"));

code = "void f() {\n"

" const char x[] = \"abcd\";\n"

" return x;\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 3U, "\"abcd\""));

code = "void f() {\n"

" char x[32] = \"abcd\";\n"

" return x;\n"

"}";

TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 3U, "\"abcd\""));

code = "void f() {\n"

" int a[10];\n"

" int *x = a;\n" // <- a value is a

" *x = 0;\n" // .. => x value is a

"}";

ASSERT_EQUALS(true, testValueOfX(code, 4, "a"));

code = "char f() {\n"

" const char *x = \"abcd\";\n"

" return x[0];\n"

"}";

ASSERT_EQUALS((int)('a'), valueOfTok(code, "[").intvalue);

code = "char f() {\n"

" const char *x = \"\";\n"

" return x[0];\n"

"}";

ASSERT_EQUALS(0, valueOfTok(code, "[").intvalue);

}

void valueFlowMove() {

const char *code;

code = "void f() {\n"

" X x;\n"

" g(std::move(x));\n"

" y=x;\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 4U, ValueFlow::Value::MovedVariable));

code = "void f() {\n"

" X x;\n"

" g(std::forward<X>(x));\n"

" y=x;\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 4U, ValueFlow::Value::ForwardedVariable));

code = "void f() {\n"

" X x;\n"

" g(std::move(x).getA());\n" // Only parts of x might be moved out

" y=x;\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 4U, ValueFlow::Value::MovedVariable));

code = "void f() {\n"

" X x;\n"

" g(std::forward<X>(x).getA());\n" // Only parts of x might be moved out

" y=x;\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 4U, ValueFlow::Value::ForwardedVariable));

code = "void f() {\n"

" X x;\n"

" g(std::move(x));\n"

" x.clear();\n"

" y=x;\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 5U, ValueFlow::Value::MovedVariable));

code = "void f() {\n"

" X x;\n"

" g(std::move(x));\n"

" y=x->y;\n"

" z=x->z;\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 5U, ValueFlow::Value::MovedVariable));

code = "void f(int i) {\n"

" X x;\n"

" z = g(std::move(x));\n"

" y = x;\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 4U, ValueFlow::Value::MovedVariable));

code = "void f(int i) {\n"

" X x;\n"

" y = g(std::move(x), \n"

" x.size());\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 4U, ValueFlow::Value::MovedVariable));

code = "void f(int i) {\n"

" X x;\n"

" x = g(std::move(x));\n"

" y = x;\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 4U, ValueFlow::Value::MovedVariable));

code = "A f(int i) {\n"

" X x;\n"

" if (i)"

" return g(std::move(x));\n"

" return h(std::move(x));\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 5U, ValueFlow::Value::MovedVariable));

}

void valueFlowCalculations() {

const char *code;

// Different operators

ASSERT_EQUALS(5, valueOfTok("3 + (a ? b : 2);", "+").intvalue);

ASSERT_EQUALS(1, valueOfTok("3 - (a ? b : 2);", "-").intvalue);

ASSERT_EQUALS(6, valueOfTok("3 * (a ? b : 2);", "*").intvalue);

ASSERT_EQUALS(6, valueOfTok("13 / (a ? b : 2);", "/").intvalue);

ASSERT_EQUALS(1, valueOfTok("13 % (a ? b : 2);", "%").intvalue);

ASSERT_EQUALS(0, valueOfTok("3 == (a ? b : 2);", "==").intvalue);

ASSERT_EQUALS(1, valueOfTok("3 != (a ? b : 2);", "!=").intvalue);

ASSERT_EQUALS(1, valueOfTok("3 > (a ? b : 2);", ">").intvalue);

ASSERT_EQUALS(1, valueOfTok("3 >= (a ? b : 2);", ">=").intvalue);

ASSERT_EQUALS(0, valueOfTok("3 < (a ? b : 2);", "<").intvalue);

ASSERT_EQUALS(0, valueOfTok("3 <= (a ? b : 2);", "<=").intvalue);

ASSERT_EQUALS(1, valueOfTok("(UNKNOWN_TYPE)1;","(").intvalue);

ASSERT(tokenValues("(UNKNOWN_TYPE)1000;","(").empty()); // don't know if there is truncation, sign extension

ASSERT_EQUALS(255, valueOfTok("(unsigned char)~0;", "(").intvalue);

ASSERT_EQUALS(0, valueOfTok("(int)0;", "(").intvalue);

ASSERT_EQUALS(3, valueOfTok("(int)(1+2);", "(").intvalue);

ASSERT_EQUALS(0, valueOfTok("(UNKNOWN_TYPE*)0;","(").intvalue);

ASSERT_EQUALS(100, valueOfTok("(int)100.0;", "(").intvalue);

// Don't calculate if there is UB

ASSERT(tokenValues(";-1<<10;","<<").empty());

ASSERT(tokenValues(";10<<-1;","<<").empty());

ASSERT(tokenValues(";10<<64;","<<").empty());

ASSERT(tokenValues(";-1>>10;",">>").empty());

ASSERT(tokenValues(";10>>-1;",">>").empty());

ASSERT(tokenValues(";10>>64;",">>").empty());

// calculation using 1,2 variables/values

code = "void f(int x) {\n"

" a = x+456;\n"

" if (x==123) {}"

"}";

ASSERT_EQUALS(579, valueOfTok(code, "+").intvalue);

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

" a = x+y;\n"

" if (x==123 || y==456) {}"

"}";

ASSERT_EQUALS(0, valueOfTok(code, "+").intvalue);

code = "void f(int x) {\n"

" a = x+x;\n"

" if (x==123) {}"

"}";

ASSERT_EQUALS(246, valueOfTok(code, "+").intvalue);

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

" a = x*x;\n"

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

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

"}";

std::list<ValueFlow::Value> values = tokenValues(code,"*");

ASSERT_EQUALS(2U, values.size());

ASSERT_EQUALS(4, values.front().intvalue);

ASSERT_EQUALS(16, values.back().intvalue);

code = "void f(int x) {\n"

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

" a = x * (1 - x - 1);\n"

"}";

ASSERT_EQUALS(-9, valueOfTok(code, "*").intvalue);

// addition of different variables with known values

code = "int f(int x) {\n"

" int a = 1;\n"

" while (x!=3) { x+=a; }\n"

" return x/a;\n"

"}\n";

ASSERT_EQUALS(3, valueOfTok(code, "/").intvalue);

// ? :

code = "x = y ? 2 : 3;\n";

values = tokenValues(code,"?");

ASSERT_EQUALS(2U, values.size());

ASSERT_EQUALS(2, values.front().intvalue);

ASSERT_EQUALS(3, values.back().intvalue);

code = "void f(int a) { x = a ? 2 : 3; }\n";

values = tokenValues(code,"?");

ASSERT_EQUALS(2U, values.size());

ASSERT_EQUALS(2, values.front().intvalue);

ASSERT_EQUALS(3, values.back().intvalue);

code = "x = (2<5) ? 2 : 3;\n";

values = tokenValues(code, "?");

ASSERT_EQUALS(1U, values.size());

ASSERT_EQUALS(2, values.front().intvalue);

code = "x = 123 ? : 456;\n";

values = tokenValues(code, "?");

ASSERT_EQUALS(1U, values.size());

ASSERT_EQUALS(123, values.empty() ? 0 : values.front().intvalue);

// ~

code = "x = ~0U;";

settings.platform(cppcheck::Platform::Native); // ensure platform is native

values = tokenValues(code,"~");

ASSERT_EQUALS(1U, values.size());

ASSERT_EQUALS(~0U, values.back().intvalue);

// !

code = "void f(int x) {\n"

" a = !x;\n"

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

"}";

values = tokenValues(code,"!");

ASSERT_EQUALS(1U, values.size());

ASSERT_EQUALS(1, values.back().intvalue);

// unary minus

code = "void f(int x) {\n"

" a = -x;\n"

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

"}";

values = tokenValues(code,"-");

ASSERT_EQUALS(1U, values.size());

ASSERT_EQUALS(-10, values.back().intvalue);

// sizeof

code = "void f() {\n"

" x = sizeof(int);\n"

"}";

values = tokenValues(code,"( int )");

ASSERT_EQUALS(1U, values.size());

ASSERT_EQUALS(settings.sizeof_int, values.back().intvalue);

code = "void f() {\n"

" struct S *a[10];"

" x = sizeof(a) / sizeof(a[0]);\n"

"}";

values = tokenValues(code,"/");

ASSERT_EQUALS(1U, values.size());

ASSERT_EQUALS(10, values.back().intvalue);

// function call => calculation

code = "void f(int x) {\n"

" a = x + 8;\n"

"}\n"

"void callf() {\n"

" f(7);\n"

"}";

ASSERT_EQUALS(15, valueOfTok(code, "+").intvalue);

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

" a = x + y;\n"

"}\n"

"void callf() {\n"

" f(1,1);\n"

" f(10,10);\n"

"}";

values = tokenValues(code, "+");

ASSERT_EQUALS(true, values.empty());

if (!values.empty()) {

/* todo.. */

ASSERT_EQUALS(2U, values.size());

ASSERT_EQUALS(2, values.front().intvalue);

ASSERT_EQUALS(22, values.back().intvalue);

}

// Comparison of string

values = tokenValues("f(\"xyz\" == \"xyz\");", "=="); // implementation defined

ASSERT_EQUALS(0U, values.size()); // <- no value

values = tokenValues("f(\"xyz\" == 0);", "==");

ASSERT_EQUALS(1U, values.size());

ASSERT_EQUALS(0, values.front().intvalue);

values = tokenValues("f(0 == \"xyz\");", "==");

ASSERT_EQUALS(1U, values.size());

ASSERT_EQUALS(0, values.front().intvalue);

values = tokenValues("f(\"xyz\" != 0);", "!=");

ASSERT_EQUALS(1U, values.size());

ASSERT_EQUALS(1, values.front().intvalue);

values = tokenValues("f(0 != \"xyz\");", "!=");

ASSERT_EQUALS(1U, values.size());

ASSERT_EQUALS(1, values.front().intvalue);

}

void valueFlowErrorPath() {

const char *code;

code = "void f() {\n"

" int x = 53;\n"

" a = x;\n"

"}\n";

ASSERT_EQUALS("2,Assignment 'x=53', assigned value is 53\n",

getErrorPathForX(code, 3U));

code = "void f(int y) {\n"

" int x = y;\n"

" a = x;\n"

" y += 12;\n"

" if (y == 32) {}"

"}\n";

ASSERT_EQUALS("5,Assuming that condition 'y==32' is not redundant\n"

"4,Compound assignment '+=', before assignment value is 20\n"

"2,Assignment 'x=y', assigned value is 20\n",

getErrorPathForX(code, 3U));

code = "void f1(int x) {\n"

" a = x;\n"

"}\n"

"void f2() {\n"

" int x = 3;\n"

" f1(x+1);\n"

"}\n";

ASSERT_EQUALS("5,Assignment 'x=3', assigned value is 3\n"

"6,Calling function 'f1', 1st argument 'x' value is 4\n",

getErrorPathForX(code, 2U));

code = "void f(int a) {\n"

" int x;\n"

" for (x = a; x < 50; x++) {}\n"

" b = x;\n"

"}\n";

ASSERT_EQUALS("3,After for loop, x has value 50\n",

getErrorPathForX(code, 4U));

}

void valueFlowBeforeCondition() {

const char *code;

code = "void f(int x) {\n"

" int a = x;\n"

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

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 123));

code = "void f(unsigned int x) {\n"

" int a = x;\n"

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

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 1));

ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));

code = "void f(unsigned int x) {\n"

" int a = x;\n"

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

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));

code = "void f(unsigned int x) {\n"

" int a = x;\n"

" if (x > 1) {}\n" // not zero => don't consider > condition

"}";

ASSERT_EQUALS(false, testValueOfX(code, 2U, 1));

code = "void f(int x) {\n" // not unsigned => don't consider > condition

" int a = x;\n"

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

"}";

ASSERT_EQUALS(false, testValueOfX(code, 2U, 0));

code = "void f(int *x) {\n"

" *x = 100;\n"

" if (x) {}\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));

code = "extern const int x;\n"

"void f() {\n"

" int a = x;\n"

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

"}";

ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));

}

void valueFlowBeforeConditionAssignIncDec() { // assignment / increment

const char *code;

code = "void f(int x) {\n"

" x = 2 + x;\n"

" if (x == 65);\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 2U, 65));

code = "void f(int x) {\n"

" x = y = 2 + x;\n"

" if (x == 65);\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 2U, 65));

code = "void f(int x) {\n"

" a[x++] = 0;\n"

" if (x == 5);\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 2U, 5));

code = "void f(int x) {\n"

" a = x;\n"

" x++;\n"

" if (x == 4);\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 3));

ASSERT_EQUALS("4,Assuming that condition 'x==4' is not redundant\n"

"3,x is incremented, before this increment the value is 3\n",

getErrorPathForX(code, 2U));

// compound assignment += , -= , ...

code = "void f(int x) {\n"

" a = x;\n"

" x += 2;\n"

" if (x == 4);\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 2));

code = "void f(int x) {\n"

" a = x;\n"

" x -= 2;\n"

" if (x == 4);\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 6));

code = "void f(int x) {\n"

" a = x;\n"

" x *= 2;\n"

" if (x == 42);\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 21));

code = "void f(int x) {\n"

" a = x;\n"

" x /= 5;\n"

" if (x == 42);\n"

"}";

ASSERT(tokenValues(code, "x ;").empty());

// bailout: assignment

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

" x = y;\n"

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

"}");

ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:2]: (debug) valueflow.cpp:1035:valueFlowReverse bailout: assignment of x\n", errout.str());

}

void valueFlowBeforeConditionAndAndOrOrGuard() { // guarding by &&

const char *code;

code = "void f(int x) {\n"

" if (!x || \n" // <- x can be 0

" a/x) {}\n" // <- x can't be 0

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

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));

ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));

code = "void f(int *x) {\n"

" ((x=ret())&&\n"

" (*x==0));\n" // <- x is not 0

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

"}";

ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));

code = "void f(int *x) {\n"

" int a = (x && *x == '1');\n"

" int b = a ? atoi(x) : 0;\n" // <- x is not 0

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

"}";

ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));

}

void valueFlowBeforeConditionFunctionCall() { // function calls

const char *code;

code = "void f(int x) {\n"

" a = x;\n"

" setx(x);\n"

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

"}";

ASSERT_EQUALS(true, testValueOfX((std::string("void setx(int x);")+code).c_str(), 2U, 1));

ASSERT_EQUALS(false, testValueOfX((std::string("void setx(int &x);")+code).c_str(), 2U, 1));

ASSERT_EQUALS(true, testValueOfX(code, 2U, 1));

code = "void f(char* x) {\n"

" strcpy(x,\"abc\");\n"

" if (x) {}\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));

code = "void addNewFunction(Scope**scope, const Token**tok);\n"

"void f(Scope *x) {\n"

" x->functionList.back();\n"

" addNewFunction(&x,&tok);\n" // address-of, x can be changed by subfunction

" if (x) {}\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));

}

void valueFlowBeforeConditionLoop() { // while, for, do-while

const char *code;

code = "void f(int x) {\n" // loop condition, x is not assigned inside loop => use condition

" a = x;\n" // x can be 37

" while (x == 37) {}\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 37));

code = "void f(int x) {\n" // loop condition, x is assigned inside loop => don't use condition

" a = x;\n" // don't assume that x can be 37

" while (x != 37) { x++; }\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 2U, 37));

code = "void f(int x) {\n"

" a = x;\n"

" for (; x!=1; x++) { }\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 2U, 1));

code = "void f(menu *x) {\n"

" a = x->parent;\n"

" for (i=0;(i<10) && (x!=0); i++) { x = x->next; }\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 2U, 0));

code = "void f(int x) {\n" // condition inside loop, x is NOT assigned inside loop => use condition

" a = x;\n"

" do {\n"

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

" } while (1);\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 76));

code = "void f(int x) {\n" // conditions inside loop, x is assigned inside do-while => don't use condition

" a = x;\n"

" do {\n"

" if (x!=76) { x=do_something(); }\n"

" } while (1);\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 2U, 76));

code = "void f(X x) {\n" // conditions inside loop, x is assigned inside do-while => don't use condition

" a = x;\n"

" for (i=1;i<=count;i++) {\n"

" BUGON(x==0)\n"

" x = x.next;\n"

" }\n"

"}";

ASSERT_EQUALS(false, testValueOfX(code, 2U, 0));

}

void valueFlowBeforeConditionTernaryOp() { // bailout: ?:

const char *code;

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

" y = ((x<0) ? x : ((x==2)?3:4));\n"

"}");

ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:2]: (debug) valueflow.cpp:1113:valueFlowReverse bailout: no simplification of x within ?: expression\n", errout.str());

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

" int r = x ? 1 / x : 0;\n"

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

"}");

ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:2]: (debug) valueflow.cpp:1113:valueFlowReverse bailout: no simplification of x within ?: expression\n", errout.str());

code = "void f(int x) {\n"

" int a =v x;\n"

" a = b ? x/2 : 20/x;\n"

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

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 123));

code = "void f(const s *x) {\n"

" x->a = 0;\n"

" if (x ? x->a : 0) {}\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));

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

" a = x;\n"

" if (y){}\n"

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

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 123));

}

void valueFlowBeforeConditionSizeof() { // skip sizeof

const char *code;

code = "void f(int *x) {\n"

" sizeof(x[0]);\n"

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

"}";

ASSERT_EQUALS(false, testValueOfX(code, 2U, 63));

code = "void f(int *x) {\n"

" char a[sizeof x.y];\n"

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

"}";

ASSERT_EQUALS(false, testValueOfX(code, 2U, 0));

}

void valueFlowBeforeConditionIfElse() { // bailout: if/else/etc

const char *code;

code = "void f(X * x) {\n"

" a = x;\n"

" if ((x != NULL) &&\n"

" (a(x->name, html)) &&\n"

" (a(x->name, body))) {}\n"

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

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));

ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));

ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));

ASSERT_EQUALS(false, testValueOfX(code, 5U, 0));

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

" if (x != 123) { b = x; }\n"

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

"}");

ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:2]: (debug) valueflow.cpp:1144:valueFlowReverse bailout: variable x stopping on }\n", errout.str());

code = "void f(int x) {\n"

" a = x;\n"

" if (abc) { x = 1; }\n" // <- condition must be false if x is 7 in next line

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

"}";

ASSERT_EQUALS(true, testValueOfX(code, 2U, 7));

}

void valueFlowBeforeConditionGlobalVariables() {

const char *code;

// handle global variables

code = "int x;\n"

"void f() {\n"

" int a = x;\n"

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

"}";

ASSERT_EQUALS(true, testValueOfX(code,3,123));

// bailout when there is function call

code = "class Fred { int x; void clear(); void f(); };\n"

"void Fred::f() {\n"

" int a = x;\n"

" clear();\n" // <- x might be assigned

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

"}";

ASSERT_EQUALS(false, testValueOfX(code,3,234));

}

void valueFlowBeforeConditionSwitch() {

// bailout: switch

// TODO : handle switch/goto more intelligently

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

" switch (y) {\n"

" case 1: a=x; break;\n"

" case 2: if (x==5) {} break;\n"

" };\n"

"}");

ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:3]: (debug) valueflow.cpp:1180:valueFlowReverse bailout: variable x stopping on break\n", errout.str());

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

" switch (y) {\n"

" case 1: a=x; return 1;\n"

" case 2: if (x==5) {} break;\n"