TestSymbolDatabase()

:TestFixture("TestSymbolDatabase")

,nullScope(nullptr, nullptr, nullptr)

,vartok(nullptr)

,typetok(nullptr) {

}

const Scope nullScope;

const Token* vartok;

const Token* typetok;

Settings settings1;

Settings settings2;

void reset() {

vartok = nullptr;

typetok = nullptr;

}

const static 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() override {

LOAD_LIB_2(settings1.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(VariableValueType1);

TEST_CASE(VariableValueType2);

TEST_CASE(VariableValueType3);

TEST_CASE(findVariableType1);

TEST_CASE(findVariableType2);

TEST_CASE(findVariableType3);

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

TEST_CASE(hasClassFunctionReturningFunctionPointer);

TEST_CASE(methodWithRedundantScope);

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

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

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(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(symboldatabase55); // #7767 (return unknown macro)

TEST_CASE(symboldatabase56); // #7909

TEST_CASE(symboldatabase57);

TEST_CASE(symboldatabase58); // #6985 (using namespace type lookup)

TEST_CASE(symboldatabase59);

TEST_CASE(symboldatabase60);

TEST_CASE(symboldatabase61);

TEST_CASE(symboldatabase62);

TEST_CASE(symboldatabase63);

TEST_CASE(symboldatabase64);

TEST_CASE(symboldatabase65);

TEST_CASE(symboldatabase66); // #8540

TEST_CASE(symboldatabase67); // #8538

TEST_CASE(symboldatabase68); // #8560

TEST_CASE(symboldatabase69);

TEST_CASE(symboldatabase70);

TEST_CASE(symboldatabase71);

TEST_CASE(symboldatabase72); // #8600

TEST_CASE(symboldatabase73); // #8603

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(isFunction1); // UNKNOWN_MACRO(a,b) { .. }

TEST_CASE(isFunction2);

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

TEST_CASE(findFunction13);

TEST_CASE(findFunction14);

TEST_CASE(findFunction15);

TEST_CASE(findFunction16);

TEST_CASE(findFunction17);

TEST_CASE(findFunction18);

TEST_CASE(findFunction19);

TEST_CASE(findFunction20); // #8280

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

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

TEST_CASE(noReturnType);

TEST_CASE(auto1);

TEST_CASE(auto2);

TEST_CASE(auto3);

TEST_CASE(auto4);

TEST_CASE(auto5);

TEST_CASE(auto6); // #7963 (segmentation fault)

TEST_CASE(auto7);

TEST_CASE(auto8);

TEST_CASE(auto9); // #8044 (segmentation fault)

TEST_CASE(auto10); // #8020

TEST_CASE(unionWithConstructor);

TEST_CASE(using1);

TEST_CASE(using2); // #8331 (segmentation fault)

TEST_CASE(using3); // #8343 (segmentation fault)

}

void array() {

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

ASSERT(db != nullptr);

if (!db)

return;

ASSERT(db->variableList().size() == 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, &settings1);

ASSERT(v.isArray());

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

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

}

void test_isVariableDeclarationCanHandleNull() {

reset();

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

ASSERT_EQUALS(false, result);

ASSERT(nullptr == vartok);

ASSERT(nullptr == typetok);

Variable v(nullptr, nullptr, nullptr, 0, Public, 0, 0, &settings1);

}

void test_isVariableDeclarationIdentifiesSimpleDeclaration() {

reset();

givenACodeSampleToTokenize simpleDeclaration("int x;");

bool result = nullScope.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, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesInitialization() {

reset();

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

bool result = nullScope.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, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesCpp11Initialization() {

reset();

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

bool result = nullScope.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, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesScopedDeclaration() {

reset();

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

bool result = nullScope.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, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesStdDeclaration() {

reset();

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

bool result = nullScope.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, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesScopedStdDeclaration() {

reset();

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

bool result = nullScope.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, &settings1);

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 = nullScope.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, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesPointers() {

reset();

givenACodeSampleToTokenize pointer("int* p;");

bool result1 = nullScope.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, &settings1);

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, &settings1);

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

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

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

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

reset();

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

bool result2 = nullScope.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, &settings1);

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 = nullScope.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 = nullScope.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, &settings1);

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 = nullScope.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, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesDeclarationWithIndirection() {

reset();

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

bool result = nullScope.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, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesDeclarationWithMultipleIndirection() {

reset();

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

bool result = nullScope.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, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesArray() {

reset();

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

bool result = nullScope.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, &settings1);

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 = nullScope.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, &settings1);

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 = nullScope.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, &settings1);

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 = nullScope.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, &settings1);

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

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

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

}

void isVariableDeclarationIdentifiesTemplatedPointerToPointerVariable() {

reset();

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

bool result = nullScope.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, &settings1);

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

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

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

}

void isVariableDeclarationIdentifiesTemplatedArrayVariable() {

reset();

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

bool result = nullScope.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, &settings1);

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

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

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

}

