ClangPchManager: Introduce PchTaskQueue

With the PchTaskQueue the pipeline is almost complete.

Task-number: QTCREATORBUG-21346
Change-Id: I5f05d525db1679eb37dd1d462076c1ed42958099
Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>

17 files changed, 540 insertions, 91 deletions

diff --git a/tests/unit/unittest/filepathstorage-test.cpp b/tests/unit/unittest/filepathstorage-test.cpp
index f94f3dfad2..be689b44f3 100644
--- a/tests/unit/unittest/filepathstorage-test.cpp
+++ b/tests/unit/unittest/filepathstorage-test.cpp
@@ -90,7 +90,7 @@ protected:
                 .Times(AnyNumber());
         EXPECT_CALL(selectAllSources, valuesReturnStdVectorSource(_))
                 .Times(AnyNumber());
-        EXPECT_CALL(selectDirectoryPathFromDirectoriesByDirectoryId, valueReturnPathString(_))
+        EXPECT_CALL(selectDirectoryPathFromDirectoriesByDirectoryId, valueReturnPathString(An<int>()))
                 .Times(AnyNumber());
         EXPECT_CALL(selectSourceNameAndDirectoryIdFromSourcesBySourceId, valueReturnSourceNameAndDirectoryId(_))
                 .Times(AnyNumber());
diff --git a/tests/unit/unittest/gtest-creator-printing.cpp b/tests/unit/unittest/gtest-creator-printing.cpp
index 072455ab76..098b1b658d 100644
--- a/tests/unit/unittest/gtest-creator-printing.cpp
+++ b/tests/unit/unittest/gtest-creator-printing.cpp
@@ -1033,8 +1033,8 @@ std::ostream &operator<<(std::ostream &out, const PchCreatorIncludes &includes)
 }
 std::ostream &operator<<(std::ostream &out, const PchTask &task)
 {
-    return out << "(" << task.projectPartId << ", " << task.dependentIds << ", " << task.includes
-               << ", " << task.compilerMacros << ", " << task.usedMacros << ")";
+    return out << "(" << task.projectPartIds << ", " << task.includes << ", " << task.compilerMacros
+               << ", " << task.usedMacros << ")";
 }
 
 std::ostream &operator<<(std::ostream &out, const BuildDependency &dependency)
@@ -1048,6 +1048,11 @@ std::ostream &operator<<(std::ostream &out, const BuildDependency &dependency)
                << ")";
 }
 
+std::ostream &operator<<(std::ostream &out, const SlotUsage &slotUsage)
+{
+    return out << "(" << slotUsage.free << ", " << slotUsage.used << ")";
+}
+
 const char *sourceTypeString(SourceType sourceType)
 {
     using ClangBackEnd::SymbolTag;
diff --git a/tests/unit/unittest/gtest-creator-printing.h b/tests/unit/unittest/gtest-creator-printing.h
index 8dd07c4795..db52d584d9 100644
--- a/tests/unit/unittest/gtest-creator-printing.h
+++ b/tests/unit/unittest/gtest-creator-printing.h
@@ -175,6 +175,7 @@ class PchTask;
 class BuildDependency;
 class SourceEntry;
 class FilePathCaching;
+class SlotUsage;
 
 std::ostream &operator<<(std::ostream &out, const SourceLocationEntry &entry);
 std::ostream &operator<<(std::ostream &out, const IdPaths &idPaths);
@@ -259,6 +260,7 @@ std::ostream &operator<<(std::ostream &out, const PchCreatorIncludes &includes);
 std::ostream &operator<<(std::ostream &out, const PchTask &task);
 std::ostream &operator<<(std::ostream &out, const BuildDependency &dependency);
 std::ostream &operator<<(std::ostream &out, const SourceEntry &entry);
+std::ostream &operator<<(std::ostream &out, const SlotUsage &slotUsage);
 
 void PrintTo(const FilePath &filePath, ::std::ostream *os);
 void PrintTo(const FilePathView &filePathView, ::std::ostream *os);
diff --git a/tests/unit/unittest/mockpchcreator.h b/tests/unit/unittest/mockpchcreator.h
index 4d1fd24707..992976d4de 100644
--- a/tests/unit/unittest/mockpchcreator.h
+++ b/tests/unit/unittest/mockpchcreator.h
@@ -35,21 +35,13 @@
 class MockPchCreator : public ClangBackEnd::PchCreatorInterface
 {
 public:
-    MOCK_METHOD1(generatePch,
-                 void(const ClangBackEnd::V2::ProjectPartContainer &projectPart));
-    MOCK_METHOD0(takeProjectIncludes,
-                 ClangBackEnd::IdPaths());
-    MOCK_METHOD0(projectPartPch,
-                 const ClangBackEnd::ProjectPartPch &());
-    MOCK_METHOD1(setUnsavedFiles,
-                 void (const ClangBackEnd::V2::FileContainers &fileContainers));
-    MOCK_METHOD0(clear,
-                 void());
-    MOCK_METHOD0(doInMainThreadAfterFinished,
-                 void());
-    MOCK_CONST_METHOD0(isUsed,
-                       bool());
-    MOCK_METHOD1(setIsUsed,
-                 void(bool));
-
+    MOCK_METHOD1(generatePchDeprecated, void(const ClangBackEnd::V2::ProjectPartContainer &projectPart));
+    MOCK_METHOD1(generatePch, void(const ClangBackEnd::PchTask &pchTask));
+    MOCK_METHOD0(takeProjectIncludes, ClangBackEnd::IdPaths());
+    MOCK_METHOD0(projectPartPch, const ClangBackEnd::ProjectPartPch &());
+    MOCK_METHOD1(setUnsavedFiles, void(const ClangBackEnd::V2::FileContainers &fileContainers));
+    MOCK_METHOD0(clear, void());
+    MOCK_METHOD0(doInMainThreadAfterFinished, void());
+    MOCK_CONST_METHOD0(isUsed, bool());
+    MOCK_METHOD1(setIsUsed, void(bool));
 };
diff --git a/tests/unit/unittest/mockprecompiledheaderstorage.h b/tests/unit/unittest/mockprecompiledheaderstorage.h
index 11493a5560..c267ecb535 100644
--- a/tests/unit/unittest/mockprecompiledheaderstorage.h
+++ b/tests/unit/unittest/mockprecompiledheaderstorage.h
@@ -32,10 +32,16 @@
 class MockPrecompiledHeaderStorage : public ClangBackEnd::PrecompiledHeaderStorageInterface
 {
 public:
-    MOCK_METHOD3(insertPrecompiledHeader,
-                 void (Utils::SmallStringView projectPartName,
-                       Utils::SmallStringView pchPath,
-                       long long pchBuildTime));
-
-    MOCK_METHOD1(deletePrecompiledHeader, void (Utils::SmallStringView projectPartName));
+    MOCK_METHOD3(insertProjectPrecompiledHeader,
+                 void(Utils::SmallStringView projectPartName,
+                      Utils::SmallStringView pchPath,
+                      long long pchBuildTime));
+    MOCK_METHOD1(deleteProjectPrecompiledHeader, void(Utils::SmallStringView projectPartName));
+    MOCK_METHOD3(insertSystemPrecompiledHeader,
+                 void(Utils::SmallStringView projectPartName,
+                      Utils::SmallStringView pchPath,
+                      long long pchBuildTime));
+    MOCK_METHOD1(deleteSystemPrecompiledHeader, void(Utils::SmallStringView projectPartName));
+    MOCK_METHOD1(fetchSystemPrecompiledHeaderPath,
+                 Utils::PathString(Utils::SmallStringView projectPartName));
 };
diff --git a/tests/unit/unittest/mocksqlitereadstatement.cpp b/tests/unit/unittest/mocksqlitereadstatement.cpp
index 66406f09fa..128b3d899f 100644
--- a/tests/unit/unittest/mocksqlitereadstatement.cpp
+++ b/tests/unit/unittest/mocksqlitereadstatement.cpp
@@ -138,6 +138,13 @@ MockSqliteReadStatement::value<Utils::PathString>(const int &directoryId)
 }
 
 template <>
