feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

ClangRefactoring: Adapt project part in the database

Browse Source 
Extend ProjectPartArtefact and use CommandLineBuilder everywhere.

Task-number: QTCREATORBUG-21842
Change-Id: Ibc78849bc543512eccec8a558a1c3f57fec33fa2
Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
This commit is contained in:
Marco Bubke
2019-01-23 14:10:58 +01:00
parent 1c2d41a63e
commit a179030a02
19 changed files with 376 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/libs/clangsupport/refactoringdatabaseinitializer.h
View File

@@ -123,10 +123,13 @@ public:
table.setName("projectParts"); table.setName("projectParts");
table.addColumn("projectPartId", Sqlite::ColumnType::Integer, Sqlite::Contraint::PrimaryKey); table.addColumn("projectPartId", Sqlite::ColumnType::Integer, Sqlite::Contraint::PrimaryKey);
const Sqlite::Column &projectPartNameColumn = table.addColumn("projectPartName", Sqlite::ColumnType::Text); const Sqlite::Column &projectPartNameColumn = table.addColumn("projectPartName", Sqlite::ColumnType::Text);
table.addColumn("compilerArguments", Sqlite::ColumnType::Text); table.addColumn("toolChainArguments", Sqlite::ColumnType::Text);
table.addColumn("compilerMacros", Sqlite::ColumnType::Text); table.addColumn("compilerMacros", Sqlite::ColumnType::Text);
table.addColumn("systemIncludeSearchPaths", Sqlite::ColumnType::Text); table.addColumn("systemIncludeSearchPaths", Sqlite::ColumnType::Text);
table.addColumn("projectIncludeSearchPaths", Sqlite::ColumnType::Text); table.addColumn("projectIncludeSearchPaths", Sqlite::ColumnType::Text);
table.addColumn("language", Sqlite::ColumnType::Integer);
table.addColumn("languageVersion", Sqlite::ColumnType::Integer);
table.addColumn("languageExtension", Sqlite::ColumnType::Integer);
table.addUniqueIndex({projectPartNameColumn}); table.addUniqueIndex({projectPartNameColumn});
table.initialize(database); table.initialize(database);

2
src/libs/utils/cpplanguage_details.h
View File

@@ -37,7 +37,7 @@ enum class LanguageVersion : unsigned char {
C11, C11,
C18, C18,
LatestC = C18, LatestC = C18,
CXX98, CXX98 = 32,
CXX03, CXX03,
CXX11, CXX11,
CXX14, CXX14,

2
src/tools/clangrefactoringbackend/source/projectpartartefact.cpp
View File

@@ -121,7 +121,7 @@ void ProjectPartArtefact::checkError(const char *whatError, const QJsonParseErro
bool operator==(const ProjectPartArtefact &first, const ProjectPartArtefact &second) bool operator==(const ProjectPartArtefact &first, const ProjectPartArtefact &second)
{ {
return first.compilerArguments == second.compilerArguments return first.toolChainArguments == second.toolChainArguments
&& first.compilerMacros == second.compilerMacros && first.compilerMacros == second.compilerMacros
&& first.systemIncludeSearchPaths == second.systemIncludeSearchPaths && first.systemIncludeSearchPaths == second.systemIncludeSearchPaths
&& first.projectIncludeSearchPaths == second.projectIncludeSearchPaths; && first.projectIncludeSearchPaths == second.projectIncludeSearchPaths;

34
src/tools/clangrefactoringbackend/source/projectpartartefact.h
View File

@@ -27,6 +27,7 @@
#include "projectpartartefactexception.h" #include "projectpartartefactexception.h"
#include <utils/cpplanguage_details.h>
#include <utils/smallstringvector.h> #include <utils/smallstringvector.h>
#include <compilermacro.h> #include <compilermacro.h>
@@ -44,12 +45,36 @@ public:
Utils::SmallStringView compilerMacrosText, Utils::SmallStringView compilerMacrosText,
Utils::SmallStringView systemIncludeSearchPathsText, Utils::SmallStringView systemIncludeSearchPathsText,
Utils::SmallStringView projectIncludeSearchPathsText, Utils::SmallStringView projectIncludeSearchPathsText,
int projectPartId) int projectPartId,
: compilerArguments(toStringVector(compilerArgumentsText)) int language,
int languageVersion,
int languageExtension)
: toolChainArguments(toStringVector(compilerArgumentsText))
, compilerMacros(toCompilerMacros(compilerMacrosText)) , compilerMacros(toCompilerMacros(compilerMacrosText))
, systemIncludeSearchPaths(toIncludeSearchPaths(systemIncludeSearchPathsText)) , systemIncludeSearchPaths(toIncludeSearchPaths(systemIncludeSearchPathsText))
, projectIncludeSearchPaths(toIncludeSearchPaths(projectIncludeSearchPathsText)) , projectIncludeSearchPaths(toIncludeSearchPaths(projectIncludeSearchPathsText))
, projectPartId(projectPartId) , projectPartId(projectPartId)
, language(static_cast<Utils::Language>(language))
, languageVersion(static_cast<Utils::LanguageVersion>(languageVersion))
, languageExtension(static_cast<Utils::LanguageExtension>(languageExtension))
{}
ProjectPartArtefact(Utils::SmallStringView compilerArgumentsText,
Utils::SmallStringView compilerMacrosText,
Utils::SmallStringView systemIncludeSearchPathsText,
Utils::SmallStringView projectIncludeSearchPathsText,
int projectPartId,
Utils::Language language,
Utils::LanguageVersion languageVersion,
Utils::LanguageExtension languageExtension)
: toolChainArguments(toStringVector(compilerArgumentsText))
, compilerMacros(toCompilerMacros(compilerMacrosText))
, systemIncludeSearchPaths(toIncludeSearchPaths(systemIncludeSearchPathsText))
, projectIncludeSearchPaths(toIncludeSearchPaths(projectIncludeSearchPathsText))
, projectPartId(projectPartId)
, language(language)
, languageVersion(languageVersion)
, languageExtension(languageExtension)
{} {}
static Utils::SmallStringVector toStringVector(Utils::SmallStringView jsonText); static Utils::SmallStringVector toStringVector(Utils::SmallStringView jsonText);
@@ -62,11 +87,14 @@ public:
friend bool operator==(const ProjectPartArtefact &first, const ProjectPartArtefact &second); friend bool operator==(const ProjectPartArtefact &first, const ProjectPartArtefact &second);
public: public:
Utils::SmallStringVector compilerArguments; Utils::SmallStringVector toolChainArguments;
CompilerMacros compilerMacros; CompilerMacros compilerMacros;
IncludeSearchPaths systemIncludeSearchPaths; IncludeSearchPaths systemIncludeSearchPaths;
IncludeSearchPaths projectIncludeSearchPaths; IncludeSearchPaths projectIncludeSearchPaths;
int projectPartId = -1; int projectPartId = -1;
Utils::Language language = Utils::Language::Cxx;
Utils::LanguageVersion languageVersion = Utils::LanguageVersion::CXX98;
Utils::LanguageExtension languageExtension = Utils::LanguageExtension::None;
}; };
using ProjectPartArtefacts = std::vector<ProjectPartArtefact>; using ProjectPartArtefacts = std::vector<ProjectPartArtefact>;

