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

}

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 (const Function & i : currScope->functionList) {

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

return &i;

}

currScope = currScope->nestedIn;

}

return nullptr;

}

void run() OVERRIDE {

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

settings2.platform(Settings::Unspecified);

TEST_CASE(array);

TEST_CASE(stlarray1);

TEST_CASE(stlarray2);

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

TEST_CASE(isVariableDeclarationIf);

TEST_CASE(isVariableStlType);

TEST_CASE(isVariablePointerToConstPointer);

TEST_CASE(isVariablePointerToVolatilePointer);

TEST_CASE(isVariablePointerToConstVolatilePointer);

TEST_CASE(isVariableMultiplePointersAndQualifiers);

TEST_CASE(variableVolatile);

TEST_CASE(VariableValueType1);

TEST_CASE(VariableValueType2);

TEST_CASE(VariableValueType3);

TEST_CASE(VariableValueType4); // smart pointer type

TEST_CASE(VariableValueType5); // smart pointer type

TEST_CASE(VariableValueTypeReferences);

TEST_CASE(findVariableType1);

TEST_CASE(findVariableType2);

TEST_CASE(findVariableType3);

TEST_CASE(findVariableTypeExternC);

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(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(functionArgs14); // #9055

TEST_CASE(functionArgs15); // #7159

TEST_CASE(functionArgs16); // #9591

TEST_CASE(functionArgs17);

TEST_CASE(functionImplicitlyVirtual);

TEST_CASE(functionStatic);

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(symboldatabase74); // #8838 - final

TEST_CASE(symboldatabase75);

TEST_CASE(symboldatabase76); // #9056

TEST_CASE(symboldatabase77); // #8663

TEST_CASE(symboldatabase78); // #9147

TEST_CASE(symboldatabase79); // #9392

TEST_CASE(symboldatabase80); // #9389

TEST_CASE(symboldatabase81); // #9411

TEST_CASE(symboldatabase82);

TEST_CASE(symboldatabase83); // #9431

TEST_CASE(symboldatabase84);

TEST_CASE(symboldatabase85);

TEST_CASE(symboldatabase86);

TEST_CASE(symboldatabase87); // #9922 'extern const char ( * x [ 256 ] ) ;'

TEST_CASE(createSymbolDatabaseFindAllScopes1);

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

TEST_CASE(findFunction22);

TEST_CASE(findFunction23);

TEST_CASE(findFunction24); // smart pointer

TEST_CASE(findFunction25); // std::vector<std::shared_ptr<Fred>>

TEST_CASE(findFunction26); // #8668 - pointer parameter in function call, const pointer function argument

TEST_CASE(findFunction27);

TEST_CASE(findFunction28);

TEST_CASE(findFunction29);

TEST_CASE(findFunction30);

TEST_CASE(findFunction31);

TEST_CASE(findFunctionContainer);

TEST_CASE(findFunctionExternC);

TEST_CASE(findFunctionGlobalScope); // ::foo

TEST_CASE(overloadedFunction1);

TEST_CASE(valueTypeMatchParameter); // ValueType::matchParameter

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

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(auto11); // #8964 - const auto startX = x;

TEST_CASE(auto12); // #8993 - const std::string &x; auto y = x; if (y.empty()) ..

TEST_CASE(auto13);

TEST_CASE(auto14);

TEST_CASE(unionWithConstructor);

TEST_CASE(incomplete_type); // #9255 (infinite recursion)

}

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

GET_SYMBOL_DB("std::array<int, 16 + 4> arr;");

ASSERT(db != nullptr);

if (!db)

return;

ASSERT_EQUALS(2, db->variableList().size()); // 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(20U, v->dimension(0));

}

void stlarray2() {

GET_SYMBOL_DB("constexpr int sz = 16; std::array<int, sz + 4> arr;");

ASSERT(db != nullptr);

if (!db)

return;

ASSERT_EQUALS(3, db->variableList().size()); // the first one is not used

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

ASSERT(v != nullptr);

if (!v)

return;

ASSERT(v->isArray());

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

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

}

void test_isVariableDeclarationCanHandleNull() {

reset();

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

ASSERT_EQUALS(false, result);

ASSERT(nullptr == vartok);

ASSERT(nullptr == typetok);

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

}

void test_isVariableDeclarationIdentifiesSimpleDeclaration() {

reset();

givenACodeSampleToTokenize simpleDeclaration("int x;");

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesInitialization() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesCpp11Initialization() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesScopedDeclaration() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesStdDeclaration() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesScopedStdDeclaration() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &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;");

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesPointers() {

reset();

givenACodeSampleToTokenize pointer("int* p;");

const 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, AccessControl::Public, nullptr, nullptr, &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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

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

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &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;");

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

const 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, AccessControl::Public, nullptr, nullptr, &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;");

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesDeclarationWithIndirection() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesDeclarationWithMultipleIndirection() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void test_isVariableDeclarationIdentifiesArray() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &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];");

const 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, AccessControl::Public, nullptr, nullptr, &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];");