+Utils::optional<Utils::PathString>
+MockSqliteReadStatement::value<Utils::PathString>(const Utils::SmallStringView &path)
+{
+    return valueReturnPathString(path);
+}
+
+template <>
 Utils::optional<ClangBackEnd::ProjectPartArtefact>
 MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 4>(const int& sourceId)
 {
diff --git a/tests/unit/unittest/mocksqlitereadstatement.h b/tests/unit/unittest/mocksqlitereadstatement.h
index e5926d2d17..4fbdda2a6d 100644
--- a/tests/unit/unittest/mocksqlitereadstatement.h
+++ b/tests/unit/unittest/mocksqlitereadstatement.h
@@ -96,6 +96,9 @@ public:
     MOCK_METHOD1(valueReturnPathString,
                  Utils::optional<Utils::PathString>(int));
 
+    MOCK_METHOD1(valueReturnPathString,
+                 Utils::optional<Utils::PathString>(Utils::SmallStringView));
+
     MOCK_METHOD1(valueReturnSmallString,
                  Utils::optional<Utils::SmallString>(int));
 
@@ -222,6 +225,10 @@ Utils::optional<Utils::PathString>
 MockSqliteReadStatement::value<Utils::PathString>(const int&);
 
 template <>
+Utils::optional<Utils::PathString>
+MockSqliteReadStatement::value<Utils::PathString>(const Utils::SmallStringView&);
+
+template <>
 Utils::optional<ClangBackEnd::ProjectPartArtefact>
 MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 4>(const int&);
 
diff --git a/tests/unit/unittest/mocktaskscheduler.h b/tests/unit/unittest/mocktaskscheduler.h
index 647e8aefc0..dde6211828 100644
--- a/tests/unit/unittest/mocktaskscheduler.h
+++ b/tests/unit/unittest/mocktaskscheduler.h
@@ -36,8 +36,8 @@ class MockTaskScheduler : public ClangBackEnd::TaskSchedulerInterface<Task>
 public:
     MOCK_METHOD1_T(addTasks,
                  void (const std::vector<Task> &));
-    MOCK_METHOD0(freeSlots,
-                 uint ());
+    MOCK_METHOD0(slotUsage,
+                 ClangBackEnd::SlotUsage ());
 
     void addTasks(std::vector<Task> &&tasks)
     {
diff --git a/tests/unit/unittest/pchcreator-test.cpp b/tests/unit/unittest/pchcreator-test.cpp
index 0b4685891c..8b556af6b7 100644
--- a/tests/unit/unittest/pchcreator-test.cpp
+++ b/tests/unit/unittest/pchcreator-test.cpp
@@ -223,14 +223,14 @@ TEST_F(PchCreator, CreateProjectPartClangCompilerArguments)
 
 TEST_F(PchCreatorVerySlowTest, IncludesForCreatePchsForProjectParts)
 {
-    creator.generatePch(projectPart1);
+    creator.generatePchDeprecated(projectPart1);
 
     ASSERT_THAT(creator.takeProjectIncludes().id, "project1");
 }
 
 TEST_F(PchCreatorVerySlowTest, ProjectPartPchsSendToPchManagerClient)
 {
-    creator.generatePch(projectPart1);
+    creator.generatePchDeprecated(projectPart1);
 
     EXPECT_CALL(mockPchManagerClient,
                 precompiledHeadersUpdated(
@@ -242,7 +242,7 @@ TEST_F(PchCreatorVerySlowTest, ProjectPartPchsSendToPchManagerClient)
 
 TEST_F(PchCreatorVerySlowTest, UpdateFileWatcherIncludes)
 {
-    creator.generatePch(projectPart1);
+    creator.generatePchDeprecated(projectPart1);
 
     EXPECT_CALL(mockClangPathWatcher,
                 updateIdPaths(ElementsAre(creator.projectIncludes())));
@@ -252,7 +252,7 @@ TEST_F(PchCreatorVerySlowTest, UpdateFileWatcherIncludes)
 
 TEST_F(PchCreatorVerySlowTest, IdPathsForCreatePchsForProjectParts)
 {
-    creator.generatePch(projectPart1);
+    creator.generatePchDeprecated(projectPart1);
 
     ASSERT_THAT(creator.takeProjectIncludes(),
                 AllOf(Field(&IdPaths::id, "project1"),
@@ -263,7 +263,7 @@ TEST_F(PchCreatorVerySlowTest, IdPathsForCreatePchsForProjectParts)
 
 TEST_F(PchCreatorVerySlowTest, ProjectPartPchForCreatesPchForProjectPart)
 {
-    creator.generatePch(projectPart1);
+    creator.generatePchDeprecated(projectPart1);
 
     ASSERT_THAT(creator.projectPartPch(),
                 AllOf(Field(&ProjectPartPch::projectPartId, Eq("project1")),
@@ -273,7 +273,7 @@ TEST_F(PchCreatorVerySlowTest, ProjectPartPchForCreatesPchForProjectPart)
 
 TEST_F(PchCreatorVerySlowTest, ProjectPartPchCleared)
 {
-    creator.generatePch(projectPart1);
+    creator.generatePchDeprecated(projectPart1);
 
     creator.clear();
 
@@ -283,7 +283,7 @@ TEST_F(PchCreatorVerySlowTest, ProjectPartPchCleared)
 
 TEST_F(PchCreatorVerySlowTest, ProjectIncludesCleared)
 {
-    creator.generatePch(projectPart1);
+    creator.generatePchDeprecated(projectPart1);
 
     creator.clear();
 
@@ -299,7 +299,7 @@ TEST_F(PchCreatorVerySlowTest, FaultyProjectPartPchForCreatesNoPchForProjectPart
                                            {},
                                            {id(TESTDATA_DIR "/builddependencycollector/project/faulty.cpp")}};
 
-    creator.generatePch(faultyProjectPart);
+    creator.generatePchDeprecated(faultyProjectPart);
 
     ASSERT_THAT(creator.projectPartPch(),
                 AllOf(Field(&ProjectPartPch::projectPartId, Eq("faultyProject")),
diff --git a/tests/unit/unittest/pchtaskgenerator-test.cpp b/tests/unit/unittest/pchtaskgenerator-test.cpp
index 9fb9038012..0cb4c93583 100644
--- a/tests/unit/unittest/pchtaskgenerator-test.cpp
+++ b/tests/unit/unittest/pchtaskgenerator-test.cpp
@@ -80,7 +80,7 @@ TEST_F(PchTaskGenerator, Create)
     EXPECT_CALL(mockPchTaskMerger,
                 mergeTasks(ElementsAre(
                     AllOf(Field(&PchTaskSet::system,
-                                AllOf(Field(&PchTask::projectPartId, Eq("ProjectPart1")),
+                                AllOf(Field(&PchTask::projectPartIds, ElementsAre("ProjectPart1")),
                                       Field(&PchTask::includes, ElementsAre(4, 5)),
                                       Field(&PchTask::compilerMacros,
                                             ElementsAre(CompilerMacro{"SE", "4", 4},
@@ -88,7 +88,8 @@ TEST_F(PchTaskGenerator, Create)
                                       Field(&PchTask::usedMacros,
                                             ElementsAre(UsedMacro{"SE", 4}, UsedMacro{"WU", 5})))),
                           AllOf(Field(&PchTaskSet::project,
-                                      AllOf(Field(&PchTask::projectPartId, Eq("ProjectPart1")),
+                                      AllOf(Field(&PchTask::projectPartIds,
+                                                  ElementsAre("ProjectPart1")),
                                             Field(&PchTask::includes, ElementsAre(1, 3)),
                                             Field(&PchTask::compilerMacros,
                                                   ElementsAre(CompilerMacro{"YI", "1", 1},
diff --git a/tests/unit/unittest/pchtaskqueue-test.cpp b/tests/unit/unittest/pchtaskqueue-test.cpp
new file mode 100644
index 0000000000..2ee1bf3cad
--- /dev/null
+++ b/tests/unit/unittest/pchtaskqueue-test.cpp
@@ -0,0 +1,343 @@
+/****************************************************************************
+**
+** 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 "mockpchcreator.h"
+#include "mockprecompiledheaderstorage.h"
+#include "mocksqlitetransactionbackend.h"
+#include "mocktaskscheduler.h"
+
+#include <pchtaskqueue.h>
+#include <progresscounter.h>
+
+namespace {
+
+using ClangBackEnd::PchTask;
+using ClangBackEnd::SlotUsage;
+
+class PchTaskQueue : public testing::Test
+{
+protected:
+    NiceMock<MockTaskScheduler<ClangBackEnd::PchTaskQueue::Task>> mockSytemPchTaskScheduler;
+    NiceMock<MockTaskScheduler<ClangBackEnd::PchTaskQueue::Task>> mockProjectPchTaskScheduler;
+    MockPrecompiledHeaderStorage mockPrecompiledHeaderStorage;
+    MockSqliteTransactionBackend mockSqliteTransactionBackend;
+    NiceMock<MockFunction<void(int, int)>> mockSetProgressCallback;
+    ClangBackEnd::ProgressCounter progressCounter{mockSetProgressCallback.AsStdFunction()};
+    ClangBackEnd::PchTaskQueue queue{mockSytemPchTaskScheduler,
+                                     mockProjectPchTaskScheduler,
+                                     progressCounter,
+                                     mockPrecompiledHeaderStorage,
+                                     mockSqliteTransactionBackend};
+    PchTask systemTask1{"ProjectPart1",
+                        {1, 2},
+                        {{"YI", "1", 1}, {"SAN", "3", 3}},
+                        {{"LIANG", 0}, {"YI", 1}}};
+    PchTask systemTask2{"ProjectPart2",
+                        {1, 2},
+                        {{"YI", "1", 1}, {"SAN", "3", 3}},
+                        {{"LIANG", 0}, {"YI", 1}}};
+    PchTask systemTask2b{"ProjectPart2",
+                         {3, 4},
+                         {{"YI", "1", 1}, {"SAN", "3", 3}},
+                         {{"LIANG", 0}, {"YI", 1}}};
+    PchTask systemTask3{"ProjectPart3",
+                        {1, 2},
+                        {{"YI", "1", 1}, {"SAN", "3", 3}},
+                        {{"LIANG", 0}, {"YI", 1}}};
+    PchTask projectTask1{"ProjectPart1",
+                         {11, 12},
+                         {{"SE", "4", 4}, {"WU", "5", 5}},
+                         {{"ER", 2}, {"SAN", 3}}};
+    PchTask projectTask2{"ProjectPart2",
+                         {11, 12},
+                         {{"SE", "4", 4}, {"WU", "5", 5}},
+                         {{"ER", 2}, {"SAN", 3}}};
+    PchTask projectTask2b{"ProjectPart2",
+                          {21, 22},
+                          {{"SE", "4", 4}, {"WU", "5", 5}},
+                          {{"ER", 2}, {"SAN", 3}}};
+    PchTask projectTask3{"ProjectPart3",
+                         {21, 22},
+                         {{"SE", "4", 4}, {"WU", "5", 5}},
+                         {{"ER", 2}, {"SAN", 3}}};
+    PchTask systemTask4{Utils::SmallStringVector{"ProjectPart1", "ProjectPart3"},
+                        {1, 2},
+                        {{"YI", "1", 1}, {"SAN", "3", 3}},
+                        {{"LIANG", 0}, {"YI", 1}}};
+};
+
+TEST_F(PchTaskQueue, AddProjectPchTask)
+{
+    queue.addProjectPchTasks({projectTask1});
+
+    queue.addProjectPchTasks({projectTask2});
+
+    ASSERT_THAT(queue.projectPchTasks(), ElementsAre(projectTask1, projectTask2));
+}
+
+TEST_F(PchTaskQueue, AddSystemPchTask)
+{
+    queue.addSystemPchTasks({systemTask1});
+
+    queue.addSystemPchTasks({systemTask2});
+
+    ASSERT_THAT(queue.systemPchTasks(), ElementsAre(systemTask1, systemTask2));
+}
+
+TEST_F(PchTaskQueue, AddProjectPchTasksCallsProcessEntriesForSystemTaskSchedulerIsNotBusy)
+{
+    InSequence s;
+
+    EXPECT_CALL(mockSytemPchTaskScheduler, slotUsage()).WillRepeatedly(Return(SlotUsage{2, 0}));
+    EXPECT_CALL(mockProjectPchTaskScheduler, slotUsage()).WillRepeatedly(Return(SlotUsage{2, 0}));
+    EXPECT_CALL(mockProjectPchTaskScheduler, addTasks(SizeIs(2)));
+
+    queue.addProjectPchTasks({projectTask1, projectTask2});
+}
+
+TEST_F(PchTaskQueue, AddProjectPchTasksCallsProcessEntriesForSystemTaskSchedulerIsBusy)
+{
+    InSequence s;
+
+    EXPECT_CALL(mockSytemPchTaskScheduler, slotUsage()).WillRepeatedly(Return(SlotUsage{2, 1}));
+    EXPECT_CALL(mockProjectPchTaskScheduler, slotUsage()).Times(0);
+    EXPECT_CALL(mockProjectPchTaskScheduler, addTasks(_)).Times(0);
+
+    queue.addProjectPchTasks({projectTask1, projectTask2});
+}
+
+TEST_F(PchTaskQueue, AddSystemPchTasksCallsProcessEntries)
+{
+    InSequence s;
+
+    EXPECT_CALL(mockSytemPchTaskScheduler, slotUsage()).WillRepeatedly(Return(SlotUsage{2, 0}));
+    EXPECT_CALL(mockSytemPchTaskScheduler, addTasks(SizeIs(2)));
+    EXPECT_CALL(mockSytemPchTaskScheduler, slotUsage()).WillRepeatedly(Return(SlotUsage{2, 1}));
+    EXPECT_CALL(mockProjectPchTaskScheduler, slotUsage()).Times(0);
+    EXPECT_CALL(mockProjectPchTaskScheduler, addTasks(_)).Times(0);
+
+    queue.addSystemPchTasks({projectTask1, projectTask2});
+}
+
+TEST_F(PchTaskQueue, AddProjectPchTasksCallsProgressCounter)
+{
+    queue.addProjectPchTasks({projectTask1, projectTask2});
+
+    EXPECT_CALL(mockSetProgressCallback, Call(0, 3));
+
+    queue.addProjectPchTasks({projectTask2b, projectTask3});
+}
+
+TEST_F(PchTaskQueue, AddSystemPchTasksCallsProgressCounter)
+{
+    queue.addSystemPchTasks({systemTask1, systemTask2});
+
+    EXPECT_CALL(mockSetProgressCallback, Call(0, 3));
+
+    queue.addSystemPchTasks({systemTask2b, systemTask3});
+}
+
+TEST_F(PchTaskQueue, AddPchCallsProgressCounter)
+{
+    queue.addSystemPchTasks({systemTask1, systemTask2});
+
+    EXPECT_CALL(mockSetProgressCallback, Call(0, 3));
+
+    queue.addSystemPchTasks({systemTask2b, systemTask3});
+}
+
+TEST_F(PchTaskQueue, ReplaceIdenticalProjectPchTasks)
+{
+    queue.addProjectPchTasks({projectTask1, projectTask2});
+
+    queue.addProjectPchTasks({projectTask1, projectTask2});
+
+    ASSERT_THAT(queue.projectPchTasks(), ElementsAre(projectTask1, projectTask2));
+}
+
+TEST_F(PchTaskQueue, ReplaceIdenticalSystemPchTasks)
+{
+    queue.addSystemPchTasks({systemTask1, systemTask2});
+
+    queue.addSystemPchTasks({systemTask1, systemTask2});
+
+    ASSERT_THAT(queue.systemPchTasks(), ElementsAre(systemTask1, systemTask2));
+}
+
+TEST_F(PchTaskQueue, ReplaceProjectPchTasksWithSameId)
+{
+    queue.addProjectPchTasks({projectTask1, projectTask2});
+
+    queue.addProjectPchTasks({projectTask1, projectTask2b, projectTask3});
+
+    ASSERT_THAT(queue.projectPchTasks(), ElementsAre(projectTask1, projectTask2b, projectTask3));
+}
+
+TEST_F(PchTaskQueue, ReplaceSystemPchTasksWithSameId)
+{
+    queue.addSystemPchTasks({systemTask1, systemTask2});
+
+    queue.addSystemPchTasks({systemTask1, systemTask2b, systemTask3});
+
+    ASSERT_THAT(queue.systemPchTasks(), ElementsAre(systemTask1, systemTask2b, systemTask3));
+}
+
+TEST_F(PchTaskQueue, RemoveProjectPchTasksByProjectPartId)
+{
+    queue.addProjectPchTasks({projectTask1, projectTask2, projectTask3});
+
+    queue.removePchTasks(projectTask2.projectPartIds);
+
+    ASSERT_THAT(queue.projectPchTasks(), ElementsAre(projectTask1, projectTask3));
+}
+
+TEST_F(PchTaskQueue, DontRemoveSystemPchTasksByProjectPartId)
+{
+    queue.addSystemPchTasks({systemTask1, systemTask2, systemTask3});
+
+    queue.removePchTasks(systemTask2.projectPartIds);
+
+    ASSERT_THAT(queue.systemPchTasks(), ElementsAre(systemTask1, systemTask2, systemTask3));
+}
+
+TEST_F(PchTaskQueue, RemovePchTasksCallsProgressCounter)
+{
+    queue.addSystemPchTasks({systemTask1, systemTask2, systemTask3});
+    queue.addProjectPchTasks({projectTask1, projectTask2, projectTask3});
+
+    EXPECT_CALL(mockSetProgressCallback, Call(0, 5));
+
+    queue.removePchTasks(systemTask2.projectPartIds);
+}
+
+TEST_F(PchTaskQueue, CreateProjectTasksSizeEqualsInputSize)
+{
+    auto tasks = queue.createProjectTasks({projectTask1, projectTask1});
+
+    ASSERT_THAT(tasks, SizeIs(2));
+}
+
+TEST_F(PchTaskQueue, CreateProjectTaskFromPchTask)
+{
+    InSequence s;
+    MockPchCreator mockPchCreator;
+    ClangBackEnd::ProjectPartPch projectPartPch{"", "/path/to/pch", 99};
+    auto tasks = queue.createProjectTasks({projectTask1});
+    auto projectTask = projectTask1;
+    projectTask.systemPchPath = "/path/to/pch";
+
+    EXPECT_CALL(mockSqliteTransactionBackend, lock());
+    EXPECT_CALL(mockSqliteTransactionBackend, deferredBegin());
+    EXPECT_CALL(mockPrecompiledHeaderStorage, fetchSystemPrecompiledHeaderPath(Eq("ProjectPart1")))
+        .WillOnce(Return(Utils::PathString{"/path/to/pch"}));
+    EXPECT_CALL(mockSqliteTransactionBackend, commit());
+    EXPECT_CALL(mockSqliteTransactionBackend, unlock());
+    EXPECT_CALL(mockPchCreator, generatePch(Eq(projectTask)));
+    EXPECT_CALL(mockPchCreator, projectPartPch()).WillOnce(ReturnRef(projectPartPch));
+    EXPECT_CALL(mockSqliteTransactionBackend, lock());
+    EXPECT_CALL(mockSqliteTransactionBackend, immediateBegin());
+    EXPECT_CALL(mockPrecompiledHeaderStorage,
+                insertProjectPrecompiledHeader(Eq("ProjectPart1"), Eq("/path/to/pch"), 99));
+    EXPECT_CALL(mockSqliteTransactionBackend, commit());
+    EXPECT_CALL(mockSqliteTransactionBackend, unlock());
+
+    tasks.front()(mockPchCreator);
+}
+
+TEST_F(PchTaskQueue, DeleteProjectPchEntryInDatabaseIfNoPchIsGenerated)
+{
+    InSequence s;
+    MockPchCreator mockPchCreator;
+    ClangBackEnd::ProjectPartPch projectPartPch{"", "", 0};
+    auto tasks = queue.createProjectTasks({projectTask1});
+    auto projectTask = projectTask1;
+    projectTask.systemPchPath = "/path/to/pch";
+
+    EXPECT_CALL(mockSqliteTransactionBackend, lock());
+    EXPECT_CALL(mockSqliteTransactionBackend, deferredBegin());
+    EXPECT_CALL(mockPrecompiledHeaderStorage, fetchSystemPrecompiledHeaderPath(Eq("ProjectPart1")))
+        .WillOnce(Return(Utils::PathString{"/path/to/pch"}));
+    EXPECT_CALL(mockSqliteTransactionBackend, commit());
+    EXPECT_CALL(mockSqliteTransactionBackend, unlock());
+    EXPECT_CALL(mockPchCreator, generatePch(Eq(projectTask)));
+    EXPECT_CALL(mockPchCreator, projectPartPch()).WillOnce(ReturnRef(projectPartPch));
+    EXPECT_CALL(mockSqliteTransactionBackend, lock());
+    EXPECT_CALL(mockSqliteTransactionBackend, immediateBegin());
+    EXPECT_CALL(mockPrecompiledHeaderStorage, deleteProjectPrecompiledHeader(Eq("ProjectPart1")));
+    EXPECT_CALL(mockSqliteTransactionBackend, commit());
+    EXPECT_CALL(mockSqliteTransactionBackend, unlock());
+
+    tasks.front()(mockPchCreator);
+}
+
+TEST_F(PchTaskQueue, CreateSystemTasksSizeEqualsInputSize)
+{
+    auto tasks = queue.createSystemTasks({systemTask1, systemTask2});
+
+    ASSERT_THAT(tasks, SizeIs(2));
+}
+
+TEST_F(PchTaskQueue, CreateSystemTaskFromPchTask)
+{
+    InSequence s;
+    MockPchCreator mockPchCreator;
+    ClangBackEnd::ProjectPartPch projectPartPch{"", "/path/to/pch", 99};
+    auto tasks = queue.createSystemTasks({systemTask4});
+
+    EXPECT_CALL(mockPchCreator, generatePch(Eq(systemTask4)));
+    EXPECT_CALL(mockPchCreator, projectPartPch()).WillOnce(ReturnRef(projectPartPch));
+    EXPECT_CALL(mockSqliteTransactionBackend, lock());
+    EXPECT_CALL(mockSqliteTransactionBackend, immediateBegin());
+    EXPECT_CALL(mockPrecompiledHeaderStorage,
+                insertSystemPrecompiledHeader(Eq("ProjectPart1"), Eq("/path/to/pch"), 99));
+    EXPECT_CALL(mockPrecompiledHeaderStorage,
+                insertSystemPrecompiledHeader(Eq("ProjectPart3"), Eq("/path/to/pch"), 99));
+    EXPECT_CALL(mockSqliteTransactionBackend, commit());
+    EXPECT_CALL(mockSqliteTransactionBackend, unlock());
+
+    tasks.front()(mockPchCreator);
+}
+
+TEST_F(PchTaskQueue, DeleteSystemPchEntryInDatabaseIfNoPchIsGenerated)
+{
+    InSequence s;
+    MockPchCreator mockPchCreator;
+    ClangBackEnd::ProjectPartPch projectPartPch{"", "", 0};
+    auto tasks = queue.createSystemTasks({systemTask4});
+
+    EXPECT_CALL(mockPchCreator, generatePch(Eq(systemTask4)));
+    EXPECT_CALL(mockPchCreator, projectPartPch()).WillOnce(ReturnRef(projectPartPch));
+    EXPECT_CALL(mockSqliteTransactionBackend, lock());
+    EXPECT_CALL(mockSqliteTransactionBackend, immediateBegin());
+    EXPECT_CALL(mockPrecompiledHeaderStorage, deleteSystemPrecompiledHeader(Eq("ProjectPart1")));
+    EXPECT_CALL(mockPrecompiledHeaderStorage, deleteSystemPrecompiledHeader(Eq("ProjectPart3")));
+    EXPECT_CALL(mockSqliteTransactionBackend, commit());
+    EXPECT_CALL(mockSqliteTransactionBackend, unlock());
+
+    tasks.front()(mockPchCreator);
+}
+} // namespace
diff --git a/tests/unit/unittest/precompiledheaderstorage-test.cpp b/tests/unit/unittest/precompiledheaderstorage-test.cpp
index 3910b9a370..61fdfb5a88 100644
--- a/tests/unit/unittest/precompiledheaderstorage-test.cpp
+++ b/tests/unit/unittest/precompiledheaderstorage-test.cpp
@@ -29,6 +29,7 @@
 #include <precompiledheaderstorage.h>
 #include <refactoringdatabaseinitializer.h>
 #include <sqlitedatabase.h>
+#include <sqlitereadstatement.h>
 #include <sqlitewritestatement.h>
 #include <sqlitetransaction.h>
 
@@ -41,9 +42,17 @@ class PrecompiledHeaderStorage : public testing::Test
 protected:
     NiceMock<MockSqliteDatabase> database;
     Storage storage{database};
-    MockSqliteWriteStatement &insertPrecompiledHeaderStatement  = storage.m_insertPrecompiledHeaderStatement;
     MockSqliteWriteStatement &insertProjectPartStatement = storage.m_insertProjectPartStatement;
-    MockSqliteWriteStatement &deletePrecompiledHeaderStatement  = storage.m_deletePrecompiledHeaderStatement;
+    MockSqliteWriteStatement &insertProjectPrecompiledHeaderStatement
+        = storage.m_insertProjectPrecompiledHeaderStatement;
+    MockSqliteWriteStatement &deleteProjectPrecompiledHeaderStatement
+        = storage.m_deleteProjectPrecompiledHeaderStatement;
+    MockSqliteWriteStatement &insertSystemPrecompiledHeaderStatement
+        = storage.m_insertSystemPrecompiledHeaderStatement;
+    MockSqliteWriteStatement &deleteSystemPrecompiledHeaderStatement
+        = storage.m_deleteSystemPrecompiledHeaderStatement;
+    MockSqliteReadStatement &fetchSystemPrecompiledHeaderPathStatement
+        = storage.m_fetchSystemPrecompiledHeaderPathStatement;
 };
 
 TEST_F(PrecompiledHeaderStorage, UseTransaction)
@@ -56,76 +65,112 @@ TEST_F(PrecompiledHeaderStorage, UseTransaction)
     Storage storage{database};
 }
 
-TEST_F(PrecompiledHeaderStorage, InsertPrecompiledHeader)
+TEST_F(PrecompiledHeaderStorage, InsertProjectPrecompiledHeader)
 {
     InSequence s;
 
     EXPECT_CALL(database, immediateBegin());
     EXPECT_CALL(insertProjectPartStatement, write(TypedEq<Utils::SmallStringView>("project1")));
-    EXPECT_CALL(insertPrecompiledHeaderStatement,
+    EXPECT_CALL(insertProjectPrecompiledHeaderStatement,
                 write(TypedEq<Utils::SmallStringView>("project1"),
                       TypedEq<Utils::SmallStringView>("/path/to/pch"),
                       TypedEq<long long>(22)));
     EXPECT_CALL(database, commit());
 
-    storage.insertPrecompiledHeader("project1", "/path/to/pch", 22);
+    storage.insertProjectPrecompiledHeader("project1", "/path/to/pch", 22);
 }
 
-TEST_F(PrecompiledHeaderStorage, InsertPrecompiledHeaderStatementIsBusy)
+TEST_F(PrecompiledHeaderStorage, InsertProjectPrecompiledHeaderStatementIsBusy)
 {
     InSequence s;
 
     EXPECT_CALL(database, immediateBegin()).WillOnce(Throw(Sqlite::StatementIsBusy("busy")));
     EXPECT_CALL(database, immediateBegin());
     EXPECT_CALL(insertProjectPartStatement, write(TypedEq<Utils::SmallStringView>("project1")));
-    EXPECT_CALL(insertPrecompiledHeaderStatement,
+    EXPECT_CALL(insertProjectPrecompiledHeaderStatement,
                 write(TypedEq<Utils::SmallStringView>("project1"),
                       TypedEq<Utils::SmallStringView>("/path/to/pch"),
                       TypedEq<long long>(22)));
     EXPECT_CALL(database, commit());
 
-    storage.insertPrecompiledHeader("project1", "/path/to/pch", 22);
+    storage.insertProjectPrecompiledHeader("project1", "/path/to/pch", 22);
 }
 
-TEST_F(PrecompiledHeaderStorage, DeletePrecompiledHeader)
+TEST_F(PrecompiledHeaderStorage, DeleteProjectPrecompiledHeader)
 {
     InSequence s;
 
     EXPECT_CALL(database, immediateBegin());
-    EXPECT_CALL(deletePrecompiledHeaderStatement, write(TypedEq<Utils::SmallStringView>("project1")));
+    EXPECT_CALL(deleteProjectPrecompiledHeaderStatement, write(TypedEq<Utils::SmallStringView>("project1")));
     EXPECT_CALL(database, commit());
 
-    storage.deletePrecompiledHeader("project1");
+    storage.deleteProjectPrecompiledHeader("project1");
 }
 
-TEST_F(PrecompiledHeaderStorage, DeletePrecompiledHeaderStatementIsBusy)
+TEST_F(PrecompiledHeaderStorage, DeleteProjectPrecompiledHeaderStatementIsBusy)
 {
     InSequence s;
 
     EXPECT_CALL(database, immediateBegin()).WillOnce(Throw(Sqlite::StatementIsBusy("busy")));
     EXPECT_CALL(database, immediateBegin());
-    EXPECT_CALL(deletePrecompiledHeaderStatement, write(TypedEq<Utils::SmallStringView>("project1")));
+    EXPECT_CALL(deleteProjectPrecompiledHeaderStatement, write(TypedEq<Utils::SmallStringView>("project1")));
     EXPECT_CALL(database, commit());
 
-    storage.deletePrecompiledHeader("project1");
+    storage.deleteProjectPrecompiledHeader("project1");
 }
 
-TEST_F(PrecompiledHeaderStorage, InsertPrecompiledHeaderStatement)
+TEST_F(PrecompiledHeaderStorage, InsertSystemPrecompiledHeader)
 {
-    ASSERT_THAT(insertPrecompiledHeaderStatement.sqlStatement,
-                Eq("INSERT OR REPLACE INTO precompiledHeaders(projectPartId, pchPath, pchBuildTime) VALUES((SELECT projectPartId FROM projectParts WHERE projectPartName = ?),?,?)"));
+    InSequence s;
+
+    EXPECT_CALL(database, immediateBegin());
+    EXPECT_CALL(insertProjectPartStatement, write(TypedEq<Utils::SmallStringView>("project1")));
+    EXPECT_CALL(insertSystemPrecompiledHeaderStatement,
+                write(TypedEq<Utils::SmallStringView>("project1"),
+                      TypedEq<Utils::SmallStringView>("/path/to/pch"),
+                      TypedEq<long long>(22)));
+    EXPECT_CALL(database, commit());
+
+    storage.insertSystemPrecompiledHeader("project1", "/path/to/pch", 22);
 }
 
-TEST_F(PrecompiledHeaderStorage, InsertProjectPartStatement)
+TEST_F(PrecompiledHeaderStorage, InsertSystemPrecompiledHeaderStatementIsBusy)
 {
-    ASSERT_THAT(insertProjectPartStatement.sqlStatement,
-                Eq("INSERT OR IGNORE INTO projectParts(projectPartName) VALUES (?)"));
+    InSequence s;
+
+    EXPECT_CALL(database, immediateBegin()).WillOnce(Throw(Sqlite::StatementIsBusy("busy")));
+    EXPECT_CALL(database, immediateBegin());
+    EXPECT_CALL(insertProjectPartStatement, write(TypedEq<Utils::SmallStringView>("project1")));
+    EXPECT_CALL(insertSystemPrecompiledHeaderStatement,
+                write(TypedEq<Utils::SmallStringView>("project1"),
+                      TypedEq<Utils::SmallStringView>("/path/to/pch"),
+                      TypedEq<long long>(22)));
+    EXPECT_CALL(database, commit());
+
+    storage.insertSystemPrecompiledHeader("project1", "/path/to/pch", 22);
+}
+
+TEST_F(PrecompiledHeaderStorage, DeleteSystemPrecompiledHeader)
+{
+    InSequence s;
+
+    EXPECT_CALL(database, immediateBegin());
+    EXPECT_CALL(deleteSystemPrecompiledHeaderStatement, write(TypedEq<Utils::SmallStringView>("project1")));
+    EXPECT_CALL(database, commit());
+
+    storage.deleteSystemPrecompiledHeader("project1");
 }
 
-TEST_F(PrecompiledHeaderStorage, DeletePrecompiledHeaderStatement)
+TEST_F(PrecompiledHeaderStorage, DeleteSystemPrecompiledHeaderStatementIsBusy)
 {
-    ASSERT_THAT(deletePrecompiledHeaderStatement.sqlStatement,
-                Eq("DELETE FROM precompiledHeaders WHERE projectPartId = (SELECT projectPartId FROM projectParts WHERE projectPartName = ?)"));
+    InSequence s;
+
+    EXPECT_CALL(database, immediateBegin()).WillOnce(Throw(Sqlite::StatementIsBusy("busy")));
+    EXPECT_CALL(database, immediateBegin());
+    EXPECT_CALL(deleteSystemPrecompiledHeaderStatement, write(TypedEq<Utils::SmallStringView>("project1")));
+    EXPECT_CALL(database, commit());
+
+    storage.deleteSystemPrecompiledHeader("project1");
 }
 
 TEST_F(PrecompiledHeaderStorage, CompilePrecompiledHeaderStatements)
@@ -136,4 +181,48 @@ TEST_F(PrecompiledHeaderStorage, CompilePrecompiledHeaderStatements)
     ASSERT_NO_THROW(ClangBackEnd::PrecompiledHeaderStorage<>{database});
 }
 
+TEST_F(PrecompiledHeaderStorage, FetchSystemPrecompiledHeaderCalls)
+{
+    InSequence s;
+
+    EXPECT_CALL(database, deferredBegin());
+    EXPECT_CALL(fetchSystemPrecompiledHeaderPathStatement,
+                valueReturnPathString(TypedEq<Utils::SmallStringView>("project1")));
+    EXPECT_CALL(database, commit());
+
+    storage.fetchSystemPrecompiledHeaderPath("project1");
+}
+
+TEST_F(PrecompiledHeaderStorage, FetchSystemPrecompiledHeader)
+{
+    EXPECT_CALL(fetchSystemPrecompiledHeaderPathStatement,
+                valueReturnPathString(TypedEq<Utils::SmallStringView>("project1")))
+        .WillOnce(Return(Utils::PathString{"/path/to/pch"}));
+
+    auto path = storage.fetchSystemPrecompiledHeaderPath("project1");
+
+    ASSERT_THAT(path, "/path/to/pch");
+}
+
+TEST_F(PrecompiledHeaderStorage, FetchSystemPrecompiledHeaderReturnsEmptyPath)
+{
+    EXPECT_CALL(fetchSystemPrecompiledHeaderPathStatement,
+                valueReturnPathString(TypedEq<Utils::SmallStringView>("project1")))
+        .WillOnce(Return(Utils::PathString{}));
+
+    auto path = storage.fetchSystemPrecompiledHeaderPath("project1");
+
+    ASSERT_THAT(path, IsEmpty());
+}
+
+TEST_F(PrecompiledHeaderStorage, FetchSystemPrecompiledHeaderReturnsNullOptional)
+{
+    EXPECT_CALL(fetchSystemPrecompiledHeaderPathStatement,
+                valueReturnPathString(TypedEq<Utils::SmallStringView>("project1")))
+        .WillOnce(Return(Utils::optional<Utils::PathString>{}));
+
+    auto path = storage.fetchSystemPrecompiledHeaderPath("project1");
+
+    ASSERT_THAT(path, IsEmpty());
+}
 }
diff --git a/tests/unit/unittest/projectpartqueue-test.cpp b/tests/unit/unittest/projectpartqueue-test.cpp
index 0c06a48cd6..65318a3e91 100644
--- a/tests/unit/unittest/projectpartqueue-test.cpp
+++ b/tests/unit/unittest/projectpartqueue-test.cpp
@@ -35,6 +35,9 @@
 
 namespace {
 
+using ClangBackEnd::SlotUsage;
+using ClangBackEnd::V2::ProjectPartContainer;
+
 class ProjectPartQueue : public testing::Test
 {
 protected:
@@ -83,7 +86,7 @@ TEST_F(ProjectPartQueue, AddProjectPartCallsProcessEntries)
 {
     InSequence s;
 
-    EXPECT_CALL(mockTaskScheduler, freeSlots()).WillRepeatedly(Return(2));
+    EXPECT_CALL(mockTaskScheduler, slotUsage()).WillRepeatedly(Return(SlotUsage{2, 0}));
     EXPECT_CALL(mockTaskScheduler, addTasks(SizeIs(2)));
 
     queue.addProjectParts({projectPart1, projectPart2});
@@ -148,11 +151,11 @@ TEST_F(ProjectPartQueue, CreateTaskFromProjectPart)
     ClangBackEnd::ProjectPartPch projectPartPch{"project1", "/path/to/pch", 99};
     auto tasks = queue.createPchTasks({projectPart1});
 
-    EXPECT_CALL(mockPchCreator, generatePch(Eq(projectPart1)));
+    EXPECT_CALL(mockPchCreator, generatePchDeprecated(Eq(projectPart1)));
     EXPECT_CALL(mockPchCreator, projectPartPch()).WillOnce(ReturnRef(projectPartPch));
     EXPECT_CALL(mockSqliteTransactionBackend, lock());
     EXPECT_CALL(mockSqliteTransactionBackend, immediateBegin());
-    EXPECT_CALL(mockPrecompiledHeaderStorage, insertPrecompiledHeader(Eq("project1"), Eq("/path/to/pch"), 99));
+    EXPECT_CALL(mockPrecompiledHeaderStorage, insertProjectPrecompiledHeader(Eq("project1"), Eq("/path/to/pch"), 99));
     EXPECT_CALL(mockSqliteTransactionBackend, commit());
     EXPECT_CALL(mockSqliteTransactionBackend, unlock());
 
@@ -166,24 +169,15 @@ TEST_F(ProjectPartQueue, DeletePchEntryInDatabaseIfNoPchIsGenerated)
     ClangBackEnd::ProjectPartPch projectPartPch{"project1", "", 0};
     auto tasks = queue.createPchTasks({projectPart1});
 
-    EXPECT_CALL(mockPchCreator, generatePch(Eq(projectPart1)));
+    EXPECT_CALL(mockPchCreator, generatePchDeprecated(Eq(projectPart1)));
     EXPECT_CALL(mockPchCreator, projectPartPch()).WillOnce(ReturnRef(projectPartPch));
     EXPECT_CALL(mockSqliteTransactionBackend, lock());
     EXPECT_CALL(mockSqliteTransactionBackend, immediateBegin());
-    EXPECT_CALL(mockPrecompiledHeaderStorage, deletePrecompiledHeader(Eq("project1")));
+    EXPECT_CALL(mockPrecompiledHeaderStorage, deleteProjectPrecompiledHeader(Eq("project1")));
     EXPECT_CALL(mockSqliteTransactionBackend, commit());
     EXPECT_CALL(mockSqliteTransactionBackend, unlock());
 
     tasks.front()(mockPchCreator);
 }
 
-
-//TEST_F(PchManagerClient, ProjectPartPchRemovedFromDatabase)
-//{
-//    EXPECT_CALL(mockPrecompiledHeaderStorage, deletePrecompiledHeader(TypedEq<Utils::SmallStringView>(projectPartId)));
-
-//    projectUpdater.removeProjectParts({QString(projectPartId)});
-//}
-
-
 }
diff --git a/tests/unit/unittest/refactoringdatabaseinitializer-test.cpp b/tests/unit/unittest/refactoringdatabaseinitializer-test.cpp
index ba7d62ddb9..555d742a60 100644
--- a/tests/unit/unittest/refactoringdatabaseinitializer-test.cpp
+++ b/tests/unit/unittest/refactoringdatabaseinitializer-test.cpp
@@ -139,7 +139,7 @@ TEST_F(RefactoringDatabaseInitializer, AddPrecompiledHeaderTable)
 {
     InSequence s;
 
-    EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS precompiledHeaders(projectPartId INTEGER PRIMARY KEY, pchPath TEXT, pchBuildTime INTEGER)")));
+    EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS precompiledHeaders(projectPartId INTEGER PRIMARY KEY, projectPchPath TEXT, projectPchBuildTime INTEGER, systemPchPath TEXT, systemPchBuildTime INTEGER)")));
 
     initializer.createPrecompiledHeadersTable();
 }
@@ -171,7 +171,7 @@ TEST_F(RefactoringDatabaseInitializer, CreateInTheContructor)
     EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS fileStatuses(sourceId INTEGER PRIMARY KEY, size INTEGER, lastModified INTEGER, buildDependencyTimeStamp INTEGER, isInPrecompiledHeader INTEGER)")));
     EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS sourceDependencies(sourceId INTEGER, dependencySourceId INTEGER)")));
     EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_sourceDependencies_sourceId_dependencySourceId ON sourceDependencies(sourceId, dependencySourceId)")));
-    EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS precompiledHeaders(projectPartId INTEGER PRIMARY KEY, pchPath TEXT, pchBuildTime INTEGER)")));
+    EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS precompiledHeaders(projectPartId INTEGER PRIMARY KEY, projectPchPath TEXT, projectPchBuildTime INTEGER, systemPchPath TEXT, systemPchBuildTime INTEGER)")));
     EXPECT_CALL(mockDatabase, commit());
     EXPECT_CALL(mockDatabase, setIsInitialized(true));
 
diff --git a/tests/unit/unittest/symbolindexertaskqueue-test.cpp b/tests/unit/unittest/symbolindexertaskqueue-test.cpp
index 83d722cbad..2932310eb0 100644
--- a/tests/unit/unittest/symbolindexertaskqueue-test.cpp
+++ b/tests/unit/unittest/symbolindexertaskqueue-test.cpp
@@ -35,6 +35,7 @@ using ClangBackEnd::FilePathId;
 using ClangBackEnd::SymbolsCollectorInterface;
 using ClangBackEnd::SymbolIndexerTask;
 using ClangBackEnd::SymbolStorageInterface;
+using ClangBackEnd::SlotUsage;
 
 using Callable = ClangBackEnd::SymbolIndexerTask::Callable;
 
@@ -167,7 +168,7 @@ TEST_F(SymbolIndexerTaskQueue, ProcessTasksCallsFreeSlotsAndAddTasksInScheduler)
                             {3, 1, Callable{}},
                             {5, 1, Callable{}}});
 
-    EXPECT_CALL(mockTaskScheduler, freeSlots()).WillRepeatedly(Return(2));
+    EXPECT_CALL(mockTaskScheduler, slotUsage()).WillRepeatedly(Return(SlotUsage{2, 0}));
     EXPECT_CALL(mockTaskScheduler, addTasks(SizeIs(2)));
 
     queue.processEntries();
@@ -177,7 +178,7 @@ TEST_F(SymbolIndexerTaskQueue, ProcessTasksCallsFreeSlotsAndAddTasksWithNoTaskIn
 {
     InSequence s;
 
-    EXPECT_CALL(mockTaskScheduler, freeSlots()).WillRepeatedly(Return(2));
+    EXPECT_CALL(mockTaskScheduler, slotUsage()).WillRepeatedly(Return(SlotUsage{2, 0}));
     EXPECT_CALL(mockTaskScheduler, addTasks(IsEmpty()));
 
     queue.processEntries();
@@ -190,7 +191,7 @@ TEST_F(SymbolIndexerTaskQueue, ProcessTasksCallsFreeSlotsAndMoveAllTasksInSchedu
                             {3, 1, Callable{}},
                             {5, 1, Callable{}}});
 
-    EXPECT_CALL(mockTaskScheduler, freeSlots()).WillRepeatedly(Return(4));
+    EXPECT_CALL(mockTaskScheduler, slotUsage()).WillRepeatedly(Return(SlotUsage{4, 0}));
     EXPECT_CALL(mockTaskScheduler, addTasks(SizeIs(3)));
 
     queue.processEntries();
@@ -201,7 +202,7 @@ TEST_F(SymbolIndexerTaskQueue, ProcessTasksRemovesProcessedTasks)
     queue.addOrUpdateTasks({{1, 1, Callable{}},
                             {3, 1, Callable{}},
                             {5, 1, Callable{}}});
-    ON_CALL(mockTaskScheduler, freeSlots()).WillByDefault(Return(2));
+    ON_CALL(mockTaskScheduler, slotUsage()).WillByDefault(Return(SlotUsage{2, 0}));
 
     queue.processEntries();
 
diff --git a/tests/unit/unittest/taskscheduler-test.cpp b/tests/unit/unittest/taskscheduler-test.cpp
index 337436aeb8..9afc52a724 100644
--- a/tests/unit/unittest/taskscheduler-test.cpp
+++ b/tests/unit/unittest/taskscheduler-test.cpp
@@ -40,6 +40,7 @@ using Task = std::function<void(ClangBackEnd::ProcessorInterface&)>;
 using ClangBackEnd::ProcessorInterface;
 using ClangBackEnd::SymbolsCollectorInterface;
 using ClangBackEnd::SymbolStorageInterface;
+using ClangBackEnd::SlotUsage;
 using NiceMockProcessorManager = NiceMock<MockProcessorManager>;
 using Scheduler = ClangBackEnd::TaskScheduler<NiceMockProcessorManager, Task>;
 
@@ -95,18 +96,18 @@ TEST_F(TaskScheduler, FreeSlots)
 {
     deferredScheduler.addTasks({nocall, nocall});
 
-    auto count = deferredScheduler.freeSlots();
+    auto slotUsage = deferredScheduler.slotUsage();
 
-    ASSERT_THAT(count, 2);
+    ASSERT_THAT(slotUsage, AllOf(Field(&SlotUsage::free, 2), Field(&SlotUsage::used, 2)));
 }
 
 TEST_F(TaskScheduler, ReturnZeroFreeSlotsIfMoreCallsThanCores)
 {
     deferredScheduler.addTasks({nocall, nocall, nocall, nocall, nocall, nocall});
 
-    auto count = deferredScheduler.freeSlots();
+    auto slotUsage = deferredScheduler.slotUsage();
 
-    ASSERT_THAT(count, 0);
+    ASSERT_THAT(slotUsage, AllOf(Field(&SlotUsage::free, 0), Field(&SlotUsage::used, 6)));
 }
 
 TEST_F(TaskScheduler, FreeSlotsAfterFinishing)
@@ -114,9 +115,9 @@ TEST_F(TaskScheduler, FreeSlotsAfterFinishing)
     scheduler.addTasks({nocall, nocall});
     scheduler.syncTasks();
 
-    auto count = scheduler.freeSlots();
+    auto slotUsage = scheduler.slotUsage();
 
-    ASSERT_THAT(count, 4);
+    ASSERT_THAT(slotUsage, AllOf(Field(&SlotUsage::free, 4), Field(&SlotUsage::used, 0)));
 }
 
 TEST_F(TaskScheduler, NoFuturesAfterFreeSlots)
@@ -124,7 +125,7 @@ TEST_F(TaskScheduler, NoFuturesAfterFreeSlots)
     scheduler.addTasks({nocall, nocall});
     scheduler.syncTasks();
 
-    scheduler.freeSlots();
+    scheduler.slotUsage();
 
     ASSERT_THAT(scheduler.futures(), IsEmpty());
 }
@@ -142,7 +143,7 @@ TEST_F(TaskScheduler, FreeSlotsCallsCleanupMethodsAfterTheWorkIsDone)
     EXPECT_CALL(mockSymbolsCollector, setIsUsed(false));
     EXPECT_CALL(mockSymbolsCollector, clear());
 
-    scheduler.freeSlots();
+    scheduler.slotUsage();
 }
 
 TEST_F(TaskScheduler, FreeSlotsCallsProgressMethodsAfterTheWorkIsDone)
@@ -153,7 +154,7 @@ TEST_F(TaskScheduler, FreeSlotsCallsProgressMethodsAfterTheWorkIsDone)
 
     EXPECT_CALL(mockSetProgressCallback, Call(2, 100));
 
-    scheduler.freeSlots();
+    scheduler.slotUsage();
 }
 
 TEST_F(TaskScheduler, AddTaskCallSymbolsCollectorManagerUnusedSymbolsCollector)
diff --git a/tests/unit/unittest/unittest.pro b/tests/unit/unittest/unittest.pro
index 043c7ff0b2..969a8bc6df 100644
--- a/tests/unit/unittest/unittest.pro
+++ b/tests/unit/unittest/unittest.pro
@@ -109,7 +109,8 @@ SOURCES += \
     builddependenciesprovider-test.cpp \
     builddependenciesstorage-test.cpp \
     usedmacrofilter-test.cpp \
-    pchtasksmerger-test.cpp
+    pchtasksmerger-test.cpp \
+    pchtaskqueue-test.cpp
 
 !isEmpty(LIBCLANG_LIBS) {
 SOURCES += \