/*

* 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 "errortypes.h"

#include "fixture.h"

#include "helpers.h"

#include "mathlib.h"

#include "platform.h"

#include "settings.h"

#include "standards.h"

#include "token.h"

#include "vfvalue.h"

#include <algorithm>

#include <climits>

#include <cmath>

#include <cstdint>

#include <cstring>

#include <functional>

#include <list>

#include <set>

#include <sstream>

#include <string>

#include <vector>

class TestValueFlow : public TestFixture {

public:

TestValueFlow() : TestFixture("TestValueFlow") {}

private:

/*const*/ Settings settings = settingsBuilder().library("std.cfg").build();

void run() override {

// strcpy, abort cfg

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

"<def>\n"

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

" <function name=\"abort\"> <noreturn>true</noreturn> </function>\n" // abort is a noreturn function

"</def>";

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

mNewTemplate = true;

TEST_CASE(valueFlowNumber);

TEST_CASE(valueFlowString);

TEST_CASE(valueFlowTypeTraits);

TEST_CASE(valueFlowPointerAlias);

TEST_CASE(valueFlowLifetime);

TEST_CASE(valueFlowArrayElement);

TEST_CASE(valueFlowMove);

TEST_CASE(valueFlowBitAnd);

TEST_CASE(valueFlowRightShift);

TEST_CASE(valueFlowCalculations);

TEST_CASE(valueFlowSizeof);

TEST_CASE(valueFlowComma);

TEST_CASE(valueFlowErrorPath);

TEST_CASE(valueFlowBeforeCondition);

TEST_CASE(valueFlowBeforeConditionAndAndOrOrGuard);

TEST_CASE(valueFlowBeforeConditionAssignIncDec);

TEST_CASE(valueFlowBeforeConditionFunctionCall);

TEST_CASE(valueFlowBeforeConditionGlobalVariables);

mNewTemplate = false;

TEST_CASE(valueFlowBeforeConditionGoto);

mNewTemplate = true;

TEST_CASE(valueFlowBeforeConditionIfElse);

TEST_CASE(valueFlowBeforeConditionLoop);

mNewTemplate = false;

TEST_CASE(valueFlowBeforeConditionMacro);

mNewTemplate = true;

TEST_CASE(valueFlowBeforeConditionSizeof);

TEST_CASE(valueFlowBeforeConditionSwitch);

TEST_CASE(valueFlowBeforeConditionTernaryOp);

TEST_CASE(valueFlowBeforeConditionForward);

TEST_CASE(valueFlowBeforeConditionConstructor);

TEST_CASE(valueFlowAfterAssign);

TEST_CASE(valueFlowAfterSwap);

TEST_CASE(valueFlowAfterCondition);

TEST_CASE(valueFlowAfterConditionTernary);

TEST_CASE(valueFlowAfterConditionExpr);

TEST_CASE(valueFlowAfterConditionSeveralNot);

TEST_CASE(valueFlowForwardCompoundAssign);

TEST_CASE(valueFlowForwardCorrelatedVariables);

TEST_CASE(valueFlowForwardModifiedVariables);

TEST_CASE(valueFlowForwardFunction);

TEST_CASE(valueFlowForwardTernary);

TEST_CASE(valueFlowForwardLambda);

TEST_CASE(valueFlowForwardTryCatch);

TEST_CASE(valueFlowForwardInconclusiveImpossible);

TEST_CASE(valueFlowForwardConst);

TEST_CASE(valueFlowForwardAfterCondition);

TEST_CASE(valueFlowFwdAnalysis);

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

TEST_CASE(valueFlowGlobalStaticVar);

TEST_CASE(valueFlowInlineAssembly);

TEST_CASE(valueFlowSameExpression);

TEST_CASE(valueFlowUninit);

TEST_CASE(valueFlowConditionExpressions);

TEST_CASE(valueFlowContainerSize);

TEST_CASE(valueFlowContainerSizeIterator);

TEST_CASE(valueFlowContainerElement);

TEST_CASE(valueFlowDynamicBufferSize);

TEST_CASE(valueFlowSafeFunctionParameterValues);

TEST_CASE(valueFlowUnknownFunctionReturn);

TEST_CASE(valueFlowUnknownFunctionReturnRand);

TEST_CASE(valueFlowUnknownFunctionReturnMalloc);

TEST_CASE(valueFlowPointerAliasDeref);

TEST_CASE(valueFlowCrashIncompleteCode);

TEST_CASE(valueFlowCrash);

TEST_CASE(valueFlowHang);

TEST_CASE(valueFlowCrashConstructorInitialization);

TEST_CASE(valueFlowUnknownMixedOperators);

TEST_CASE(valueFlowSolveExpr);

TEST_CASE(valueFlowIdempotent);

TEST_CASE(valueFlowUnsigned);

TEST_CASE(valueFlowMod);

TEST_CASE(valueFlowIncDec);

TEST_CASE(valueFlowNotNull);

TEST_CASE(valueFlowSymbolic);

TEST_CASE(valueFlowSymbolicIdentity);

TEST_CASE(valueFlowSymbolicStrlen);

TEST_CASE(valueFlowSmartPointer);

TEST_CASE(valueFlowImpossibleMinMax);

TEST_CASE(valueFlowImpossibleIncDec);

TEST_CASE(valueFlowImpossibleUnknownConstant);

TEST_CASE(valueFlowContainerEqual);

mNewTemplate = false;

TEST_CASE(valueFlowBailoutIncompleteVar);

TEST_CASE(valueFlowBailoutNoreturn);

mNewTemplate = true;

TEST_CASE(performanceIfCount);

TEST_CASE(bitfields);

TEST_CASE(bitfieldsHang);

}