10
src/tools/clangrefactoringbackend/source/projectpartentry.h
View File

@@ -37,20 +37,22 @@ public:
ProjectPartEntry(Utils::SmallStringView projectPathName, ProjectPartEntry(Utils::SmallStringView projectPathName,
const FilePathIds &filePathIds, const FilePathIds &filePathIds,
Utils::SmallStringVector &&compilerArguments) Utils::SmallStringVector &&compilerArguments)
: projectPathName(projectPathName), filePathIds(filePathIds), compilerArguments(compilerArguments) : projectPathName(projectPathName)
, filePathIds(filePathIds)
, toolChainArguments(compilerArguments)
{} {}
friend bool operator==(const ProjectPartEntry &first, const ProjectPartEntry &second) friend bool operator==(const ProjectPartEntry &first, const ProjectPartEntry &second)
{ {
return first.projectPathName == second.projectPathName return first.projectPathName == second.projectPathName
&& first.filePathIds == second.filePathIds && first.filePathIds == second.filePathIds
&& first.compilerArguments == second.compilerArguments; && first.toolChainArguments == second.toolChainArguments;
} }
public: public:
Utils::PathString projectPathName; Utils::PathString projectPathName;
FilePathIds filePathIds; FilePathIds filePathIds;
Utils::SmallStringVector compilerArguments; Utils::SmallStringVector toolChainArguments;
}; };
using ProjectPartEntries = std::vector<ProjectPartEntry>; using ProjectPartEntries = std::vector<ProjectPartEntry>;

61
src/tools/clangrefactoringbackend/source/symbolindexer.cpp
View File

@@ -91,7 +91,10 @@ void SymbolIndexer::updateProjectPart(ProjectPartContainer &&projectPart)
projectPart.toolChainArguments, projectPart.toolChainArguments,
projectPart.compilerMacros, projectPart.compilerMacros,
projectPart.systemIncludeSearchPaths, projectPart.systemIncludeSearchPaths,
projectPart.projectIncludeSearchPaths); projectPart.projectIncludeSearchPaths,
projectPart.language,
projectPart.languageVersion,
projectPart.languageExtension);
if (optionalArtefact) if (optionalArtefact)
projectPartId = optionalArtefact->projectPartId; projectPartId = optionalArtefact->projectPartId;
const Utils::optional<ProjectPartPch> optionalProjectPartPch = m_symbolStorage.fetchPrecompiledHeader(projectPartId); const Utils::optional<ProjectPartPch> optionalProjectPartPch = m_symbolStorage.fetchPrecompiledHeader(projectPartId);
@@ -174,39 +177,37 @@ void SymbolIndexer::updateChangedPath(FilePathId filePathId,
optionalArtefact->projectPartId); optionalArtefact->projectPartId);
transaction.commit(); transaction.commit();
if (!optionalArtefact.value().compilerArguments.empty()) { const ProjectPartArtefact &artefact = optionalArtefact.value();
const ProjectPartArtefact &artefact = optionalArtefact.value();
const Utils::SmallStringVector arguments = compilerArguments(artefact.compilerArguments, auto pchPath = optionalProjectPartPch ? optionalProjectPartPch.value().pchPath : FilePath{};
optionalProjectPartPch);
auto indexing = [projectPartId = artefact.projectPartId, arguments, filePathId, this]( CommandLineBuilder<ProjectPartArtefact, Utils::SmallStringVector> builder{
SymbolsCollectorInterface &symbolsCollector) { artefact, artefact.toolChainArguments, {}, {}, pchPath};
symbolsCollector.setFile(filePathId, arguments);
symbolsCollector.collectSymbols(); auto indexing = [projectPartId = artefact.projectPartId, arguments=builder.commandLine, filePathId, this](
SymbolsCollectorInterface &symbolsCollector) {
symbolsCollector.setFile(filePathId, arguments);
Sqlite::ImmediateTransaction transaction{m_transactionInterface}; symbolsCollector.collectSymbols();
m_symbolStorage.addSymbolsAndSourceLocations(symbolsCollector.symbols(), Sqlite::ImmediateTransaction transaction{m_transactionInterface};
symbolsCollector.sourceLocations());
m_symbolStorage.updateProjectPartSources(projectPartId, symbolsCollector.sourceFiles()); m_symbolStorage.addSymbolsAndSourceLocations(symbolsCollector.symbols(),
symbolsCollector.sourceLocations());
m_buildDependencyStorage.insertOrUpdateUsedMacros(symbolsCollector.usedMacros()); m_symbolStorage.updateProjectPartSources(projectPartId, symbolsCollector.sourceFiles());
m_buildDependencyStorage.insertFileStatuses(symbolsCollector.fileStatuses()); m_buildDependencyStorage.insertOrUpdateUsedMacros(symbolsCollector.usedMacros());
m_buildDependencyStorage.insertOrUpdateSourceDependencies( m_buildDependencyStorage.insertFileStatuses(symbolsCollector.fileStatuses());
symbolsCollector.sourceDependencies());
transaction.commit(); m_buildDependencyStorage.insertOrUpdateSourceDependencies(
}; symbolsCollector.sourceDependencies());
symbolIndexerTask.emplace_back(filePathId, transaction.commit();
optionalArtefact->projectPartId, };
std::move(indexing));
} symbolIndexerTask.emplace_back(filePathId, optionalArtefact->projectPartId, std::move(indexing));
} }
bool SymbolIndexer::compilerMacrosOrIncludeSearchPathsAreDifferent( bool SymbolIndexer::compilerMacrosOrIncludeSearchPathsAreDifferent(
@@ -247,18 +248,4 @@ FilePathIds SymbolIndexer::updatableFilePathIds(const ProjectPartContainer &proj
return filterChangedFiles(projectPart); return filterChangedFiles(projectPart);
} }
Utils::SmallStringVector SymbolIndexer::compilerArguments(
Utils::SmallStringVector arguments,
const Utils::optional<ProjectPartPch> optionalProjectPartPch) const
{
if (optionalProjectPartPch) {
arguments.emplace_back("-Xclang");
arguments.emplace_back("-include-pch");
arguments.emplace_back("-Xclang");
arguments.emplace_back(std::move(optionalProjectPartPch.value().pchPath));
}
return arguments;
}
} // namespace ClangBackEnd } // namespace ClangBackEnd

4
src/tools/clangrefactoringbackend/source/symbolindexer.h
View File

@@ -67,10 +67,6 @@ public:
FilePathIds updatableFilePathIds(const ProjectPartContainer &projectPart, FilePathIds updatableFilePathIds(const ProjectPartContainer &projectPart,
const Utils::optional<ProjectPartArtefact> &optionalArtefact) const; const Utils::optional<ProjectPartArtefact> &optionalArtefact) const;
Utils::SmallStringVector compilerArguments(
Utils::SmallStringVector arguments,
const Utils::optional<ProjectPartPch> optionalProjectPartPch) const;
private: private:
SymbolIndexerTaskQueueInterface &m_symbolIndexerTaskQueue; SymbolIndexerTaskQueueInterface &m_symbolIndexerTaskQueue;
SymbolStorageInterface &m_symbolStorage; SymbolStorageInterface &m_symbolStorage;

