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

359 lines
14 KiB
C++
Raw Normal View History

Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#include "googletest.h"
Clang: Add Process Generator So far we only compiled the precompiled headers only sequentially. The process generator is creating, managing a queue of processes to compile the PCHs parallel. Change-Id: I8075def4ef9e6b0191bbd51b3631d1c51ec7b361 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-31 14:21:05 +01:00
#include "fakeprocess.h"
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
Clang: Add Process Generator So far we only compiled the precompiled headers only sequentially. The process generator is creating, managing a queue of processes to compile the PCHs parallel. Change-Id: I8075def4ef9e6b0191bbd51b3631d1c51ec7b361 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-31 14:21:05 +01:00
#include "mockpchgeneratornotifier.h"
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
#include "testenvironment.h"
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
#include <refactoringdatabaseinitializer.h>
#include <filepathcaching.h>
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
#include <pchcreator.h>
Clang: Add Process Generator So far we only compiled the precompiled headers only sequentially. The process generator is creating, managing a queue of processes to compile the PCHs parallel. Change-Id: I8075def4ef9e6b0191bbd51b3631d1c51ec7b361 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-31 14:21:05 +01:00
#include <pchgenerator.h>
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
#include <sqlitedatabase.h>
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
#include <QFileInfo>
namespace {
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
using ClangBackEnd::FilePathId;
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
using ClangBackEnd::IdPaths;
using ClangBackEnd::ProjectPartPch;
using ClangBackEnd::V2::ProjectPartContainer;
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
using ClangBackEnd::V2::FileContainer;
Clang: Improve speed by content generation The argument parsing has some considerable overhead. We try to avoid that with merging all content together in one file. Change-Id: Icf426bb5d6a5569d59c180f94c7eab66a22a251c Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-16 18:25:19 +01:00
using ClangBackEnd::FilePath;
Clang: Fix includes in the PCH creator We now distinguish between the the top external headers which are used for the PCH and all external includes which are used for watching. Adding indirect external includes can lead to errors because some are not protected by a header guard. Change-Id: I01576fcf1ad25e7a6e3efc252eabbd23d5c0e727 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-03-28 16:00:10 +02:00
using ClangBackEnd::FilePathIds;
Clang: Handle native file in the file cache Different types are introduced for normalized and native file path. So the compiler is warning you if you try the wrong format. Change-Id: I1da0686b142cbf9bb7578468c2b50f90a94cebf9 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-11-16 17:48:53 +01:00
using ClangBackEnd::FilePathView;
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
using Utils::PathString;
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
using Utils::SmallString;
Utils: Convert to SmallStringView for comparison Change-Id: I38d9716225b81091e8e75b26c9c2258a2aefa987 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-29 12:54:10 +02:00
using UnitTests::EndsWith;
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
class PchCreator: public ::testing::Test
{
protected:
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
ClangBackEnd::FilePathId id(ClangBackEnd::FilePathView path)
{
return filePathCache.filePathId(path);
}
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
protected:
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
Sqlite::Database database{":memory:", Sqlite::JournalMode::Memory};
ClangBackEnd::RefactoringDatabaseInitializer<Sqlite::Database> databaseInitializer{database};
ClangBackEnd::FilePathCaching filePathCache{database};
Clang: Handle native file in the file cache Different types are introduced for normalized and native file path. So the compiler is warning you if you try the wrong format. Change-Id: I1da0686b142cbf9bb7578468c2b50f90a94cebf9 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-11-16 17:48:53 +01:00
FilePath main1Path = TESTDATA_DIR "/includecollector_main3.cpp";
FilePath main2Path = TESTDATA_DIR "/includecollector_main2.cpp";
FilePath header1Path = TESTDATA_DIR "/includecollector_header1.h";
FilePath header2Path = TESTDATA_DIR "/includecollector_header2.h";
Utils::SmallStringView generatedFileName = "includecollector_generated_file.h";
FilePath generatedFilePath = TESTDATA_DIR "/includecollector_generated_file.h";
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
ProjectPartContainer projectPart1{"project1",
{"-I", TESTDATA_DIR, "-Wno-pragma-once-outside-header"},
Clang: Introduce CompilerMacro We want not only the name but the value of the macro too. So we can compare if anything has changed. Change-Id: Ie59caf8cbf54d108f9e15299d25306a406b5c40d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-06 19:03:14 +01:00
{{"DEFINE", "1"}},
Clang: Check if the include search path has changed If the include search paths and the compiler macros have not changed it is save to assume that we don't need to update the symbol database. This saves us from executing a very expensive task. Later we have to test the modification time of the files too. Change-Id: I6b958075024a811c2abd3d7918263fd74bba090b Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-08 12:48:46 +01:00
{"/includes"},
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
{id(header1Path)},
{id(main1Path)}};
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
ProjectPartContainer projectPart2{"project2",
{"-I", TESTDATA_DIR, "-x", "c++-header", "-Wno-pragma-once-outside-header"},
Clang: Introduce CompilerMacro We want not only the name but the value of the macro too. So we can compare if anything has changed. Change-Id: Ie59caf8cbf54d108f9e15299d25306a406b5c40d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-06 19:03:14 +01:00
{{"DEFINE", "1"}},
Clang: Check if the include search path has changed If the include search paths and the compiler macros have not changed it is save to assume that we don't need to update the symbol database. This saves us from executing a very expensive task. Later we have to test the modification time of the files too. Change-Id: I6b958075024a811c2abd3d7918263fd74bba090b Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-08 12:48:46 +01:00
{"/includes"},
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
{id(header2Path)},
{id(main2Path)}};
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
TestEnvironment environment;
Clang: Handle native file in the file cache Different types are introduced for normalized and native file path. So the compiler is warning you if you try the wrong format. Change-Id: I1da0686b142cbf9bb7578468c2b50f90a94cebf9 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-11-16 17:48:53 +01:00
FileContainer generatedFile{{TESTDATA_DIR, generatedFileName}, "#pragma once", {}};
Clang: Add Process Generator So far we only compiled the precompiled headers only sequentially. The process generator is creating, managing a queue of processes to compile the PCHs parallel. Change-Id: I8075def4ef9e6b0191bbd51b3631d1c51ec7b361 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-31 14:21:05 +01:00
NiceMock<MockPchGeneratorNotifier> mockPchGeneratorNotifier;
ClangBackEnd::PchGenerator<FakeProcess> generator{environment, &mockPchGeneratorNotifier};
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
ClangBackEnd::PchCreator creator{{projectPart1.clone(),projectPart2.clone()},
environment,
Clang: Add Process Generator So far we only compiled the precompiled headers only sequentially. The process generator is creating, managing a queue of processes to compile the PCHs parallel. Change-Id: I8075def4ef9e6b0191bbd51b3631d1c51ec7b361 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-31 14:21:05 +01:00
filePathCache,
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
&generator,
{generatedFile}};
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
};
using PchCreatorSlowTest = PchCreator;
using PchCreatorVerySlowTest = PchCreator;
TEST_F(PchCreator, CreateGlobalHeaderPaths)
{
auto filePaths = creator.generateGlobalHeaderPaths();
ASSERT_THAT(filePaths,
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
UnorderedElementsAre(header1Path, header2Path, generatedFilePath));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
TEST_F(PchCreator, CreateGlobalSourcePaths)
{
auto filePaths = creator.generateGlobalSourcePaths();
ASSERT_THAT(filePaths,
UnorderedElementsAre(main1Path, main2Path));
}
TEST_F(PchCreator, CreateGlobalHeaderAndSourcePaths)
{
auto filePaths = creator.generateGlobalHeaderAndSourcePaths();
ASSERT_THAT(filePaths,
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
UnorderedElementsAre(main1Path, main2Path, header1Path, header2Path, generatedFilePath));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
TEST_F(PchCreator, CreateGlobalArguments)
{
auto arguments = creator.generateGlobalArguments();
ASSERT_THAT(arguments, ElementsAre("-I", TESTDATA_DIR, "-Wno-pragma-once-outside-header", "-I", TESTDATA_DIR, "-x" , "c++-header", "-Wno-pragma-once-outside-header"));
}
TEST_F(PchCreator, CreateGlobalCommandLine)
{
auto arguments = creator.generateGlobalCommandLine();
ASSERT_THAT(arguments, ElementsAre(environment.clangCompilerPath(), "-I", TESTDATA_DIR, "-Wno-pragma-once-outside-header", "-I", TESTDATA_DIR, "-x" , "c++-header", "-Wno-pragma-once-outside-header"));
}
Clang: Add Process Generator So far we only compiled the precompiled headers only sequentially. The process generator is creating, managing a queue of processes to compile the PCHs parallel. Change-Id: I8075def4ef9e6b0191bbd51b3631d1c51ec7b361 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-31 14:21:05 +01:00
TEST_F(PchCreatorVerySlowTest, CreateGlobalPchIncludes)
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
{
auto includeIds = creator.generateGlobalPchIncludeIds();
ASSERT_THAT(includeIds,
Clang: Improve speed by content generation The argument parsing has some considerable overhead. We try to avoid that with merging all content together in one file. Change-Id: Icf426bb5d6a5569d59c180f94c7eab66a22a251c Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-16 18:25:19 +01:00
AllOf(Contains(id(TESTDATA_DIR "/includecollector_external3.h")),
Contains(id(TESTDATA_DIR "/includecollector_external1.h")),
Contains(id(TESTDATA_DIR "/includecollector_external2.h"))));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
TEST_F(PchCreatorVerySlowTest, CreateGlobalPchFileContent)
{
auto content = creator.generateGlobalPchHeaderFileContent();
Utils: Convert to SmallStringView for comparison Change-Id: I38d9716225b81091e8e75b26c9c2258a2aefa987 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-29 12:54:10 +02:00
ASSERT_THAT(std::string(content),
Clang: Improve speed by content generation The argument parsing has some considerable overhead. We try to avoid that with merging all content together in one file. Change-Id: Icf426bb5d6a5569d59c180f94c7eab66a22a251c Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-16 18:25:19 +01:00
AllOf(HasSubstr("#include \"" TESTDATA_DIR "/includecollector_external3.h\"\n"),
HasSubstr("#include \"" TESTDATA_DIR "/includecollector_external1.h\"\n"),
HasSubstr("#include \"" TESTDATA_DIR "/includecollector_external2.h\"\n")));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
TEST_F(PchCreatorVerySlowTest, CreateGlobalPchHeaderFile)
{
auto file = creator.generateGlobalPchHeaderFile();
file->open(QIODevice::ReadOnly);
auto content = file->readAll();
Clang: Improve speed by content generation The argument parsing has some considerable overhead. We try to avoid that with merging all content together in one file. Change-Id: Icf426bb5d6a5569d59c180f94c7eab66a22a251c Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-16 18:25:19 +01:00
ASSERT_THAT(content.toStdString(),
AllOf(HasSubstr("#include \"" TESTDATA_DIR "/includecollector_external3.h\"\n"),
HasSubstr("#include \"" TESTDATA_DIR "/includecollector_external1.h\"\n"),
HasSubstr("#include \"" TESTDATA_DIR "/includecollector_external2.h\"\n")));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
TEST_F(PchCreator, ConvertToQStringList)
{
auto arguments = creator.convertToQStringList({"-I", TESTDATA_DIR});
ASSERT_THAT(arguments, ElementsAre(QString("-I"), QString(TESTDATA_DIR)));
}
TEST_F(PchCreator, CreateGlobalPchCompilerArguments)
{
auto arguments = creator.generateGlobalPchCompilerArguments();
ASSERT_THAT(arguments, ElementsAre("-x","c++-header", "-Xclang", "-emit-pch", "-o", EndsWith(".pch"), EndsWith(".h")));
}
TEST_F(PchCreator, CreateGlobalClangCompilerArguments)
{
auto arguments = creator.generateGlobalClangCompilerArguments();
ASSERT_THAT(arguments, AllOf(Contains("-Wno-pragma-once-outside-header"),
Contains("-emit-pch"),
Contains("-o"),
Not(Contains(environment.clangCompilerPath()))));
}
TEST_F(PchCreator, CreateProjectPartCommandLine)
{
auto commandLine = creator.generateProjectPartCommandLine(projectPart1);
ASSERT_THAT(commandLine, ElementsAre(environment.clangCompilerPath(), "-I", TESTDATA_DIR, "-Wno-pragma-once-outside-header"));
}
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
TEST_F(PchCreator, CreateProjectPartHeaders)
{
auto includeIds = creator.generateProjectPartHeaders(projectPart1);
ASSERT_THAT(includeIds, UnorderedElementsAre(header1Path, generatedFilePath));
}
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
TEST_F(PchCreator, CreateProjectPartHeaderAndSources)
{
auto includeIds = creator.generateProjectPartHeaderAndSourcePaths(projectPart1);
ASSERT_THAT(includeIds, UnorderedElementsAre(main1Path, header1Path));
}
TEST_F(PchCreatorSlowTest, CreateProjectPartPchIncludes)
{
Clang: Fix includes in the PCH creator We now distinguish between the the top external headers which are used for the PCH and all external includes which are used for watching. Adding indirect external includes can lead to errors because some are not protected by a header guard. Change-Id: I01576fcf1ad25e7a6e3efc252eabbd23d5c0e727 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-03-28 16:00:10 +02:00
using IncludePair = decltype(creator.generateProjectPartPchIncludes(projectPart1));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
auto includeIds = creator.generateProjectPartPchIncludes(projectPart1);
Clang: Improve speed by content generation The argument parsing has some considerable overhead. We try to avoid that with merging all content together in one file. Change-Id: Icf426bb5d6a5569d59c180f94c7eab66a22a251c Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-16 18:25:19 +01:00
ASSERT_THAT(includeIds,
Clang: Fix includes in the PCH creator We now distinguish between the the top external headers which are used for the PCH and all external includes which are used for watching. Adding indirect external includes can lead to errors because some are not protected by a header guard. Change-Id: I01576fcf1ad25e7a6e3efc252eabbd23d5c0e727 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-03-28 16:00:10 +02:00
AllOf(
Field(&IncludePair::first,
AllOf(Contains(id(TESTDATA_DIR "/includecollector_external1.h")),
Contains(id(TESTDATA_DIR "/includecollector_external2.h")),
Contains(id(TESTDATA_DIR "/includecollector_header2.h")))),
Field(&IncludePair::second,
AllOf(Contains(id(TESTDATA_DIR "/includecollector_external1.h")),
Contains(id(TESTDATA_DIR "/includecollector_external2.h"))))));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
TEST_F(PchCreatorSlowTest, CreateProjectPartPchFileContent)
{
Clang: Fix includes in the PCH creator We now distinguish between the the top external headers which are used for the PCH and all external includes which are used for watching. Adding indirect external includes can lead to errors because some are not protected by a header guard. Change-Id: I01576fcf1ad25e7a6e3efc252eabbd23d5c0e727 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-03-28 16:00:10 +02:00
FilePathIds topExternalIncludes;
std::tie(std::ignore, topExternalIncludes) = creator.generateProjectPartPchIncludes(projectPart1);
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
Clang: Fix includes in the PCH creator We now distinguish between the the top external headers which are used for the PCH and all external includes which are used for watching. Adding indirect external includes can lead to errors because some are not protected by a header guard. Change-Id: I01576fcf1ad25e7a6e3efc252eabbd23d5c0e727 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-03-28 16:00:10 +02:00
auto content = creator.generatePchIncludeFileContent(topExternalIncludes);
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
Utils: Convert to SmallStringView for comparison Change-Id: I38d9716225b81091e8e75b26c9c2258a2aefa987 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-29 12:54:10 +02:00
ASSERT_THAT(std::string(content),
Clang: Improve speed by content generation The argument parsing has some considerable overhead. We try to avoid that with merging all content together in one file. Change-Id: Icf426bb5d6a5569d59c180f94c7eab66a22a251c Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-16 18:25:19 +01:00
AllOf(HasSubstr("#include \"" TESTDATA_DIR "/includecollector_header2.h\"\n"),
HasSubstr("#include \"" TESTDATA_DIR "/includecollector_external1.h\"\n"),
HasSubstr("#include \"" TESTDATA_DIR "/includecollector_external2.h\"\n")));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
TEST_F(PchCreatorSlowTest, CreateProjectPartPchIncludeFile)
{
Clang: Fix includes in the PCH creator We now distinguish between the the top external headers which are used for the PCH and all external includes which are used for watching. Adding indirect external includes can lead to errors because some are not protected by a header guard. Change-Id: I01576fcf1ad25e7a6e3efc252eabbd23d5c0e727 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-03-28 16:00:10 +02:00
FilePathIds topExternalIncludes;
std::tie(std::ignore, topExternalIncludes) = creator.generateProjectPartPchIncludes(projectPart1);
auto content = creator.generatePchIncludeFileContent(topExternalIncludes);
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
auto pchIncludeFilePath = creator.generateProjectPathPchHeaderFilePath(projectPart1);
Clang: Improve speed by content generation The argument parsing has some considerable overhead. We try to avoid that with merging all content together in one file. Change-Id: Icf426bb5d6a5569d59c180f94c7eab66a22a251c Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-16 18:25:19 +01:00
auto file = creator.generateFileWithContent(pchIncludeFilePath, content);
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
file->open(QIODevice::ReadOnly);
auto fileContent = file->readAll();
Clang: Improve speed by content generation The argument parsing has some considerable overhead. We try to avoid that with merging all content together in one file. Change-Id: Icf426bb5d6a5569d59c180f94c7eab66a22a251c Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-16 18:25:19 +01:00
ASSERT_THAT(fileContent.toStdString(),
AllOf(HasSubstr("#include \"" TESTDATA_DIR "/includecollector_header2.h\"\n"),
HasSubstr("#include \"" TESTDATA_DIR "/includecollector_external1.h\"\n"),
HasSubstr("#include \"" TESTDATA_DIR "/includecollector_external2.h\"\n")));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
TEST_F(PchCreator, CreateProjectPartPchCompilerArguments)
{
auto arguments = creator.generateProjectPartPchCompilerArguments(projectPart1);
ASSERT_THAT(arguments, AllOf(Contains("-x"),
Contains("c++-header"),
// Contains("-Xclang"),
// Contains("-include-pch"),
// Contains("-Xclang"),
// Contains(EndsWith(".pch")),
Contains("-Xclang"),
Contains("-emit-pch"),
Contains("-o"),
Contains(EndsWith(".pch"))));
}
TEST_F(PchCreator, CreateProjectPartClangCompilerArguments)
{
auto arguments = creator.generateProjectPartClangCompilerArguments(projectPart1);
ASSERT_THAT(arguments, AllOf(Contains(TESTDATA_DIR),
Contains("-emit-pch"),
Contains("-o"),
Not(Contains(environment.clangCompilerPath()))));
}
TEST_F(PchCreatorVerySlowTest, ProjectPartPchsExistsAfterCreation)
{
creator.generateGlobalPch();
creator.generateProjectPartPch(projectPart1);
Utils: Convert to SmallStringView for comparison Change-Id: I38d9716225b81091e8e75b26c9c2258a2aefa987 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-29 12:54:10 +02:00
ASSERT_TRUE(QFileInfo::exists(QString(creator.generateProjectPathPchHeaderFilePath(projectPart1))));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
Clang: Improve speed by content generation The argument parsing has some considerable overhead. We try to avoid that with merging all content together in one file. Change-Id: Icf426bb5d6a5569d59c180f94c7eab66a22a251c Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-16 18:25:19 +01:00
TEST_F(PchCreatorVerySlowTest, DISABLED_CreatePartPchs)
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
{
creator.generateGlobalPch();
Clang: Add Process Generator So far we only compiled the precompiled headers only sequentially. The process generator is creating, managing a queue of processes to compile the PCHs parallel. Change-Id: I8075def4ef9e6b0191bbd51b3631d1c51ec7b361 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-31 14:21:05 +01:00
auto includePaths = creator.generateProjectPartPch(projectPart1);
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
Clang: Fix build This amends commit cf4dbb4bb628c4d51ae866b278a5d0733674c129. Change-Id: Ib74fba38348a02f6bb9d254b7a5e9013a2013942 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2018-04-08 01:20:42 +03:00
ASSERT_THAT(includePaths.id, projectPart1.projectPartId);
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
ASSERT_THAT(includePaths.filePathIds,
AllOf(Contains(FilePathId{1, 1}),
Contains(FilePathId{1, 2}),
Contains(FilePathId{1, 3})));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
Clang: Add Process Generator So far we only compiled the precompiled headers only sequentially. The process generator is creating, managing a queue of processes to compile the PCHs parallel. Change-Id: I8075def4ef9e6b0191bbd51b3631d1c51ec7b361 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-31 14:21:05 +01:00
TEST_F(PchCreatorVerySlowTest, IncludesForCreatePchsForProjectParts)
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
{
creator.generatePchs();
Clang: Add Process Generator So far we only compiled the precompiled headers only sequentially. The process generator is creating, managing a queue of processes to compile the PCHs parallel. Change-Id: I8075def4ef9e6b0191bbd51b3631d1c51ec7b361 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-31 14:21:05 +01:00
ASSERT_THAT(creator.takeProjectsIncludes(),
ElementsAre(Field(&IdPaths::id, "project1"),
Field(&IdPaths::id, "project2")));
}
TEST_F(PchCreatorVerySlowTest, ProjectPartPchsForCreatePchsForProjectParts)
{
EXPECT_CALL(mockPchGeneratorNotifier,
taskFinished(ClangBackEnd::TaskFinishStatus::Successfully,
Clang: Add lastModified to the precompiled header It is important to know then the PCH generation started, so we can compare the header file time stamps against it. Change-Id: Id8ee91e886c153d9d4a37cc0438c682f2098f7fa Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-15 14:29:20 +01:00
Field(&ProjectPartPch::projectPartId, "project1")));
Clang: Add Process Generator So far we only compiled the precompiled headers only sequentially. The process generator is creating, managing a queue of processes to compile the PCHs parallel. Change-Id: I8075def4ef9e6b0191bbd51b3631d1c51ec7b361 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-31 14:21:05 +01:00
EXPECT_CALL(mockPchGeneratorNotifier,
taskFinished(ClangBackEnd::TaskFinishStatus::Successfully,
Clang: Add lastModified to the precompiled header It is important to know then the PCH generation started, so we can compare the header file time stamps against it. Change-Id: Id8ee91e886c153d9d4a37cc0438c682f2098f7fa Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-15 14:29:20 +01:00
Field(&ProjectPartPch::projectPartId, "project2")));
Clang: Add Process Generator So far we only compiled the precompiled headers only sequentially. The process generator is creating, managing a queue of processes to compile the PCHs parallel. Change-Id: I8075def4ef9e6b0191bbd51b3631d1c51ec7b361 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-31 14:21:05 +01:00
creator.generatePchs();
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
TEST_F(PchCreatorVerySlowTest, IdPathsForCreatePchsForProjectParts)
{
creator.generatePchs();
ASSERT_THAT(creator.takeProjectsIncludes(),
ElementsAre(AllOf(Field(&IdPaths::id, "project1"),
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
Field(&IdPaths::filePathIds, AllOf(Contains(id(TESTDATA_DIR "/includecollector_header2.h")),
Clang: Improve speed by content generation The argument parsing has some considerable overhead. We try to avoid that with merging all content together in one file. Change-Id: Icf426bb5d6a5569d59c180f94c7eab66a22a251c Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-16 18:25:19 +01:00
Contains(id(TESTDATA_DIR "/includecollector_external1.h")),
Contains(id(TESTDATA_DIR "/includecollector_external2.h"))))),
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
AllOf(Field(&IdPaths::id, "project2"),
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
Field(&IdPaths::filePathIds, AllOf(Contains(id(TESTDATA_DIR "/includecollector_external1.h")),
Clang: Improve speed by content generation The argument parsing has some considerable overhead. We try to avoid that with merging all content together in one file. Change-Id: Icf426bb5d6a5569d59c180f94c7eab66a22a251c Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-16 18:25:19 +01:00
Contains(id(TESTDATA_DIR "/includecollector_external3.h")),
Contains(id(TESTDATA_DIR "/includecollector_header1.h")),
Contains(id(TESTDATA_DIR "/includecollector_external2.h")))))));
}
TEST_F(PchCreator, CreateProjectPartHeaderAndSourcesContent)
{
auto content = creator.generateProjectPartHeaderAndSourcesContent(projectPart1);
ASSERT_THAT(content, Eq("#include \"" TESTDATA_DIR "/includecollector_header1.h\"\n"
"#include \"" TESTDATA_DIR "/includecollector_main3.cpp\"\n"));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
Clang: Add file cache The database is using file path integer ids to handle file paths because otherwise we would save many redundant data. This patch is improving it further with the introduction of a database based file path cache. The entries are now divided in a directory path and file name. This is quite handy for directory based file watching. Change-Id: I03f2e388e43f3d521d6bf8e39dfb95eb2309dc73 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-09-21 11:43:59 +02:00
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
Copy Permalink