static bool isNotTokValue(const ValueFlow::Value &val) {

return !val.isTokValue();

}

// cppcheck-suppress unusedPrivateFunction

static bool isNotLifetimeValue(const ValueFlow::Value& val) {

return !val.isLifetimeValue();

}

static bool isNotUninitValue(const ValueFlow::Value& val) {

return !val.isUninitValue();

}

static bool isNotPossible(const ValueFlow::Value& val) {

return !val.isPossible();

}

static bool isNotKnown(const ValueFlow::Value& val) {

return !val.isKnown();

}

static bool isNotInconclusive(const ValueFlow::Value& val) {

return !val.isInconclusive();

}

static bool isNotImpossible(const ValueFlow::Value& val) {

return !val.isImpossible();

}

#define testValueOfXKnown(...) testValueOfXKnown_(__FILE__, __LINE__, __VA_ARGS__)

bool testValueOfXKnown_(const char* file, int line, const char code[], unsigned int linenr, int value) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

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

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

if (std::any_of(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& val) {

if (val.isSymbolicValue())

return false;

if (val.isKnown() && val.intvalue == value)

return true;

return false;

}))

return true;

}

}

return false;

}

bool testValueOfXKnown_(const char* file, int line, const char code[], unsigned int linenr, const std::string& expr, int value) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

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

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

if (std::any_of(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& val) {

if (!val.isSymbolicValue())

return false;

if (val.isKnown() && val.intvalue == value && val.tokvalue->expressionString() == expr)

return true;

return false;

}))

return true;

}

}

return false;

}

#define testValueOfXImpossible(...) testValueOfXImpossible_(__FILE__, __LINE__, __VA_ARGS__)

bool testValueOfXImpossible_(const char* file, int line, const char code[], unsigned int linenr, int value) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

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

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

if (std::any_of(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& val) {

if (val.isSymbolicValue())

return false;

if (val.isImpossible() && val.intvalue == value)

return true;

return false;

}))

return true;

}

}

return false;

}

bool testValueOfXImpossible_(const char* file, int line, const char code[], unsigned int linenr, const std::string& expr, int value)

{

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

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

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

if (std::any_of(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& val) {

if (!val.isSymbolicValue())

return false;

if (val.isImpossible() && val.intvalue == value && val.tokvalue->expressionString() == expr)

return true;

return false;

}))

return true;

}

}

return false;

}

#define testValueOfXInconclusive(...) testValueOfXInconclusive_(__FILE__, __LINE__, __VA_ARGS__)