46
src/tools/clangrefactoringbackend/source/symbolstorage.h
View File

@@ -33,6 +33,8 @@
#include <sqlitetable.h> #include <sqlitetable.h>
#include <includesearchpath.h> #include <includesearchpath.h>
#include <utils/cpplanguage_details.h>
#include <QJsonArray> #include <QJsonArray>
#include <QJsonDocument> #include <QJsonDocument>
#include <QJsonObject> #include <QJsonObject>
@@ -69,21 +71,27 @@ public:
} }
int insertOrUpdateProjectPart(Utils::SmallStringView projectPartName, int insertOrUpdateProjectPart(Utils::SmallStringView projectPartName,
const Utils::SmallStringVector &commandLineArguments, const Utils::SmallStringVector &toolChainArguments,
const CompilerMacros &compilerMacros, const CompilerMacros &compilerMacros,
const IncludeSearchPaths &systemIncludeSearchPaths, const IncludeSearchPaths &systemIncludeSearchPaths,
const IncludeSearchPaths &projectIncludeSearchPaths) override const IncludeSearchPaths &projectIncludeSearchPaths,
Utils::Language language,
Utils::LanguageVersion languageVersion,
Utils::LanguageExtension languageExtension) override
{ {
Utils::SmallString compilerArguementsAsJson = toJson(commandLineArguments); Utils::SmallString toolChainArgumentsAsJson = toJson(toolChainArguments);
Utils::SmallString compilerMacrosAsJson = toJson(compilerMacros); Utils::SmallString compilerMacrosAsJson = toJson(compilerMacros);
Utils::SmallString systemIncludeSearchPathsAsJason = toJson(systemIncludeSearchPaths); Utils::SmallString systemIncludeSearchPathsAsJason = toJson(systemIncludeSearchPaths);
Utils::SmallString projectIncludeSearchPathsAsJason = toJson(projectIncludeSearchPaths); Utils::SmallString projectIncludeSearchPathsAsJason = toJson(projectIncludeSearchPaths);
m_insertOrUpdateProjectPartStatement.write(projectPartName, m_insertOrUpdateProjectPartStatement.write(projectPartName,
compilerArguementsAsJson, toolChainArgumentsAsJson,
compilerMacrosAsJson, compilerMacrosAsJson,
systemIncludeSearchPathsAsJason, systemIncludeSearchPathsAsJason,
projectIncludeSearchPathsAsJason); projectIncludeSearchPathsAsJason,
static_cast<int>(language),
static_cast<int>(languageVersion),
static_cast<int>(languageExtension));
auto projectPartId = m_getProjectPartIdStatement.template value<int>(projectPartName); auto projectPartId = m_getProjectPartIdStatement.template value<int>(projectPartName);
@@ -94,14 +102,14 @@ public:
{ {
ReadStatement &statement = m_getProjectPartArtefactsBySourceId; ReadStatement &statement = m_getProjectPartArtefactsBySourceId;
return statement.template value<ProjectPartArtefact, 5>(sourceId.filePathId); return statement.template value<ProjectPartArtefact, 8>(sourceId.filePathId);
} }
Utils::optional<ProjectPartArtefact> fetchProjectPartArtefact(Utils::SmallStringView projectPartName) const override Utils::optional<ProjectPartArtefact> fetchProjectPartArtefact(Utils::SmallStringView projectPartName) const override
{ {
ReadStatement &statement = m_getProjectPartArtefactsByProjectPartName; ReadStatement &statement = m_getProjectPartArtefactsByProjectPartName;
return statement.template value<ProjectPartArtefact, 5>(projectPartName); return statement.template value<ProjectPartArtefact, 8>(projectPartName);
} }
void updateProjectPartSources(int projectPartId, void updateProjectPartSources(int projectPartId,
@@ -308,10 +316,12 @@ public:
m_database m_database
}; };
WriteStatement m_insertOrUpdateProjectPartStatement{ WriteStatement m_insertOrUpdateProjectPartStatement{
"INSERT INTO projectParts(projectPartName, compilerArguments, compilerMacros, " "INSERT INTO projectParts(projectPartName, toolChainArguments, compilerMacros, "
"systemIncludeSearchPaths, projectIncludeSearchPaths) VALUES (?001,?002,?003,?004,?005) ON " "systemIncludeSearchPaths, projectIncludeSearchPaths, language, languageVersion, "
"CONFLICT(projectPartName) DO UPDATE SET compilerArguments=?002, compilerMacros=?003, " "languageExtension) VALUES (?001,?002,?003,?004,?005,?006,?007,?008) ON "
"systemIncludeSearchPaths=?004, projectIncludeSearchPaths=?005", "CONFLICT(projectPartName) DO UPDATE SET toolChainArguments=?002, compilerMacros=?003, "
"systemIncludeSearchPaths=?004, projectIncludeSearchPaths=?005, language=?006, "
"languageVersion=?007, languageExtension=?008",
m_database}; m_database};
mutable ReadStatement m_getProjectPartIdStatement{ mutable ReadStatement m_getProjectPartIdStatement{
"SELECT projectPartId FROM projectParts WHERE projectPartName = ?", "SELECT projectPartId FROM projectParts WHERE projectPartName = ?",
@@ -326,16 +336,16 @@ public:
m_database m_database
}; };
mutable ReadStatement m_getCompileArgumentsForFileIdStatement{ mutable ReadStatement m_getCompileArgumentsForFileIdStatement{
"SELECT compilerArguments FROM projectParts WHERE projectPartId = (SELECT projectPartId FROM projectPartsSources WHERE sourceId = ?)", "SELECT toolChainArguments FROM projectParts WHERE projectPartId = (SELECT projectPartId "
m_database "FROM projectPartsSources WHERE sourceId = ?)",
}; m_database};
mutable ReadStatement m_getProjectPartArtefactsBySourceId{ mutable ReadStatement m_getProjectPartArtefactsBySourceId{
"SELECT compilerArguments, compilerMacros, systemIncludeSearchPaths, projectIncludeSearchPaths, " "SELECT toolChainArguments, compilerMacros, systemIncludeSearchPaths, "
"projectPartId FROM projectParts WHERE projectPartId = (SELECT projectPartId FROM " "projectIncludeSearchPaths, projectPartId FROM projectParts WHERE projectPartId = (SELECT "
"projectPartsSources WHERE sourceId = ?)", "projectPartId FROM projectPartsSources WHERE sourceId = ?)",
m_database}; m_database};
mutable ReadStatement m_getProjectPartArtefactsByProjectPartName{ mutable ReadStatement m_getProjectPartArtefactsByProjectPartName{
"SELECT compilerArguments, compilerMacros, systemIncludeSearchPaths, " "SELECT toolChainArguments, compilerMacros, systemIncludeSearchPaths, "
"projectIncludeSearchPaths, projectPartId FROM projectParts WHERE projectPartName = ?", "projectIncludeSearchPaths, projectPartId FROM projectParts WHERE projectPartName = ?",
m_database}; m_database};
mutable ReadStatement m_getPrecompiledHeader{ mutable ReadStatement m_getPrecompiledHeader{

5
src/tools/clangrefactoringbackend/source/symbolstorageinterface.h
View File

@@ -57,7 +57,10 @@ public:
const Utils::SmallStringVector &commandLineArguments, const Utils::SmallStringVector &commandLineArguments,
const CompilerMacros &compilerMacros, const CompilerMacros &compilerMacros,
const ClangBackEnd::IncludeSearchPaths &systemIncludeSearchPaths, const ClangBackEnd::IncludeSearchPaths &systemIncludeSearchPaths,
const ClangBackEnd::IncludeSearchPaths &projectIncludeSearchPaths) const ClangBackEnd::IncludeSearchPaths &projectIncludeSearchPaths,
Utils::Language language,
Utils::LanguageVersion languageVersion,
Utils::LanguageExtension languageExtension)
= 0; = 0;
virtual void updateProjectPartSources(int projectPartId, const FilePathIds &sourceFilePathIds) = 0; virtual void updateProjectPartSources(int projectPartId, const FilePathIds &sourceFilePathIds) = 0;
virtual Utils::optional<ProjectPartArtefact> fetchProjectPartArtefact( virtual Utils::optional<ProjectPartArtefact> fetchProjectPartArtefact(

33
tests/unit/unittest/commandlinebuilder-test.cpp
View File

@@ -28,6 +28,7 @@
#include <commandlinebuilder.h> #include <commandlinebuilder.h>
#include <pchtask.h> #include <pchtask.h>
#include <projectpartcontainer.h> #include <projectpartcontainer.h>
#include <projectpartartefact.h>
namespace { namespace {
template<typename ProjectInfo> template<typename ProjectInfo>
@@ -86,7 +87,37 @@ public:
Utils::LanguageExtension::None}; Utils::LanguageExtension::None};
}; };
using ProjectInfos = testing::Types<ClangBackEnd::PchTask, ClangBackEnd::ProjectPartContainer>; template <>
class CommandLineBuilder<ClangBackEnd::ProjectPartArtefact> : public testing::Test
{
public:
CommandLineBuilder()
{
cppProjectInfo.language = Utils::Language::Cxx;
}
public:
ClangBackEnd::ProjectPartArtefact emptyProjectInfo{{},
{},
{},
{},
{},
Utils::Language::Cxx,
Utils::LanguageVersion::CXX98,
Utils::LanguageExtension::None};
ClangBackEnd::ProjectPartArtefact cppProjectInfo{{},
{},
{},
{},
{},
Utils::Language::Cxx,
Utils::LanguageVersion::CXX98,
Utils::LanguageExtension::None};
};
using ProjectInfos = testing::Types<ClangBackEnd::PchTask,
ClangBackEnd::ProjectPartContainer,
ClangBackEnd::ProjectPartArtefact>;
TYPED_TEST_SUITE(CommandLineBuilder, ProjectInfos); TYPED_TEST_SUITE(CommandLineBuilder, ProjectInfos);
TYPED_TEST(CommandLineBuilder, AddToolChainArguments) TYPED_TEST(CommandLineBuilder, AddToolChainArguments)

2
tests/unit/unittest/gtest-creator-printing.cpp
View File

@@ -1023,7 +1023,7 @@ std::ostream &operator<<(std::ostream &out, const SourceDependency &sourceDepend
std::ostream &operator<<(std::ostream &out, const ProjectPartArtefact &projectPartArtefact) std::ostream &operator<<(std::ostream &out, const ProjectPartArtefact &projectPartArtefact)
{ {
return out << "(" return out << "("
<< projectPartArtefact.compilerArguments << ", " << projectPartArtefact.toolChainArguments << ", "
<< projectPartArtefact.compilerMacros << projectPartArtefact.compilerMacros
<<")"; <<")";
} }

4
tests/unit/unittest/mocksqlitereadstatement.cpp
View File

@@ -153,14 +153,14 @@ MockSqliteReadStatement::value<ClangBackEnd::FilePath>(const Utils::SmallStringV
template <> template <>
Utils::optional<ClangBackEnd::ProjectPartArtefact> Utils::optional<ClangBackEnd::ProjectPartArtefact>
MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 5>(const int& sourceId) MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 8>(const int& sourceId)
{ {
return valueReturnProjectPartArtefact(sourceId); return valueReturnProjectPartArtefact(sourceId);
} }
template <> template <>
Utils::optional<ClangBackEnd::ProjectPartArtefact> Utils::optional<ClangBackEnd::ProjectPartArtefact>
MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 5>(const Utils::SmallStringView &projectPartName) MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 8>(const Utils::SmallStringView &projectPartName)
{ {
return valueReturnProjectPartArtefact(projectPartName); return valueReturnProjectPartArtefact(projectPartName);
} }

4
tests/unit/unittest/mocksqlitereadstatement.h
View File

@@ -237,11 +237,11 @@ MockSqliteReadStatement::value<Utils::PathString>(const Utils::SmallStringView&)
template <> template <>
Utils::optional<ClangBackEnd::ProjectPartArtefact> Utils::optional<ClangBackEnd::ProjectPartArtefact>
MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 5>(const int&); MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 8>(const int&);
template <> template <>
Utils::optional<ClangBackEnd::ProjectPartArtefact> Utils::optional<ClangBackEnd::ProjectPartArtefact>
MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 5>(const int&); MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 8>(const int&);
template <> template <>
Utils::optional<ClangBackEnd::ProjectPartPch> Utils::optional<ClangBackEnd::ProjectPartPch>

10
tests/unit/unittest/mocksqlitewritestatement.h
View File

@@ -78,12 +78,16 @@ public:
Utils::SmallStringView, Utils::SmallStringView,
Utils::SmallStringView)); Utils::SmallStringView));
MOCK_METHOD5(write, MOCK_METHOD8(write,
void (Utils::SmallStringView, void(Utils::SmallStringView,
Utils::SmallStringView, Utils::SmallStringView,
Utils::SmallStringView, Utils::SmallStringView,
Utils::SmallStringView, Utils::SmallStringView,
Utils::SmallStringView)); Utils::SmallStringView,
int,
int,
int));
MOCK_METHOD1(write, MOCK_METHOD1(write,
void (Utils::SmallStringView)); void (Utils::SmallStringView));

