feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity
Files
6976341e4b1270ca9d3088f61202f3e05f8eeaa2
qt-creator/tests/unit/unittest/symbolstorage-test.cpp

261 lines
11 KiB
C++
Raw Normal View History

Clang: Add symbol storage Extend file path cache to 64 bit integer. Change-Id: I5627f13d59a3214f389087038482cbcc8d0eb484 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-21 12:00:27 +02:00
/****************************************************************************
**
** Copyright (C) 2017 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#include "googletest.h"
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
#include "mockfilepathcaching.h"
Clang: Add symbol storage Extend file path cache to 64 bit integer. Change-Id: I5627f13d59a3214f389087038482cbcc8d0eb484 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-21 12:00:27 +02:00
#include "mocksqlitereadstatement.h"
#include "mocksqlitewritestatement.h"
#include <storagesqlitestatementfactory.h>
#include <symbolstorage.h>
#include <sqlitedatabase.h>
#include <storagesqlitestatementfactory.h>
namespace {
using Utils::PathString;
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
using ClangBackEnd::FilePathCachingInterface;
Clang: Add symbol storage Extend file path cache to 64 bit integer. Change-Id: I5627f13d59a3214f389087038482cbcc8d0eb484 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-21 12:00:27 +02:00
using ClangBackEnd::SymbolEntries;
using ClangBackEnd::SymbolEntry;
using ClangBackEnd::SourceLocationEntries;
using ClangBackEnd::SourceLocationEntry;
using ClangBackEnd::StorageSqliteStatementFactory;
using ClangBackEnd::SymbolType;
Sqlite: Remove the Sqlite Prefix We use a name space now, so the prefix is not of much use. Change-Id: I2b077576f94dab778add6ab2e54870f7ca18da78 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-18 10:21:45 +02:00
using Sqlite::Database;
using Sqlite::Table;
Clang: Add symbol storage Extend file path cache to 64 bit integer. Change-Id: I5627f13d59a3214f389087038482cbcc8d0eb484 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-21 12:00:27 +02:00
using StatementFactory = StorageSqliteStatementFactory<MockSqliteDatabase,
MockSqliteReadStatement,
MockSqliteWriteStatement>;
using Storage = ClangBackEnd::SymbolStorage<StatementFactory>;
class SymbolStorage : public testing::Test
{
protected:
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
MockFilePathCaching filePathCache;
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
NiceMock<MockSqliteDatabase> mockDatabase;
Clang: Add symbol storage Extend file path cache to 64 bit integer. Change-Id: I5627f13d59a3214f389087038482cbcc8d0eb484 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-21 12:00:27 +02:00
StatementFactory statementFactory{mockDatabase};
MockSqliteWriteStatement &insertSymbolsToNewSymbolsStatement = statementFactory.insertSymbolsToNewSymbolsStatement;
MockSqliteWriteStatement &insertLocationsToNewLocationsStatement = statementFactory.insertLocationsToNewLocationsStatement;
MockSqliteReadStatement &selectNewSourceIdsStatement = statementFactory.selectNewSourceIdsStatement;
MockSqliteWriteStatement &addNewSymbolsToSymbolsStatement = statementFactory.addNewSymbolsToSymbolsStatement;
MockSqliteWriteStatement &syncNewSymbolsFromSymbolsStatement = statementFactory.syncNewSymbolsFromSymbolsStatement;
MockSqliteWriteStatement &syncSymbolsIntoNewLocationsStatement = statementFactory.syncSymbolsIntoNewLocationsStatement;
MockSqliteWriteStatement &deleteAllLocationsFromUpdatedFilesStatement = statementFactory.deleteAllLocationsFromUpdatedFilesStatement;
MockSqliteWriteStatement &insertNewLocationsInLocationsStatement = statementFactory.insertNewLocationsInLocationsStatement;
MockSqliteWriteStatement &deleteNewSymbolsTableStatement = statementFactory.deleteNewSymbolsTableStatement;
MockSqliteWriteStatement &deleteNewLocationsTableStatement = statementFactory.deleteNewLocationsTableStatement;
Clang: Fix statement names for symbol storage Change-Id: Ieb242baf70ffedbdcfdbdbff2b780a1ffb810cc2 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-24 19:06:58 +01:00
MockSqliteWriteStatement &insertProjectPartStatement = statementFactory.insertProjectPartStatement;
MockSqliteWriteStatement &updateProjectPartStatement = statementFactory.updateProjectPartStatement;
MockSqliteReadStatement &getProjectPartIdStatement = statementFactory.getProjectPartIdStatement;
MockSqliteWriteStatement &deleteAllProjectPartsSourcesWithProjectPartIdStatement = statementFactory.deleteAllProjectPartsSourcesWithProjectPartIdStatement;
MockSqliteWriteStatement &insertProjectPartSourcesStatement = statementFactory.insertProjectPartSourcesStatement;
Clang: Rename defineName in macroName Change-Id: Iaf8da991032e5ed4726384c051290a77887351fa Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-25 15:20:47 +01:00
MockSqliteWriteStatement &insertIntoNewUsedMacrosStatement = statementFactory.insertIntoNewUsedMacrosStatement;
MockSqliteWriteStatement &syncNewUsedMacrosStatement = statementFactory.syncNewUsedMacrosStatement;
MockSqliteWriteStatement &deleteOutdatedUsedMacrosStatement = statementFactory.deleteOutdatedUsedMacrosStatement;
MockSqliteWriteStatement &deleteNewUsedMacrosTableStatement = statementFactory.deleteNewUsedMacrosTableStatement;
Clang: Add insert file information to symbol storage We use INSERT OR REPLACE because it is simpler than the insert and update and we provide the primary key by our self. Change-Id: I868e040918cc6c2ed183cecc746c89bec136f974 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-30 13:31:14 +01:00
MockSqliteWriteStatement &insertFileInformations = statementFactory.insertFileInformations;
Clang: Add source dependency saving to the symbol storage The source dependencies are simply a table which connects the include file with the included file. Change-Id: I5454e81a2b5b98f05c7ff3f6740a6d45e01772c3 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-30 18:41:45 +01:00
MockSqliteWriteStatement &insertIntoNewSourceDependenciesStatement = statementFactory.insertIntoNewSourceDependenciesStatement;
MockSqliteWriteStatement &syncNewSourceDependenciesStatement = statementFactory.syncNewSourceDependenciesStatement;
MockSqliteWriteStatement &deleteOutdatedSourceDependenciesStatement = statementFactory.deleteOutdatedSourceDependenciesStatement;
MockSqliteWriteStatement &deleteNewSourceDependenciesStatement = statementFactory.deleteNewSourceDependenciesStatement;
Clang: Add symbol storage Extend file path cache to 64 bit integer. Change-Id: I5627f13d59a3214f389087038482cbcc8d0eb484 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-21 12:00:27 +02:00
SymbolEntries symbolEntries{{1, {"functionUSR", "function"}},
{2, {"function2USR", "function2"}}};
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
SourceLocationEntries sourceLocations{{1, {1, 3}, {42, 23}, SymbolType::Declaration},
{2, {1, 4}, {7, 11}, SymbolType::Declaration}};
Clang: Add symbol storage Extend file path cache to 64 bit integer. Change-Id: I5627f13d59a3214f389087038482cbcc8d0eb484 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-21 12:00:27 +02:00
Storage storage{statementFactory, filePathCache};
};
TEST_F(SymbolStorage, CreateAndFillTemporaryLocationsTable)
{
InSequence sequence;
EXPECT_CALL(insertLocationsToNewLocationsStatement, write(1, 42, 23, 3));
EXPECT_CALL(insertLocationsToNewLocationsStatement, write(2, 7, 11, 4));
storage.fillTemporaryLocationsTable(sourceLocations);
}
TEST_F(SymbolStorage, AddNewSymbolsToSymbols)
{
EXPECT_CALL(addNewSymbolsToSymbolsStatement, execute());
storage.addNewSymbolsToSymbols();
}
TEST_F(SymbolStorage, SyncNewSymbolsFromSymbols)
{
EXPECT_CALL(syncNewSymbolsFromSymbolsStatement, execute());
storage.syncNewSymbolsFromSymbols();
}
TEST_F(SymbolStorage, SyncSymbolsIntoNewLocations)
{
EXPECT_CALL(syncSymbolsIntoNewLocationsStatement, execute());
storage.syncSymbolsIntoNewLocations();
}
TEST_F(SymbolStorage, DeleteAllLocationsFromUpdatedFiles)
{
EXPECT_CALL(deleteAllLocationsFromUpdatedFilesStatement, execute());
storage.deleteAllLocationsFromUpdatedFiles();
}
TEST_F(SymbolStorage, InsertNewLocationsInLocations)
{
EXPECT_CALL(insertNewLocationsInLocationsStatement, execute());
storage.insertNewLocationsInLocations();
}
TEST_F(SymbolStorage, DropNewSymbolsTable)
{
EXPECT_CALL(deleteNewSymbolsTableStatement, execute());
storage.deleteNewSymbolsTable();
}
TEST_F(SymbolStorage, DropNewLocationsTable)
{
EXPECT_CALL(deleteNewLocationsTableStatement, execute());
storage.deleteNewLocationsTable();
}
TEST_F(SymbolStorage, AddSymbolsAndSourceLocationsCallsWrite)
{
InSequence sequence;
Clang: Add insert file information to symbol storage We use INSERT OR REPLACE because it is simpler than the insert and update and we provide the primary key by our self. Change-Id: I868e040918cc6c2ed183cecc746c89bec136f974 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-30 13:31:14 +01:00
EXPECT_CALL(insertSymbolsToNewSymbolsStatement, write(An<uint>(), An<Utils::SmallStringView>(), _)).Times(2);
Clang: Add symbol storage Extend file path cache to 64 bit integer. Change-Id: I5627f13d59a3214f389087038482cbcc8d0eb484 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-21 12:00:27 +02:00
EXPECT_CALL(insertLocationsToNewLocationsStatement, write(1, 42, 23, 3));
EXPECT_CALL(insertLocationsToNewLocationsStatement, write(2, 7, 11, 4));
EXPECT_CALL(addNewSymbolsToSymbolsStatement, execute());
EXPECT_CALL(syncNewSymbolsFromSymbolsStatement, execute());
EXPECT_CALL(syncSymbolsIntoNewLocationsStatement, execute());
EXPECT_CALL(deleteAllLocationsFromUpdatedFilesStatement, execute());
EXPECT_CALL(insertNewLocationsInLocationsStatement, execute());
EXPECT_CALL(deleteNewSymbolsTableStatement, execute());
EXPECT_CALL(deleteNewLocationsTableStatement, execute());
storage.addSymbolsAndSourceLocations(symbolEntries, sourceLocations);
}
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
TEST_F(SymbolStorage, ConvertStringsToJson)
{
Utils::SmallStringVector strings{"foo", "bar", "foo"};
auto jsonText = storage.toJson(strings);
ASSERT_THAT(jsonText, Eq("[\"foo\",\"bar\",\"foo\"]"));
}
TEST_F(SymbolStorage, InsertProjectPart)
{
InSequence sequence;
ON_CALL(mockDatabase, lastInsertedRowId()).WillByDefault(Return(1));
EXPECT_CALL(mockDatabase, setLastInsertedRowId(-1));
Clang: Add macro names the to project part So we can compare later if the macro names have changed. Change-Id: I65c5f76e07fced8df6cc7282c03430adffcf5fa8 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-29 12:07:15 +01:00
EXPECT_CALL(insertProjectPartStatement,
write(TypedEq<Utils::SmallStringView>("project"),
TypedEq<Utils::SmallStringView>("[\"foo\"]"),
TypedEq<Utils::SmallStringView>("[\"FOO\"]")));
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
EXPECT_CALL(mockDatabase, lastInsertedRowId());
Clang: Add macro names the to project part So we can compare later if the macro names have changed. Change-Id: I65c5f76e07fced8df6cc7282c03430adffcf5fa8 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-29 12:07:15 +01:00
storage.insertOrUpdateProjectPart("project", {"foo"}, {"FOO"});
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
}
TEST_F(SymbolStorage, UpdateProjectPart)
{
InSequence sequence;
ON_CALL(mockDatabase, lastInsertedRowId()).WillByDefault(Return(-1));
EXPECT_CALL(mockDatabase, setLastInsertedRowId(-1));
Clang: Add macro names the to project part So we can compare later if the macro names have changed. Change-Id: I65c5f76e07fced8df6cc7282c03430adffcf5fa8 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-29 12:07:15 +01:00
EXPECT_CALL(insertProjectPartStatement,
write(TypedEq<Utils::SmallStringView>("project"),
TypedEq<Utils::SmallStringView>("[\"foo\"]"),
TypedEq<Utils::SmallStringView>("[\"FOO\"]")));
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
EXPECT_CALL(mockDatabase, lastInsertedRowId());
Clang: Add macro names the to project part So we can compare later if the macro names have changed. Change-Id: I65c5f76e07fced8df6cc7282c03430adffcf5fa8 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-29 12:07:15 +01:00
EXPECT_CALL(updateProjectPartStatement,
write(TypedEq<Utils::SmallStringView>("[\"foo\"]"),
TypedEq<Utils::SmallStringView>("[\"FOO\"]"),
TypedEq<Utils::SmallStringView>("project")));
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
Clang: Add macro names the to project part So we can compare later if the macro names have changed. Change-Id: I65c5f76e07fced8df6cc7282c03430adffcf5fa8 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-29 12:07:15 +01:00
storage.insertOrUpdateProjectPart("project", {"foo"}, {"FOO"});
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
}
TEST_F(SymbolStorage, UpdateProjectPartSources)
Clang: Add symbol storage Extend file path cache to 64 bit integer. Change-Id: I5627f13d59a3214f389087038482cbcc8d0eb484 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-21 12:00:27 +02:00
{
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
InSequence sequence;
Clang: Fix statement names for symbol storage Change-Id: Ieb242baf70ffedbdcfdbdbff2b780a1ffb810cc2 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-24 19:06:58 +01:00
EXPECT_CALL(getProjectPartIdStatement, valueReturnInt32(TypedEq<Utils::SmallStringView>("project"))).WillRepeatedly(Return(42));
EXPECT_CALL(deleteAllProjectPartsSourcesWithProjectPartIdStatement, write(TypedEq<int>(42)));
EXPECT_CALL(insertProjectPartSourcesStatement, write(TypedEq<int>(42), TypedEq<int>(1)));
EXPECT_CALL(insertProjectPartSourcesStatement, write(TypedEq<int>(42), TypedEq<int>(2)));
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
storage.updateProjectPartSources("project", {{1, 1}, {1, 2}});
Clang: Add symbol storage Extend file path cache to 64 bit integer. Change-Id: I5627f13d59a3214f389087038482cbcc8d0eb484 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-21 12:00:27 +02:00
}
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
Clang: Rename defineName in macroName Change-Id: Iaf8da991032e5ed4726384c051290a77887351fa Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-25 15:20:47 +01:00
TEST_F(SymbolStorage, InsertOrUpdateUsedMacros)
Clang: Store UsedDefines in the symbol database We write the new defines in a temporary table and then write every new entry in the usedDefines table, followed by remove of every entry in usedDefines which are not in the temporary table but have a file entry in common with one of the entries in the temporary table. At last we clean up the temporary table. Change-Id: Idf11ce8d17ad9ccef490578059fac08409fcc5d9 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-24 18:06:15 +01:00
{
InSequence sequence;
Clang: Rename defineName in macroName Change-Id: Iaf8da991032e5ed4726384c051290a77887351fa Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-25 15:20:47 +01:00
EXPECT_CALL(insertIntoNewUsedMacrosStatement, write(TypedEq<uint>(42), TypedEq<Utils::SmallStringView>("FOO")));
EXPECT_CALL(insertIntoNewUsedMacrosStatement, write(TypedEq<uint>(43), TypedEq<Utils::SmallStringView>("BAR")));
EXPECT_CALL(syncNewUsedMacrosStatement, execute());
EXPECT_CALL(deleteOutdatedUsedMacrosStatement, execute());
EXPECT_CALL(deleteNewUsedMacrosTableStatement, execute());
Clang: Store UsedDefines in the symbol database We write the new defines in a temporary table and then write every new entry in the usedDefines table, followed by remove of every entry in usedDefines which are not in the temporary table but have a file entry in common with one of the entries in the temporary table. At last we clean up the temporary table. Change-Id: Idf11ce8d17ad9ccef490578059fac08409fcc5d9 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-24 18:06:15 +01:00
Clang: Rename defineName in macroName Change-Id: Iaf8da991032e5ed4726384c051290a77887351fa Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-25 15:20:47 +01:00
storage.insertOrUpdateUsedMacros({{"FOO", {1, 42}}, {"BAR", {1, 43}}});
Clang: Store UsedDefines in the symbol database We write the new defines in a temporary table and then write every new entry in the usedDefines table, followed by remove of every entry in usedDefines which are not in the temporary table but have a file entry in common with one of the entries in the temporary table. At last we clean up the temporary table. Change-Id: Idf11ce8d17ad9ccef490578059fac08409fcc5d9 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-24 18:06:15 +01:00
}
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
Clang: Add insert file information to symbol storage We use INSERT OR REPLACE because it is simpler than the insert and update and we provide the primary key by our self. Change-Id: I868e040918cc6c2ed183cecc746c89bec136f974 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-30 13:31:14 +01:00
TEST_F(SymbolStorage, InsertFileInformations)
{
EXPECT_CALL(insertFileInformations, write(TypedEq<uint>(42), TypedEq<uint>(1), TypedEq<uint>(2)));
EXPECT_CALL(insertFileInformations, write(TypedEq<uint>(43), TypedEq<uint>(4), TypedEq<uint>(5)));
storage.insertFileInformations({{{1, 42}, 1, 2}, {{1, 43}, 4, 5}});
}
Clang: Add source dependency saving to the symbol storage The source dependencies are simply a table which connects the include file with the included file. Change-Id: I5454e81a2b5b98f05c7ff3f6740a6d45e01772c3 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-30 18:41:45 +01:00
TEST_F(SymbolStorage, InsertOrUpdateSourceDependencies)
{
InSequence sequence;
EXPECT_CALL(insertIntoNewSourceDependenciesStatement, write(TypedEq<int>(42), TypedEq<int>(1)));
EXPECT_CALL(insertIntoNewSourceDependenciesStatement, write(TypedEq<int>(42), TypedEq<int>(2)));
EXPECT_CALL(syncNewSourceDependenciesStatement, execute());
EXPECT_CALL(deleteOutdatedSourceDependenciesStatement, execute());
EXPECT_CALL(deleteNewSourceDependenciesStatement, execute());
storage.insertOrUpdateSourceDependencies({{{1, 42}, {1, 1}}, {{1, 42}, {1, 2}}});
}
Clang: Add symbol storage Extend file path cache to 64 bit integer. Change-Id: I5627f13d59a3214f389087038482cbcc8d0eb484 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-21 12:00:27 +02:00
}
Copy Permalink