const 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, AccessControl::Public, nullptr, nullptr, &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;");

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void isVariableDeclarationIdentifiesTemplatedPointerToPointerVariable() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void isVariableDeclarationIdentifiesTemplatedArrayVariable() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void isVariableDeclarationIdentifiesTemplatedVariable() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void isVariableDeclarationIdentifiesTemplatedVariableIterator() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void isVariableDeclarationIdentifiesNestedTemplateVariable() {

reset();

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

const 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, AccessControl::Public, nullptr, nullptr, &settings1);

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

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

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

}

void isVariableDeclarationIdentifiesReference() {

reset();

givenACodeSampleToTokenize var1("int& foo;");

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

ASSERT_EQUALS(true, result1);

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

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

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

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

reset();

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

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

ASSERT_EQUALS(true, result2);

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

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

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

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

reset();

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

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

ASSERT_EQUALS(true, result3);

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

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

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

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

}

void isVariableDeclarationDoesNotIdentifyTemplateClass() {

reset();

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

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

ASSERT_EQUALS(false, result);

}

void isVariableDeclarationDoesNotIdentifyCppCast() {

reset();

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

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

ASSERT_EQUALS(false, result);

}

void isVariableDeclarationPointerConst() {

reset();

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

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

ASSERT_EQUALS(true, result);

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

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

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

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

}

void isVariableDeclarationRValueRef() {

reset();

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

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

ASSERT_EQUALS(true, result);

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

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

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

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

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

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

}

void isVariableDeclarationDoesNotIdentifyCase() {

GET_SYMBOL_DB_C("a b;\n"

"void f() {\n"

" switch (c) {\n"

" case b:;\n"

" }"

"}");

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

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

ASSERT_EQUALS("a", b->typeStartToken()->str());

}

void isVariableDeclarationIf() {

GET_SYMBOL_DB("void foo() {\n"

" for (auto& elem : items) {\n"

" if (auto x = bar()) { int y = 3; }\n"

" }\n"

"}");

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

ASSERT(x);

ASSERT(x->varId());

ASSERT(x->variable());

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

ASSERT(y);

ASSERT(y->varId());

ASSERT(y->variable());

}

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

// std::string::size_type

{

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

const Variable* const 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_INT, x->valueType()->type);

ASSERT_EQUALS(ValueType::Sign::UNSIGNED, x->valueType()->sign);

}

// std::wstring::size_type

{

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

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

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

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

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

ASSERT_EQUALS(ValueType::Sign::UNSIGNED, x->valueType()->sign);

}

// std::u16string::size_type

{

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

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

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

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

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

ASSERT_EQUALS(ValueType::Sign::UNSIGNED, x->valueType()->sign);

}

// std::u32string::size_type

{

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

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

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

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

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

ASSERT_EQUALS(ValueType::Sign::UNSIGNED, x->valueType()->sign);

}

}

void VariableValueType4() {

GET_SYMBOL_DB("class C {\n"

"public:\n"

" std::shared_ptr<C> x;\n"

"};");

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

ASSERT(x->valueType());

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

}

void VariableValueType5() {

GET_SYMBOL_DB("class C {};\n"

"void foo(std::shared_ptr<C>* p) {}\n");

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

ASSERT(p->valueType());

ASSERT(p->valueType()->smartPointerTypeToken);

ASSERT(p->valueType()->pointer == 1);

}

void VariableValueTypeReferences() {

{

GET_SYMBOL_DB("void foo(int x) {}\n");

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

ASSERT(p->valueType());

ASSERT(p->valueType()->pointer == 0);

ASSERT(p->valueType()->constness == 0);

ASSERT(p->valueType()->reference == Reference::None);

}

{

GET_SYMBOL_DB("void foo(int* x) {}\n");

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

ASSERT(p->valueType());

ASSERT(p->valueType()->pointer == 1);

ASSERT(p->valueType()->constness == 0);

ASSERT(p->valueType()->reference == Reference::None);

}

{

GET_SYMBOL_DB("void foo(int& x) {}\n");

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

ASSERT(p->valueType());

ASSERT(p->valueType()->pointer == 0);

ASSERT(p->valueType()->constness == 0);

ASSERT(p->valueType()->reference == Reference::LValue);

}

{

GET_SYMBOL_DB("void foo(int&& x) {}\n");