bool testValueOfXInconclusive_(const char* file, int line, const char code[], unsigned int linenr, int value) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

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

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

if (std::any_of(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& val) {

if (val.isSymbolicValue())

return false;

if (val.isInconclusive() && val.intvalue == value)

return true;

return false;

}))

return true;

}

}

return false;

}

#define testValueOfX(...) testValueOfX_(__FILE__, __LINE__, __VA_ARGS__)

bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, MathLib::bigint value, const Settings *s = nullptr) {

const Settings *settings1 = s ? s : &settings;

// Tokenize..

SimpleTokenizer tokenizer(*settings1, *this);

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

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

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

if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {

return v.isIntValue() && !v.isImpossible() && v.intvalue == value;

}))

return true;

}

}

return false;

}

bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, const std::string& expr, int value)

{

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

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

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

if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {

return v.isSymbolicValue() && !v.isImpossible() && v.intvalue == value && v.tokvalue->expressionString() == expr;

}))

return true;

}

}

return false;

}

bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, double value, double diff) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

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

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

if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {

return v.isFloatValue() && !v.isImpossible() && v.floatValue >= value - diff && v.floatValue <= value + diff;

}))

return true;

}

}

return false;

}

#define getErrorPathForX(...) getErrorPathForX_(__FILE__, __LINE__, __VA_ARGS__)

std::string getErrorPathForX_(const char* file, int line, const char code[], unsigned int linenr) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

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

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

continue;

std::ostringstream ostr;

for (const ValueFlow::Value &v : tok->values()) {

for (const ErrorPathItem &ep : v.errorPath) {

const Token *eptok = ep.first;

const std::string &msg = ep.second;

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

}

}

return ostr.str();

}

return "";

}

bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, const char value[], ValueFlow::Value::ValueType type) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

const std::size_t len = strlen(value);

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

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

if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {

return v.valueType == type && Token::simpleMatch(v.tokvalue, value, len);

}))

return true;

}

}

return false;

}

#define testLifetimeOfX(...) testLifetimeOfX_(__FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

bool testLifetimeOfX_(const char* file, int line, const char (&code)[size], unsigned int linenr, const char value[]) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

const std::size_t len = strlen(value);

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

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

if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {

return v.isLifetimeValue() && v.lifetimeScope == ValueFlow::Value::LifetimeScope::Local && Token::simpleMatch(v.tokvalue, value, len);

}))

return true;

}

}

return false;

}

bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, int value, ValueFlow::Value::ValueType type) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

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

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

if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {

return v.valueType == type && v.intvalue == value;

}))

return true;

}

}

return false;

}

bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, ValueFlow::Value::MoveKind moveKind) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

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

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

if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {

return v.isMovedValue() && v.moveKind == moveKind;

}))

return true;

}

}

return false;

}

#define testConditionalValueOfX(...) testConditionalValueOfX_(__FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

bool testConditionalValueOfX_(const char* file, int line, const char (&code)[size], unsigned int linenr, int value) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

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

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

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

if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {

return v.isIntValue() && v.intvalue == value && v.condition;

}))

return true;

}

}

return false;

}

#define bailout(...) bailout_(__FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

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

const Settings s = settingsBuilder().debugwarnings().build();

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

// Tokenize..

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

}

#define tokenValues(...) tokenValues_(__FILE__, __LINE__, __VA_ARGS__)

std::list<ValueFlow::Value> tokenValues_(const char* file, int line, const char code[], const char tokstr[], const Settings *s = nullptr, bool cpp = true) {

SimpleTokenizer tokenizer(s ? *s : settings, *this, cpp);

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

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

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

}

std::list<ValueFlow::Value> tokenValues_(const char* file, int line, const char code[], const char tokstr[], ValueFlow::Value::ValueType vt) {

std::list<ValueFlow::Value> values = tokenValues_(file, line, code, tokstr);

values.remove_if([&](const ValueFlow::Value& v) {

return v.valueType != vt;

});

return values;

}

#define lifetimeValues(...) lifetimeValues_(__FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