7
tests/unit/unittest/mocksymbolstorage.h
View File

@@ -37,12 +37,15 @@ public:
MOCK_METHOD2(addSymbolsAndSourceLocations, MOCK_METHOD2(addSymbolsAndSourceLocations,
void(const ClangBackEnd::SymbolEntries &symbolEentries, void(const ClangBackEnd::SymbolEntries &symbolEentries,
const ClangBackEnd::SourceLocationEntries &sourceLocations)); const ClangBackEnd::SourceLocationEntries &sourceLocations));
MOCK_METHOD5(insertOrUpdateProjectPart, MOCK_METHOD8(insertOrUpdateProjectPart,
int(Utils::SmallStringView projectPartName, int(Utils::SmallStringView projectPartName,
const Utils::SmallStringVector &commandLineArgument, const Utils::SmallStringVector &commandLineArgument,
const ClangBackEnd::CompilerMacros &compilerMacros, const ClangBackEnd::CompilerMacros &compilerMacros,
const ClangBackEnd::IncludeSearchPaths &systemIncludeSearchPaths, const ClangBackEnd::IncludeSearchPaths &systemIncludeSearchPaths,
const ClangBackEnd::IncludeSearchPaths &projectIncludeSearchPaths)); const ClangBackEnd::IncludeSearchPaths &projectIncludeSearchPaths,
Utils::Language language,
Utils::LanguageVersion languageVersion,
Utils::LanguageExtension languageExtension));
MOCK_METHOD2(updateProjectPartSources, MOCK_METHOD2(updateProjectPartSources,
void(int projectPartId, void(int projectPartId,
const ClangBackEnd::FilePathIds &sourceFilePathIds)); const ClangBackEnd::FilePathIds &sourceFilePathIds));

