/*

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

* Copyright (C) 2007-2014 Daniel Marjamäki and 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 <sstream>

#define GET_SYMBOL_DB(code) \

errout.str(""); \

Settings settings; \

Tokenizer tokenizer(&settings, this); \

std::istringstream istr(code); \

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

const SymbolDatabase *db = tokenizer.getSymbolDatabase();

#define GET_SYMBOL_DB_C(code) \

errout.str(""); \

Settings settings; \

Tokenizer tokenizer(&settings, this); \

std::istringstream istr(code); \

tokenizer.tokenize(istr, "test.c"); \

const SymbolDatabase *db = tokenizer.getSymbolDatabase();

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;

void reset() {

vartok = nullptr;

typetok = nullptr;

t = nullptr;

found = false;

}

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 std::string& 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() {

TEST_CASE(array);

TEST_CASE(test_isVariableDeclarationCanHandleNull);

TEST_CASE(test_isVariableDeclarationIdentifiesSimpleDeclaration);

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_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(isVariableDeclarationPointerConst);

TEST_CASE(isVariableDeclarationRValueRef);

TEST_CASE(isVariableStlType);

TEST_CASE(arrayMemberVar1);

TEST_CASE(arrayMemberVar2);

TEST_CASE(arrayMemberVar3);

TEST_CASE(staticMemberVar);

TEST_CASE(hasRegularFunction);

TEST_CASE(hasInlineClassFunction);

TEST_CASE(hasMissingInlineClassFunction);

TEST_CASE(hasClassFunction);

TEST_CASE(hasRegularFunctionReturningFunctionPointer);

TEST_CASE(hasInlineClassFunctionReturningFunctionPointer);

TEST_CASE(hasMissingInlineClassFunctionReturningFunctionPointer);

TEST_CASE(hasClassFunctionReturningFunctionPointer);

TEST_CASE(hasSubClassConstructor);

TEST_CASE(testConstructors);

TEST_CASE(functionDeclarationTemplate);

TEST_CASE(functionDeclarations);

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

TEST_CASE(functionArgs2);

TEST_CASE(functionArgs3);

TEST_CASE(functionArgs4);

TEST_CASE(namespaces1);

TEST_CASE(namespaces2);

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

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

TEST_CASE(garbage);

TEST_CASE(findFunction1);

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

}

void array() const {

std::istringstream code("int a[10+2];");

TokenList list(nullptr);

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

list.front()->tokAt(2)->link(list.front()->tokAt(6));

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

ASSERT(v.isArray());

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

ASSERT_EQUALS(0U, 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);

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 isVariableDeclarationPointerConst() {

reset();

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

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

ASSERT_EQUALS(true, result);

Variable v(vartok, typetok, vartok->previous(), 0, Public, 0, 0);

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

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

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

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

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

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

}

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

const char* types[] = { "string", "wstring" };

const char* no_types[] = { "set" };

ASSERT_EQUALS(true, v.isStlType());

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

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

}

{

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

const char* types[] = { "bitset", "set", "vector", "wstring" };

const char* no_types[] = { "bitset", "map", "set" };

ASSERT_EQUALS(true, v.isStlType());

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

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

}

{

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

const char* types[] = { "bitset", "set", "vector" };

ASSERT_EQUALS(false, v.isStlType());

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

}

}

void arrayMemberVar1() {

const char code[] = "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

"}";

Settings settings;

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

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

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

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

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

}

void arrayMemberVar2() {

const char code[] = "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

"}";

Settings settings;

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

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

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

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

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

}

void arrayMemberVar3() {

const char code[] = "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

"}";

Settings settings;

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

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

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

ASSERT(tok && tok->variable() && Token::Match(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 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");

ASSERT(scope && 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 hasInlineClassFunction() {

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

// 3 scopes: Global, Class, and Function

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

if (db) {

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

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

ASSERT(scope && 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 == tokenizer.tokens()->tokAt(4));

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

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

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

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 Scope *scope = findFunctionScopeByToken(db, tokenizer.tokens()->tokAt(4));

ASSERT(scope == nullptr);

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

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

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

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

}

}

void hasClassFunction() {

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

// 3 scopes: Global, Class, and Function

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

if (db) {

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

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

ASSERT(scope && 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 == tokenizer.tokens()->tokAt(12));

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

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

}

}

void hasRegularFunctionReturningFunctionPointer() {

GET_SYMBOL_DB("void (*func(int f))(char) { }\n")

// 2 scopes: Global and Function

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

if (db) {

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

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

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

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

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

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

}

}

void hasInlineClassFunctionReturningFunctionPointer() {

GET_SYMBOL_DB("class Fred { void (*func(int f))(char) { } };\n")

// 3 scopes: Global, Class, and Function

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

if (db) {

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

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

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

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

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

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

}

}

void hasMissingInlineClassFunctionReturningFunctionPointer() {

GET_SYMBOL_DB("class Fred { void (*func(int f))(char); };\n")

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

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

if (db) {

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

ASSERT(scope == nullptr);

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

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

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

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

}

}

void hasClassFunctionReturningFunctionPointer() {

GET_SYMBOL_DB("class Fred { void (*func(int f))(char); }; void (*Fred::func(int f))(char) { }\n")

// 3 scopes: Global, Class, and Function

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

if (db) {

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

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

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

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

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

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

}

}

void hasSubClassConstructor() {

GET_SYMBOL_DB("class Foo { class Sub; }; class Foo::Sub { Sub() {} };");

ASSERT(db != nullptr);

if (db) {

bool seen_something = false;

for (std::list<Scope>::const_iterator scope = db->scopeList.begin(); scope != db->scopeList.end(); ++scope) {

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

ASSERT_EQUALS("Sub", func->token->str());

ASSERT_EQUALS(true, func->hasBody);

ASSERT_EQUALS(Function::eConstructor, func->type);

seen_something = true;

}

}

ASSERT_EQUALS(true, seen_something);

}

}

void testConstructors() {

{

GET_SYMBOL_DB("class Foo { Foo(Foo f); };");

const Function* ctor = tokenizer.tokens()->tokAt(3)->function();

ASSERT(db && ctor && ctor->type == Function::eConstructor && !ctor->isExplicit);

ASSERT(ctor && ctor->retDef == 0);

}

{

GET_SYMBOL_DB("class Foo { explicit Foo(Foo f); };");

const Function* ctor = tokenizer.tokens()->tokAt(4)->function();

ASSERT(db && ctor && ctor->type == Function::eConstructor && ctor->isExplicit);

ASSERT(ctor && ctor->retDef == 0);

}

{

GET_SYMBOL_DB("class Foo { Foo(Foo& f); };");

const Function* ctor = tokenizer.tokens()->tokAt(3)->function();

ASSERT(db && ctor && ctor->type == Function::eCopyConstructor);

ASSERT(ctor && ctor->retDef == 0);

}

{

GET_SYMBOL_DB("class Foo { Foo(Foo&& f); };");

const Function* ctor = tokenizer.tokens()->tokAt(3)->function();

ASSERT(db && ctor && ctor->type == Function::eMoveConstructor);

ASSERT(ctor && ctor->retDef == 0);

}

}

void functionDeclarationTemplate() {

GET_SYMBOL_DB("std::map<int, string> foo() {}")

// 2 scopes: Global and Function

ASSERT(db && db->scopeList.size() == 2 && findFunctionByName("foo", &db->scopeList.back()));

if (db) {

const Scope *scope = &db->scopeList.front();

ASSERT(scope && scope->functionList.size() == 1);

const Function *foo = &scope->functionList.front();

ASSERT(foo && foo->token->str() == "foo");

ASSERT(foo && foo->hasBody);

}

}

void functionDeclarations() {

GET_SYMBOL_DB("void foo();\nvoid foo();\nint foo(int i);\nvoid foo() {}")

// 2 scopes: Global and Function

ASSERT(db && db->scopeList.size() == 2 && findFunctionByName("foo", &db->scopeList.back()));

if (db) {

const Scope *scope = &db->scopeList.front();

ASSERT(scope && scope->functionList.size() == 2);

const Function *foo = &scope->functionList.front();

const Function *foo_int = &scope->functionList.back();

ASSERT(foo && foo->token->str() == "foo");

ASSERT(foo && foo->hasBody);

ASSERT(foo && foo->token->strAt(2) == ")");

ASSERT(foo_int && !foo_int->token);

ASSERT(foo_int && foo_int->tokenDef->str() == "foo");

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

ASSERT(foo_int && foo_int->tokenDef->strAt(2) == "int");

ASSERT(&foo_int->argumentList.front() == db->getVariableFromVarId(1));

}

}

void classWithFriend() {

GET_SYMBOL_DB("class Foo {}; class Bar1 { friend class Foo; }; class Bar2 { friend Foo; };")

// 3 scopes: Global, 3 classes

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

if (db) {

const Scope* foo = db->findScopeByName("Foo");

ASSERT(foo != nullptr);

const Scope* bar1 = db->findScopeByName("Bar1");

ASSERT(bar1 != nullptr);

const Scope* bar2 = db->findScopeByName("Bar2");

ASSERT(bar2 != nullptr);

if (foo && bar1 && bar2) {

ASSERT(bar1->definedType->friendList.size() == 1 && bar1->definedType->friendList.front().name == "Foo" && bar1->definedType->friendList.front().type == foo->definedType);

ASSERT(bar2->definedType->friendList.size() == 1 && bar2->definedType->friendList.front().name == "Foo" && bar2->definedType->friendList.front().type == foo->definedType);

}

}

}

void parseFunctionCorrect() {

// ticket 3188 - "if" statement parsed as function

GET_SYMBOL_DB("void func(i) int i; { if (i == 1) return; }\n")

ASSERT(db != nullptr);

// 3 scopes: Global, function, if

ASSERT_EQUALS(3, db->scopeList.size());

ASSERT(findFunctionByName("func", &db->scopeList.back()) != nullptr);

ASSERT(findFunctionByName("if", &db->scopeList.back()) == nullptr);

}

void parseFunctionDeclarationCorrect() {

GET_SYMBOL_DB("void func();\n"

"int bar() {}\n"

"void func() {}")

ASSERT_EQUALS(3, db->findScopeByName("func")->classStart->linenr());

}

void Cpp11InitInInitList() {

GET_SYMBOL_DB("class Foo {\n"

" std::vector<std::string> bar;\n"

" Foo() : bar({\"a\", \"b\"})\n"

" {}\n"

"};");

ASSERT_EQUALS(4, db->scopeList.front().nestedList.front()->nestedList.front()->classStart->linenr());

}

void hasGlobalVariables1() {

GET_SYMBOL_DB("int i;\n")

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

if (db && db->scopeList.size() == 1) {

std::list<Scope>::const_iterator it = db->scopeList.begin();

ASSERT(it->varlist.size() == 1);

if (it->varlist.size() == 1) {

std::list<Variable>::const_iterator var = it->varlist.begin();

ASSERT(var->name() == "i");

ASSERT(var->typeStartToken()->str() == "int");

}

}

}

void hasGlobalVariables2() {

GET_SYMBOL_DB("int array[2][2];\n")

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

if (db && db->scopeList.size() == 1) {

std::list<Scope>::const_iterator it = db->scopeList.begin();

ASSERT(it->varlist.size() == 1);

if (it->varlist.size() == 1) {

std::list<Variable>::const_iterator var = it->varlist.begin();

ASSERT(var->name() == "array");

ASSERT(var->typeStartToken()->str() == "int");