void isVariableDeclarationIdentifiesTemplatedVariable() {

reset();

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

bool result = nullScope.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, &settings1);

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 = nullScope.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, &settings1);

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 = nullScope.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, &settings1);

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

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

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

}

void isVariableDeclarationIdentifiesReference() {

reset();

givenACodeSampleToTokenize var1("int& foo;");

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

ASSERT_EQUALS(true, result1);

Variable v1(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings1);

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

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

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

reset();

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

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

ASSERT_EQUALS(true, result2);

Variable v2(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings1);

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

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

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

reset();

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

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

ASSERT_EQUALS(true, result3);

Variable v3(vartok, typetok, vartok->previous(), 0, Public, 0, 0, &settings1);

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

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

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

}

void isVariableDeclarationDoesNotIdentifyTemplateClass() {

reset();

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

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

ASSERT_EQUALS(false, result);

}

void isVariableDeclarationDoesNotIdentifyCppCast() {

reset();

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

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

ASSERT_EQUALS(false, result);

}

void isVariableDeclarationPointerConst() {

reset();

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

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

ASSERT_EQUALS(true, result);

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

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

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

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

}

void isVariableDeclarationRValueRef() {

reset();

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

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

ASSERT_EQUALS(true, result);

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

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

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

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

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

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

}

void VariableValueType1() {

GET_SYMBOL_DB("typedef uint8_t u8;\n"

"static u8 x;\n");

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

ASSERT_EQUALS("x", x->name());

ASSERT(x->valueType()->isIntegral());

}

void VariableValueType2() {

GET_SYMBOL_DB("using u8 = uint8_t;\n"

"static u8 x;\n");

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

ASSERT_EQUALS("x", x->name());

ASSERT(x->valueType()->isIntegral());

}

void VariableValueType3() {

GET_SYMBOL_DB("void f(std::string::size_type x);\n");

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

ASSERT_EQUALS("x", x->name());

// TODO: Configure std::string::size_type somehow.

TODO_ASSERT_EQUALS(ValueType::Type::LONGLONG, ValueType::Type::UNKNOWN_TYPE, x->valueType()->type);

}

void findVariableType1() {

GET_SYMBOL_DB("class A {\n"

"public:\n"

" struct B {};\n"

" void f();\n"

"};\n"

"\n"

"void f()\n"

"{\n"

" struct A::B b;\n"

" b.x = 1;\n"

"}");

ASSERT(db != nullptr);

if (!db)

return;

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

ASSERT_EQUALS("b", bvar->name());

ASSERT(bvar->type() != nullptr);

}

void findVariableType2() {

GET_SYMBOL_DB("class A {\n"

"public:\n"

" class B {\n"

" public:\n"

" struct C {\n"

" int x;\n"

" int y;\n"

" };\n"

" };\n"

"\n"

" void f();\n"

"};\n"

"\n"

"void A::f()\n"

"{\n"

" struct B::C c;\n"

" c.x = 1;\n"

"}");

ASSERT(db != nullptr);

if (!db)

return;

const Variable* cvar = db->getVariableFromVarId(3);

ASSERT_EQUALS("c", cvar->name());

ASSERT(cvar->type() != nullptr);

}

void findVariableType3() {

GET_SYMBOL_DB("namespace {\n"

" struct A {\n"

" int x;\n"

" int y;\n"

" };\n"

"}\n"

"\n"

"void f()\n"

"{\n"

" struct A a;\n"

" a.x = 1;\n"

"}");

(void)db;

const Variable* avar = Token::findsimplematch(tokenizer.tokens(), "a")->variable();

ASSERT(avar);

ASSERT(avar && avar->type() != nullptr);

}

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->variableList().size());

if (db->variableList().size() < 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 = nullScope.isVariableDeclaration(list.front(), vartok, typetok);

ASSERT_EQUALS(true, result);

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

static const std::set<std::string> types = { "string", "wstring" };

static const std::set<std::string> no_types = { "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 = nullScope.isVariableDeclaration(list.front(), vartok, typetok);

ASSERT_EQUALS(true, result);

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

static const std::set<std::string> types = { "bitset", "set", "vector", "wstring" };

static const std::set<std::string> no_types = { "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 = nullScope.isVariableDeclaration(list.front(), vartok, typetok);

ASSERT_EQUALS(true, result);

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

static const std::set<std::string> types = { "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() == 3U); // 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() == 3U); // 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() == 3U); // 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->variableList().size() == 2);

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