TestValueFlow() : TestFixture("TestValueFlow") {

}

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

TEST_CASE(valueFlowCalculations);

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

TEST_CASE(valueFlowForLoop);

TEST_CASE(valueFlowSubFunction);

TEST_CASE(valueFlowFunctionReturn);

TEST_CASE(valueFlowFunctionDefaultParameter);

TEST_CASE(knownValue);

}

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->intvalue == value && !it->tokvalue)

return true;

}

}

}

return false;

}

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 (Token::simpleMatch(it->tokvalue, value))

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->intvalue == value && !it->tokvalue && it->condition)

return true;

}

}

}

return false;

}

void bailout(const char code[]) {

settings.debugwarnings = true;

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

errout.str("");

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

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().tokvalue ? values.front() : ValueFlow::Value();

}

void valueFlowNumber() {

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

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

}

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

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

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

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

// bailout: assignment

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

" x = y;\n"

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

"}");

ASSERT_EQUALS("[test.cpp:2]: (debug) ValueFlow 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 => dont 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 => dont 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 => dont 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("[test.cpp:2]: (debug) ValueFlow 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("[test.cpp:2]: (debug) ValueFlow 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(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("[test.cpp:2]: (debug) ValueFlow 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() {

// bailout: global variables

bailout("int x;\n"

"void f() {\n"

" int a = x;\n"

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

"}");

ASSERT_EQUALS("[test.cpp:4]: (debug) ValueFlow bailout: global variable x\n", errout.str());

// class variable

const char *code;

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("[test.cpp:3]: (debug) ValueFlow 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"

" };\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (debug) ValueFlow bailout: variable x stopping on return\n", errout.str());

}

void valueFlowBeforeConditionMacro() {

// bailout: condition is a expanded macro

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

" a = x;\n"

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

"}");

ASSERT_EQUALS("[test.cpp:3]: (debug) ValueFlow bailout: variable x, condition is defined in macro\n", errout.str());

}

void valueFlowBeforeConditionGoto() {

// bailout: goto label (TODO: handle gotos more intelligently)

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

" if (x == 123) { goto out; }\n"

" a=x;\n" // <- x is not 123

"out:"

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

"}");

ASSERT_EQUALS("[test.cpp:4]: (debug) ValueFlow bailout: variable x stopping on goto label\n"

"[test.cpp:2]: (debug) ValueFlow bailout: variable x. noreturn conditional scope.\n"

, errout.str());

// #5721 - FP

bailout("static void f(int rc) {\n"

" ABC* abc = getabc();\n"

" if (!abc) { goto out };\n"

"\n"

" abc->majortype = 0;\n"

" if (FAILED(rc)) {}\n"

"\n"

"out:\n"

" if (abc) {}\n"

"}\n");

ASSERT_EQUALS("[test.cpp:2]: (debug) ValueFlow bailout: assignment of abc\n"

"[test.cpp:8]: (debug) ValueFlow bailout: variable abc stopping on goto label\n"

"[test.cpp:3]: (debug) ValueFlow bailout: variable abc. noreturn conditional scope.\n",

errout.str());

}