120
tests/unit/unittest/projectpartartefact-test.cpp
View File

@@ -35,27 +35,55 @@ using ClangBackEnd::IncludeSearchPathType;
TEST(ProjectPartArtefact, CompilerArguments) TEST(ProjectPartArtefact, CompilerArguments)
{ {
ClangBackEnd::ProjectPartArtefact artefact{"[\"-DFoo\",\"-DBar\"]", "", "", "", 1}; ClangBackEnd::ProjectPartArtefact artefact{"[\"-DFoo\",\"-DBar\"]",
"",
"",
"",
1,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None};
ASSERT_THAT(artefact.compilerArguments, ElementsAre(Eq("-DFoo"), Eq("-DBar"))); ASSERT_THAT(artefact.toolChainArguments, ElementsAre(Eq("-DFoo"), Eq("-DBar")));
} }
TEST(ProjectPartArtefact, EmptyCompilerArguments) TEST(ProjectPartArtefact, EmptyCompilerArguments)
{ {
ClangBackEnd::ProjectPartArtefact artefact{"", "", "", "", 1}; ClangBackEnd::ProjectPartArtefact artefact{"",
"",
"",
"",
1,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None};
ASSERT_THAT(artefact.compilerArguments, IsEmpty()); ASSERT_THAT(artefact.toolChainArguments, IsEmpty());
} }
TEST(ProjectPartArtefact, CompilerArgumentsParseError) TEST(ProjectPartArtefact, CompilerArgumentsParseError)
{ {
ASSERT_THROW(ClangBackEnd::ProjectPartArtefact("\"-DFoo\",\"-DBar\"]", "", "", "", 1), ASSERT_THROW(ClangBackEnd::ProjectPartArtefact("\"-DFoo\",\"-DBar\"]",
"",
"",
"",
1,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None),
ClangBackEnd::ProjectPartArtefactParseError); ClangBackEnd::ProjectPartArtefactParseError);
} }
TEST(ProjectPartArtefact, CompilerMacros) TEST(ProjectPartArtefact, CompilerMacros)
{ {
ClangBackEnd::ProjectPartArtefact artefact{"", R"([["Foo","1",1], ["Bar","42",2]])", "", "", 1}; ClangBackEnd::ProjectPartArtefact artefact{"",
R"([["Foo","1",1], ["Bar","42",2]])",
"",
"",
1,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None};
ASSERT_THAT(artefact.compilerMacros, ASSERT_THAT(artefact.compilerMacros,
UnorderedElementsAre(Eq(CompilerMacro{"Foo", "1", 1}), Eq(CompilerMacro{"Bar", "42", 2}))); UnorderedElementsAre(Eq(CompilerMacro{"Foo", "1", 1}), Eq(CompilerMacro{"Bar", "42", 2})));
@@ -63,21 +91,41 @@ TEST(ProjectPartArtefact, CompilerMacros)
TEST(ProjectPartArtefact, EmptyCompilerMacros) TEST(ProjectPartArtefact, EmptyCompilerMacros)
{ {
ClangBackEnd::ProjectPartArtefact artefact{"", "", "", "", 1}; ClangBackEnd::ProjectPartArtefact artefact{"",
"",
"",
"",
1,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None};
ASSERT_THAT(artefact.compilerMacros, IsEmpty()); ASSERT_THAT(artefact.compilerMacros, IsEmpty());
} }
TEST(ProjectPartArtefact, CompilerMacrosParseError) TEST(ProjectPartArtefact, CompilerMacrosParseError)
{ {
ASSERT_THROW(ClangBackEnd::ProjectPartArtefact("", R"([["Foo":"1", 1], ["Bar", "42", 2]])", "", "", 1), ASSERT_THROW(ClangBackEnd::ProjectPartArtefact("",
R"([["Foo":"1", 1], ["Bar", "42", 2]])",
"",
"",
1,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None),
ClangBackEnd::ProjectPartArtefactParseError); ClangBackEnd::ProjectPartArtefactParseError);
} }
TEST(ProjectPartArtefact, SystemIncludeSearchPaths) TEST(ProjectPartArtefact, SystemIncludeSearchPaths)
{ {
ClangBackEnd::ProjectPartArtefact artefact{ ClangBackEnd::ProjectPartArtefact artefact{"",
"", "", R"([["/includes", 1, 2], ["/other/includes", 2, 3]])", "", 1}; "",
R"([["/includes", 1, 2], ["/other/includes", 2, 3]])",
"",
1,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None};
ASSERT_THAT( ASSERT_THAT(
artefact.systemIncludeSearchPaths, artefact.systemIncludeSearchPaths,
@@ -87,7 +135,14 @@ TEST(ProjectPartArtefact, SystemIncludeSearchPaths)
TEST(ProjectPartArtefact, EmptySystemIncludeSearchPaths) TEST(ProjectPartArtefact, EmptySystemIncludeSearchPaths)
{ {
ClangBackEnd::ProjectPartArtefact artefact{"", "", "", "", 1}; ClangBackEnd::ProjectPartArtefact artefact{"",
"",
"",
"",
1,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None};
ASSERT_THAT(artefact.systemIncludeSearchPaths, IsEmpty()); ASSERT_THAT(artefact.systemIncludeSearchPaths, IsEmpty());
} }
@@ -95,7 +150,14 @@ TEST(ProjectPartArtefact, EmptySystemIncludeSearchPaths)
TEST(ProjectPartArtefact, ProjectIncludeSearchPaths) TEST(ProjectPartArtefact, ProjectIncludeSearchPaths)
{ {
ClangBackEnd::ProjectPartArtefact artefact{ ClangBackEnd::ProjectPartArtefact artefact{
"", "", R"([["/project/includes", 1, 1], ["/other/project/includes", 2, 1]])", "", 1}; "",
"",
R"([["/project/includes", 1, 1], ["/other/project/includes", 2, 1]])",
"",
1,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None};
ASSERT_THAT( ASSERT_THAT(
artefact.systemIncludeSearchPaths, artefact.systemIncludeSearchPaths,
@@ -106,22 +168,42 @@ TEST(ProjectPartArtefact, ProjectIncludeSearchPaths)
TEST(ProjectPartArtefact, EmptyProjectIncludeSearchPaths) TEST(ProjectPartArtefact, EmptyProjectIncludeSearchPaths)
{ {
ClangBackEnd::ProjectPartArtefact artefact{"", "", "", "", 1}; ClangBackEnd::ProjectPartArtefact artefact{"",
"",
"",
"",
1,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None};
ASSERT_THAT(artefact.projectIncludeSearchPaths, IsEmpty()); ASSERT_THAT(artefact.projectIncludeSearchPaths, IsEmpty());
} }
TEST(ProjectPartArtefact, IncludeSystemSearchPathsParseError) TEST(ProjectPartArtefact, IncludeSystemSearchPathsParseError)
{ {
ASSERT_THROW( ASSERT_THROW(ClangBackEnd::ProjectPartArtefact("",
ClangBackEnd::ProjectPartArtefact("", "", R"(["/includes", 1, 3], ["/other/includes", 2, 2]])", "", 1), "",
ClangBackEnd::ProjectPartArtefactParseError); R"(["/includes", 1, 3], ["/other/includes", 2, 2]])",
"",
1,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None),
ClangBackEnd::ProjectPartArtefactParseError);
} }
TEST(ProjectPartArtefact, IncludeProjectSearchPathsParseError) TEST(ProjectPartArtefact, IncludeProjectSearchPathsParseError)
{ {
ASSERT_THROW( ASSERT_THROW(ClangBackEnd::ProjectPartArtefact(
ClangBackEnd::ProjectPartArtefact("", "", R"(["/project/includes", 1, 1], ["/other/project/includes", 2, 1]])", "", 1), "",
ClangBackEnd::ProjectPartArtefactParseError); "",
R"(["/project/includes", 1, 1], ["/other/project/includes", 2, 1]])",
"",
1,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None),
ClangBackEnd::ProjectPartArtefactParseError);
} }
} }

19
tests/unit/unittest/refactoringdatabaseinitializer-test.cpp
View File

@@ -88,7 +88,11 @@ TEST_F(RefactoringDatabaseInitializer, AddProjectPartsTable)
{ {
InSequence s; InSequence s;
EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectParts(projectPartId INTEGER PRIMARY KEY, projectPartName TEXT, compilerArguments TEXT, compilerMacros TEXT, systemIncludeSearchPaths TEXT, projectIncludeSearchPaths TEXT)"))); EXPECT_CALL(mockDatabase,
execute(Eq("CREATE TABLE IF NOT EXISTS projectParts(projectPartId INTEGER PRIMARY "
"KEY, projectPartName TEXT, toolChainArguments TEXT, compilerMacros "
"TEXT, systemIncludeSearchPaths TEXT, projectIncludeSearchPaths TEXT, "
"language INTEGER, languageVersion INTEGER, languageExtension INTEGER)")));
EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectParts_projectPartName ON projectParts(projectPartName)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectParts_projectPartName ON projectParts(projectPartName)")));
initializer.createProjectPartsTable(); initializer.createProjectPartsTable();
@@ -160,7 +164,12 @@ TEST_F(RefactoringDatabaseInitializer, CreateInTheContructor)
EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_sources_directoryId_sourceName ON sources(directoryId, sourceName)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_sources_directoryId_sourceName ON sources(directoryId, sourceName)")));
EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS directories(directoryId INTEGER PRIMARY KEY, directoryPath TEXT)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS directories(directoryId INTEGER PRIMARY KEY, directoryPath TEXT)")));
EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_directories_directoryPath ON directories(directoryPath)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_directories_directoryPath ON directories(directoryPath)")));
EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectParts(projectPartId INTEGER PRIMARY KEY, projectPartName TEXT, compilerArguments TEXT, compilerMacros TEXT, systemIncludeSearchPaths TEXT, projectIncludeSearchPaths TEXT)"))); EXPECT_CALL(mockDatabase,
execute(
Eq("CREATE TABLE IF NOT EXISTS projectParts(projectPartId INTEGER PRIMARY "
"KEY, projectPartName TEXT, toolChainArguments TEXT, compilerMacros "
"TEXT, systemIncludeSearchPaths TEXT, projectIncludeSearchPaths TEXT, "
"language INTEGER, languageVersion INTEGER, languageExtension INTEGER)")));
EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectParts_projectPartName ON projectParts(projectPartName)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectParts_projectPartName ON projectParts(projectPartName)")));
EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectPartsSources(projectPartId INTEGER, sourceId INTEGER, sourceType INTEGER)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectPartsSources(projectPartId INTEGER, sourceId INTEGER, sourceType INTEGER)")));
EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectPartsSources_sourceId_projectPartId ON projectPartsSources(sourceId, projectPartId)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectPartsSources_sourceId_projectPartId ON projectPartsSources(sourceId, projectPartId)")));
@@ -194,7 +203,11 @@ TEST_F(RefactoringDatabaseInitializer, DontCreateIfAlreadyInitialized)
EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_sources_directoryId_sourceName ON sources(directoryId, sourceName)"))).Times(0); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_sources_directoryId_sourceName ON sources(directoryId, sourceName)"))).Times(0);
EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS directories(directoryId INTEGER PRIMARY KEY, directoryPath TEXT)"))).Times(0); EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS directories(directoryId INTEGER PRIMARY KEY, directoryPath TEXT)"))).Times(0);
EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_directories_directoryPath ON directories(directoryPath)"))).Times(0); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_directories_directoryPath ON directories(directoryPath)"))).Times(0);
EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectParts(projectPartId INTEGER PRIMARY KEY, projectPartName TEXT, compilerArguments TEXT, compilerMacros TEXT, includeSearchPaths TEXT)"))).Times(0); EXPECT_CALL(mockDatabase,
execute(Eq("CREATE TABLE IF NOT EXISTS projectParts(projectPartId INTEGER PRIMARY "
"KEY, projectPartName TEXT, toolChainArguments TEXT, compilerMacros "
"TEXT, includeSearchPaths TEXT)")))
.Times(0);
EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectParts_projectPartName ON projectParts(projectPartName)"))).Times(0); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectParts_projectPartName ON projectParts(projectPartName)"))).Times(0);
EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectPartsSources(projectPartId INTEGER, sourceId INTEGER)"))).Times(0); EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectPartsSources(projectPartId INTEGER, sourceId INTEGER)"))).Times(0);
EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectPartsSources_sourceId_projectPartId ON projectPartsSources(sourceId, projectPartId)"))).Times(0); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectPartsSources_sourceId_projectPartId ON projectPartsSources(sourceId, projectPartId)"))).Times(0);

