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

667 lines
28 KiB
C++
Raw Normal View History

Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
/****************************************************************************
**
** Copyright (C) 2018 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"
#include "mocksqlitedatabase.h"
Clang: Minimize reindexing We optimal indexer is only reindexing if the index would be changed. This patch is a step in that direction. We only reindex now if the file or project has changed. It fixes some typos too. Task-number: QTCREATORBUG-21150 Change-Id: I6ea1c13282fbcd70253b9b2939aed37580dbd160 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-21 17:55:24 +01:00
#include <builddependenciesstorage.h>
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
#include <projectpartsstorage.h>
Clang: Reduce database accesses If we prefetch data from the database to the caches we reduce the database transaction calls which are quite expensive. Change-Id: I617a0d886807402e0a94291a913a77f989970b55 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-20 14:45:01 +02:00
#include <projectpartstoragestructs.h>
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
#include <refactoringdatabaseinitializer.h>
#include <sqlitedatabase.h>
#include <sqlitereadstatement.h>
#include <sqlitewritestatement.h>
Clang: Minimize reindexing We optimal indexer is only reindexing if the index would be changed. This patch is a step in that direction. We only reindex now if the file or project has changed. It fixes some typos too. Task-number: QTCREATORBUG-21150 Change-Id: I6ea1c13282fbcd70253b9b2939aed37580dbd160 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-21 17:55:24 +01:00
#include <symbolstorage.h>
Clang: Reduce database accesses If we prefetch data from the database to the caches we reduce the database transaction calls which are quite expensive. Change-Id: I617a0d886807402e0a94291a913a77f989970b55 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-20 14:45:01 +02:00
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
namespace {
using ClangBackEnd::FilePathId;
using ClangBackEnd::IncludeSearchPath;
using ClangBackEnd::IncludeSearchPaths;
using ClangBackEnd::IncludeSearchPathType;
using ClangBackEnd::ProjectPartId;
using ClangBackEnd::ProjectPartIds;
class Data
{
protected:
ClangBackEnd::ProjectPartContainer projectPart1{1,
{"-m32"},
{{"FOO", "1", 1}},
{{"/include", 1, IncludeSearchPathType::System}},
{{"/home/yi", 2, IncludeSearchPathType::User}},
{1, 2},
{3, 4},
Utils::Language::Cxx,
Utils::LanguageVersion::CXX14,
Utils::LanguageExtension::Microsoft};
ClangBackEnd::ProjectPartContainer projectPart2{2,
{"-m64"},
{{"BAR", "2", 1}},
{{"/usr/include", 1, IncludeSearchPathType::System}},
{{"/home/er", 2, IncludeSearchPathType::User}},
{5, 6},
{7, 8},
Utils::Language::C,
Utils::LanguageVersion::C11,
Utils::LanguageExtension::Gnu};
};
class ProjectPartsStorage : public testing::Test, public Data
{
using Storage = ClangBackEnd::ProjectPartsStorage<MockSqliteDatabase>;
protected:
ProjectPartsStorage()
{
ON_CALL(fetchProjectPartByIdStatement, valueReturnProjectPartContainer(Eq(1)))
.WillByDefault(Return(projectPart1));
ON_CALL(fetchProjectPartByIdStatement, valueReturnProjectPartContainer(Eq(2)))
.WillByDefault(Return(projectPart2));
ON_CALL(fetchProjectPartsHeadersByIdStatement, valuesReturnFilePathIds(_, Eq(1)))
.WillByDefault(Return(projectPart1.headerPathIds));
ON_CALL(fetchProjectPartsHeadersByIdStatement, valuesReturnFilePathIds(_, Eq(2)))
.WillByDefault(Return(projectPart2.headerPathIds));
ON_CALL(fetchProjectPartsSourcesByIdStatement, valuesReturnFilePathIds(_, Eq(1)))
.WillByDefault(Return(projectPart1.sourcePathIds));
ON_CALL(fetchProjectPartsSourcesByIdStatement, valuesReturnFilePathIds(_, Eq(2)))
.WillByDefault(Return(projectPart2.sourcePathIds));
}
NiceMock<MockSqliteDatabase> mockDatabase;
Storage storage{mockDatabase};
MockSqliteReadStatement &fetchProjectPartIdStatement = storage.fetchProjectPartIdStatement;
MockSqliteWriteStatement &insertProjectPartNameStatement = storage.insertProjectPartNameStatement;
MockSqliteReadStatement &fetchProjectPartNameStatement = storage.fetchProjectPartNameStatement;
MockSqliteReadStatement &fetchProjectPartsStatement = storage.fetchProjectPartsStatement;
MockSqliteReadStatement &fetchProjectPartByIdStatement = storage.fetchProjectPartByIdStatement;
MockSqliteWriteStatement &updateProjectPartStatement = storage.updateProjectPartStatement;
MockSqliteReadStatement &getProjectPartArtefactsBySourceId = storage.getProjectPartArtefactsBySourceId;
MockSqliteReadStatement &getProjectPartArtefactsByProjectPartId = storage.getProjectPartArtefactsByProjectPartId;
MockSqliteWriteStatement &deleteProjectPartsHeadersByIdStatement = storage.deleteProjectPartsHeadersByIdStatement;
MockSqliteWriteStatement &deleteProjectPartsSourcesByIdStatement = storage.deleteProjectPartsSourcesByIdStatement;
MockSqliteWriteStatement &insertProjectPartsHeadersStatement = storage.insertProjectPartsHeadersStatement;
MockSqliteWriteStatement &insertProjectPartsSourcesStatement = storage.insertProjectPartsSourcesStatement;
MockSqliteReadStatement &fetchProjectPartsHeadersByIdStatement = storage.fetchProjectPartsHeadersByIdStatement;
MockSqliteReadStatement &fetchProjectPartsSourcesByIdStatement = storage.fetchProjectPartsSourcesByIdStatement;
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
MockSqliteReadStatement &fetchProjectPrecompiledHeaderPathStatement = storage.fetchProjectPrecompiledHeaderBuildTimeStatement;
MockSqliteReadStatement &fetchProjectPrecompiledHeaderBuildTimeStatement = storage.fetchProjectPrecompiledHeaderBuildTimeStatement;
Clang: Minimize reindexing We optimal indexer is only reindexing if the index would be changed. This patch is a step in that direction. We only reindex now if the file or project has changed. It fixes some typos too. Task-number: QTCREATORBUG-21150 Change-Id: I6ea1c13282fbcd70253b9b2939aed37580dbd160 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-21 17:55:24 +01:00
MockSqliteWriteStatement &resetDependentIndexingTimeStampsStatement = storage.resetDependentIndexingTimeStampsStatement;
Clang: Reduce database accesses If we prefetch data from the database to the caches we reduce the database transaction calls which are quite expensive. Change-Id: I617a0d886807402e0a94291a913a77f989970b55 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-20 14:45:01 +02:00
MockSqliteReadStatement &fetchAllProjectPartNamesAndIdsStatement = storage.fetchAllProjectPartNamesAndIdsStatement;
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
IncludeSearchPaths systemIncludeSearchPaths{{"/includes", 1, IncludeSearchPathType::BuiltIn},
{"/other/includes", 2, IncludeSearchPathType::System}};
IncludeSearchPaths projectIncludeSearchPaths{{"/project/includes", 1, IncludeSearchPathType::User},
{"/other/project/includes",
2,
IncludeSearchPathType::User}};
Utils::SmallString systemIncludeSearchPathsText{R"([["/includes",1,2],["/other/includes",2,3]])"};
Utils::SmallString projectIncludeSearchPathsText{
R"([["/project/includes",1,1],["/other/project/includes",2,1]])"};
ClangBackEnd::ProjectPartArtefact artefact{R"(["-DFOO"])",
R"([["FOO","1",1]])",
systemIncludeSearchPathsText,
projectIncludeSearchPathsText,
74,
Utils::Language::Cxx,
Utils::LanguageVersion::CXX11,
Utils::LanguageExtension::None};
Clang: Reduce database accesses If we prefetch data from the database to the caches we reduce the database transaction calls which are quite expensive. Change-Id: I617a0d886807402e0a94291a913a77f989970b55 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-20 14:45:01 +02:00
ClangBackEnd::Internal::ProjectPartNameIds projectPartNameIds{{"projectPartName", 2}};
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
};
TEST_F(ProjectPartsStorage, CallsFetchProjectIdWithNonExistingProjectPartName)
{
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchProjectPartIdStatement,
valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")));
EXPECT_CALL(insertProjectPartNameStatement, write(TypedEq<Utils::SmallStringView>("test")));
EXPECT_CALL(mockDatabase, commit());
storage.fetchProjectPartId("test");
}
Clang: Reduce database accesses If we prefetch data from the database to the caches we reduce the database transaction calls which are quite expensive. Change-Id: I617a0d886807402e0a94291a913a77f989970b55 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-20 14:45:01 +02:00
TEST_F(ProjectPartsStorage, CallsFetchProjectIdWithNonExistingProjectPartNameUnguarded)
{
InSequence s;
EXPECT_CALL(fetchProjectPartIdStatement,
valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")));
EXPECT_CALL(insertProjectPartNameStatement, write(TypedEq<Utils::SmallStringView>("test")));
storage.fetchProjectPartIdUnguarded("test");
}
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
TEST_F(ProjectPartsStorage, CallsFetchProjectIdWithExistingProjectPart)
{
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchProjectPartIdStatement,
valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")))
.WillOnce(Return(Utils::optional<ProjectPartId>{20}));
EXPECT_CALL(insertProjectPartNameStatement, write(TypedEq<Utils::SmallStringView>("test"))).Times(0);
EXPECT_CALL(mockDatabase, commit());
storage.fetchProjectPartId("test");
}
Clang: Reduce database accesses If we prefetch data from the database to the caches we reduce the database transaction calls which are quite expensive. Change-Id: I617a0d886807402e0a94291a913a77f989970b55 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-20 14:45:01 +02:00
TEST_F(ProjectPartsStorage, CallsFetchProjectIdWithExistingProjectPartUnguarded)
{
InSequence s;
EXPECT_CALL(fetchProjectPartIdStatement,
valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")))
.WillOnce(Return(Utils::optional<ProjectPartId>{20}));
EXPECT_CALL(insertProjectPartNameStatement, write(TypedEq<Utils::SmallStringView>("test"))).Times(0);
storage.fetchProjectPartIdUnguarded("test");
}
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
TEST_F(ProjectPartsStorage, CallsFetchProjectIdWithBusyDatabaset)
{
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchProjectPartIdStatement,
valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")));
EXPECT_CALL(insertProjectPartNameStatement, write(TypedEq<Utils::SmallStringView>("test")))
.WillOnce(Throw(Sqlite::StatementIsBusy("busy")));
EXPECT_CALL(mockDatabase, rollback());
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchProjectPartIdStatement,
valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")));
EXPECT_CALL(insertProjectPartNameStatement, write(TypedEq<Utils::SmallStringView>("test")));
EXPECT_CALL(mockDatabase, commit());
storage.fetchProjectPartId("test");
}
TEST_F(ProjectPartsStorage, FetchProjectIdWithNonExistingProjectPartName)
{
ON_CALL(fetchProjectPartIdStatement,
valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")))
.WillByDefault(Return(Utils::optional<ProjectPartId>{}));
ON_CALL(mockDatabase, lastInsertedRowId()).WillByDefault(Return(21));
auto id = storage.fetchProjectPartId("test");
ASSERT_THAT(id.projectPathId, 21);
}
Clang: Reduce database accesses If we prefetch data from the database to the caches we reduce the database transaction calls which are quite expensive. Change-Id: I617a0d886807402e0a94291a913a77f989970b55 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-20 14:45:01 +02:00
TEST_F(ProjectPartsStorage, FetchProjectIdWithNonExistingProjectPartNameUnguarded)
{
ON_CALL(fetchProjectPartIdStatement,
valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")))
.WillByDefault(Return(Utils::optional<ProjectPartId>{}));
ON_CALL(mockDatabase, lastInsertedRowId()).WillByDefault(Return(21));
auto id = storage.fetchProjectPartIdUnguarded("test");
ASSERT_THAT(id.projectPathId, 21);
}
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
TEST_F(ProjectPartsStorage, FetchProjectIdWithNonExistingProjectPartNameAndIsBusy)
{
InSequence s;
EXPECT_CALL(fetchProjectPartIdStatement,
valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")))
.WillOnce(Throw(Sqlite::StatementIsBusy("busy")));
EXPECT_CALL(fetchProjectPartIdStatement,
valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")))
.WillOnce(Return(ClangBackEnd::ProjectPartId{21}));
ON_CALL(mockDatabase, lastInsertedRowId()).WillByDefault(Return(21));
auto id = storage.fetchProjectPartId("test");
ASSERT_THAT(id.projectPathId, 21);
}
TEST_F(ProjectPartsStorage, FetchProjectIdWithExistingProjectPartName)
{
ON_CALL(fetchProjectPartIdStatement,
valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")))
.WillByDefault(Return(Utils::optional<ProjectPartId>{20}));
auto id = storage.fetchProjectPartId("test");
ASSERT_THAT(id.projectPathId, 20);
}
Clang: Reduce database accesses If we prefetch data from the database to the caches we reduce the database transaction calls which are quite expensive. Change-Id: I617a0d886807402e0a94291a913a77f989970b55 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-20 14:45:01 +02:00
TEST_F(ProjectPartsStorage, FetchProjectIdWithExistingProjectPartNameUnguarded)
{
ON_CALL(fetchProjectPartIdStatement,
valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")))
.WillByDefault(Return(Utils::optional<ProjectPartId>{20}));
auto id = storage.fetchProjectPartIdUnguarded("test");
ASSERT_THAT(id.projectPathId, 20);
}
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
TEST_F(ProjectPartsStorage, FetchProjectPartName)
{
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchProjectPartNameStatement, valueReturnPathString(TypedEq<int>(12)))
.WillOnce(Return(Utils::optional<Utils::PathString>{"test"}));
EXPECT_CALL(mockDatabase, commit());
storage.fetchProjectPartName(12);
}
TEST_F(ProjectPartsStorage, FetchProjectPartNameStatementIsBusy)
{
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchProjectPartNameStatement, valueReturnPathString(TypedEq<int>(12)))
.WillOnce(Throw(Sqlite::StatementIsBusy{""}));
EXPECT_CALL(mockDatabase, rollback());
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchProjectPartNameStatement, valueReturnPathString(TypedEq<int>(12)))
.WillOnce(Return(Utils::optional<Utils::PathString>{"test"}));
EXPECT_CALL(mockDatabase, commit());
storage.fetchProjectPartName(12);
}
TEST_F(ProjectPartsStorage, FetchProjectParts)
{
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchProjectPartsStatement, valuesReturnProjectPartContainers(4096));
EXPECT_CALL(mockDatabase, commit());
storage.fetchProjectParts();
}
TEST_F(ProjectPartsStorage, FetchProjectPartsByIds)
{
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchProjectPartByIdStatement, valueReturnProjectPartContainer(Eq(1)));
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
EXPECT_CALL(fetchProjectPartsHeadersByIdStatement, valuesReturnFilePathIds(1024, Eq(1)));
EXPECT_CALL(fetchProjectPartsSourcesByIdStatement, valuesReturnFilePathIds(1024, Eq(1)));
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
EXPECT_CALL(fetchProjectPrecompiledHeaderBuildTimeStatement, valueReturnInt64(Eq(1)));
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
EXPECT_CALL(fetchProjectPartByIdStatement, valueReturnProjectPartContainer(Eq(2)));
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
EXPECT_CALL(fetchProjectPartsHeadersByIdStatement, valuesReturnFilePathIds(1024, Eq(2)));
EXPECT_CALL(fetchProjectPartsSourcesByIdStatement, valuesReturnFilePathIds(1024, Eq(2)));
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
EXPECT_CALL(fetchProjectPrecompiledHeaderBuildTimeStatement, valueReturnInt64(Eq(2)));
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
EXPECT_CALL(mockDatabase, commit());
storage.fetchProjectParts({1, 2});
}
TEST_F(ProjectPartsStorage, FetchProjectPartsByIdsIsBusy)
{
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchProjectPartByIdStatement, valueReturnProjectPartContainer(Eq(1)));
EXPECT_CALL(fetchProjectPartByIdStatement, valueReturnProjectPartContainer(Eq(2)))
.WillOnce(Throw(Sqlite::StatementIsBusy{""}));
EXPECT_CALL(mockDatabase, rollback());
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchProjectPartByIdStatement, valueReturnProjectPartContainer(Eq(1)));
EXPECT_CALL(fetchProjectPartByIdStatement, valueReturnProjectPartContainer(Eq(2)));
EXPECT_CALL(mockDatabase, commit());
storage.fetchProjectParts({1, 2});
}
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
TEST_F(ProjectPartsStorage, FetchProjectPartsByIdsPreCompiledHeaderWasGeneratedNullOptional)
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
{
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
ON_CALL(fetchProjectPrecompiledHeaderBuildTimeStatement, valueReturnInt64(Eq(1)))
.WillByDefault(Return(Utils::optional<long long>{}));
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
auto projectParts = storage.fetchProjectParts({1});
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
ASSERT_FALSE(projectParts.front().preCompiledHeaderWasGenerated);
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
}
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
TEST_F(ProjectPartsStorage, FetchProjectPartsByIdsPreCompiledHeaderWasGeneratedZero)
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
{
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
ON_CALL(fetchProjectPrecompiledHeaderBuildTimeStatement, valueReturnInt64(Eq(1)))
.WillByDefault(Return(Utils::optional<long long>{0}));
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
auto projectParts = storage.fetchProjectParts({1});
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
ASSERT_FALSE(projectParts.front().preCompiledHeaderWasGenerated);
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
}
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
TEST_F(ProjectPartsStorage, FetchProjectPartsByIdsPreCompiledHeaderWasGeneratedSomeNumber)
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
{
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
ON_CALL(fetchProjectPrecompiledHeaderBuildTimeStatement, valueReturnInt64(Eq(1)))
.WillByDefault(Return(Utils::optional<long long>{23}));
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
auto projectParts = storage.fetchProjectParts({1});
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
ASSERT_TRUE(projectParts.front().preCompiledHeaderWasGenerated);
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
}
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
TEST_F(ProjectPartsStorage, FetchProjectPartsByIdsHasMissingId)
{
auto projectParts = storage.fetchProjectParts({1, 2, 3});
ASSERT_THAT(projectParts, ElementsAre(projectPart1, projectPart2));
}
TEST_F(ProjectPartsStorage, ConvertStringsToJson)
{
Utils::SmallStringVector strings{"foo", "bar", "foo"};
auto jsonText = storage.toJson(strings);
ASSERT_THAT(jsonText, Eq("[\"foo\",\"bar\",\"foo\"]"));
}
TEST_F(ProjectPartsStorage, UpdateProjectParts)
{
InSequence sequence;
EXPECT_CALL(mockDatabase, immediateBegin());
EXPECT_CALL(updateProjectPartStatement,
write(TypedEq<int>(1),
TypedEq<Utils::SmallStringView>(R"(["-m32"])"),
TypedEq<Utils::SmallStringView>(R"([["FOO","1",1]])"),
TypedEq<Utils::SmallStringView>(R"([["/include",1,3]])"),
TypedEq<Utils::SmallStringView>(R"([["/home/yi",2,1]])"),
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
2,
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
35,
2));
EXPECT_CALL(deleteProjectPartsHeadersByIdStatement, write(TypedEq<int>(1)));
EXPECT_CALL(insertProjectPartsHeadersStatement, write(TypedEq<int>(1), TypedEq<int>(1)));
EXPECT_CALL(insertProjectPartsHeadersStatement, write(TypedEq<int>(1), TypedEq<int>(2)));
EXPECT_CALL(deleteProjectPartsSourcesByIdStatement, write(TypedEq<int>(1)));
EXPECT_CALL(insertProjectPartsSourcesStatement, write(TypedEq<int>(1), TypedEq<int>(3)));
EXPECT_CALL(insertProjectPartsSourcesStatement, write(TypedEq<int>(1), TypedEq<int>(4)));
EXPECT_CALL(updateProjectPartStatement,
write(TypedEq<int>(2),
TypedEq<Utils::SmallStringView>(R"(["-m64"])"),
TypedEq<Utils::SmallStringView>(R"([["BAR","2",1]])"),
TypedEq<Utils::SmallStringView>(R"([["/usr/include",1,3]])"),
TypedEq<Utils::SmallStringView>(R"([["/home/er",2,1]])"),
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
1,
3,
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
1));
EXPECT_CALL(deleteProjectPartsHeadersByIdStatement, write(TypedEq<int>(2)));
EXPECT_CALL(insertProjectPartsHeadersStatement, write(TypedEq<int>(2), TypedEq<int>(5)));
EXPECT_CALL(insertProjectPartsHeadersStatement, write(TypedEq<int>(2), TypedEq<int>(6)));
EXPECT_CALL(deleteProjectPartsSourcesByIdStatement, write(TypedEq<int>(2)));
EXPECT_CALL(insertProjectPartsSourcesStatement, write(TypedEq<int>(2), TypedEq<int>(7)));
EXPECT_CALL(insertProjectPartsSourcesStatement, write(TypedEq<int>(2), TypedEq<int>(8)));
EXPECT_CALL(mockDatabase, commit());
storage.updateProjectParts({projectPart1, projectPart2});
}
TEST_F(ProjectPartsStorage, UpdateProjectPartsIsBusy)
{
InSequence sequence;
EXPECT_CALL(mockDatabase, immediateBegin()).WillOnce(Throw(Sqlite::StatementIsBusy{""}));
EXPECT_CALL(mockDatabase, immediateBegin());
EXPECT_CALL(updateProjectPartStatement,
write(TypedEq<int>(1),
TypedEq<Utils::SmallStringView>(R"(["-m32"])"),
TypedEq<Utils::SmallStringView>(R"([["FOO","1",1]])"),
TypedEq<Utils::SmallStringView>(R"([["/include",1,3]])"),
TypedEq<Utils::SmallStringView>(R"([["/home/yi",2,1]])"),
ClangPchManager: Handle non generated PCHs Sometimes we start generation of PCHs but not finish it. In that case we should redo it at the next start of the backend process. So we now remove the old precompiled header if we add the task to the queue. If we successfully generated the PCH it will be set again. But if we did not it will be read from the database and set to false. Task-number: QTCREATORBUG-22035 Change-Id: Id53c2b4e4f501fc5ef7830558085607baa6a49f1 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-19 17:00:03 +01:00
2,
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
35,
2));
EXPECT_CALL(mockDatabase, commit());
storage.updateProjectParts({projectPart1});
}
TEST_F(ProjectPartsStorage, FetchProjectPartArtefactBySourceIdCallsValueInStatement)
{
Clang: Move transactions to storage We call the function anyway only isolated from other queries, so we can move the transaction guards to the project storage. Change-Id: I7cca26b25c2258856c68821671085c0a68044693 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-15 11:24:58 +02:00
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
EXPECT_CALL(getProjectPartArtefactsBySourceId, valueReturnProjectPartArtefact(1))
.WillRepeatedly(Return(artefact));
Clang: Move transactions to storage We call the function anyway only isolated from other queries, so we can move the transaction guards to the project storage. Change-Id: I7cca26b25c2258856c68821671085c0a68044693 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-15 11:24:58 +02:00
EXPECT_CALL(mockDatabase, commit());
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
storage.fetchProjectPartArtefact(FilePathId{1});
}
Clang: Move transactions to storage We call the function anyway only isolated from other queries, so we can move the transaction guards to the project storage. Change-Id: I7cca26b25c2258856c68821671085c0a68044693 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-15 11:24:58 +02:00
TEST_F(ProjectPartsStorage, FetchProjectPartArtefactBySourceIdCallsValueInStatementIsBusy)
{
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(getProjectPartArtefactsBySourceId, valueReturnProjectPartArtefact(1))
.WillOnce(Throw(Sqlite::StatementIsBusy{""}));
EXPECT_CALL(mockDatabase, rollback());
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(getProjectPartArtefactsBySourceId, valueReturnProjectPartArtefact(1))
.WillRepeatedly(Return(artefact));
EXPECT_CALL(mockDatabase, commit());
storage.fetchProjectPartArtefact(FilePathId{1});
}
Clang: Reduce database accesses If we prefetch data from the database to the caches we reduce the database transaction calls which are quite expensive. Change-Id: I617a0d886807402e0a94291a913a77f989970b55 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-20 14:45:01 +02:00
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
TEST_F(ProjectPartsStorage, FetchProjectPartArtefactBySourceIdReturnArtefact)
{
EXPECT_CALL(getProjectPartArtefactsBySourceId, valueReturnProjectPartArtefact(1))
.WillRepeatedly(Return(artefact));
auto result = storage.fetchProjectPartArtefact(FilePathId{1});
ASSERT_THAT(result, Eq(artefact));
}
TEST_F(ProjectPartsStorage, FetchProjectPartArtefactByProjectPartIdCallsValueInStatement)
{
Clang: Move transactions to storage We call the function anyway only isolated from other queries, so we can move the transaction guards to the project storage. Change-Id: I7cca26b25c2258856c68821671085c0a68044693 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-15 11:24:58 +02:00
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
EXPECT_CALL(getProjectPartArtefactsByProjectPartId, valueReturnProjectPartArtefact(74))
.WillRepeatedly(Return(artefact));
Clang: Move transactions to storage We call the function anyway only isolated from other queries, so we can move the transaction guards to the project storage. Change-Id: I7cca26b25c2258856c68821671085c0a68044693 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-15 11:24:58 +02:00
EXPECT_CALL(mockDatabase, commit());
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
storage.fetchProjectPartArtefact(ProjectPartId{74});
}
TEST_F(ProjectPartsStorage, FetchProjectPartArtefactByProjectPartIdReturnArtefact)
{
EXPECT_CALL(getProjectPartArtefactsByProjectPartId, valueReturnProjectPartArtefact(74))
.WillRepeatedly(Return(artefact));
auto result = storage.fetchProjectPartArtefact(ProjectPartId{74});
ASSERT_THAT(result, Eq(artefact));
}
Clang: Move transactions to storage We call the function anyway only isolated from other queries, so we can move the transaction guards to the project storage. Change-Id: I7cca26b25c2258856c68821671085c0a68044693 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-15 11:24:58 +02:00
TEST_F(ProjectPartsStorage, FetchProjectPartArtefactByProjectPartIdReturnArtefactIsBusy)
{
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(getProjectPartArtefactsByProjectPartId, valueReturnProjectPartArtefact(74))
.WillOnce(Throw(Sqlite::StatementIsBusy{""}));
EXPECT_CALL(mockDatabase, rollback());
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(getProjectPartArtefactsByProjectPartId, valueReturnProjectPartArtefact(74))
.WillRepeatedly(Return(artefact));
EXPECT_CALL(mockDatabase, commit());
storage.fetchProjectPartArtefact(ProjectPartId{74});
}
Clang: Minimize reindexing We optimal indexer is only reindexing if the index would be changed. This patch is a step in that direction. We only reindex now if the file or project has changed. It fixes some typos too. Task-number: QTCREATORBUG-21150 Change-Id: I6ea1c13282fbcd70253b9b2939aed37580dbd160 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-21 17:55:24 +01:00
TEST_F(ProjectPartsStorage, ResetDependentIndexingTimeStamps)
{
InSequence s;
EXPECT_CALL(mockDatabase, immediateBegin());
EXPECT_CALL(resetDependentIndexingTimeStampsStatement, write(TypedEq<int>(3)));
EXPECT_CALL(resetDependentIndexingTimeStampsStatement, write(TypedEq<int>(4)));
EXPECT_CALL(resetDependentIndexingTimeStampsStatement, write(TypedEq<int>(7)));
EXPECT_CALL(resetDependentIndexingTimeStampsStatement, write(TypedEq<int>(8)));
EXPECT_CALL(mockDatabase, commit());
storage.resetIndexingTimeStamps({projectPart1, projectPart2});
}
TEST_F(ProjectPartsStorage, ResetDependentIndexingTimeStampsIsBusy)
{
InSequence s;
EXPECT_CALL(mockDatabase, immediateBegin()).WillOnce(Throw(Sqlite::StatementIsBusy{""}));
EXPECT_CALL(mockDatabase, immediateBegin());
EXPECT_CALL(resetDependentIndexingTimeStampsStatement, write(TypedEq<int>(3)));
EXPECT_CALL(resetDependentIndexingTimeStampsStatement, write(TypedEq<int>(4)));
EXPECT_CALL(resetDependentIndexingTimeStampsStatement, write(TypedEq<int>(7)));
EXPECT_CALL(resetDependentIndexingTimeStampsStatement, write(TypedEq<int>(8)));
EXPECT_CALL(mockDatabase, commit());
storage.resetIndexingTimeStamps({projectPart1, projectPart2});
}
Clang: Reduce database accesses If we prefetch data from the database to the caches we reduce the database transaction calls which are quite expensive. Change-Id: I617a0d886807402e0a94291a913a77f989970b55 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-20 14:45:01 +02:00
TEST_F(ProjectPartsStorage, FetchAllProjectPartNamesAndIdsCalls)
{
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchAllProjectPartNamesAndIdsStatement, valuesReturnProjectPartNameIds(_))
.WillRepeatedly(Return(projectPartNameIds));
EXPECT_CALL(mockDatabase, commit());
storage.fetchAllProjectPartNamesAndIds();
}
TEST_F(ProjectPartsStorage, FetchAllProjectPartNamesAndIdsCallsIsBusy)
{
InSequence s;
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchAllProjectPartNamesAndIdsStatement, valuesReturnProjectPartNameIds(_))
.WillOnce(Throw(Sqlite::StatementIsBusy{""}));
EXPECT_CALL(mockDatabase, rollback());
EXPECT_CALL(mockDatabase, deferredBegin());
EXPECT_CALL(fetchAllProjectPartNamesAndIdsStatement, valuesReturnProjectPartNameIds(_))
.WillRepeatedly(Return(projectPartNameIds));
EXPECT_CALL(mockDatabase, commit());
storage.fetchAllProjectPartNamesAndIds();
}
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
class ProjectPartsStorageSlow : public testing::Test, public Data
{
using Storage = ClangBackEnd::ProjectPartsStorage<Sqlite::Database>;
protected:
Sqlite::Database database{":memory:", Sqlite::JournalMode::Memory};
ClangBackEnd::RefactoringDatabaseInitializer<Sqlite::Database> databaseInitializer{database};
Storage storage{database};
Clang: Minimize reindexing We optimal indexer is only reindexing if the index would be changed. This patch is a step in that direction. We only reindex now if the file or project has changed. It fixes some typos too. Task-number: QTCREATORBUG-21150 Change-Id: I6ea1c13282fbcd70253b9b2939aed37580dbd160 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-21 17:55:24 +01:00
ClangBackEnd::BuildDependenciesStorage<> buildDependenciesStorage{database};
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
};
TEST_F(ProjectPartsStorageSlow, FetchProjectPartName)
{
auto id = storage.fetchProjectPartId("test");
auto name = storage.fetchProjectPartName(id);
ASSERT_THAT(name, "test");
}
TEST_F(ProjectPartsStorageSlow, FetchNonExistingProjectPartName)
{
ASSERT_THROW(storage.fetchProjectPartName(ClangBackEnd::ProjectPartId{1}),
ClangBackEnd::ProjectPartDoesNotExists);
}
TEST_F(ProjectPartsStorageSlow, FetchProjectPartId)
{
auto first = storage.fetchProjectPartId("test");
auto second = storage.fetchProjectPartId("test");
ASSERT_THAT(first, Eq(second));
}
Clang: Reduce database accesses If we prefetch data from the database to the caches we reduce the database transaction calls which are quite expensive. Change-Id: I617a0d886807402e0a94291a913a77f989970b55 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-20 14:45:01 +02:00
TEST_F(ProjectPartsStorageSlow, FetchProjectPartIdUnguarded)
{
auto first = storage.fetchProjectPartId("test");
auto second = storage.fetchProjectPartIdUnguarded("test");
ASSERT_THAT(first, Eq(second));
}
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
TEST_F(ProjectPartsStorageSlow, FetchProjectParts)
{
projectPart1.projectPartId = storage.fetchProjectPartId("project1");
projectPart2.projectPartId = storage.fetchProjectPartId("project2");
storage.updateProjectParts({projectPart1, projectPart2});
auto projectParts = storage.fetchProjectParts(
{projectPart1.projectPartId, projectPart2.projectPartId});
ASSERT_THAT(projectParts, ElementsAre(projectPart1, projectPart2));
}
Clang: Minimize reindexing We optimal indexer is only reindexing if the index would be changed. This patch is a step in that direction. We only reindex now if the file or project has changed. It fixes some typos too. Task-number: QTCREATORBUG-21150 Change-Id: I6ea1c13282fbcd70253b9b2939aed37580dbd160 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-21 17:55:24 +01:00
TEST_F(ProjectPartsStorageSlow, ResetDependentIndexingTimeStamps)
{
Clang: Differentiate between user and non user includes for updating We don't want to recreate a PCH if the include or source is not contained by a PCH. Change-Id: If52fc1aed92054b4165cdc634656147fbe8baa47 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-06-20 18:34:02 +02:00
buildDependenciesStorage.insertOrUpdateIndexingTimeStamps({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 34);
Clang: Minimize reindexing We optimal indexer is only reindexing if the index would be changed. This patch is a step in that direction. We only reindex now if the file or project has changed. It fixes some typos too. Task-number: QTCREATORBUG-21150 Change-Id: I6ea1c13282fbcd70253b9b2939aed37580dbd160 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-21 17:55:24 +01:00
buildDependenciesStorage.insertOrUpdateSourceDependencies(
{{3, 1}, {4, 1}, {1, 2}, {7, 5}, {8, 6}, {6, 5}, {9, 10}});
storage.resetIndexingTimeStamps({projectPart1, projectPart2});
Clang: Differentiate between user and non user includes for updating We don't want to recreate a PCH if the include or source is not contained by a PCH. Change-Id: If52fc1aed92054b4165cdc634656147fbe8baa47 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-06-20 18:34:02 +02:00
ASSERT_THAT(buildDependenciesStorage.fetchIndexingTimeStamps(),
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
ElementsAre(SourceTimeStamp{1, 34},
SourceTimeStamp{2, 34},
Clang: Minimize reindexing We optimal indexer is only reindexing if the index would be changed. This patch is a step in that direction. We only reindex now if the file or project has changed. It fixes some typos too. Task-number: QTCREATORBUG-21150 Change-Id: I6ea1c13282fbcd70253b9b2939aed37580dbd160 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-21 17:55:24 +01:00
SourceTimeStamp{3, 0},
SourceTimeStamp{4, 0},
Clang: Improve updating of PCHs Instead of deleting the path and time stamp of the project PCH we always set the time stamp but delete only the path if PCH creation failed. A failed PCH will be no rebuilt if the files changed. We have to add that feature later. Change-Id: I1094271f9ead5d906e94b68ac91c0becd2371ca9 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-07-24 16:23:08 +02:00
SourceTimeStamp{5, 34},
SourceTimeStamp{6, 34},
Clang: Minimize reindexing We optimal indexer is only reindexing if the index would be changed. This patch is a step in that direction. We only reindex now if the file or project has changed. It fixes some typos too. Task-number: QTCREATORBUG-21150 Change-Id: I6ea1c13282fbcd70253b9b2939aed37580dbd160 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-21 17:55:24 +01:00
SourceTimeStamp{7, 0},
SourceTimeStamp{8, 0},
SourceTimeStamp{9, 34},
SourceTimeStamp{10, 34}));
}
Clang: Reduce database accesses If we prefetch data from the database to the caches we reduce the database transaction calls which are quite expensive. Change-Id: I617a0d886807402e0a94291a913a77f989970b55 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-20 14:45:01 +02:00
TEST_F(ProjectPartsStorageSlow, FetchAllProjectPartNamesAndIdsy)
{
using ClangBackEnd::Internal::ProjectPartNameId;
auto id = storage.fetchProjectPartId("projectPartName");
auto id2 = storage.fetchProjectPartId("projectPartName2");
auto values = storage.fetchAllProjectPartNamesAndIds();
ASSERT_THAT(values,
UnorderedElementsAre(ProjectPartNameId{"projectPartName", id},
ProjectPartNameId{"projectPartName2", id2}));
}
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
} // namespace
Copy Permalink