void valueFlowAfterAssign() {

const char *code;

code = "void f() {\n"

" int x = 123;\n"

" a = x;\n"

"}";

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

code = "void f() {\n"

" int x = 123;\n"

" a = sizeof(x);\n"

"}";

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

code = "void f() {\n"

" int x = 123;\n"

" a = 2 + x;\n"

"}";

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

code = "void f() {\n"

" int x = 9;\n"

" --x;\n"

" return x;\n"

"}";

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

ASSERT_EQUALS(true, testValueOfX(code, 4U, 8));

code = "void f() {\n"

" int x = 0;\n"

" y = x += z;\n"

" return x;\n"

"}";

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

code = "void f() {\n"

" static int x = 2;\n"

" x++;\n"

" return x;\n"

"}";

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

code = "void f() {\n"

" static int x = 2;\n"

" a >> x;\n"

" return x;\n"

"}";

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

code = "void f() {\n"

" static int x = 0;\n"

" if (x==0) x = getX();\n"

" return x;\n"

"}";

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

// function

code = "void f() {\n"

" char *x = 0;\n"

" int success = getx((char**)&x);\n"

" if (success) x[0] = 0;\n"

"}";

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

code = "void f() {\n"

" char *x = 0;\n"

" getx(reinterpret_cast<void **>(&x));\n"

" *x = 0;\n"

"}";

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

// lambda

code = "void f() {\n"

" int x = 0;\n"

" Q q = [&]() {\n"

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

" x++;\n"

" };\n"

" dosomething(q);\n"

"}\n";

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

// ?:

code = "void f() {\n"

" int x = 8;\n"

" a = ((x > 10) ?\n"

" x : 0);\n" // <- x is not 8

"}";

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

code = "void f() {\n" // #6973

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

" a = ((x[0] == 'U') ?\n"

" x[1] : 0);\n" // <- x is not ""

"}";

ASSERT_EQUALS(false, testValueOfX(code, 4U, "\"\""));

code = "void f() {\n" // #6973

" char *x = getenv (\"LC_ALL\");\n"

" if (x == NULL)\n"

" x = \"\";\n"

"\n"

" if ( (x[0] == 'U') &&\n" // x can be ""

" (x[1] ?\n" // x can't be ""

" x[3] :\n" // x can't be ""

" x[2] ))\n" // x can't be ""

" {}\n"

"}\n";

ASSERT_EQUALS(true, testValueOfX(code, 6U, "\"\""));

ASSERT_EQUALS(false, testValueOfX(code, 7U, "\"\""));

ASSERT_EQUALS(false, testValueOfX(code, 8U, "\"\""));

ASSERT_EQUALS(false, testValueOfX(code, 9U, "\"\""));

code = "void f() {\n" // #7599

" t *x = 0;\n"

" y = (a ? 1 : x\n" // <- x is 0

" && x->y ? 1 : 2);" // <- x is not 0

"}";

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

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

code = "void f() {\n" // #7599

" t *x = 0;\n"

" y = (a ? 1 : !x\n" // <- x is 0

" || x->y ? 1 : 2);" // <- x is not 0

"}";

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

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

// if/else

code = "void f() {\n"

" int x = 123;\n"

" if (condition) return;\n"

" a = 2 + x;\n"

"}";

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

code = "void f() {\n"

" int x = 1;\n"

" if (condition) x = 2;\n"

" a = 2 + x;\n"

"}";

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

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

code = "void f() {\n"

" int x = 123;\n"

" if (condition1) x = 456;\n"

" if (condition2) x = 789;\n"

" a = 2 + x;\n" // <- either assignment "x=123" is redundant or x can be 123 here.

"}";

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

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

" int x = 123;\n"

" if (a > 1)\n"

" ++x;\n"

" else\n"

" ++x;\n"

" return 2 + x;\n"

"}";

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

code = "void f() {\n"

" int x = 1;\n"

" if (condition1) x = 2;\n"

" else return;\n"

" a = 2 + x;\n"

"}";

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

code = "void f(){\n"

" int x = 0;\n"

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

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

" return 123 / x;\n"

"}\n";

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

code = "void f() {\n"

" X *x = getx();\n"

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

" else { x->y = 1; }\n"

"}";

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

code = "void f() {\n" // #6239

" int x = 4;\n"

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

" a = x;\n"

"}";

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

code = "void f() {\n"

" int x = 32;\n"

" if (x>=32) return;\n"

" a[x]=0;\n"

"}";

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

code = "void f() {\n"

" int x = 32;\n"

" if (x>=32) {\n"

" a[x] = 0;\n" // <- should have possible value 32

" return;\n"

" }\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 4U, 32));

code = "void f() {\n"

" int x = 33;\n"

" if (x==33) goto fail;\n"

" a[x]=0;\n"

"fail:\n"

"}";

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

code = "void f() {\n"

" int x = 32;\n"

" if (a==1) { z=x+12; }\n"

" if (a==2) { z=x+32; }\n"

" z = x;\n"

"}";

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

ASSERT_EQUALS(true, testValueOfX(code, 4U, 32));

ASSERT_EQUALS(true, testValueOfX(code, 5U, 32));

code = "void f() {\n" // #5656 - FP

" int x = 0;\n"

" if (!x) {\n"

" x = getx();\n"

" }\n"

" y = x;\n"

"}";

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

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

" int x = y;\n"

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

" else { a = x; }\n"

"}";

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

code = "void f () {\n"

" ST * x = g_pST;\n"

" if (x->y == 0) {\n"

" x = NULL;\n"

" return 1;\n"

" }\n"

" a = x->y;\n"

"}";

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

code = "void f () {\n"