TestSymbolDatabase()

:TestFixture("TestSymbolDatabase")

,si(nullptr, nullptr, nullptr)

,vartok(nullptr)

,typetok(nullptr)

,t(nullptr)

,found(false) {

}

const Scope si;

const Token* vartok;

const Token* typetok;

const Token* t;

bool found;

Settings settings;

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

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

TEST_CASE(arrayMemberVar2);

TEST_CASE(arrayMemberVar3);

TEST_CASE(staticMemberVar);

TEST_CASE(getVariableFromVarIdBoundsCheck);

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

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(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); // ticket #5867

TEST_CASE(lambda); // ticket #5867

}

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, &settings.library);

ASSERT(v.isArray());

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

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

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

}

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

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

}

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.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.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, &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(), 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 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() {

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

Tokenizer tokenizer(&localsettings, this);

std::istringstream istr(code);

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

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

tok = tok ? tok->next() : 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() {

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

Tokenizer tokenizer(&localsettings, this);

std::istringstream istr(code);

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

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

tok = tok ? tok->next() : 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() {

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

Tokenizer tokenizer(&localsettings, this);

std::istringstream istr(code);

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

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

tok = tok ? tok->next() : 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");

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 Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");

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

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

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

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 Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");

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

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

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

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

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

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

}

}

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 Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");

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

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

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

}

}

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 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 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 Token * const functionToken = Token::findsimplematch(tokenizer.tokens()->linkAt(2), "func");

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

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

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

}

}

void complexFunctionArrayPtr() {

GET_SYMBOL_DB("int(*p1)[10]; \n" // pointer to array 10 of int

"void(*p2)(char); \n" // pointer to function (char) returning void

"int(*(*p3)(char))[10];\n" // pointer to function (char) returning pointer to array 10 of int

"float(*(*p4)(char))(long); \n" // pointer to function (char) returning pointer to function (long) returning float

"short(*(*(p5) (char))(long))(double); \n" // pointer to function (char) returning pointer to function (long) returning pointer to function (double) returning short

"int(*a1[10])(void); \n" // array 10 of pointer to function (void) returning int

"float(*(*a2[10])(char))(long);\n" // array 10 of pointer to func (char) returning pointer to func (long) returning float

"short(*(*(*a3[10])(char))(long))(double);\n" // array 10 of pointer to function (char) returning pointer to function (long) returning pointer to function (double) returning short

"::boost::rational(&r_)[9];\n" // reference to array of ::boost::rational

"::boost::rational<T>(&r_)[9];"); // reference to array of ::boost::rational<T> (template!)

ASSERT(db != nullptr);

if (db) {

ASSERT_EQUALS(10, db->getVariableListSize() - 1);

ASSERT_EQUALS(true, db->getVariableFromVarId(1) && db->getVariableFromVarId(1)->dimensions().size() == 1);

ASSERT_EQUALS(true, db->getVariableFromVarId(2) != nullptr);

ASSERT_EQUALS(true, db->getVariableFromVarId(3) && db->getVariableFromVarId(3)->dimensions().size() == 0);

ASSERT_EQUALS(true, db->getVariableFromVarId(4) != nullptr);

ASSERT_EQUALS(true, db->getVariableFromVarId(5) != nullptr);

ASSERT_EQUALS(true, db->getVariableFromVarId(6) && db->getVariableFromVarId(6)->dimensions().size() == 1);

ASSERT_EQUALS(true, db->getVariableFromVarId(7) && db->getVariableFromVarId(7)->dimensions().size() == 1);

ASSERT_EQUALS(true, db->getVariableFromVarId(8) && db->getVariableFromVarId(8)->dimensions().size() == 1);

ASSERT_EQUALS(true, db->getVariableFromVarId(9) && db->getVariableFromVarId(9)->dimensions().size() == 1);

ASSERT_EQUALS(true, db->getVariableFromVarId(10) && db->getVariableFromVarId(10)->dimensions().size() == 1);

ASSERT_EQUALS("", errout.str());

}

}

void pointerToMemberFunction() {

GET_SYMBOL_DB("bool (A::*pFun)();"); // Pointer to member function of A, returning bool and taking no parameters

ASSERT(db != nullptr);

if (db) {

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