/*

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

#include "testutils.h"

#include "symboldatabase.h"

#include "utils.h"

#include <sstream>

#include <stdexcept>

#define GET_SYMBOL_DB(code) \

Tokenizer tokenizer(&settings, this); \

const SymbolDatabase *db = getSymbolDB_inner(tokenizer, code, "test.cpp");

#define GET_SYMBOL_DB_C(code) \

Tokenizer tokenizer(&settings, this); \

const SymbolDatabase *db = getSymbolDB_inner(tokenizer, code, "test.c");

class TestSymbolDatabase: public TestFixture {

public:

TestSymbolDatabase()

:TestFixture("TestSymbolDatabase")

,si(nullptr, nullptr, nullptr)

,vartok(nullptr)

,typetok(nullptr)

,t(nullptr)

,found(false) {

}

private:

const Scope si;

const Token* vartok;

const Token* typetok;

const Token* t;

bool found;

Settings settings;

Settings settings2;

void reset() {

vartok = nullptr;

typetok = nullptr;

t = nullptr;

found = false;

}

const SymbolDatabase* getSymbolDB_inner(Tokenizer& tokenizer, const char* code, const char* filename) {

errout.str("");

std::istringstream istr(code);

tokenizer.tokenize(istr, filename);

return tokenizer.getSymbolDatabase();

}

static const Scope *findFunctionScopeByToken(const SymbolDatabase * db, const Token *tok) {

std::list<Scope>::const_iterator scope;

for (scope = db->scopeList.begin(); scope != db->scopeList.end(); ++scope) {

if (scope->type == Scope::eFunction) {

if (scope->classDef == tok)

return &(*scope);

}

}

return 0;

}

static const Function *findFunctionByName(const char str[], const Scope* startScope) {

const Scope* currScope = startScope;

while (currScope && currScope->isExecutable()) {

if (currScope->functionOf)

currScope = currScope->functionOf;

else

currScope = currScope->nestedIn;

}

while (currScope) {

for (std::list<Function>::const_iterator i = currScope->functionList.begin(); i != currScope->functionList.end(); ++i) {

if (i->tokenDef->str() == str)

return &*i;

}

currScope = currScope->nestedIn;

}

return 0;

}

void run() {

LOAD_LIB_2(settings.library, "std.cfg");

settings2.platform(Settings::Unspecified);

TEST_CASE(array);

TEST_CASE(stlarray);

TEST_CASE(test_isVariableDeclarationCanHandleNull);

TEST_CASE(test_isVariableDeclarationIdentifiesSimpleDeclaration);

TEST_CASE(test_isVariableDeclarationIdentifiesInitialization);

TEST_CASE(test_isVariableDeclarationIdentifiesCpp11Initialization);

TEST_CASE(test_isVariableDeclarationIdentifiesScopedDeclaration);

TEST_CASE(test_isVariableDeclarationIdentifiesStdDeclaration);

TEST_CASE(test_isVariableDeclarationIdentifiesScopedStdDeclaration);

TEST_CASE(test_isVariableDeclarationIdentifiesManyScopes);

TEST_CASE(test_isVariableDeclarationIdentifiesPointers);

TEST_CASE(test_isVariableDeclarationDoesNotIdentifyConstness);

TEST_CASE(test_isVariableDeclarationIdentifiesFirstOfManyVariables);

TEST_CASE(test_isVariableDeclarationIdentifiesScopedPointerDeclaration);

TEST_CASE(test_isVariableDeclarationIdentifiesDeclarationWithIndirection);

TEST_CASE(test_isVariableDeclarationIdentifiesDeclarationWithMultipleIndirection);

TEST_CASE(test_isVariableDeclarationIdentifiesArray);

TEST_CASE(test_isVariableDeclarationIdentifiesPointerArray);

TEST_CASE(test_isVariableDeclarationIdentifiesOfArrayPointers);

TEST_CASE(isVariableDeclarationIdentifiesTemplatedPointerVariable);

TEST_CASE(isVariableDeclarationIdentifiesTemplatedPointerToPointerVariable);

TEST_CASE(isVariableDeclarationIdentifiesTemplatedArrayVariable);

TEST_CASE(isVariableDeclarationIdentifiesTemplatedVariable);

TEST_CASE(isVariableDeclarationIdentifiesTemplatedVariableIterator);

TEST_CASE(isVariableDeclarationIdentifiesNestedTemplateVariable);

TEST_CASE(isVariableDeclarationIdentifiesReference);

TEST_CASE(isVariableDeclarationDoesNotIdentifyTemplateClass);

TEST_CASE(isVariableDeclarationDoesNotIdentifyCppCast);

TEST_CASE(isVariableDeclarationPointerConst);

TEST_CASE(isVariableDeclarationRValueRef);

TEST_CASE(isVariableStlType);

TEST_CASE(rangeBasedFor);

TEST_CASE(arrayMemberVar1);

TEST_CASE(arrayMemberVar2);

TEST_CASE(arrayMemberVar3);

TEST_CASE(staticMemberVar);

TEST_CASE(getVariableFromVarIdBoundsCheck);

TEST_CASE(hasRegularFunction);

TEST_CASE(hasRegularFunction_trailingReturnType);

TEST_CASE(hasInlineClassFunction);

TEST_CASE(hasInlineClassFunction_trailingReturnType);

TEST_CASE(hasMissingInlineClassFunction);

TEST_CASE(hasClassFunction);

TEST_CASE(hasClassFunction_trailingReturnType);

TEST_CASE(hasRegularFunctionReturningFunctionPointer);

TEST_CASE(hasInlineClassFunctionReturningFunctionPointer);

TEST_CASE(hasMissingInlineClassFunctionReturningFunctionPointer);

TEST_CASE(hasClassFunctionReturningFunctionPointer);

TEST_CASE(complexFunctionArrayPtr);

TEST_CASE(pointerToMemberFunction);

TEST_CASE(hasSubClassConstructor);

TEST_CASE(testConstructors);

TEST_CASE(functionDeclarationTemplate);

TEST_CASE(functionDeclarations);

TEST_CASE(constructorInitialization);

TEST_CASE(memberFunctionOfUnknownClassMacro1);

TEST_CASE(memberFunctionOfUnknownClassMacro2);

TEST_CASE(memberFunctionOfUnknownClassMacro3);

TEST_CASE(functionLinkage);

TEST_CASE(classWithFriend);

TEST_CASE(parseFunctionCorrect);

TEST_CASE(parseFunctionDeclarationCorrect);

TEST_CASE(Cpp11InitInInitList);

TEST_CASE(hasGlobalVariables1);

TEST_CASE(hasGlobalVariables2);

TEST_CASE(hasGlobalVariables3);

TEST_CASE(checkTypeStartEndToken1);

TEST_CASE(checkTypeStartEndToken2); // handling for unknown macro: 'void f() MACRO {..'

TEST_CASE(checkTypeStartEndToken3); // no variable name: void f(const char){}

TEST_CASE(functionArgs1);

TEST_CASE(functionArgs2);

TEST_CASE(functionArgs3);

TEST_CASE(functionArgs4);

TEST_CASE(functionArgs5); // #7650

TEST_CASE(functionArgs6); // #7651

TEST_CASE(functionArgs7); // #7652

TEST_CASE(functionArgs8); // #7653

TEST_CASE(functionArgs9); // #7657

TEST_CASE(functionArgs10);

TEST_CASE(functionArgs11);

TEST_CASE(functionArgs12); // #7661

TEST_CASE(functionArgs13); // #7697

TEST_CASE(namespaces1);

TEST_CASE(namespaces2);

TEST_CASE(namespaces3); // #3854 - unknown macro

TEST_CASE(namespaces4);

TEST_CASE(tryCatch1);

TEST_CASE(symboldatabase1);

TEST_CASE(symboldatabase2);

TEST_CASE(symboldatabase3); // ticket #2000

TEST_CASE(symboldatabase4);

TEST_CASE(symboldatabase5); // ticket #2178

TEST_CASE(symboldatabase6); // ticket #2221

TEST_CASE(symboldatabase7); // ticket #2230

TEST_CASE(symboldatabase8); // ticket #2252

TEST_CASE(symboldatabase9); // ticket #2525

TEST_CASE(symboldatabase10); // ticket #2537

TEST_CASE(symboldatabase11); // ticket #2539

TEST_CASE(symboldatabase12); // ticket #2547

TEST_CASE(symboldatabase13); // ticket #2577

TEST_CASE(symboldatabase14); // ticket #2589

TEST_CASE(symboldatabase15); // ticket #2591

TEST_CASE(symboldatabase16); // ticket #2637

TEST_CASE(symboldatabase17); // ticket #2657

TEST_CASE(symboldatabase18); // ticket #2865

TEST_CASE(symboldatabase19); // ticket #2991 (segmentation fault)

TEST_CASE(symboldatabase20); // ticket #3013 (segmentation fault)

TEST_CASE(symboldatabase21);

TEST_CASE(symboldatabase22); // ticket #3437 (segmentation fault)

TEST_CASE(symboldatabase23); // ticket #3435

TEST_CASE(symboldatabase24); // ticket #3508 (constructor, destructor)

TEST_CASE(symboldatabase25); // ticket #3561 (throw C++)

TEST_CASE(symboldatabase26); // ticket #3561 (throw C)

TEST_CASE(symboldatabase27); // ticket #3543 (segmentation fault)

TEST_CASE(symboldatabase28);

TEST_CASE(symboldatabase29); // ticket #4442 (segmentation fault)

TEST_CASE(symboldatabase30);

TEST_CASE(symboldatabase31);

TEST_CASE(symboldatabase32);

TEST_CASE(symboldatabase33); // ticket #4682 (false negatives)

TEST_CASE(symboldatabase34); // ticket #4694 (segmentation fault)

TEST_CASE(symboldatabase35); // ticket #4806 (segmentation fault)

TEST_CASE(symboldatabase36); // ticket #4892 (segmentation fault)

TEST_CASE(symboldatabase37);

TEST_CASE(symboldatabase38); // ticket #5125 (infinite recursion)

TEST_CASE(symboldatabase39); // ticket #5120 (infinite recursion)

TEST_CASE(symboldatabase40); // ticket #5153

TEST_CASE(symboldatabase41); // ticket #5197 (unknown macro)

TEST_CASE(symboldatabase42); // only put variables in variable list

TEST_CASE(symboldatabase43); // #4738

TEST_CASE(symboldatabase44);

TEST_CASE(symboldatabase45); // #6125

TEST_CASE(symboldatabase46); // #6171 (anonymous namespace)

TEST_CASE(symboldatabase47); // #6308

TEST_CASE(symboldatabase48); // #6417

TEST_CASE(symboldatabase49); // #6424

TEST_CASE(symboldatabase50); // #6432

TEST_CASE(symboldatabase51); // #6538

TEST_CASE(symboldatabase52); // #6581

TEST_CASE(symboldatabase53); // #7124 (library podtype)

TEST_CASE(symboldatabase54); // #7257

TEST_CASE(enum1);

TEST_CASE(enum2);

TEST_CASE(enum3);

TEST_CASE(enum4);

TEST_CASE(enum5);

TEST_CASE(enum6);

TEST_CASE(enum7);

TEST_CASE(sizeOfType);

TEST_CASE(isImplicitlyVirtual);

TEST_CASE(isPure);

TEST_CASE(isFunction); // UNKNOWN_MACRO(a,b) { .. }

TEST_CASE(findFunction1);

TEST_CASE(findFunction2); // mismatch: parameter passed by address => reference argument

TEST_CASE(findFunction3);

TEST_CASE(findFunction4);

TEST_CASE(findFunction5); // #6230

TEST_CASE(findFunction6);

TEST_CASE(findFunction7); // #6700

TEST_CASE(findFunction8);

TEST_CASE(findFunction9);

TEST_CASE(findFunction10); // #7673

TEST_CASE(findFunction11);

TEST_CASE(noexceptFunction1);

TEST_CASE(noexceptFunction2);

TEST_CASE(noexceptFunction3);

TEST_CASE(noexceptFunction4);

TEST_CASE(throwFunction1);

TEST_CASE(throwFunction2);

TEST_CASE(nothrowAttributeFunction);

TEST_CASE(nothrowDeclspecFunction);

TEST_CASE(varTypesIntegral); // known integral

TEST_CASE(varTypesFloating); // known floating

TEST_CASE(varTypesOther); // (un)known

TEST_CASE(functionPrototype); // #5867

TEST_CASE(lambda); // #5867

TEST_CASE(lambda2); // #7473

TEST_CASE(circularDependencies); // #6298

TEST_CASE(executableScopeWithUnknownFunction);

TEST_CASE(valuetype);

TEST_CASE(variadic1); // #7453

TEST_CASE(variadic2); // #7649

TEST_CASE(variadic3); // #7387

}

void array() {

GET_SYMBOL_DB_C("int a[10+2];");

ASSERT(db != nullptr);

if (!db)

return;

ASSERT(db->getVariableListSize() == 2); // the first one is not used

const Variable * v = db->getVariableFromVarId(1);

ASSERT(v != nullptr);

if (!v)

return;

ASSERT(v->isArray());

ASSERT_EQUALS(1U, v->dimensions().size());

ASSERT_EQUALS(12U, v->dimension(0));

}

void stlarray() const {

std::istringstream code("std::array<int, 20> arr;");

TokenList list(nullptr);

list.createTokens(code, "test.c");

list.front()->tokAt(3)->link(list.front()->tokAt(7));

Variable v(list.front()->next(), list.front(), list.back(), 0, Public, nullptr, nullptr, &settings.library);

ASSERT(v.isArray());

ASSERT_EQUALS(1U, v.dimensions().size());

ASSERT_EQUALS(20U, v.dimension(0));

}

void test_isVariableDeclarationCanHandleNull() {

reset();

bool result = si.isVariableDeclaration(nullptr, vartok, typetok);

ASSERT_EQUALS(false, result);

ASSERT(nullptr == vartok);

ASSERT(nullptr == typetok);

Variable v(nullptr, nullptr, nullptr, 0, Public, 0, 0, &settings.library);

}

void test_isVariableDeclarationIdentifiesSimpleDeclaration() {

reset();

givenACodeSampleToTokenize simpleDeclaration("int x;");

bool result = si.isVariableDeclaration(simpleDeclaration.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("x", vartok->str());

ASSERT_EQUALS("int", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesInitialization() {

reset();

givenACodeSampleToTokenize simpleDeclaration("int x (1);");

bool result = si.isVariableDeclaration(simpleDeclaration.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("x", vartok->str());

ASSERT_EQUALS("int", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesCpp11Initialization() {

reset();

givenACodeSampleToTokenize simpleDeclaration("int x {1};");

bool result = si.isVariableDeclaration(simpleDeclaration.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("x", vartok->str());

ASSERT_EQUALS("int", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesScopedDeclaration() {

reset();

givenACodeSampleToTokenize ScopedDeclaration("::int x;");

bool result = si.isVariableDeclaration(ScopedDeclaration.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("x", vartok->str());

ASSERT_EQUALS("int", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesStdDeclaration() {

reset();

givenACodeSampleToTokenize StdDeclaration("std::string x;");

bool result = si.isVariableDeclaration(StdDeclaration.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("x", vartok->str());

ASSERT_EQUALS("string", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesScopedStdDeclaration() {

reset();

givenACodeSampleToTokenize StdDeclaration("::std::string x;");

bool result = si.isVariableDeclaration(StdDeclaration.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("x", vartok->str());

ASSERT_EQUALS("string", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesManyScopes() {

reset();

givenACodeSampleToTokenize manyScopes("AA::BB::CC::DD::EE x;");

bool result = si.isVariableDeclaration(manyScopes.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("x", vartok->str());

ASSERT_EQUALS("EE", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesPointers() {

reset();

givenACodeSampleToTokenize pointer("int* p;");

bool result1 = si.isVariableDeclaration(pointer.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result1);

ASSERT_EQUALS("p", vartok->str());

ASSERT_EQUALS("int", typetok->str());

Variable v1(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v1.isArray());

ASSERT(true == v1.isPointer());

ASSERT(false == v1.isReference());

reset();

givenACodeSampleToTokenize constpointer("const int* p;");

Variable v2(constpointer.tokens()->tokAt(3), constpointer.tokens()->next(), constpointer.tokens()->tokAt(2), 0, Public, 0, 0, &settings.library);

ASSERT(false == v2.isArray());

ASSERT(true == v2.isPointer());

ASSERT(false == v2.isConst());

ASSERT(false == v2.isReference());

reset();

givenACodeSampleToTokenize pointerconst("int* const p;");

bool result2 = si.isVariableDeclaration(pointerconst.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result2);

ASSERT_EQUALS("p", vartok->str());

ASSERT_EQUALS("int", typetok->str());

Variable v3(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v3.isArray());

ASSERT(true == v3.isPointer());

ASSERT(true == v3.isConst());

ASSERT(false == v3.isReference());

}

void test_isVariableDeclarationDoesNotIdentifyConstness() {

reset();

givenACodeSampleToTokenize constness("const int* cp;");

bool result = si.isVariableDeclaration(constness.tokens(), vartok, typetok);

ASSERT_EQUALS(false, result);

ASSERT(nullptr == vartok);

ASSERT(nullptr == typetok);

}

void test_isVariableDeclarationIdentifiesFirstOfManyVariables() {

reset();

givenACodeSampleToTokenize multipleDeclaration("int first, second;");

bool result = si.isVariableDeclaration(multipleDeclaration.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("first", vartok->str());

ASSERT_EQUALS("int", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesScopedPointerDeclaration() {

reset();

givenACodeSampleToTokenize manyScopes("AA::BB::CC::DD::EE* p;");

bool result = si.isVariableDeclaration(manyScopes.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("p", vartok->str());

ASSERT_EQUALS("EE", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(true == v.isPointer());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesDeclarationWithIndirection() {

reset();

givenACodeSampleToTokenize pointerToPointer("int** pp;");

bool result = si.isVariableDeclaration(pointerToPointer.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("pp", vartok->str());

ASSERT_EQUALS("int", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(true == v.isPointer());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesDeclarationWithMultipleIndirection() {

reset();

givenACodeSampleToTokenize pointerToPointer("int***** p;");

bool result = si.isVariableDeclaration(pointerToPointer.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("p", vartok->str());

ASSERT_EQUALS("int", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(true == v.isPointer());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesArray() {

reset();

givenACodeSampleToTokenize arr("::std::string v[3];");

bool result = si.isVariableDeclaration(arr.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("v", vartok->str());

ASSERT_EQUALS("string", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(true == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isPointerArray());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesPointerArray() {

reset();

givenACodeSampleToTokenize arr("A *a[5];");

bool result = si.isVariableDeclaration(arr.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("a", vartok->str());

ASSERT_EQUALS("A", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isPointer());

ASSERT(true == v.isArray());

ASSERT(false == v.isPointerToArray());

ASSERT(true == v.isPointerArray());

ASSERT(false == v.isReference());

}

void test_isVariableDeclarationIdentifiesOfArrayPointers() {

reset();

givenACodeSampleToTokenize arr("A (*a)[5];");

bool result = si.isVariableDeclaration(arr.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("a", vartok->str());

ASSERT_EQUALS("A", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(true == v.isPointer());

ASSERT(false == v.isArray());

ASSERT(true == v.isPointerToArray());

ASSERT(false == v.isPointerArray());

ASSERT(false == v.isReference());

}

void isVariableDeclarationIdentifiesTemplatedPointerVariable() {

reset();

givenACodeSampleToTokenize var("std::set<char>* chars;");

bool result = si.isVariableDeclaration(var.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("chars", vartok->str());

ASSERT_EQUALS("set", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(true == v.isPointer());

ASSERT(false == v.isReference());

}

void isVariableDeclarationIdentifiesTemplatedPointerToPointerVariable() {

reset();

givenACodeSampleToTokenize var("std::deque<int>*** ints;");

bool result = si.isVariableDeclaration(var.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("ints", vartok->str());

ASSERT_EQUALS("deque", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(true == v.isPointer());

ASSERT(false == v.isReference());

}

void isVariableDeclarationIdentifiesTemplatedArrayVariable() {

reset();

givenACodeSampleToTokenize var("std::deque<int> ints[3];");

bool result = si.isVariableDeclaration(var.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("ints", vartok->str());

ASSERT_EQUALS("deque", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(true == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isReference());

}

void isVariableDeclarationIdentifiesTemplatedVariable() {

reset();

givenACodeSampleToTokenize var("std::vector<int> ints;");

bool result = si.isVariableDeclaration(var.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("ints", vartok->str());

ASSERT_EQUALS("vector", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isReference());

}

void isVariableDeclarationIdentifiesTemplatedVariableIterator() {

reset();

givenACodeSampleToTokenize var("std::list<int>::const_iterator floats;");

bool result = si.isVariableDeclaration(var.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("floats", vartok->str());

ASSERT_EQUALS("const_iterator", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isReference());

}

void isVariableDeclarationIdentifiesNestedTemplateVariable() {

reset();

givenACodeSampleToTokenize var("std::deque<std::set<int> > intsets;");

bool result = si.isVariableDeclaration(var.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

ASSERT_EQUALS("intsets", vartok->str());

ASSERT_EQUALS("deque", typetok->str());

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(false == v.isReference());

}

void isVariableDeclarationIdentifiesReference() {

reset();

givenACodeSampleToTokenize var1("int& foo;");

bool result1 = si.isVariableDeclaration(var1.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result1);

Variable v1(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v1.isArray());

ASSERT(false == v1.isPointer());

ASSERT(true == v1.isReference());

reset();

givenACodeSampleToTokenize var2("foo*& bar;");

bool result2 = si.isVariableDeclaration(var2.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result2);

Variable v2(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v2.isArray());

ASSERT(true == v2.isPointer());

ASSERT(true == v2.isReference());

reset();

givenACodeSampleToTokenize var3("std::vector<int>& foo;");

bool result3 = si.isVariableDeclaration(var3.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result3);

Variable v3(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v3.isArray());

ASSERT(false == v3.isPointer());

ASSERT(true == v3.isReference());

}

void isVariableDeclarationDoesNotIdentifyTemplateClass() {

reset();

givenACodeSampleToTokenize var("template <class T> class SomeClass{};");

bool result = si.isVariableDeclaration(var.tokens(), vartok, typetok);

ASSERT_EQUALS(false, result);

}

void isVariableDeclarationDoesNotIdentifyCppCast() {

reset();

givenACodeSampleToTokenize var("reinterpret_cast <char *> (code)[0] = 0;");

bool result = si.isVariableDeclaration(var.tokens(), vartok, typetok);

ASSERT_EQUALS(false, result);

}

void isVariableDeclarationPointerConst() {

reset();

givenACodeSampleToTokenize var("std::string const* s;");

bool result = si.isVariableDeclaration(var.tokens()->next(), vartok, typetok);

ASSERT_EQUALS(true, result);

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(true == v.isPointer());

ASSERT(false == v.isReference());

}

void isVariableDeclarationRValueRef() {

reset();

givenACodeSampleToTokenize var("int&& i;");

bool result = si.isVariableDeclaration(var.tokens(), vartok, typetok);

ASSERT_EQUALS(true, result);

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings.library);

ASSERT(false == v.isArray());

ASSERT(false == v.isPointer());

ASSERT(true == v.isReference());

ASSERT(true == v.isRValueReference());

ASSERT(var.tokens()->tokAt(2)->scope() != 0);

}

void rangeBasedFor() {

GET_SYMBOL_DB("void reset() {\n"

" for(auto& e : array)\n"

" foo(e);\n"

"}");

ASSERT(db != nullptr);

if (!db)

return;

ASSERT(db->scopeList.back().type == Scope::eFor);

ASSERT_EQUALS(2, db->getVariableListSize());

if (db->getVariableListSize() < 2)

return;

const Variable* e = db->getVariableFromVarId(1);

ASSERT(e && e->isReference() && e->isLocal());

}

void isVariableStlType() {

{

reset();

std::istringstream code("std::string s;");

TokenList list(nullptr);

list.createTokens(code, "test.cpp");

bool result = si.isVariableDeclaration(list.front(), vartok, typetok);

ASSERT_EQUALS(true, result);

Variable v(vartok, list.front(), list.back(), 0, Public, 0, 0, &settings.library);

static const std::set<std::string> types = make_container< std::set<std::string> >() <<

"string" << "wstring" ;

static const std::set<std::string> no_types = make_container< std::set<std::string> >() <<

"set" ;

ASSERT_EQUALS(true, v.isStlType());

ASSERT_EQUALS(true, v.isStlType(types));

ASSERT_EQUALS(false, v.isStlType(no_types));

ASSERT_EQUALS(true, v.isStlStringType());

}

{

reset();

std::istringstream code("std::vector<int> v;");

TokenList list(nullptr);

list.createTokens(code, "test.cpp");

list.front()->tokAt(3)->link(list.front()->tokAt(5));

bool result = si.isVariableDeclaration(list.front(), vartok, typetok);

ASSERT_EQUALS(true, result);

Variable v(vartok, list.front(), list.back(), 0, Public, 0, 0, &settings.library);

static const std::set<std::string> types = make_container< std::set<std::string> >() <<

"bitset" << "set" << "vector" << "wstring" ;

static const std::set<std::string> no_types = make_container< std::set<std::string> >() <<

"bitset" << "map" << "set" ;

ASSERT_EQUALS(true, v.isStlType());

ASSERT_EQUALS(true, v.isStlType(types));

ASSERT_EQUALS(false, v.isStlType(no_types));

ASSERT_EQUALS(false, v.isStlStringType());

}

{

reset();

std::istringstream code("SomeClass s;");

TokenList list(nullptr);

list.createTokens(code, "test.cpp");

bool result = si.isVariableDeclaration(list.front(), vartok, typetok);

ASSERT_EQUALS(true, result);

Variable v(vartok, list.front(), list.back(), 0, Public, 0, 0, &settings.library);

static const std::set<std::string> types = make_container< std::set<std::string> >() <<

"bitset" << "set" << "vector" ;

ASSERT_EQUALS(false, v.isStlType());

ASSERT_EQUALS(false, v.isStlType(types));

ASSERT_EQUALS(false, v.isStlStringType());

}

}

void arrayMemberVar1() {

GET_SYMBOL_DB("struct Foo {\n"

" int x;\n"

"};\n"

"void f() {\n"

" struct Foo foo[10];\n"

" foo[1].x = 123;\n" // <- x should get a variable() pointer

"}");

const Token *tok = Token::findsimplematch(tokenizer.tokens(), ". x");

tok = tok ? tok->next() : nullptr;

ASSERT(db != nullptr);

ASSERT(tok && tok->variable() && Token::simpleMatch(tok->variable()->typeStartToken(), "int x ;"));

ASSERT(tok && tok->varId() == 0U); // It's possible to set a varId

}

void arrayMemberVar2() {

GET_SYMBOL_DB("struct Foo {\n"

" int x;\n"

"};\n"

"void f() {\n"

" struct Foo foo[10][10];\n"

" foo[1][2].x = 123;\n" // <- x should get a variable() pointer

"}");

const Token *tok = Token::findsimplematch(tokenizer.tokens(), ". x");

tok = tok ? tok->next() : nullptr;

ASSERT(db != nullptr);

ASSERT(tok && tok->variable() && Token::simpleMatch(tok->variable()->typeStartToken(), "int x ;"));

ASSERT(tok && tok->varId() == 0U); // It's possible to set a varId

}

void arrayMemberVar3() {

GET_SYMBOL_DB("struct Foo {\n"

" int x;\n"

"};\n"

"void f() {\n"

" struct Foo foo[10];\n"

" (foo[1]).x = 123;\n" // <- x should get a variable() pointer

"}");

const Token *tok = Token::findsimplematch(tokenizer.tokens(), ". x");

tok = tok ? tok->next() : nullptr;

ASSERT(db != nullptr);

ASSERT(tok && tok->variable() && Token::simpleMatch(tok->variable()->typeStartToken(), "int x ;"));

ASSERT(tok && tok->varId() == 0U); // It's possible to set a varId

}

void staticMemberVar() {

GET_SYMBOL_DB("class Foo {\n"

" static const double d;\n"

"};\n"

"const double Foo::d = 5.0;");

const Variable* v = db->getVariableFromVarId(1);

ASSERT(v && db->getVariableListSize() == 2);

ASSERT(v && v->isStatic() && v->isConst() && v->isPrivate());

}

void getVariableFromVarIdBoundsCheck() {

GET_SYMBOL_DB("int x;\n"

"int y;\n");

const Variable* v = db->getVariableFromVarId(2);

// three elements: varId 0 also counts via a fake-entry

ASSERT(v && db->getVariableListSize() == 3);

ASSERT_THROW(db->getVariableFromVarId(3), std::out_of_range);

}

void hasRegularFunction() {

GET_SYMBOL_DB("void func() { }\n")

// 2 scopes: Global and Function

ASSERT(db && db->scopeList.size() == 2);

if (db) {

const Scope *scope = findFunctionScopeByToken(db, tokenizer.tokens()->next());

ASSERT(scope && scope->className == "func");

if (!scope)

return;

ASSERT(scope->functionOf == 0);

const Function *function = findFunctionByName("func", &db->scopeList.front());

ASSERT(function && function->token->str() == "func");

ASSERT(function && function->token == tokenizer.tokens()->next());

ASSERT(function && function->hasBody());

ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn != scope);

ASSERT(function && function->retDef == tokenizer.tokens());

}

}

void hasRegularFunction_trailingReturnType() {

GET_SYMBOL_DB("auto func() -> int { }")

// 2 scopes: Global and Function

ASSERT(db && db->scopeList.size() == 2);

if (db) {

const Scope *scope = findFunctionScopeByToken(db, tokenizer.tokens()->next());

ASSERT(scope && scope->className == "func");

if (!scope)

return;

ASSERT(scope->functionOf == 0);

const Function *function = findFunctionByName("func", &db->scopeList.front());

ASSERT(function && function->token->str() == "func");

ASSERT(function && function->token == tokenizer.tokens()->next());

ASSERT(function && function->hasBody());

ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn != scope);

ASSERT(function && function->retDef == tokenizer.tokens()->tokAt(5));

}

}

void hasInlineClassFunction() {

GET_SYMBOL_DB("class Fred { void func() { } };\n")

// 3 scopes: Global, Class, and Function

ASSERT(db && db->scopeList.size() == 3);

if (db) {

const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");

const Scope *scope = findFunctionScopeByToken(db, functionToken);

ASSERT(scope && scope->className == "func");

if (!scope)

return;

ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));

const Function *function = findFunctionByName("func", &db->scopeList.back());

ASSERT(function && function->token->str() == "func");

ASSERT(function && function->token == functionToken);

ASSERT(function && function->hasBody() && function->isInline());

ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn == db->findScopeByName("Fred"));

ASSERT(function && function->retDef == functionToken->previous());

ASSERT(db && db->findScopeByName("Fred") && db->findScopeByName("Fred")->definedType->getFunction("func") == function);

}

}

void hasInlineClassFunction_trailingReturnType() {

GET_SYMBOL_DB("class Fred { auto func() -> int { } };")

// 3 scopes: Global, Class, and Function

ASSERT(db && db->scopeList.size() == 3);

if (db) {

const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");

const Scope *scope = findFunctionScopeByToken(db, functionToken);

ASSERT(scope && scope->className == "func");

if (!scope)

return;

ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));

const Function *function = findFunctionByName("func", &db->scopeList.back());

ASSERT(function && function->token->str() == "func");

ASSERT(function && function->token == functionToken);

ASSERT(function && function->hasBody() && function->isInline());

ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn == db->findScopeByName("Fred"));

ASSERT(function && function->retDef == functionToken->tokAt(4));

ASSERT(db && db->findScopeByName("Fred") && db->findScopeByName("Fred")->definedType->getFunction("func") == function);

}

}

void hasMissingInlineClassFunction() {

GET_SYMBOL_DB("class Fred { void func(); };\n")

// 2 scopes: Global and Class (no Function scope because there is no function implementation)

ASSERT(db && db->scopeList.size() == 2);

if (db) {

const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");

const Scope *scope = findFunctionScopeByToken(db, functionToken);

ASSERT(scope == nullptr);

const Function *function = findFunctionByName("func", &db->scopeList.back());

ASSERT(function && function->token->str() == "func");

ASSERT(function && function->token == functionToken);

ASSERT(function && !function->hasBody());

}

}

void hasClassFunction() {

GET_SYMBOL_DB("class Fred { void func(); }; void Fred::func() { }\n")

// 3 scopes: Global, Class, and Function

ASSERT(db && db->scopeList.size() == 3);

if (db) {

const Token * const functionToken = Token::findsimplematch(tokenizer.tokens()->linkAt(2), "func");

const Scope *scope = findFunctionScopeByToken(db, functionToken);

ASSERT(scope && scope->className == "func");

if (!scope)