113
tests/unit/unittest/symbolindexer-test.cpp
View File

@@ -218,8 +218,18 @@ protected:
R"([["FOO","1", 2],["BAR","1", 1]])", R"([["FOO","1", 2],["BAR","1", 1]])",
systemIncludeSearchPathsText, systemIncludeSearchPathsText,
projectIncludeSearchPathsText, projectIncludeSearchPathsText,
74}; 74,
ClangBackEnd::ProjectPartArtefact emptyArtefact{"", "", "", "", 74}; Utils::Language::Cxx,
Utils::LanguageVersion::CXX14,
Utils::LanguageExtension::None};
ClangBackEnd::ProjectPartArtefact emptyArtefact{"",
"",
"",
"",
74,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX14,
Utils::LanguageExtension::None};
Utils::optional<ClangBackEnd::ProjectPartArtefact > nullArtefact; Utils::optional<ClangBackEnd::ProjectPartArtefact > nullArtefact;
ClangBackEnd::ProjectPartPch projectPartPch{"/path/to/pch", 4}; ClangBackEnd::ProjectPartPch projectPartPch{"/path/to/pch", 4};
NiceMock<MockSqliteTransactionBackend> mockSqliteTransactionBackend; NiceMock<MockSqliteTransactionBackend> mockSqliteTransactionBackend;
@@ -398,7 +408,10 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartsInStorage)
ElementsAre("-Wno-pragma-once-outside-header"), ElementsAre("-Wno-pragma-once-outside-header"),
ElementsAre(CompilerMacro{"BAR", "1", 1}, CompilerMacro{"FOO", "1", 2}), ElementsAre(CompilerMacro{"BAR", "1", 1}, CompilerMacro{"FOO", "1", 2}),
Eq(systemIncludeSearchPaths), Eq(systemIncludeSearchPaths),
Eq(projectIncludeSearchPaths))); Eq(projectIncludeSearchPaths),
Eq(Utils::Language::Cxx),
Eq(Utils::LanguageVersion::CXX14),
Eq(Utils::LanguageExtension::None)));
EXPECT_CALL( EXPECT_CALL(
mockSymbolStorage, mockSymbolStorage,
insertOrUpdateProjectPart( insertOrUpdateProjectPart(
@@ -406,7 +419,10 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartsInStorage)
ElementsAre("-Wno-pragma-once-outside-header"), ElementsAre("-Wno-pragma-once-outside-header"),
ElementsAre(CompilerMacro{"BAR", "1", 1}, CompilerMacro{"FOO", "0", 2}), ElementsAre(CompilerMacro{"BAR", "1", 1}, CompilerMacro{"FOO", "0", 2}),
Eq(systemIncludeSearchPaths), Eq(systemIncludeSearchPaths),
Eq(projectIncludeSearchPaths))); Eq(projectIncludeSearchPaths),
Eq(Utils::Language::Cxx),
Eq(Utils::LanguageVersion::CXX14),
Eq(Utils::LanguageExtension::None)));
indexer.updateProjectParts({projectPart1, projectPart2}); indexer.updateProjectParts({projectPart1, projectPart2});
} }
@@ -414,7 +430,7 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartsInStorage)
TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartSourcesWithArtifact) TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartSourcesWithArtifact)
{ {
ON_CALL(mockSymbolStorage, fetchProjectPartArtefact(TypedEq<Utils::SmallStringView>("project1"))).WillByDefault(Return(artefact)); ON_CALL(mockSymbolStorage, fetchProjectPartArtefact(TypedEq<Utils::SmallStringView>("project1"))).WillByDefault(Return(artefact));
ON_CALL(mockSymbolStorage, insertOrUpdateProjectPart(Eq("project1"), _, _, _, _)).WillByDefault(Return(-1)); ON_CALL(mockSymbolStorage, insertOrUpdateProjectPart(Eq("project1"), _, _, _, _, _, _, _)).WillByDefault(Return(-1));
EXPECT_CALL(mockSymbolStorage, updateProjectPartSources(_, _)); EXPECT_CALL(mockSymbolStorage, updateProjectPartSources(_, _));
@@ -424,7 +440,7 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartSourcesWithArtifac
TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartSourcesWithoutArtifact) TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartSourcesWithoutArtifact)
{ {
ON_CALL(mockSymbolStorage, fetchProjectPartArtefact(TypedEq<Utils::SmallStringView>("project2"))).WillByDefault(Return(nullArtefact)); ON_CALL(mockSymbolStorage, fetchProjectPartArtefact(TypedEq<Utils::SmallStringView>("project2"))).WillByDefault(Return(nullArtefact));
ON_CALL(mockSymbolStorage, insertOrUpdateProjectPart(Eq("project2"), _, _, _, _)).WillByDefault(Return(3)); ON_CALL(mockSymbolStorage, insertOrUpdateProjectPart(Eq("project2"), _, _, _, _, _, _, _)).WillByDefault(Return(3));
EXPECT_CALL(mockSymbolStorage, updateProjectPartSources(3, ElementsAre(IsFileId(1), IsFileId(23)))); EXPECT_CALL(mockSymbolStorage, updateProjectPartSources(3, ElementsAre(IsFileId(1), IsFileId(23))));
@@ -474,7 +490,10 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsInOrderWithoutProjectPartArtifact)
Eq(projectPart1.toolChainArguments), Eq(projectPart1.toolChainArguments),
Eq(projectPart1.compilerMacros), Eq(projectPart1.compilerMacros),
Eq(projectPart1.systemIncludeSearchPaths), Eq(projectPart1.systemIncludeSearchPaths),
Eq(projectPart1.projectIncludeSearchPaths))) Eq(projectPart1.projectIncludeSearchPaths),
Eq(Utils::Language::Cxx),
Eq(Utils::LanguageVersion::CXX14),
Eq(Utils::LanguageExtension::None)))
.WillOnce(Return(12)); .WillOnce(Return(12));
EXPECT_CALL(mockSymbolStorage, fetchPrecompiledHeader(Eq(12))); EXPECT_CALL(mockSymbolStorage, fetchPrecompiledHeader(Eq(12)));
EXPECT_CALL(mockBuildDependenciesStorage, fetchLowestLastModifiedTime(Eq(main1PathId))).Times(0); EXPECT_CALL(mockBuildDependenciesStorage, fetchLowestLastModifiedTime(Eq(main1PathId))).Times(0);
@@ -521,7 +540,10 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsInOrderWithProjectPartArtifact)
Eq(projectPart1.toolChainArguments), Eq(projectPart1.toolChainArguments),
Eq(projectPart1.compilerMacros), Eq(projectPart1.compilerMacros),
Eq(projectPart1.systemIncludeSearchPaths), Eq(projectPart1.systemIncludeSearchPaths),
Eq(projectPart1.projectIncludeSearchPaths))) Eq(projectPart1.projectIncludeSearchPaths),
Eq(Utils::Language::Cxx),
Eq(Utils::LanguageVersion::CXX14),
Eq(Utils::LanguageExtension::None)))
.WillOnce(Return(-1)); .WillOnce(Return(-1));
EXPECT_CALL(mockSymbolStorage, fetchPrecompiledHeader(Eq(artefact.projectPartId))); EXPECT_CALL(mockSymbolStorage, fetchPrecompiledHeader(Eq(artefact.projectPartId)));
EXPECT_CALL(mockBuildDependenciesStorage, fetchLowestLastModifiedTime(Eq(main1PathId))).WillOnce(Return(-1)); EXPECT_CALL(mockBuildDependenciesStorage, fetchLowestLastModifiedTime(Eq(main1PathId))).WillOnce(Return(-1));
@@ -580,7 +602,25 @@ TEST_F(SymbolIndexer, UpdateChangedPathCallsInOrder)
EXPECT_CALL(mockSymbolStorage, fetchProjectPartArtefact(TypedEq<FilePathId>(sourceFileIds[0]))).WillOnce(Return(artefact)); EXPECT_CALL(mockSymbolStorage, fetchProjectPartArtefact(TypedEq<FilePathId>(sourceFileIds[0]))).WillOnce(Return(artefact));
EXPECT_CALL(mockSymbolStorage, fetchPrecompiledHeader(Eq(artefact.projectPartId))); EXPECT_CALL(mockSymbolStorage, fetchPrecompiledHeader(Eq(artefact.projectPartId)));
EXPECT_CALL(mockSqliteTransactionBackend, commit()); EXPECT_CALL(mockSqliteTransactionBackend, commit());
EXPECT_CALL(mockCollector, setFile(Eq(sourceFileIds[0]), Eq(artefact.compilerArguments))); EXPECT_CALL(mockCollector,
setFile(Eq(sourceFileIds[0]),
ElementsAre("clang++",
"-DFOO",
"-x",
"c++-header",
"-std=c++14",
"-nostdinc",
"-nostdlibinc",
"-I",
"/project/includes",
"-I",
"/other/project/includes",
"-isystem",
TESTDATA_DIR,
"-isystem",
"/other/includes",
"-isystem",
"/includes")));
EXPECT_CALL(mockCollector, collectSymbols()); EXPECT_CALL(mockCollector, collectSymbols());
EXPECT_CALL(mockSqliteTransactionBackend, immediateBegin()); EXPECT_CALL(mockSqliteTransactionBackend, immediateBegin());
EXPECT_CALL(mockSymbolStorage, addSymbolsAndSourceLocations(symbolEntries, sourceLocations)); EXPECT_CALL(mockSymbolStorage, addSymbolsAndSourceLocations(symbolEntries, sourceLocations));
@@ -622,12 +662,29 @@ TEST_F(SymbolIndexer, UpdateChangedPathIsUsingPrecompiledHeader)
.WillByDefault(Return(projectPartPch)); .WillByDefault(Return(projectPartPch));
std::vector<SymbolIndexerTask> symbolIndexerTask; std::vector<SymbolIndexerTask> symbolIndexerTask;
EXPECT_CALL(mockCollector, setFile(Eq(sourceFileIds[0]), EXPECT_CALL(mockCollector,
ElementsAre(Eq("-DFOO"), setFile(Eq(sourceFileIds[0]),
Eq("-Xclang"), ElementsAre("clang++",
Eq("-include-pch"), "-DFOO",
Eq("-Xclang"), "-x",
Eq("/path/to/pch")))); "c++-header",
"-std=c++14",
"-nostdinc",
"-nostdlibinc",
"-I",
"/project/includes",
"-I",
"/other/project/includes",
"-isystem",
TESTDATA_DIR,
"-isystem",
"/other/includes",
"-isystem",
"/includes",
"-Xclang",
"-include-pch",
"-Xclang",
"/path/to/pch")));
indexer.pathsChanged({sourceFileIds[0]}); indexer.pathsChanged({sourceFileIds[0]});
} }
@@ -638,8 +695,25 @@ TEST_F(SymbolIndexer, UpdateChangedPathIsNotUsingPrecompiledHeaderIfItNotExists)
.WillByDefault(Return(artefact)); .WillByDefault(Return(artefact));
std::vector<SymbolIndexerTask> symbolIndexerTask; std::vector<SymbolIndexerTask> symbolIndexerTask;
EXPECT_CALL(mockCollector, setFile(Eq(sourceFileIds[0]), EXPECT_CALL(mockCollector,
ElementsAre(Eq("-DFOO")))); setFile(Eq(sourceFileIds[0]),
ElementsAre("clang++",
"-DFOO",
"-x",
"c++-header",
"-std=c++14",
"-nostdinc",
"-nostdlibinc",
"-I",
"/project/includes",
"-I",
"/other/project/includes",
"-isystem",
TESTDATA_DIR,
"-isystem",
"/other/includes",
"-isystem",
"/includes")));
indexer.pathsChanged({sourceFileIds[0]}); indexer.pathsChanged({sourceFileIds[0]});
} }
@@ -728,7 +802,10 @@ TEST_F(SymbolIndexer, DontReparseInUpdateProjectPartsIfDefinesAreTheSame)
Eq(projectPart1.toolChainArguments), Eq(projectPart1.toolChainArguments),
Eq(projectPart1.compilerMacros), Eq(projectPart1.compilerMacros),
Eq(projectPart1.systemIncludeSearchPaths), Eq(projectPart1.systemIncludeSearchPaths),
Eq(projectPart1.projectIncludeSearchPaths))); Eq(projectPart1.projectIncludeSearchPaths),
Eq(Utils::Language::Cxx),
Eq(Utils::LanguageVersion::CXX14),
Eq(Utils::LanguageExtension::None)));
EXPECT_CALL(mockBuildDependenciesStorage, fetchLowestLastModifiedTime(A<FilePathId>())).WillRepeatedly(Return(QDateTime::currentSecsSinceEpoch())); EXPECT_CALL(mockBuildDependenciesStorage, fetchLowestLastModifiedTime(A<FilePathId>())).WillRepeatedly(Return(QDateTime::currentSecsSinceEpoch()));
EXPECT_CALL(mockSqliteTransactionBackend, commit()); EXPECT_CALL(mockSqliteTransactionBackend, commit());
EXPECT_CALL(mockCollector, setFile(_, _)).Times(0); EXPECT_CALL(mockCollector, setFile(_, _)).Times(0);

