/*

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

* Copyright (C) 2007-2024 Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include "errortypes.h"

#include "fixture.h"

#include "helpers.h"

#include "platform.h"

#include "settings.h"

#include "sourcelocation.h"

#include "symboldatabase.h"

#include "token.h"

#include "tokenize.h"

#include "tokenlist.h"

#include <algorithm>

#include <cstdint>

#include <cstring>

#include <iterator>

#include <limits>

#include <list>

#include <set>

#include <sstream>

#include <stdexcept>

#include <string>

#include <vector>

class TestSymbolDatabase;

#define GET_SYMBOL_DB(code) \

SimpleTokenizer tokenizer(settings1, *this); \

const SymbolDatabase *db = getSymbolDB_inner(tokenizer, code, true); \

ASSERT(db); \

do {} while (false)

#define GET_SYMBOL_DB_C(code) \

SimpleTokenizer tokenizer(settings1, *this); \

const SymbolDatabase *db = getSymbolDB_inner(tokenizer, code, false); \

do {} while (false)

#define GET_SYMBOL_DB_DBG(code) \

SimpleTokenizer tokenizer(settingsDbg, *this); \

const SymbolDatabase *db = getSymbolDB_inner(tokenizer, code, true); \

ASSERT(db); \

do {} while (false)

class TestSymbolDatabase : public TestFixture {

public:

TestSymbolDatabase() : TestFixture("TestSymbolDatabase") {}

private:

const Token* vartok{nullptr};

const Token* typetok{nullptr};

const Settings settings1 = settingsBuilder().library("std.cfg").build();

const Settings settings2 = settingsBuilder().platform(Platform::Type::Unspecified).build();

const Settings settingsDbg = settingsBuilder().library("std.cfg").debugwarnings(true).build();

void reset() {

vartok = nullptr;

typetok = nullptr;

}

template<size_t size>

static const SymbolDatabase* getSymbolDB_inner(SimpleTokenizer& tokenizer, const char (&code)[size], bool cpp) {

return tokenizer.tokenize(code, cpp) ? tokenizer.getSymbolDatabase() : nullptr;

}

static const Token* findToken(Tokenizer& tokenizer, const std::string& expr, unsigned int exprline)

{

for (const Token* tok = tokenizer.tokens(); tok; tok = tok->next()) {

if (Token::simpleMatch(tok, expr.c_str(), expr.size()) && tok->linenr() == exprline) {

return tok;

}

}

return nullptr;

}

static std::string asExprIdString(const Token* tok)

{

return tok->expressionString() + "@" + std::to_string(tok->exprId());

}

template<size_t size>

std::string testExprIdEqual(const char (&code)[size],

const std::string& expr1,

unsigned int exprline1,

const std::string& expr2,

unsigned int exprline2,

SourceLocation loc = SourceLocation::current())

{

SimpleTokenizer tokenizer(settings1, *this);

ASSERT_LOC(tokenizer.tokenize(code), loc.file_name(), loc.line());

const Token* tok1 = findToken(tokenizer, expr1, exprline1);

const Token* tok2 = findToken(tokenizer, expr2, exprline2);

if (!tok1)

return "'" + expr1 + "'" + " not found";

if (!tok2)

return "'" + expr2 + "'" + " not found";

if (tok1->exprId() == 0)

return asExprIdString(tok1) + " has not exprId";

if (tok2->exprId() == 0)

return asExprIdString(tok2) + " has not exprId";

if (tok1->exprId() != tok2->exprId())

return asExprIdString(tok1) + " != " + asExprIdString(tok2);

return "";

}

template<size_t size>

bool testExprIdNotEqual(const char (&code)[size],

const std::string& expr1,

unsigned int exprline1,

const std::string& expr2,

unsigned int exprline2,

SourceLocation loc = SourceLocation::current())

{

std::string result = testExprIdEqual(code, expr1, exprline1, expr2, exprline2, loc);

return !result.empty();

}

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

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

for (scope = db->scopeList.cbegin(); scope != db->scopeList.cend(); ++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) {

auto it = std::find_if(currScope->functionList.cbegin(), currScope->functionList.cend(), [&](const Function& f) {

return f.tokenDef->str() == str;

});

if (it != currScope->functionList.end())

return &*it;

currScope = currScope->nestedIn;

}

return nullptr;

}

void run() override {

TEST_CASE(array);

TEST_CASE(array_ptr);

TEST_CASE(stlarray1);

TEST_CASE(stlarray2);

TEST_CASE(stlarray3);

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

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

TEST_CASE(test_isVariableDeclarationIdentifiesOfArrayPointers2);

TEST_CASE(test_isVariableDeclarationIdentifiesOfArrayPointers3);

TEST_CASE(test_isVariableDeclarationIdentifiesArrayOfFunctionPointers);

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

TEST_CASE(isVariableDecltype);

TEST_CASE(isVariableAlignas);

TEST_CASE(VariableValueType1);

TEST_CASE(VariableValueType2);

TEST_CASE(VariableValueType3);

TEST_CASE(VariableValueType4); // smart pointer type

TEST_CASE(VariableValueType5); // smart pointer type

TEST_CASE(VariableValueType6); // smart pointer type

TEST_CASE(VariableValueTypeReferences);

TEST_CASE(VariableValueTypeTemplate);

TEST_CASE(findVariableType1);

TEST_CASE(findVariableType2);

TEST_CASE(findVariableType3);

TEST_CASE(findVariableTypeExternC);

TEST_CASE(rangeBasedFor);

TEST_CASE(memberVar1);

TEST_CASE(arrayMemberVar1);

TEST_CASE(arrayMemberVar2);

TEST_CASE(arrayMemberVar3);

TEST_CASE(arrayMemberVar4);

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

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

TEST_CASE(constexprFunction);

TEST_CASE(constructorInitialization);

TEST_CASE(memberFunctionOfUnknownClassMacro1);

TEST_CASE(memberFunctionOfUnknownClassMacro2);

TEST_CASE(memberFunctionOfUnknownClassMacro3);

TEST_CASE(functionLinkage);

TEST_CASE(externalFunctionsInsideAFunction); // #12420

TEST_CASE(namespacedFunctionInsideExternBlock); // #12420

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(functionArgs18); // #10376

TEST_CASE(functionArgs19); // #10376

TEST_CASE(functionArgs20);

TEST_CASE(functionArgs21);

TEST_CASE(functionImplicitlyVirtual);

TEST_CASE(functionGetOverridden);

TEST_CASE(functionIsInlineKeyword);

TEST_CASE(functionStatic);

TEST_CASE(functionReturnsReference); // Function::returnsReference

TEST_CASE(namespaces1);

TEST_CASE(namespaces2);

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

TEST_CASE(namespaces4);

TEST_CASE(needInitialization);

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(symboldatabase88); // #10040 (using namespace)

TEST_CASE(symboldatabase89); // valuetype name

TEST_CASE(symboldatabase90);

TEST_CASE(symboldatabase91);

TEST_CASE(symboldatabase92); // daca crash

TEST_CASE(symboldatabase93); // alignas attribute

TEST_CASE(symboldatabase94); // structured bindings

TEST_CASE(symboldatabase95); // #10295

TEST_CASE(symboldatabase96); // #10126

TEST_CASE(symboldatabase97); // #10598 - final class

TEST_CASE(symboldatabase98); // #10451

TEST_CASE(symboldatabase99); // #10864

TEST_CASE(symboldatabase100); // #10174

TEST_CASE(symboldatabase101);

TEST_CASE(symboldatabase102);

TEST_CASE(symboldatabase103);

TEST_CASE(symboldatabase104);

TEST_CASE(symboldatabase105);

TEST_CASE(symboldatabase106);

TEST_CASE(createSymbolDatabaseFindAllScopes1);

TEST_CASE(createSymbolDatabaseFindAllScopes2);

TEST_CASE(createSymbolDatabaseFindAllScopes3);

TEST_CASE(createSymbolDatabaseFindAllScopes4);

TEST_CASE(createSymbolDatabaseFindAllScopes5);

TEST_CASE(createSymbolDatabaseFindAllScopes6);

TEST_CASE(createSymbolDatabaseFindAllScopes7);

TEST_CASE(createSymbolDatabaseFindAllScopes8); // #12761

TEST_CASE(createSymbolDatabaseFindAllScopes9);

TEST_CASE(createSymbolDatabaseIncompleteVars);

TEST_CASE(enum1);

TEST_CASE(enum2);

TEST_CASE(enum3);

TEST_CASE(enum4);

TEST_CASE(enum5);

TEST_CASE(enum6);

TEST_CASE(enum7);

TEST_CASE(enum8);

TEST_CASE(enum9);

TEST_CASE(enum10); // #11001

TEST_CASE(enum11);

TEST_CASE(enum12);

TEST_CASE(enum13);

TEST_CASE(enum14);

TEST_CASE(enum15);

TEST_CASE(enum16);

TEST_CASE(enum17);

TEST_CASE(enum18);

TEST_CASE(sizeOfType);

TEST_CASE(isImplicitlyVirtual);

TEST_CASE(isPure);

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

TEST_CASE(isFunction2);

TEST_CASE(isFunction3);

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(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(findFunction32); // C: relax type matching

TEST_CASE(findFunction33); // #9885 variadic function

TEST_CASE(findFunction34); // #10061

TEST_CASE(findFunction35);

TEST_CASE(findFunction36); // #10122

TEST_CASE(findFunction37); // #10124

TEST_CASE(findFunction38); // #10125

TEST_CASE(findFunction39); // #10127

TEST_CASE(findFunction40); // #10135

TEST_CASE(findFunction41); // #10202

TEST_CASE(findFunction42);

TEST_CASE(findFunction43); // #10087

TEST_CASE(findFunction44); // #11182

TEST_CASE(findFunction45);

TEST_CASE(findFunction46);

TEST_CASE(findFunction47);

TEST_CASE(findFunction48);

TEST_CASE(findFunction49); // #11888

TEST_CASE(findFunction50); // #11904 - method with same name and arguments in derived class

TEST_CASE(findFunction51); // #11975 - method with same name in derived class

TEST_CASE(findFunction52);

TEST_CASE(findFunction53);

TEST_CASE(findFunction54);

TEST_CASE(findFunction55); // #13004

TEST_CASE(findFunction56);

TEST_CASE(findFunctionRef1);

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

TEST_CASE(pureAttributeFunction);

TEST_CASE(nothrowAttributeFunction);

TEST_CASE(nothrowDeclspecFunction);

TEST_CASE(noreturnAttributeFunction);

TEST_CASE(nodiscardAttributeFunction);

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

TEST_CASE(lambda5);

TEST_CASE(circularDependencies); // #6298

TEST_CASE(executableScopeWithUnknownFunction);

TEST_CASE(valueType1);

TEST_CASE(valueType2);

TEST_CASE(valueType3);

TEST_CASE(valueTypeThis);

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(auto15); // C++17 auto deduction from braced-init-list

TEST_CASE(auto16);

TEST_CASE(auto17); // #11163

TEST_CASE(auto18);

TEST_CASE(auto19);

TEST_CASE(auto20);

TEST_CASE(auto21);

TEST_CASE(auto22);

TEST_CASE(unionWithConstructor);

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

TEST_CASE(exprIds);

TEST_CASE(testValuetypeOriginalName);

}

void array() {

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

ASSERT(db != nullptr);

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

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

ASSERT(v != nullptr);

ASSERT(v->isArray());

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

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

}

void array_ptr() {

GET_SYMBOL_DB("const char* a[] = { \"abc\" };\n"

"const char* b[] = { \"def\", \"ghijkl\" };");

ASSERT(db != nullptr);

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

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

ASSERT(v != nullptr);

ASSERT(v->isArray());

ASSERT(v->isPointerArray());

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

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

v = db->getVariableFromVarId(2);

ASSERT(v != nullptr);

ASSERT(v->isArray());

ASSERT(v->isPointerArray());

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

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

}

void stlarray1() {

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

ASSERT(db != nullptr);

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

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

ASSERT(v != nullptr);

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

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

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

ASSERT(v != nullptr);

ASSERT(v->isArray());

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

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

}

void stlarray3() {

GET_SYMBOL_DB("std::array<int, 4> a;\n"

"std::array<int, 4> b[2];\n"

"const std::array<int, 4>& r = a;\n");

ASSERT(db != nullptr);

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

auto it = db->variableList().begin() + 1;

ASSERT((*it)->isArray());

ASSERT(!(*it)->isPointer());

ASSERT(!(*it)->isReference());

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

ASSERT_EQUALS(4U, (*it)->dimension(0));

const ValueType* vt = (*it)->valueType();

ASSERT(vt);

ASSERT(vt->container);

ASSERT_EQUALS(vt->pointer, 0);

const Token* tok = (*it)->nameToken();

ASSERT(tok && (vt = tok->valueType()));

ASSERT_EQUALS(vt->pointer, 0);

++it;

ASSERT((*it)->isArray());

ASSERT(!(*it)->isPointer());

ASSERT(!(*it)->isReference());

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

ASSERT_EQUALS(4U, (*it)->dimension(0));

vt = (*it)->valueType();

ASSERT_EQUALS(vt->pointer, 0);

tok = (*it)->nameToken();

ASSERT(tok && (vt = tok->valueType()));

ASSERT_EQUALS(vt->pointer, 1);

++it;

ASSERT((*it)->isArray());

ASSERT(!(*it)->isPointer());

ASSERT((*it)->isReference());

ASSERT((*it)->isConst());

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

ASSERT_EQUALS(4U, (*it)->dimension(0));

vt = (*it)->valueType();

ASSERT_EQUALS(vt->pointer, 0);

ASSERT(vt->reference == Reference::LValue);

tok = (*it)->nameToken();

ASSERT(tok && (vt = tok->valueType()));

ASSERT_EQUALS(vt->pointer, 0);

ASSERT_EQUALS(vt->constness, 1);

ASSERT(vt->reference == Reference::LValue);

}

void test_isVariableDeclarationCanHandleNull() {

reset();

GET_SYMBOL_DB("void main(){}");

const bool result = db->scopeList.front().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();

GET_SYMBOL_DB("int x;");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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();

GET_SYMBOL_DB("int x (1);");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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();

GET_SYMBOL_DB("int x {1};");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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();

GET_SYMBOL_DB("::int x;");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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();

GET_SYMBOL_DB("std::string x;");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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();

GET_SYMBOL_DB("::std::string x;");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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();

GET_SYMBOL_DB("AA::BB::CC::DD::EE x;");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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();

GET_SYMBOL_DB("int* p;");

const bool result1 = db->scopeList.front().isVariableDeclaration(tokenizer.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();

const SimpleTokenizer constpointer(*this, "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();

GET_SYMBOL_DB("int* const p;");

const bool result2 = db->scopeList.front().isVariableDeclaration(tokenizer.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_isVariableDeclarationIdentifiesPointers2() {

GET_SYMBOL_DB("void slurpInManifest() {\n"

" std::string tmpiostring(*tI);\n"

" if(tmpiostring==\"infoonly\"){}\n"

"}");

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

ASSERT(tok->variable());

ASSERT(!tok->variable()->isPointer());

}

void test_isVariableDeclarationDoesNotIdentifyConstness() {

reset();

GET_SYMBOL_DB("const int* cp;");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);

ASSERT_EQUALS(false, result);

ASSERT(nullptr == vartok);

ASSERT(nullptr == typetok);

}

void test_isVariableDeclarationIdentifiesFirstOfManyVariables() {

reset();

GET_SYMBOL_DB("int first, second;");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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();

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

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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();

GET_SYMBOL_DB("int** pp;");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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();

GET_SYMBOL_DB("int***** p;");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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();

GET_SYMBOL_DB("::std::string v[3];");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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();

GET_SYMBOL_DB("A *a[5];");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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_isVariableDeclarationIdentifiesOfArrayPointers1() {

reset();

GET_SYMBOL_DB("A (*a)[5];");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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 test_isVariableDeclarationIdentifiesOfArrayPointers2() {

reset();

GET_SYMBOL_DB("A (*const a)[5];");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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 test_isVariableDeclarationIdentifiesOfArrayPointers3() {

reset();

GET_SYMBOL_DB("A (** a)[5];");

const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.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());