std::vector<std::string> lifetimeValues_(const char* file, int line, const char (&code)[size], const char tokstr[]) {

std::vector<std::string> result;

SimpleTokenizer tokenizer(settings, *this);

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

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

if (!tok)

return result;

for (const ValueFlow::Value& value:tok->values()) {

if (!value.isLifetimeValue())

continue;

if (!value.tokvalue)

continue;

result.push_back(value.tokvalue->expressionString());

}

return result;

}

#define valueOfTok(...) valueOfTok_(__FILE__, __LINE__, __VA_ARGS__)

ValueFlow::Value valueOfTok_(const char* file, int line, const char code[], const char tokstr[], const Settings *s = nullptr, bool cpp = true) {

std::list<ValueFlow::Value> values = removeImpossible(tokenValues_(file, line, code, tokstr, s, cpp));

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

}

#define testKnownValueOfTok(...) testKnownValueOfTok_(__FILE__, __LINE__, __VA_ARGS__)

bool testKnownValueOfTok_(const char* file,

int line,

const char code[],

const char tokstr[],

int value)

{

std::list<ValueFlow::Value> values = removeImpossible(tokenValues_(file, line, code, tokstr));

return std::any_of(values.begin(), values.end(), [&](const ValueFlow::Value& v) {

return v.isKnown() && v.isIntValue() && v.intvalue == value;

});

}

static std::list<ValueFlow::Value> removeSymbolicTok(std::list<ValueFlow::Value> values)

{

values.remove_if([](const ValueFlow::Value& v) {

return v.isSymbolicValue() || v.isTokValue();

});

return values;

}

static std::list<ValueFlow::Value> removeImpossible(std::list<ValueFlow::Value> values)

{

values.remove_if(std::mem_fn(&ValueFlow::Value::isImpossible));

return values;

}

void valueFlowNumber() {

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

ASSERT_EQUALS_DOUBLE(192.0, valueOfTok("x=0x0.3p10;", "0x0.3p10").floatValue, 1e-5); // 3 * 16^-1 * 2^10 = 192

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

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(static_cast<int>('a'), valueOfTok("x='a';", "'a'").intvalue);

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

TODO_ASSERT_EQUALS(0xFFFFFFFF00000000, 0, valueOfTok("x=0xFFFFFFFF00000000;", "0xFFFFFFFF00000000").intvalue); // #7701

ASSERT_EQUALS_DOUBLE(16, valueOfTok("x=(double)16;", "(").floatValue, 1e-5);

ASSERT_EQUALS_DOUBLE(0.0625, valueOfTok("x=1/(double)16;", "/").floatValue, 1e-5);

const Settings settingsC23 = settingsBuilder().c(Standards::C23).build();

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

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

const Settings settingsC17 = settingsBuilder().c(Standards::C17).build();

ASSERT(!valueOfTok("x=true;", "true", &settingsC17, false).isKnown());

ASSERT(!valueOfTok("x=false;", "false", &settingsC17, false).isKnown());

// scope

{

const char code[] = "namespace N { enum E {e0,e1}; }\n"

"void foo() { x = N::e1; }";

ASSERT_EQUALS(1, valueOfTok(code, "::").intvalue);

}

ASSERT_EQUALS(63, valueOfTok("x = 3 * uint32_t{21};", "*").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\"", ValueFlow::Value::ValueType::TOK));

// valueFlowSubFunction

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

" f(x);\n"

"}\n"

"\n"

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

ASSERT_EQUALS(true, testValueOfX(code, 2, "\"abc\"", ValueFlow::Value::ValueType::TOK));

}

void valueFlowTypeTraits()

