/*

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

 * Copyright (C) 2007-2018 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, abort cfg

        const char cfg[] = "\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.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(valueFlowSizeof);

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

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

        // 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 valueFlowSizeof() {

        const char *code;

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

#define CHECK(A, B)                              \

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

               "    x = sizeof(" A ");\n"        \

               "}";                              \

        values = tokenValues(code,"( " A " )");  \

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

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

        // standard types

        CHECK("void *", settings.sizeof_pointer);

        CHECK("char", 1U);

        CHECK("short", settings.sizeof_short);

        CHECK("int", settings.sizeof_int);

        CHECK("long", settings.sizeof_long);

#undef CHECK

        // array size

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

#define CHECK(A, B, C, D)                         \

        code = "enum " A " E " B " { E0, E1 };\n" \

               "void f() {\n"                     \

               "    x = sizeof(" C ");\n"         \

               "}";                               \

        values = tokenValues(code,"( " C " )");   \

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

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

        // enums

        CHECK("", "", "E", settings.sizeof_int);

        // typed enums

        CHECK("", ": char", "E", 1U);

        CHECK("", ": signed char", "E", 1U);

        CHECK("", ": unsigned char", "E", 1U);

        CHECK("", ": short", "E", settings.sizeof_short);

        CHECK("", ": signed short", "E", settings.sizeof_short);

        CHECK("", ": unsigned short", "E", settings.sizeof_short);

        CHECK("", ": int", "E", settings.sizeof_int);

        CHECK("", ": signed int", "E", settings.sizeof_int);

        CHECK("", ": unsigned int", "E", settings.sizeof_int);

        CHECK("", ": long", "E", settings.sizeof_long);

        CHECK("", ": signed long", "E", settings.sizeof_long);

        CHECK("", ": unsigned long", "E", settings.sizeof_long);

        CHECK("", ": long long", "E", settings.sizeof_long_long);

        CHECK("", ": signed long long", "E", settings.sizeof_long_long);

        CHECK("", ": unsigned long long", "E", settings.sizeof_long_long);

        CHECK("", ": wchar_t", "E", settings.sizeof_wchar_t);

        CHECK("", ": size_t", "E", settings.sizeof_size_t);

        // enumerators

        CHECK("", "", "E0", settings.sizeof_int);

        // typed enumerators

        CHECK("", ": char", "E0", 1U);

        CHECK("", ": signed char", "E0", 1U);

        CHECK("", ": unsigned char", "E0", 1U);

        CHECK("", ": short", "E0", settings.sizeof_short);

        CHECK("", ": signed short", "E0", settings.sizeof_short);

        CHECK("", ": unsigned short", "E0", settings.sizeof_short);

        CHECK("", ": int", "E0", settings.sizeof_int);

        CHECK("", ": signed int", "E0", settings.sizeof_int);

        CHECK("", ": unsigned int", "E0", settings.sizeof_int);

        CHECK("", ": long", "E0", settings.sizeof_long);

        CHECK("", ": signed long", "E0", settings.sizeof_long);

        CHECK("", ": unsigned long", "E0", settings.sizeof_long);

        CHECK("", ": long long", "E0", settings.sizeof_long_long);

        CHECK("", ": signed long long", "E0", settings.sizeof_long_long);

        CHECK("", ": unsigned long long", "E0", settings.sizeof_long_long);

        CHECK("", ": wchar_t", "E0", settings.sizeof_wchar_t);

        CHECK("", ": size_t", "E0", settings.sizeof_size_t);

        // class typed enumerators

        CHECK("class", ": char", "E :: E0", 1U);

        CHECK("class", ": signed char", "E :: E0", 1U);

        CHECK("class", ": unsigned char", "E :: E0", 1U);

        CHECK("class", ": short", "E :: E0", settings.sizeof_short);

        CHECK("class", ": signed short", "E :: E0", settings.sizeof_short);

        CHECK("class", ": unsigned short", "E :: E0", settings.sizeof_short);

        CHECK("class", ": int", "E :: E0", settings.sizeof_int);

        CHECK("class", ": signed int", "E :: E0", settings.sizeof_int);

        CHECK("class", ": unsigned int", "E :: E0", settings.sizeof_int);

        CHECK("class", ": long", "E :: E0", settings.sizeof_long);

        CHECK("class", ": signed long", "E :: E0", settings.sizeof_long);

        CHECK("class", ": unsigned long", "E :: E0", settings.sizeof_long);

        CHECK("class", ": long long", "E :: E0", settings.sizeof_long_long);

        CHECK("class", ": signed long long", "E :: E0", settings.sizeof_long_long);

        CHECK("class", ": unsigned long long", "E :: E0", settings.sizeof_long_long);

        CHECK("class", ": wchar_t", "E :: E0", settings.sizeof_wchar_t);

        CHECK("class", ": size_t", "E :: E0", settings.sizeof_size_t);

#undef CHECK

#define CHECK(A, B)                                   \

        code = "enum E " A " { E0, E1 };\n"           \

               "void f() {\n"                         \

               "    E arrE[] = { E0, E1 };\n"         \

               "    x = sizeof(arrE);\n"              \

               "}";                                   \

        values = tokenValues(code,"( arrE )");        \

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

        ASSERT_EQUALS(B * 2U, values.back().intvalue);

        // enum array

        CHECK("", settings.sizeof_int);

        // typed enum array

        CHECK(": char", 1U);

        CHECK(": signed char", 1U);

        CHECK(": unsigned char", 1U);

        CHECK(": short", settings.sizeof_short);

        CHECK(": signed short", settings.sizeof_short);

        CHECK(": unsigned short", settings.sizeof_short);

        CHECK(": int", settings.sizeof_int);

        CHECK(": signed int", settings.sizeof_int);

        CHECK(": unsigned int", settings.sizeof_int);

        CHECK(": long", settings.sizeof_long);

        CHECK(": signed long", settings.sizeof_long);

        CHECK(": unsigned long", settings.sizeof_long);

        CHECK(": long long", settings.sizeof_long_long);

        CHECK(": signed long long", settings.sizeof_long_long);

        CHECK(": unsigned long long", settings.sizeof_long_long);

        CHECK(": wchar_t", settings.sizeof_wchar_t);

        CHECK(": size_t", settings.sizeof_size_t);

#undef CHECK

#define CHECK(A, B)                                   \

        code = "enum class E " A " { E0, E1 };\n"     \

               "void f() {\n"                         \

               "    E arrE[] = { E::E0, E::E1 };\n"   \

               "    x = sizeof(arrE);\n"              \

               "}";                                   \

        values = tokenValues(code,"( arrE )");        \

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

        ASSERT_EQUALS(B * 2U, values.back().intvalue);

        // enum array

        CHECK("", settings.sizeof_int);

        // typed enum array

        CHECK(": char", 1U);

        CHECK(": signed char", 1U);

        CHECK(": unsigned char", 1U);

        CHECK(": short", settings.sizeof_short);

        CHECK(": signed short", settings.sizeof_short);

        CHECK(": unsigned short", settings.sizeof_short);

        CHECK(": int", settings.sizeof_int);

        CHECK(": signed int", settings.sizeof_int);

        CHECK(": unsigned int", settings.sizeof_int);

        CHECK(": long", settings.sizeof_long);

        CHECK(": signed long", settings.sizeof_long);

        CHECK(": unsigned long", settings.sizeof_long);

        CHECK(": long long", settings.sizeof_long_long);

        CHECK(": signed long long", settings.sizeof_long_long);

        CHECK(": unsigned long long", settings.sizeof_long_long);

        CHECK(": wchar_t", settings.sizeof_wchar_t);

        CHECK(": size_t", settings.sizeof_size_t);

#undef CHECK

    }

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

        // after loop

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

               "  do {\n"

               "    if (!x)\n"

               "      break;\n"

               "  } while (x->a);\n"

               "  if (x) {}\n"

               "}\n";

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

    }

    void valueFlowBeforeConditionAssignIncDec() {  // assignment / increment

        const char *code;

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