20
tests/unit/unittest/symbolstorage-test.cpp
View File

@@ -94,7 +94,10 @@ protected:
R"([["FOO","1",1]])", R"([["FOO","1",1]])",
systemIncludeSearchPathsText, systemIncludeSearchPathsText,
projectIncludeSearchPathsText, projectIncludeSearchPathsText,
74}; 74,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None};
}; };
TEST_F(SymbolStorage, CreateAndFillTemporaryLocationsTable) TEST_F(SymbolStorage, CreateAndFillTemporaryLocationsTable)
@@ -192,13 +195,22 @@ TEST_F(SymbolStorage, InsertOrUpdateProjectPart)
TypedEq<Utils::SmallStringView>(R"(["foo"])"), TypedEq<Utils::SmallStringView>(R"(["foo"])"),
TypedEq<Utils::SmallStringView>(R"([["FOO","1",1]])"), TypedEq<Utils::SmallStringView>(R"([["FOO","1",1]])"),
TypedEq<Utils::SmallStringView>(systemIncludeSearchPathsText), TypedEq<Utils::SmallStringView>(systemIncludeSearchPathsText),
TypedEq<Utils::SmallStringView>(projectIncludeSearchPathsText))); TypedEq<Utils::SmallStringView>(projectIncludeSearchPathsText),
1,
34,
0));
EXPECT_CALL( EXPECT_CALL(
getProjectPartIdStatement, valueReturnInt32(TypedEq<Utils::SmallStringView>("project"))) getProjectPartIdStatement, valueReturnInt32(TypedEq<Utils::SmallStringView>("project")))
.WillOnce(Return(74)); .WillOnce(Return(74));
storage.insertOrUpdateProjectPart( storage.insertOrUpdateProjectPart("project",
"project", {"foo"}, {{"FOO", "1", 1}}, systemIncludeSearchPaths, projectIncludeSearchPaths); {"foo"},
{{"FOO", "1", 1}},
systemIncludeSearchPaths,
projectIncludeSearchPaths,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None);
} }