{

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<void>{};", "{", 1));

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<void>::value;", ":: value", 1));

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void_v<void>;", "::", 1));

// is_void

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<int>{};", "{", 0));

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<void*>{};", "{", 0));

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<const void>{};", "{", 1));

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<volatile void>{};", "{", 1));

// is_lvalue_reference

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_lvalue_reference<int>{};", "{", 0));

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_lvalue_reference<int&>{};", "{", 1));

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_lvalue_reference<int&&>{};", "{", 0));

// is_rvalue_reference

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_rvalue_reference<int>{};", "{", 0));

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_rvalue_reference<int&>{};", "{", 0));

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_rvalue_reference<int&&>{};", "{", 1));

// is_reference

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_reference<int>{};", "{", 0));

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_reference<int&>{};", "{", 1));

ASSERT_EQUALS(true, testKnownValueOfTok("std::is_reference<int&&>{};", "{", 1));

{

const char* code;

code = "void bar();\n"

"void foo() { std::is_void<decltype(bar())>::value; }";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));

code = "int bar();\n"

"void foo() { std::is_void<decltype(bar())>::value; }";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "void bar();\n"

"void foo() { std::is_void<decltype(bar)>::value; }";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "class A;\n"

"void foo() { std::is_lvalue_reference<A>::value; }";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "class A;\n"

"void foo() { std::is_lvalue_reference<A&>::value; }";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));

code = "class A;\n"

"void foo() { std::is_lvalue_reference<A&&>::value; }";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "class A;\n"

"void foo() { std::is_rvalue_reference<A>::value; }";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "class A;\n"

"void foo() { std::is_rvalue_reference<A&>::value; }";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "class A;\n"

"void foo() { std::is_rvalue_reference<A&&>::value; }";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));

code = "class A;\n"

"void foo() { std::is_reference<A>::value; }";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "class A;\n"

"void foo() { std::is_reference<A&>::value; }";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));

code = "class A;\n"

"void foo() { std::is_reference<A&&>::value; }";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));

code = "void foo() {\n"

" int bar;\n"

" std::is_void<decltype(bar)>::value;\n"

"}\n";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "void foo(int bar) {\n"

" std::is_lvalue_reference<decltype(bar)>::value;\n"

"}\n";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "void foo(int& bar) {\n"

" std::is_lvalue_reference<decltype(bar)>::value;\n"

"}\n";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));

code = "void foo(int&& bar) {\n"

" std::is_lvalue_reference<decltype(bar)>::value;\n"

"}\n";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "void foo(int bar) {\n"

" std::is_rvalue_reference<decltype(bar)>::value;\n"

"}\n";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "void foo(int& bar) {\n"

" std::is_rvalue_reference<decltype(bar)>::value;\n"

"}\n";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "void foo(int&& bar) {\n"

" std::is_rvalue_reference<decltype(bar)>::value;\n"

"}\n";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));

code = "void foo(int bar) {\n"

" std::is_reference<decltype(bar)>::value;\n"

"}\n";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));

code = "void foo(int& bar) {\n"

" std::is_reference<decltype(bar)>::value;\n"

"}\n";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));

code = "void foo(int&& bar) {\n"

" std::is_reference<decltype(bar)>::value;\n"

"}\n";

ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));

}

}

void valueFlowPointerAlias() {

const char *code;

std::list<ValueFlow::Value> values;

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 ]", ValueFlow::Value::ValueType::TOK));

// 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", ValueFlow::Value::ValueType::TOK));

code = "void f() {\n"

" struct X *x;\n"

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

"}";

values = tokenValues(code, "&");

values.remove_if(&isNotTokValue);

ASSERT_EQUALS(true, values.empty());

values = tokenValues(code, "x [");

values.remove_if(&isNotTokValue);

ASSERT_EQUALS(true, values.empty());

}

void valueFlowLifetime() {

std::vector<std::string> lifetimes;

{

const char code[] = "void f() {\n"

" int a = 1;\n"

" auto x = [&]() { return a + 1; };\n"

" auto b = x;\n"

"}\n";

ASSERT_EQUALS(true, testLifetimeOfX(code, 4, "a + 1"));

}

{

const char code[] = "void f() {\n"

" int a = 1;\n"

" auto x = [=]() { return a + 1; };\n"

" auto b = x;\n"

"}\n";

ASSERT_EQUALS(false, testLifetimeOfX(code, 4, "a ;"));

}

{

const char code[] = "void f(int v) {\n"

" int a = v;\n"

" int * p = &a;\n"

" auto x = [=]() { return p + 1; };\n"

" auto b = x;\n"

"}\n";

ASSERT_EQUALS(true, testLifetimeOfX(code, 5, "a ;"));

}

{

const char code[] = "void f() {\n"

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

" auto x = v.begin();\n"

" auto it = x;\n"

"}\n";

ASSERT_EQUALS(true, testLifetimeOfX(code, 4, "v . begin"));

}

{

const char code[] = "void f() {\n"

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

" auto x = v.begin() + 1;\n"

" auto it = x;\n"

"}\n";

ASSERT_EQUALS(true, testLifetimeOfX(code, 4, "v . begin"));

}

{

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

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

" int * x = v.data();\n"

" return x;\n"

"}\n";

ASSERT_EQUALS(true, testLifetimeOfX(code, 4, "v . data"));

}

{

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

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

" int * x = v.data() + 1;\n"

" return x;\n"

"}\n";

ASSERT_EQUALS(true, testLifetimeOfX(code, 4, "v . data"));

}

{

const char code[] = "int f(int* a) {\n"

" int **p = &a;\n"

" int * x = *p;\n"

" return x; \n"

"}\n";

ASSERT_EQUALS(false, testLifetimeOfX(code, 4, "a"));

}

{

const char code[] = "void f() {\n"

" int i = 0;\n"

" void* x = (void*)&i;\n"

"}\n";

lifetimes = lifetimeValues(code, "( void * )");

ASSERT_EQUALS(true, lifetimes.size() == 1);

ASSERT_EQUALS(true, lifetimes.front() == "i");

}

{

const char code[] = "struct T {\n" // #10810

" static int g() { return 0; }\n"

"};\n"

"T t;\n"

"struct S { int i; };\n"

"S f() {\n"

" S s = { decltype(t)::g() };\n"

" return s;\n"

"};\n";

lifetimes = lifetimeValues(code, "=");

ASSERT_EQUALS(true, lifetimes.empty());

}

{

const char code[] = "struct T {\n" // #10838

" void f();\n"

" double d[4][4];\n"

"};\n"

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

" auto g = [this]() -> double(&)[4] {\n"

" double(&q)[4] = d[0];\n"

" return q;\n"

" };\n"

"}\n";

lifetimes = lifetimeValues(code, "return"); // don't crash

ASSERT_EQUALS(true, lifetimes.empty());

}

{

const char code[] = "void f() {\n" // #13076

" char a[10];\n"

" struct S s = { sizeof(a), 0 };\n"

" s.p = a;\n"

"}\n";

lifetimes = lifetimeValues(code, "= a");

ASSERT_EQUALS(true, lifetimes.size() == 1);

ASSERT_EQUALS(true, lifetimes.front() == "a");

}

{

const char code[] = "void f(const char *s, size_t len) {\n"

" char buf[10];\n"

" {\n"

" char *tmp = buf;\n"

" s = strcpy(tmp, s);\n"

" }\n"

" if (s[len] == '\0') {}\n"

"}\n";

lifetimes = lifetimeValues(code, "s [");

ASSERT_EQUALS(true, lifetimes.size() == 1);

ASSERT_EQUALS(true, lifetimes.front() == "buf");

}

}

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 }", ValueFlow::Value::ValueType::TOK));

code = "void f() {\n"

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

" return x;\n"

"}";

ASSERT_EQUALS(true, testValueOfX(code, 3U, "\"abcd\"", ValueFlow::Value::ValueType::TOK));

code = "void f() {\n"

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

" return x;\n"

"}";

TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 3U, "\"abcd\"", ValueFlow::Value::ValueType::TOK));

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", ValueFlow::Value::ValueType::TOK));

code = "char f() {\n"

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

" return x[0];\n"

"}";

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

code = "char f() {\n"

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

" return x[0];\n"

"}";

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

code = "int g() { return 3; }\n"

"void f() {\n"

" const int x[2] = { g(), g() };\n"

" return x[0];\n"

"}\n";

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

code = "int g() { return 3; }\n"

"void f() {\n"

" const int x[2] = { g(), g() };\n"

" return x[1];\n"

"}\n";

ASSERT_EQUALS(3, valueOfTok(code, "[ 1").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::MoveKind::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::MoveKind::ForwardedVariable));

code = "void f() {\n"

" X x;\n"