CppTools: Move CompilerOptionsBuilder tests to plugin

... where they belong.

Change-Id: Ifc6aebc218f9f85ffeb6a4b7121f97379b53b69d
Reviewed-by: Christian Stenger <christian.stenger@qt.io>
This commit is contained in:
Christian Kandeler
2021-06-30 17:44:22 +02:00
parent af3fa22d51
commit 85797068bb
11 changed files with 764 additions and 748 deletions

View File

@@ -110,6 +110,7 @@ add_qtc_plugin(CppTools
extend_qtc_plugin(CppTools extend_qtc_plugin(CppTools
CONDITION WITH_TESTS CONDITION WITH_TESTS
SOURCES SOURCES
compileroptionsbuilder_test.cpp
cppcodegen_test.cpp cppcodegen_test.cpp
cppcompletion_test.cpp cppcompletion_test.cpp
cppheadersource_test.cpp cppheadersource_test.cpp

View File

@@ -0,0 +1,719 @@
/****************************************************************************
**
** 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 "cpptoolsplugin.h"
#include "compileroptionsbuilder.h"
#include "projectpart.h"
#include <projectexplorer/headerpath.h>
#include <projectexplorer/project.h>
#include <utils/algorithm.h>
#include <utils/temporarydirectory.h>
#include <QtTest>
#include <memory>
using namespace ProjectExplorer;
namespace CppTools {
namespace Internal {
namespace {
class CompilerOptionsBuilderTest
{
public:
CompilerOptionsBuilderTest()
{
QFile pchFile(pchFileNativePath());
pchFile.open(QIODevice::WriteOnly);
projectPart.project = project.get();
projectPart.toolchainType = ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID;
projectPart.languageVersion = Utils::LanguageVersion::CXX17;
projectPart.toolChainWordWidth = CppTools::ProjectPart::WordWidth64Bit;
projectPart.toolChainTargetTriple = "x86_64-apple-darwin10";
projectPart.precompiledHeaders = QStringList{pchFileNativePath()};
projectPart.toolChainMacros = {ProjectExplorer::Macro{"foo", "bar"},
ProjectExplorer::Macro{"__cplusplus", "2"},
ProjectExplorer::Macro{"__STDC_VERSION__", "2"},
ProjectExplorer::Macro{"_MSVC_LANG", "2"},
ProjectExplorer::Macro{"_MSC_BUILD", "2"},
ProjectExplorer::Macro{"_MSC_FULL_VER", "1900"},
ProjectExplorer::Macro{"_MSC_VER", "19"}};
projectPart.projectMacros = {ProjectExplorer::Macro{"projectFoo", "projectBar"}};
projectPart.qtVersion = Utils::QtVersion::Qt5;
projectPart.headerPaths = {HeaderPath{"/tmp/builtin_path", HeaderPathType::BuiltIn},
HeaderPath{"/tmp/system_path", HeaderPathType::System},
HeaderPath{"/tmp/path", HeaderPathType::User}};
}
static HeaderPath builtIn(const QString &path)
{
return HeaderPath{path, HeaderPathType::BuiltIn};
}
QString toNative(const QString &toNative) const
{
return QDir::toNativeSeparators(toNative);
}
QString pchFileNativePath() const
{
return toNative(Utils::TemporaryDirectory::masterDirectoryPath()
+ "/compileroptionsbuilder.pch");
}
std::unique_ptr<Project> project{std::make_unique<ProjectExplorer::Project>(QString(),
Utils::FilePath())};
ProjectPart projectPart;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart};
};
}
void CppToolsPlugin::test_optionsBuilder_addProjectMacros()
{
CompilerOptionsBuilderTest t;
t.compilerOptionsBuilder.addProjectMacros();
QCOMPARE(t.compilerOptionsBuilder.options(), QStringList("-DprojectFoo=projectBar"));
}
void CppToolsPlugin::test_optionsBuilder_unknownFlagsAreForwarded()
{
CompilerOptionsBuilderTest t;
ProjectPart part = t.projectPart;
part.compilerFlags = QStringList{"-fancyFlag"};
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{part,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::No,
CppTools::UseLanguageDefines::Yes};
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
QVERIFY(compilerOptionsBuilder.options().contains(part.compilerFlags.first()));
}
void CppToolsPlugin::test_optionsBuilder_warningsFlagsAreNotFilteredIfRequested()
{
CompilerOptionsBuilderTest t;
ProjectPart part = t.projectPart;
part.compilerFlags = QStringList{"-Whello"};
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{part,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::No,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::Yes};
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
QVERIFY(compilerOptionsBuilder.options().contains(part.compilerFlags.first()));
}
void CppToolsPlugin::test_optionsBuilder_diagnosticOptionsAreRemoved()
{
CompilerOptionsBuilderTest t;
ProjectPart part = t.projectPart;
part.compilerFlags = QStringList{"-Wbla", "-pedantic"};
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{part,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::No,
CppTools::UseLanguageDefines::Yes};
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
QVERIFY(!compilerOptionsBuilder.options().contains(part.compilerFlags.at(0)));
QVERIFY(!compilerOptionsBuilder.options().contains(part.compilerFlags.at(1)));
}
void CppToolsPlugin::test_optionsBuilder_cLanguageVersionIsRewritten()
{
CompilerOptionsBuilderTest t;
ProjectPart part = t.projectPart;
part.compilerFlags = QStringList{"-std=c18"};
// We need to set the language version here to overcome a QTC_ASSERT checking
// consistency between ProjectFile::Kind and ProjectPart::LanguageVersion
part.languageVersion = Utils::LanguageVersion::C18;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{part,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::No,
CppTools::UseLanguageDefines::Yes};
compilerOptionsBuilder.build(ProjectFile::CSource, CppTools::UsePrecompiledHeaders::No);
QVERIFY(!compilerOptionsBuilder.options().contains(part.compilerFlags.first()));
QVERIFY(compilerOptionsBuilder.options().contains("-std=c17"));
}
void CppToolsPlugin::test_optionsBuilder_languageVersionIsExplicitlySetIfNotProvided()
{
CompilerOptionsBuilderTest t;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{t.projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::No,
CppTools::UseLanguageDefines::Yes};
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
QVERIFY(compilerOptionsBuilder.options().contains("-std=c++17"));
}
void CppToolsPlugin::test_optionsBuilder_LanguageVersionIsExplicitlySetIfNotProvidedMsvc()
{
CompilerOptionsBuilderTest t;
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{t.projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::No,
CppTools::UseLanguageDefines::Yes};
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
QVERIFY(compilerOptionsBuilder.options().contains("/std:c++17"));
}
void CppToolsPlugin::test_optionsBuilder_addWordWidth()
{
CompilerOptionsBuilderTest t;
t.compilerOptionsBuilder.addWordWidth();
QCOMPARE(t.compilerOptionsBuilder.options(), QStringList("-m64"));
}
void CppToolsPlugin::test_optionsBuilder_headerPathOptionsOrder()
{
CompilerOptionsBuilderTest t;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{t.projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
""};
compilerOptionsBuilder.addHeaderPathOptions();
QCOMPARE(compilerOptionsBuilder.options(),
(QStringList{"-nostdinc", "-nostdinc++", "-I", t.toNative("/tmp/path"),
"-I", t.toNative("/tmp/system_path"), "-isystem", "", "-isystem",
t.toNative("/tmp/builtin_path")}));
}
void CppToolsPlugin::test_optionsBuilder_HeaderPathOptionsOrderMsvc()
{
CompilerOptionsBuilderTest t;
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{t.projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
""};
compilerOptionsBuilder.evaluateCompilerFlags();
compilerOptionsBuilder.addHeaderPathOptions();
QCOMPARE(compilerOptionsBuilder.options(),
(QStringList{"-nostdinc", "-nostdinc++", "-I", t.toNative("/tmp/path"),
"-I", t.toNative("/tmp/system_path"), "/clang:-isystem",
"/clang:", "/clang:-isystem",
"/clang:" + t.toNative("/tmp/builtin_path")}));
}
void CppToolsPlugin::test_optionsBuilder_useSystemHeader()
{
CompilerOptionsBuilderTest t;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{t.projectPart,
CppTools::UseSystemHeader::Yes,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
""};
compilerOptionsBuilder.addHeaderPathOptions();
QCOMPARE(compilerOptionsBuilder.options(),
(QStringList{"-nostdinc", "-nostdinc++", "-I", t.toNative("/tmp/path"),
"-isystem", t.toNative("/tmp/system_path"),
"-isystem", "", "-isystem", t.toNative("/tmp/builtin_path")}));
}
void CppToolsPlugin::test_optionsBuilder_noClangHeadersPath()
{
CompilerOptionsBuilderTest t;
t.compilerOptionsBuilder.addHeaderPathOptions();
QCOMPARE(t.compilerOptionsBuilder.options(),
(QStringList{"-I", t.toNative("/tmp/path"), "-I", t.toNative("/tmp/system_path")}));
}
void CppToolsPlugin::test_optionsBuilder_clangHeadersAndCppIncludePathsOrderMacOs()
{
CompilerOptionsBuilderTest t;
const auto defaultPaths = t.projectPart.headerPaths;
t.projectPart.headerPaths = {
t.builtIn("/usr/include/c++/4.2.1"),
t.builtIn("/usr/include/c++/4.2.1/backward"),
t.builtIn("/usr/local/include"),
t.builtIn("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/6.0/include"),
t.builtIn("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include"),
t.builtIn("/usr/include")
};
t.projectPart.headerPaths.append(defaultPaths);
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(t.projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.addHeaderPathOptions();
QCOMPARE(compilerOptionsBuilder.options(),
(QStringList{"-nostdinc", "-nostdinc++", "-I", t.toNative("/tmp/path"),
"-I", t.toNative("/tmp/system_path"),
"-isystem", t.toNative("/usr/include/c++/4.2.1"),
"-isystem", t.toNative("/usr/include/c++/4.2.1/backward"),
"-isystem", t.toNative("/usr/local/include"),
"-isystem", "",
"-isystem", t.toNative("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include"),
"-isystem", t.toNative("/usr/include"),
"-isystem", t.toNative("/tmp/builtin_path")}));
}
void CppToolsPlugin::test_optionsBuilder_clangHeadersAndCppIncludePathsOrderLinux()
{
CompilerOptionsBuilderTest t;
t.projectPart.headerPaths = {
t.builtIn("/usr/include/c++/4.8"),
t.builtIn("/usr/include/c++/4.8/backward"),
t.builtIn("/usr/include/x86_64-linux-gnu/c++/4.8"),
t.builtIn("/usr/local/include"),
t.builtIn("/usr/lib/gcc/x86_64-linux-gnu/4.8/include"),
t.builtIn("/usr/include/x86_64-linux-gnu"),
t.builtIn("/usr/include"),
};
t.projectPart.toolChainTargetTriple = "x86_64-linux-gnu";
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(t.projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.addHeaderPathOptions();
QCOMPARE(compilerOptionsBuilder.options(),
(QStringList{"-nostdinc", "-nostdinc++",
"-isystem", t.toNative("/usr/include/c++/4.8"),
"-isystem", t.toNative("/usr/include/c++/4.8/backward"),
"-isystem", t.toNative("/usr/include/x86_64-linux-gnu/c++/4.8"),
"-isystem", t.toNative("/usr/local/include"),
"-isystem", "",
"-isystem", t.toNative("/usr/lib/gcc/x86_64-linux-gnu/4.8/include"),
"-isystem", t.toNative("/usr/include/x86_64-linux-gnu"),
"-isystem", t.toNative("/usr/include")}));
}
void CppToolsPlugin::test_optionsBuilder_clangHeadersAndCppIncludePathsOrderNoVersion()
{
CompilerOptionsBuilderTest t;
t.projectPart.headerPaths = {
t.builtIn("C:/mingw530/i686-w64-mingw32/include"),
t.builtIn("C:/mingw530/i686-w64-mingw32/include/c++"),
t.builtIn("C:/mingw530/i686-w64-mingw32/include/c++/i686-w64-mingw32"),
t.builtIn("C:/mingw530/i686-w64-mingw32/include/c++/backward"),
};
t.projectPart.toolChainTargetTriple = "x86_64-w64-windows-gnu";
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(t.projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.addHeaderPathOptions();
QCOMPARE(compilerOptionsBuilder.options(),
(QStringList{"-nostdinc", "-nostdinc++",
"-isystem", t.toNative("C:/mingw530/i686-w64-mingw32/include/c++"),
"-isystem", t.toNative("C:/mingw530/i686-w64-mingw32/include/c++/i686-w64-mingw32"),
"-isystem", t.toNative("C:/mingw530/i686-w64-mingw32/include/c++/backward"),
"-isystem", "",
"-isystem", t.toNative("C:/mingw530/i686-w64-mingw32/include")}));
}
void CppToolsPlugin::test_optionsBuilder_clangHeadersAndCppIncludePathsOrderAndroidClang()
{
CompilerOptionsBuilderTest t;
t.projectPart.headerPaths = {
t.builtIn("C:/Android/sdk/ndk-bundle/sysroot/usr/include/i686-linux-android"),
t.builtIn("C:/Android/sdk/ndk-bundle/sources/cxx-stl/llvm-libc++/include"),
t.builtIn("C:/Android/sdk/ndk-bundle/sources/android/support/include"),
t.builtIn("C:/Android/sdk/ndk-bundle/sources/cxx-stl/llvm-libc++abi/include"),
t.builtIn("C:/Android/sdk/ndk-bundle/sysroot/usr/include"),
};
t.projectPart.toolChainTargetTriple = "i686-linux-android";
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(t.projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.addHeaderPathOptions();
QCOMPARE(compilerOptionsBuilder.options(),
(QStringList{"-nostdinc", "-nostdinc++",
"-isystem", t.toNative("C:/Android/sdk/ndk-bundle/sources/cxx-stl/llvm-libc++/include"),
"-isystem", t.toNative("C:/Android/sdk/ndk-bundle/sources/cxx-stl/llvm-libc++abi/include"),
"-isystem", t.toNative(""),
"-isystem", t.toNative("C:/Android/sdk/ndk-bundle/sysroot/usr/include/i686-linux-android"),
"-isystem", t.toNative("C:/Android/sdk/ndk-bundle/sources/android/support/include"),
"-isystem", t.toNative("C:/Android/sdk/ndk-bundle/sysroot/usr/include")}));
}
void CppToolsPlugin::test_optionsBuilder_noPrecompiledHeader()
{
CompilerOptionsBuilderTest t;
t.compilerOptionsBuilder.addPrecompiledHeaderOptions(CppTools::UsePrecompiledHeaders::No);
QVERIFY(t.compilerOptionsBuilder.options().empty());
}
void CppToolsPlugin::test_optionsBuilder_usePrecompiledHeader()
{
CompilerOptionsBuilderTest t;
t.compilerOptionsBuilder.addPrecompiledHeaderOptions(CppTools::UsePrecompiledHeaders::Yes);
QCOMPARE(t.compilerOptionsBuilder.options(), (QStringList{"-include", t.pchFileNativePath()}));
}
void CppToolsPlugin::test_optionsBuilder_usePrecompiledHeaderMsvc()
{
CompilerOptionsBuilderTest t;
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{t.projectPart};
compilerOptionsBuilder.evaluateCompilerFlags();
compilerOptionsBuilder.addPrecompiledHeaderOptions(CppTools::UsePrecompiledHeaders::Yes);
QCOMPARE(compilerOptionsBuilder.options(), (QStringList{"/FI", t.pchFileNativePath()}));
}
void CppToolsPlugin::test_optionsBuilder_addMacros()
{
CompilerOptionsBuilderTest t;
t.compilerOptionsBuilder.addMacros(
ProjectExplorer::Macros{ProjectExplorer::Macro{"key", "value"}});
QCOMPARE(t.compilerOptionsBuilder.options(), QStringList("-Dkey=value"));
}
void CppToolsPlugin::test_optionsBuilder_addTargetTriple()
{
CompilerOptionsBuilderTest t;
t.compilerOptionsBuilder.addTargetTriple();
QCOMPARE(t.compilerOptionsBuilder.options(), QStringList("--target=x86_64-apple-darwin10"));
}
void CppToolsPlugin::test_optionsBuilder_enableCExceptions()
{
CompilerOptionsBuilderTest t;
t.projectPart.languageVersion = Utils::LanguageVersion::C99;
t.compilerOptionsBuilder.enableExceptions();
QCOMPARE(t.compilerOptionsBuilder.options(), QStringList("-fexceptions"));
}
void CppToolsPlugin::test_optionsBuilder_enableCxxExceptions()
{
CompilerOptionsBuilderTest t;
t.compilerOptionsBuilder.enableExceptions();
QCOMPARE(t.compilerOptionsBuilder.options(), (QStringList{"-fcxx-exceptions", "-fexceptions"}));
}
void CppToolsPlugin::test_optionsBuilder_insertWrappedQtHeaders()
{
CompilerOptionsBuilderTest t;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{t.projectPart,
CppTools::UseSystemHeader::Yes,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
""};
compilerOptionsBuilder.insertWrappedQtHeaders();
QVERIFY(Utils::contains(compilerOptionsBuilder.options(),
[](const QString &o) { return o.contains("wrappedQtHeaders"); }));
}
void CppToolsPlugin::test_optionsBuilder_insertWrappedMingwHeadersWithNonMingwToolchain()
{
CompilerOptionsBuilderTest t;
CppTools::CompilerOptionsBuilder builder{t.projectPart,
CppTools::UseSystemHeader::Yes,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
""};
builder.insertWrappedMingwHeaders();
QVERIFY(!Utils::contains(builder.options(),
[](const QString &o) { return o.contains("wrappedMingwHeaders"); }));
}
void CppToolsPlugin::test_optionsBuilder_insertWrappedMingwHeadersWithMingwToolchain()
{
CompilerOptionsBuilderTest t;
CppTools::CompilerOptionsBuilder builder{t.projectPart,
CppTools::UseSystemHeader::Yes,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
""};
t.projectPart.toolchainType = ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID;
builder.insertWrappedMingwHeaders();
QVERIFY(Utils::contains(builder.options(),
[](const QString &o) { return o.contains("wrappedMingwHeaders"); }));
}
void CppToolsPlugin::test_optionsBuilder_setLanguageVersion()
{
CompilerOptionsBuilderTest t;
t.compilerOptionsBuilder.updateFileLanguage(ProjectFile::CXXSource);
QCOMPARE(t.compilerOptionsBuilder.options(), (QStringList{"-x", "c++"}));
}
void CppToolsPlugin::test_optionsBuilder_setLanguageVersionMsvc()
{
CompilerOptionsBuilderTest t;
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{t.projectPart};
compilerOptionsBuilder.evaluateCompilerFlags();
compilerOptionsBuilder.updateFileLanguage(ProjectFile::CXXSource);
QCOMPARE(compilerOptionsBuilder.options(), QStringList("/TP"));
}
void CppToolsPlugin::test_optionsBuilder_handleLanguageExtension()
{
CompilerOptionsBuilderTest t;
t.projectPart.languageExtensions = Utils::LanguageExtension::ObjectiveC;
t.compilerOptionsBuilder.updateFileLanguage(ProjectFile::CXXSource);
QCOMPARE(t.compilerOptionsBuilder.options(), (QStringList{"-x", "objective-c++"}));
}
void CppToolsPlugin::test_optionsBuilder_updateLanguageVersion()
{
CompilerOptionsBuilderTest t;
t.compilerOptionsBuilder.updateFileLanguage(ProjectFile::CXXSource);
t.compilerOptionsBuilder.updateFileLanguage(ProjectFile::CXXHeader);
QCOMPARE(t.compilerOptionsBuilder.options(), (QStringList{"-x", "c++-header"}));
}
void CppToolsPlugin::test_optionsBuilder_updateLanguageVersionMsvc()
{
CompilerOptionsBuilderTest t;
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{t.projectPart};
compilerOptionsBuilder.evaluateCompilerFlags();
compilerOptionsBuilder.updateFileLanguage(ProjectFile::CXXSource);
compilerOptionsBuilder.updateFileLanguage(ProjectFile::CSource);
QCOMPARE(compilerOptionsBuilder.options(), QStringList("/TC"));
}
void CppToolsPlugin::test_optionsBuilder_addMsvcCompatibilityVersion()
{
CompilerOptionsBuilderTest t;
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
t.projectPart.toolChainMacros.append(ProjectExplorer::Macro{"_MSC_FULL_VER", "190000000"});
t.compilerOptionsBuilder.addMsvcCompatibilityVersion();
QCOMPARE(t.compilerOptionsBuilder.options(), QStringList("-fms-compatibility-version=19.00"));
}
void CppToolsPlugin::test_optionsBuilder_undefineCppLanguageFeatureMacrosForMsvc2015()
{
CompilerOptionsBuilderTest t;
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
t.projectPart.isMsvc2015Toolchain = true;
t.compilerOptionsBuilder.undefineCppLanguageFeatureMacrosForMsvc2015();
QVERIFY(t.compilerOptionsBuilder.options().contains("-U__cpp_aggregate_bases"));
}
void CppToolsPlugin::test_optionsBuilder_addDefineFunctionMacrosMsvc()
{
CompilerOptionsBuilderTest t;
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
t.compilerOptionsBuilder.addDefineFunctionMacrosMsvc();
QVERIFY(t.compilerOptionsBuilder.options().contains(
"-D__FUNCTION__=\"someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580\""));
}
void CppToolsPlugin::test_optionsBuilder_addProjectConfigFileInclude()
{
CompilerOptionsBuilderTest t;
t.projectPart.projectConfigFile = "dummy_file.h";
t.compilerOptionsBuilder.addProjectConfigFileInclude();
QCOMPARE(t.compilerOptionsBuilder.options(), (QStringList{"-include", "dummy_file.h"}));
}
void CppToolsPlugin::test_optionsBuilder_addProjectConfigFileIncludeMsvc()
{
CompilerOptionsBuilderTest t;
t.projectPart.projectConfigFile = "dummy_file.h";
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{t.projectPart};
compilerOptionsBuilder.evaluateCompilerFlags();
compilerOptionsBuilder.addProjectConfigFileInclude();
QCOMPARE(compilerOptionsBuilder.options(), (QStringList{"/FI", "dummy_file.h"}));
}
void CppToolsPlugin::test_optionsBuilder_noUndefineClangVersionMacrosForNewMsvc()
{
CompilerOptionsBuilderTest t;
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
t.compilerOptionsBuilder.undefineClangVersionMacrosForMsvc();
QVERIFY(!t.compilerOptionsBuilder.options().contains("-U__clang__"));
}
void CppToolsPlugin::test_optionsBuilder_undefineClangVersionMacrosForOldMsvc()
{
CompilerOptionsBuilderTest t;
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
t.projectPart.toolChainMacros = {ProjectExplorer::Macro{"_MSC_FULL_VER", "1300"},
ProjectExplorer::Macro{"_MSC_VER", "13"}};
t.compilerOptionsBuilder.undefineClangVersionMacrosForMsvc();
QVERIFY(t.compilerOptionsBuilder.options().contains("-U__clang__"));
}
void CppToolsPlugin::test_optionsBuilder_buildAllOptions()
{
CompilerOptionsBuilderTest t;
t.projectPart.extraCodeModelFlags = QStringList{"-arch", "x86_64"};
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(t.projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
const QString wrappedQtHeadersPath = Utils::findOrDefault(compilerOptionsBuilder.options(),
[](const QString &o) { return o.contains("wrappedQtHeaders"); });
const QString wrappedQtCoreHeadersPath = Utils::findOrDefault(compilerOptionsBuilder.options(),
[&t](const QString &o) { return o.contains(t.toNative("wrappedQtHeaders/QtCore")); });
QCOMPARE(compilerOptionsBuilder.options(),
(QStringList{"-nostdinc", "-nostdinc++", "-arch", "x86_64", "-fsyntax-only", "-m64",
"--target=x86_64-apple-darwin10", "-x", "c++", "-std=c++17",
"-DprojectFoo=projectBar", "-I", wrappedQtHeadersPath,
"-I", wrappedQtCoreHeadersPath,
"-I", t.toNative("/tmp/path"),
"-I", t.toNative("/tmp/system_path"),
"-isystem", "",
"-isystem", t.toNative("/tmp/builtin_path")}));
}
void CppToolsPlugin::test_optionsBuilder_buildAllOptionsMsvc()
{
CompilerOptionsBuilderTest t;
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(t.projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
const QString wrappedQtHeadersPath = Utils::findOrDefault(compilerOptionsBuilder.options(),
[](const QString &o) { return o.contains("wrappedQtHeaders"); });
const QString wrappedQtCoreHeadersPath = Utils::findOrDefault(compilerOptionsBuilder.options(),
[&t](const QString &o) { return o.contains(t.toNative("wrappedQtHeaders/QtCore")); });
QCOMPARE(compilerOptionsBuilder.options(),
(QStringList{"-nostdinc", "-nostdinc++", "--driver-mode=cl", "/Zs", "-m64",
"--target=x86_64-apple-darwin10", "/TP", "/std:c++17",
"-fms-compatibility-version=19.00", "-DprojectFoo=projectBar",
"-D__FUNCSIG__=\"void __cdecl someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580(void)\"",
"-D__FUNCTION__=\"someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580\"",
"-D__FUNCDNAME__=\"?someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580@@YAXXZ\"",
"-I", wrappedQtHeadersPath,
"-I", wrappedQtCoreHeadersPath,
"-I", t.toNative("/tmp/path"),
"-I", t.toNative("/tmp/system_path"),
"/clang:-isystem", "/clang:",
"/clang:-isystem", "/clang:" + t.toNative("/tmp/builtin_path")}));
}
void CppToolsPlugin::test_optionsBuilder_buildAllOptionsMsvcWithExceptions()
{
CompilerOptionsBuilderTest t;
t.projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
t.projectPart.toolChainMacros.append(ProjectExplorer::Macro{"_CPPUNWIND", "1"});
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(t.projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
const QString wrappedQtHeadersPath = Utils::findOrDefault(compilerOptionsBuilder.options(),
[](const QString &o) { return o.contains("wrappedQtHeaders"); });
const QString wrappedQtCoreHeadersPath = Utils::findOrDefault(compilerOptionsBuilder.options(),
[&t](const QString &o) { return o.contains(t.toNative("wrappedQtHeaders/QtCore")); });
QCOMPARE(compilerOptionsBuilder.options(),
(QStringList{"-nostdinc", "-nostdinc++", "--driver-mode=cl", "/Zs", "-m64",
"--target=x86_64-apple-darwin10", "/TP", "/std:c++17", "-fcxx-exceptions",
"-fexceptions", "-fms-compatibility-version=19.00",
"-DprojectFoo=projectBar",
"-D__FUNCSIG__=\"void __cdecl someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580(void)\"",
"-D__FUNCTION__=\"someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580\"",
"-D__FUNCDNAME__=\"?someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580@@YAXXZ\"",
"-I", wrappedQtHeadersPath,
"-I", wrappedQtCoreHeadersPath,
"-I", t.toNative("/tmp/path"),
"-I", t.toNative("/tmp/system_path"),
"/clang:-isystem", "/clang:",
"/clang:-isystem", "/clang:" + t.toNative("/tmp/builtin_path")}));
}
} // namespace Internal
} // namespace CppTools

View File

@@ -214,6 +214,7 @@ equals(TEST, 1) {
cppsourceprocessertesthelper.cpp \ cppsourceprocessertesthelper.cpp \
cppsourceprocessor_test.cpp \ cppsourceprocessor_test.cpp \
cpptoolstestcase.cpp \ cpptoolstestcase.cpp \
compileroptionsbuilder_test.cpp \
modelmanagertesthelper.cpp \ modelmanagertesthelper.cpp \
symbolsearcher_test.cpp \ symbolsearcher_test.cpp \
typehierarchybuilder_test.cpp typehierarchybuilder_test.cpp

View File

@@ -229,6 +229,7 @@ Project {
name: "Tests" name: "Tests"
condition: qtc.testsEnabled condition: qtc.testsEnabled
files: [ files: [
"compileroptionsbuilder_test.cpp",
"cppcodegen_test.cpp", "cppcodegen_test.cpp",
"cppcompletion_test.cpp", "cppcompletion_test.cpp",
"cppheadersource_test.cpp", "cppheadersource_test.cpp",

View File

@@ -168,6 +168,48 @@ private slots:
void test_includeGroups_detectIncludeGroupsByNewLines(); void test_includeGroups_detectIncludeGroupsByNewLines();
void test_includeGroups_detectIncludeGroupsByIncludeDir(); void test_includeGroups_detectIncludeGroupsByIncludeDir();
void test_includeGroups_detectIncludeGroupsByIncludeType(); void test_includeGroups_detectIncludeGroupsByIncludeType();
void test_optionsBuilder_addProjectMacros();
void test_optionsBuilder_unknownFlagsAreForwarded();
void test_optionsBuilder_warningsFlagsAreNotFilteredIfRequested();
void test_optionsBuilder_diagnosticOptionsAreRemoved();
void test_optionsBuilder_cLanguageVersionIsRewritten();
void test_optionsBuilder_languageVersionIsExplicitlySetIfNotProvided();
void test_optionsBuilder_LanguageVersionIsExplicitlySetIfNotProvidedMsvc();
void test_optionsBuilder_addWordWidth();
void test_optionsBuilder_headerPathOptionsOrder();
void test_optionsBuilder_HeaderPathOptionsOrderMsvc();
void test_optionsBuilder_useSystemHeader();
void test_optionsBuilder_noClangHeadersPath();
void test_optionsBuilder_clangHeadersAndCppIncludePathsOrderMacOs();
void test_optionsBuilder_clangHeadersAndCppIncludePathsOrderLinux();
void test_optionsBuilder_clangHeadersAndCppIncludePathsOrderNoVersion();
void test_optionsBuilder_clangHeadersAndCppIncludePathsOrderAndroidClang();
void test_optionsBuilder_noPrecompiledHeader();
void test_optionsBuilder_usePrecompiledHeader();
void test_optionsBuilder_usePrecompiledHeaderMsvc();
void test_optionsBuilder_addMacros();
void test_optionsBuilder_addTargetTriple();
void test_optionsBuilder_enableCExceptions();
void test_optionsBuilder_enableCxxExceptions();
void test_optionsBuilder_insertWrappedQtHeaders();
void test_optionsBuilder_insertWrappedMingwHeadersWithNonMingwToolchain();
void test_optionsBuilder_insertWrappedMingwHeadersWithMingwToolchain();
void test_optionsBuilder_setLanguageVersion();
void test_optionsBuilder_setLanguageVersionMsvc();
void test_optionsBuilder_handleLanguageExtension();
void test_optionsBuilder_updateLanguageVersion();
void test_optionsBuilder_updateLanguageVersionMsvc();
void test_optionsBuilder_addMsvcCompatibilityVersion();
void test_optionsBuilder_undefineCppLanguageFeatureMacrosForMsvc2015();
void test_optionsBuilder_addDefineFunctionMacrosMsvc();
void test_optionsBuilder_addProjectConfigFileInclude();
void test_optionsBuilder_addProjectConfigFileIncludeMsvc();
void test_optionsBuilder_noUndefineClangVersionMacrosForNewMsvc();
void test_optionsBuilder_undefineClangVersionMacrosForOldMsvc();
void test_optionsBuilder_buildAllOptions();
void test_optionsBuilder_buildAllOptionsMsvc();
void test_optionsBuilder_buildAllOptionsMsvcWithExceptions();
#endif #endif
private: private:

View File

@@ -8,7 +8,6 @@ HEADERS += \
$$PWD/cppprojectfile.h \ $$PWD/cppprojectfile.h \
$$PWD/senddocumenttracker.h \ $$PWD/senddocumenttracker.h \
$$PWD/projectpart.h \ $$PWD/projectpart.h \
$$PWD/compileroptionsbuilder.h \
$$PWD/cppprojectfilecategorizer.h \ $$PWD/cppprojectfilecategorizer.h \
$$PWD/projectinfo.h \ $$PWD/projectinfo.h \
$$PWD/cppprojectinfogenerator.cpp \ $$PWD/cppprojectinfogenerator.cpp \
@@ -19,7 +18,6 @@ SOURCES += \
$$PWD/cppprojectfile.cpp \ $$PWD/cppprojectfile.cpp \
$$PWD/senddocumenttracker.cpp \ $$PWD/senddocumenttracker.cpp \
$$PWD/projectpart.cpp \ $$PWD/projectpart.cpp \
$$PWD/compileroptionsbuilder.cpp \
$$PWD/cppprojectfilecategorizer.cpp \ $$PWD/cppprojectfilecategorizer.cpp \
$$PWD/projectinfo.cpp \ $$PWD/projectinfo.cpp \
$$PWD/cppprojectinfogenerator.cpp \ $$PWD/cppprojectinfogenerator.cpp \

View File

@@ -42,7 +42,6 @@ add_qtc_test(unittest GTEST
clientserverinprocess-test.cpp clientserverinprocess-test.cpp
clientserveroutsideprocess-test.cpp clientserveroutsideprocess-test.cpp
compare-operators.h compare-operators.h
compileroptionsbuilder-test.cpp
conditionally-disabled-tests.h conditionally-disabled-tests.h
cppprojectfilecategorizer-test.cpp cppprojectfilecategorizer-test.cpp
cppprojectinfogenerator-test.cpp cppprojectinfogenerator-test.cpp
@@ -456,7 +455,6 @@ extend_qtc_test(unittest
cppprojectfile.cpp cppprojectfile.h cppprojectfile.cpp cppprojectfile.h
senddocumenttracker.cpp senddocumenttracker.h senddocumenttracker.cpp senddocumenttracker.h
projectpart.cpp projectpart.h projectpart.cpp projectpart.h
compileroptionsbuilder.cpp compileroptionsbuilder.h
cppprojectfilecategorizer.cpp cppprojectfilecategorizer.h cppprojectfilecategorizer.cpp cppprojectfilecategorizer.h
projectinfo.cpp projectinfo.h projectinfo.cpp projectinfo.h
cppprojectinfogenerator.cpp cppprojectinfogenerator.cpp cppprojectinfogenerator.cpp cppprojectinfogenerator.cpp

View File

@@ -1,740 +0,0 @@
/****************************************************************************
**
** 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 <cpptools/compileroptionsbuilder.h>
#include <cpptools/cppprojectfile.h>
#include <cpptools/projectpart.h>
#include <projectexplorer/project.h>
#include <projectexplorer/projectexplorerconstants.h>
using CppTools::CompilerOptionsBuilder;
using CppTools::ProjectFile;
using CppTools::ProjectPart;
using ProjectExplorer::HeaderPath;
using ProjectExplorer::HeaderPathType;
using ProjectExplorer::Project;
MATCHER_P(IsPartOfHeader, headerPart, std::string(negation ? "isn't " : "is ") + headerPart)
{
return arg.contains(QString::fromStdString(headerPart));
}
namespace {
class CompilerOptionsBuilder : public ::testing::Test
{
protected:
void SetUp() final
{
projectPart.project = project.get();
projectPart.toolchainType = ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID;
projectPart.languageVersion = Utils::LanguageVersion::CXX17;
projectPart.toolChainWordWidth = CppTools::ProjectPart::WordWidth64Bit;
projectPart.toolChainTargetTriple = "x86_64-apple-darwin10";
projectPart.precompiledHeaders = QStringList{TESTDATA_DIR "/compileroptionsbuilder.pch"};
projectPart.toolChainMacros = {ProjectExplorer::Macro{"foo", "bar"},
ProjectExplorer::Macro{"__cplusplus", "2"},
ProjectExplorer::Macro{"__STDC_VERSION__", "2"},
ProjectExplorer::Macro{"_MSVC_LANG", "2"},
ProjectExplorer::Macro{"_MSC_BUILD", "2"},
ProjectExplorer::Macro{"_MSC_FULL_VER", "1900"},
ProjectExplorer::Macro{"_MSC_VER", "19"}};
projectPart.projectMacros = {ProjectExplorer::Macro{"projectFoo", "projectBar"}};
projectPart.qtVersion = Utils::QtVersion::Qt5;
projectPart.headerPaths = {HeaderPath{"/tmp/builtin_path", HeaderPathType::BuiltIn},
HeaderPath{"/tmp/system_path", HeaderPathType::System},
HeaderPath{"/tmp/path", HeaderPathType::User}};
}
static HeaderPath builtIn(const QString &path)
{
return HeaderPath{path, HeaderPathType::BuiltIn};
}
QString toNative(const QString &toNative)
{
return QDir::toNativeSeparators(toNative);
}
std::unique_ptr<Project> project{std::make_unique<ProjectExplorer::Project>()};
ProjectPart projectPart;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart};
};
TEST_F(CompilerOptionsBuilder, AddProjectMacros)
{
compilerOptionsBuilder.addProjectMacros();
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-DprojectFoo=projectBar"));
}
TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_UnknownOptionsAreForwarded)
{
ProjectPart part = projectPart;
part.compilerFlags = QStringList{"-fancyFlag"};
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{part,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::No,
CppTools::UseLanguageDefines::Yes};
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
ASSERT_THAT(compilerOptionsBuilder.options(), Contains(part.compilerFlags.first()));
}
TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_WarningsFlagsAreNotFilteredIfRequested)
{
ProjectPart part = projectPart;
part.compilerFlags = QStringList{"-Whello"};
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{part,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::No,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::Yes};
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
ASSERT_THAT(compilerOptionsBuilder.options(), Contains(part.compilerFlags.first()));
}
TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_DiagnosticOptionsAreRemoved)
{
ProjectPart part = projectPart;
part.compilerFlags = QStringList{"-Wbla", "-pedantic"};
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{part,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::No,
CppTools::UseLanguageDefines::Yes};
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
ASSERT_THAT(compilerOptionsBuilder.options(), Not(Contains(part.compilerFlags[0])));
ASSERT_THAT(compilerOptionsBuilder.options(), Not(Contains(part.compilerFlags[1])));
}
TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_CLanguageVersionIsRewritten)
{
ProjectPart part = projectPart;
part.compilerFlags = QStringList{"-std=c18"};
// We need to set the language version here to overcome a QTC_ASSERT checking
// consistency between ProjectFile::Kind and ProjectPart::LanguageVersion
part.languageVersion = Utils::LanguageVersion::C18;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{part,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::No,
CppTools::UseLanguageDefines::Yes};
compilerOptionsBuilder.build(ProjectFile::CSource, CppTools::UsePrecompiledHeaders::No);
ASSERT_THAT(compilerOptionsBuilder.options(), Not(Contains(part.compilerFlags.first())));
ASSERT_THAT(compilerOptionsBuilder.options(), Contains("-std=c17"));
}
TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_LanguageVersionIsExplicitlySetIfNotProvided)
{
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::No,
CppTools::UseLanguageDefines::Yes};
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
ASSERT_THAT(compilerOptionsBuilder.options(), Contains("-std=c++17"));
}
TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_ClLanguageVersionIsExplicitlySetIfNotProvided)
{
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::No,
CppTools::UseLanguageDefines::Yes};
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
ASSERT_THAT(compilerOptionsBuilder.options(), Contains("/std:c++17"));
}
TEST_F(CompilerOptionsBuilder, AddWordWidth)
{
compilerOptionsBuilder.addWordWidth();
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-m64"));
}
TEST_F(CompilerOptionsBuilder, HeaderPathOptionsOrder)
{
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
""};
compilerOptionsBuilder.addHeaderPathOptions();
ASSERT_THAT(compilerOptionsBuilder.options(),
ElementsAre("-nostdinc",
"-nostdinc++",
"-I", toNative("/tmp/path"),
"-I", toNative("/tmp/system_path"),
"-isystem", toNative(CLANG_INCLUDE_DIR ""),
"-isystem", toNative("/tmp/builtin_path")));
}
TEST_F(CompilerOptionsBuilder, HeaderPathOptionsOrderCl)
{
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
""};
compilerOptionsBuilder.evaluateCompilerFlags();
compilerOptionsBuilder.addHeaderPathOptions();
ASSERT_THAT(compilerOptionsBuilder.options(),
ElementsAre("-nostdinc",
"-nostdinc++",
"-I", toNative("/tmp/path"),
"-I", toNative("/tmp/system_path"),
"/clang:-isystem",
"/clang:" + toNative(CLANG_INCLUDE_DIR ""),
"/clang:-isystem",
"/clang:" + toNative("/tmp/builtin_path")));
}
TEST_F(CompilerOptionsBuilder, UseSystemHeader)
{
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart,
CppTools::UseSystemHeader::Yes,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
""};
compilerOptionsBuilder.addHeaderPathOptions();
ASSERT_THAT(compilerOptionsBuilder.options(),
ElementsAre("-nostdinc",
"-nostdinc++",
"-I", toNative("/tmp/path"),
"-isystem", toNative("/tmp/system_path"),
"-isystem", toNative(CLANG_INCLUDE_DIR ""),
"-isystem", toNative("/tmp/builtin_path")));
}
TEST_F(CompilerOptionsBuilder, NoClangHeadersPath)
{
compilerOptionsBuilder.addHeaderPathOptions();
ASSERT_THAT(compilerOptionsBuilder.options(),
ElementsAre("-I", toNative("/tmp/path"),
"-I", toNative("/tmp/system_path")));
}
TEST_F(CompilerOptionsBuilder, ClangHeadersAndCppIncludesPathsOrderMacOs)
{
auto defaultPaths = projectPart.headerPaths;
projectPart.headerPaths = {
builtIn("/usr/include/c++/4.2.1"),
builtIn("/usr/include/c++/4.2.1/backward"),
builtIn("/usr/local/include"),
builtIn("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/6.0/include"),
builtIn("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include"),
builtIn("/usr/include")
};
projectPart.headerPaths.append(defaultPaths);
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.addHeaderPathOptions();
ASSERT_THAT(compilerOptionsBuilder.options(),
ElementsAre("-nostdinc",
"-nostdinc++",
"-I", toNative("/tmp/path"),
"-I", toNative("/tmp/system_path"),
"-isystem", toNative("/usr/include/c++/4.2.1"),
"-isystem", toNative("/usr/include/c++/4.2.1/backward"),
"-isystem", toNative("/usr/local/include"),
"-isystem", toNative(CLANG_INCLUDE_DIR ""),
"-isystem", toNative("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include"),
"-isystem", toNative("/usr/include"),
"-isystem", toNative("/tmp/builtin_path")));
}
TEST_F(CompilerOptionsBuilder, ClangHeadersAndCppIncludesPathsOrderLinux)
{
projectPart.headerPaths = {
builtIn("/usr/include/c++/4.8"),
builtIn("/usr/include/c++/4.8/backward"),
builtIn("/usr/include/x86_64-linux-gnu/c++/4.8"),
builtIn("/usr/local/include"),
builtIn("/usr/lib/gcc/x86_64-linux-gnu/4.8/include"),
builtIn("/usr/include/x86_64-linux-gnu"),
builtIn("/usr/include"),
};
projectPart.toolChainTargetTriple = "x86_64-linux-gnu";
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.addHeaderPathOptions();
ASSERT_THAT(
compilerOptionsBuilder.options(),
ElementsAre(
"-nostdinc",
"-nostdinc++",
"-isystem", toNative("/usr/include/c++/4.8"),
"-isystem", toNative("/usr/include/c++/4.8/backward"),
"-isystem", toNative("/usr/include/x86_64-linux-gnu/c++/4.8"),
"-isystem", toNative("/usr/local/include"),
"-isystem", toNative(CLANG_INCLUDE_DIR ""),
"-isystem", toNative("/usr/lib/gcc/x86_64-linux-gnu/4.8/include"),
"-isystem", toNative("/usr/include/x86_64-linux-gnu"),
"-isystem", toNative("/usr/include")));
}
TEST_F(CompilerOptionsBuilder, ClangHeadersAndCppIncludesPathsOrderNoVersion)
{
projectPart.headerPaths = {
builtIn("C:/mingw530/i686-w64-mingw32/include"),
builtIn("C:/mingw530/i686-w64-mingw32/include/c++"),
builtIn("C:/mingw530/i686-w64-mingw32/include/c++/i686-w64-mingw32"),
builtIn("C:/mingw530/i686-w64-mingw32/include/c++/backward"),
};
projectPart.toolChainTargetTriple = "x86_64-w64-windows-gnu";
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.addHeaderPathOptions();
ASSERT_THAT(
compilerOptionsBuilder.options(),
ElementsAre("-nostdinc",
"-nostdinc++",
"-isystem", toNative("C:/mingw530/i686-w64-mingw32/include/c++"),
"-isystem", toNative("C:/mingw530/i686-w64-mingw32/include/c++/i686-w64-mingw32"),
"-isystem", toNative("C:/mingw530/i686-w64-mingw32/include/c++/backward"),
"-isystem", toNative(CLANG_INCLUDE_DIR ""),
"-isystem", toNative("C:/mingw530/i686-w64-mingw32/include")));
}
TEST_F(CompilerOptionsBuilder, ClangHeadersAndCppIncludesPathsOrderAndroidClang)
{
projectPart.headerPaths = {
builtIn("C:/Android/sdk/ndk-bundle/sysroot/usr/include/i686-linux-android"),
builtIn("C:/Android/sdk/ndk-bundle/sources/cxx-stl/llvm-libc++/include"),
builtIn("C:/Android/sdk/ndk-bundle/sources/android/support/include"),
builtIn("C:/Android/sdk/ndk-bundle/sources/cxx-stl/llvm-libc++abi/include"),
builtIn("C:/Android/sdk/ndk-bundle/sysroot/usr/include"),
};
projectPart.toolChainTargetTriple = "i686-linux-android";
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.addHeaderPathOptions();
ASSERT_THAT(compilerOptionsBuilder.options(),
ElementsAre("-nostdinc",
"-nostdinc++",
"-isystem", toNative("C:/Android/sdk/ndk-bundle/sources/cxx-stl/llvm-libc++/include"),
"-isystem", toNative("C:/Android/sdk/ndk-bundle/sources/cxx-stl/llvm-libc++abi/include"),
"-isystem", toNative(CLANG_INCLUDE_DIR ""),
"-isystem", toNative("C:/Android/sdk/ndk-bundle/sysroot/usr/include/i686-linux-android"),
"-isystem", toNative("C:/Android/sdk/ndk-bundle/sources/android/support/include"),
"-isystem", toNative("C:/Android/sdk/ndk-bundle/sysroot/usr/include")));
}
TEST_F(CompilerOptionsBuilder, NoPrecompiledHeader)
{
compilerOptionsBuilder.addPrecompiledHeaderOptions(CppTools::UsePrecompiledHeaders::No);
ASSERT_THAT(compilerOptionsBuilder.options().empty(), true);
}
TEST_F(CompilerOptionsBuilder, UsePrecompiledHeader)
{
compilerOptionsBuilder.addPrecompiledHeaderOptions(CppTools::UsePrecompiledHeaders::Yes);
ASSERT_THAT(compilerOptionsBuilder.options(),
ElementsAre("-include",
toNative(TESTDATA_DIR "/compileroptionsbuilder.pch")));
}
TEST_F(CompilerOptionsBuilder, UsePrecompiledHeaderCl)
{
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart};
compilerOptionsBuilder.evaluateCompilerFlags();
compilerOptionsBuilder.addPrecompiledHeaderOptions(CppTools::UsePrecompiledHeaders::Yes);
ASSERT_THAT(compilerOptionsBuilder.options(),
ElementsAre("/FI",
toNative(TESTDATA_DIR "/compileroptionsbuilder.pch")));
}
TEST_F(CompilerOptionsBuilder, AddMacros)
{
compilerOptionsBuilder.addMacros(ProjectExplorer::Macros{ProjectExplorer::Macro{"key", "value"}});
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-Dkey=value"));
}
TEST_F(CompilerOptionsBuilder, AddTargetTriple)
{
compilerOptionsBuilder.addTargetTriple();
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("--target=x86_64-apple-darwin10"));
}
TEST_F(CompilerOptionsBuilder, EnableCExceptions)
{
projectPart.languageVersion = Utils::LanguageVersion::C99;
compilerOptionsBuilder.enableExceptions();
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-fexceptions"));
}
TEST_F(CompilerOptionsBuilder, EnableCXXExceptions)
{
compilerOptionsBuilder.enableExceptions();
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-fcxx-exceptions", "-fexceptions"));
}
TEST_F(CompilerOptionsBuilder, InsertWrappedQtHeaders)
{
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart,
CppTools::UseSystemHeader::Yes,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
""};
compilerOptionsBuilder.insertWrappedQtHeaders();
ASSERT_THAT(compilerOptionsBuilder.options(), Contains(IsPartOfHeader("wrappedQtHeaders")));
}
TEST_F(CompilerOptionsBuilder, InsertWrappedMingwHeadersWithNonMingwToolchain)
{
CppTools::CompilerOptionsBuilder builder{
projectPart,
CppTools::UseSystemHeader::Yes,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
""};
builder.insertWrappedMingwHeaders();
ASSERT_THAT(builder.options(), Not(Contains(IsPartOfHeader("wrappedMingwHeaders"))));
}
TEST_F(CompilerOptionsBuilder, InsertWrappedMingwHeadersWithMingwToolchain)
{
CppTools::CompilerOptionsBuilder builder{
projectPart,
CppTools::UseSystemHeader::Yes,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
""};
projectPart.toolchainType = ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID;
builder.insertWrappedMingwHeaders();
ASSERT_THAT(builder.options(), Contains(IsPartOfHeader("wrappedMingwHeaders")));
}
TEST_F(CompilerOptionsBuilder, SetLanguageVersion)
{
compilerOptionsBuilder.updateFileLanguage(ProjectFile::CXXSource);
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-x", "c++"));
}
TEST_F(CompilerOptionsBuilder, SetLanguageVersionCl)
{
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart};
compilerOptionsBuilder.evaluateCompilerFlags();
compilerOptionsBuilder.updateFileLanguage(ProjectFile::CXXSource);
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("/TP"));
}
TEST_F(CompilerOptionsBuilder, HandleLanguageExtension)
{
projectPart.languageExtensions = Utils::LanguageExtension::ObjectiveC;
compilerOptionsBuilder.updateFileLanguage(ProjectFile::CXXSource);
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-x", "objective-c++"));
}
TEST_F(CompilerOptionsBuilder, UpdateLanguageVersion)
{
compilerOptionsBuilder.updateFileLanguage(ProjectFile::CXXSource);
compilerOptionsBuilder.updateFileLanguage(ProjectFile::CXXHeader);
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-x", "c++-header"));
}
TEST_F(CompilerOptionsBuilder, UpdateLanguageVersionCl)
{
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart};
compilerOptionsBuilder.evaluateCompilerFlags();
compilerOptionsBuilder.updateFileLanguage(ProjectFile::CXXSource);
compilerOptionsBuilder.updateFileLanguage(ProjectFile::CSource);
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("/TC"));
}
TEST_F(CompilerOptionsBuilder, AddMsvcCompatibilityVersion)
{
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
projectPart.toolChainMacros.append(ProjectExplorer::Macro{"_MSC_FULL_VER", "190000000"});
compilerOptionsBuilder.addMsvcCompatibilityVersion();
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-fms-compatibility-version=19.00"));
}
TEST_F(CompilerOptionsBuilder, UndefineCppLanguageFeatureMacrosForMsvc2015)
{
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
projectPart.isMsvc2015Toolchain = true;
compilerOptionsBuilder.undefineCppLanguageFeatureMacrosForMsvc2015();
ASSERT_THAT(compilerOptionsBuilder.options(), Contains(QString{"-U__cpp_aggregate_bases"}));
}
TEST_F(CompilerOptionsBuilder, AddDefineFunctionMacrosMsvc)
{
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
compilerOptionsBuilder.addDefineFunctionMacrosMsvc();
ASSERT_THAT(compilerOptionsBuilder.options(),
Contains(QString{"-D__FUNCTION__=\"someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580\""}));
}
TEST_F(CompilerOptionsBuilder, AddProjectConfigFileInclude)
{
projectPart.projectConfigFile = "dummy_file.h";
compilerOptionsBuilder.addProjectConfigFileInclude();
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-include", "dummy_file.h"));
}
TEST_F(CompilerOptionsBuilder, AddProjectConfigFileIncludeCl)
{
projectPart.projectConfigFile = "dummy_file.h";
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart};
compilerOptionsBuilder.evaluateCompilerFlags();
compilerOptionsBuilder.addProjectConfigFileInclude();
ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("/FI", "dummy_file.h"));
}
TEST_F(CompilerOptionsBuilder, NoUndefineClangVersionMacrosForNewMsvc)
{
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
compilerOptionsBuilder.undefineClangVersionMacrosForMsvc();
ASSERT_THAT(compilerOptionsBuilder.options(), Not(Contains(QString{"-U__clang__"})));
}
TEST_F(CompilerOptionsBuilder, UndefineClangVersionMacrosForOldMsvc)
{
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
projectPart.toolChainMacros = {ProjectExplorer::Macro{"_MSC_FULL_VER", "1300"},
ProjectExplorer::Macro{"_MSC_VER", "13"}};
compilerOptionsBuilder.undefineClangVersionMacrosForMsvc();
ASSERT_THAT(compilerOptionsBuilder.options(), Contains(QString{"-U__clang__"}));
}
TEST_F(CompilerOptionsBuilder, BuildAllOptions)
{
projectPart.extraCodeModelFlags = QStringList{"-arch", "x86_64"};
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
ASSERT_THAT(compilerOptionsBuilder.options(),
ElementsAre("-nostdinc",
"-nostdinc++",
"-arch",
"x86_64",
"-fsyntax-only",
"-m64",
"--target=x86_64-apple-darwin10",
"-x",
"c++",
"-std=c++17",
"-DprojectFoo=projectBar",
"-I", IsPartOfHeader("wrappedQtHeaders"),
"-I", IsPartOfHeader(toNative("wrappedQtHeaders/QtCore").toStdString()),
"-I", toNative("/tmp/path"),
"-I", toNative("/tmp/system_path"),
"-isystem", toNative(CLANG_INCLUDE_DIR ""),
"-isystem", toNative("/tmp/builtin_path")));
}
TEST_F(CompilerOptionsBuilder, BuildAllOptionsCl)
{
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
ASSERT_THAT(compilerOptionsBuilder.options(),
ElementsAre("-nostdinc",
"-nostdinc++",
"--driver-mode=cl",
"/Zs",
"-m64",
"--target=x86_64-apple-darwin10",
"/TP",
"/std:c++17",
"-fms-compatibility-version=19.00",
"-DprojectFoo=projectBar",
"-D__FUNCSIG__=\"void __cdecl someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580(void)\"",
"-D__FUNCTION__=\"someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580\"",
"-D__FUNCDNAME__=\"?someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580@@YAXXZ\"",
"-I", IsPartOfHeader("wrappedQtHeaders"),
"-I", IsPartOfHeader(toNative("wrappedQtHeaders/QtCore").toStdString()),
"-I", toNative("/tmp/path"),
"-I", toNative("/tmp/system_path"),
"/clang:-isystem",
"/clang:" + toNative(CLANG_INCLUDE_DIR ""),
"/clang:-isystem",
"/clang:" + toNative("/tmp/builtin_path")));
}
TEST_F(CompilerOptionsBuilder, BuildAllOptionsClWithExceptions)
{
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
projectPart.toolChainMacros.append(ProjectExplorer::Macro{"_CPPUNWIND", "1"});
CppTools::CompilerOptionsBuilder compilerOptionsBuilder(projectPart,
CppTools::UseSystemHeader::No,
CppTools::UseTweakedHeaderPaths::Yes,
CppTools::UseLanguageDefines::No,
CppTools::UseBuildSystemWarnings::No,
"dummy_version",
"");
compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
ASSERT_THAT(compilerOptionsBuilder.options(),
ElementsAre("-nostdinc",
"-nostdinc++",
"--driver-mode=cl",
"/Zs",
"-m64",
"--target=x86_64-apple-darwin10",
"/TP",
"/std:c++17",
"-fcxx-exceptions",
"-fexceptions",
"-fms-compatibility-version=19.00",
"-DprojectFoo=projectBar",
"-D__FUNCSIG__=\"void __cdecl someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580(void)\"",
"-D__FUNCTION__=\"someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580\"",
"-D__FUNCDNAME__=\"?someLegalAndLongishFunctionNameThatWorksAroundQTCREATORBUG-24580@@YAXXZ\"",
"-I", IsPartOfHeader("wrappedQtHeaders"),
"-I", IsPartOfHeader(toNative("wrappedQtHeaders/QtCore").toStdString()),
"-I", toNative("/tmp/path"),
"-I", toNative("/tmp/system_path"),
"/clang:-isystem",
"/clang:" + toNative(CLANG_INCLUDE_DIR ""),
"/clang:-isystem",
"/clang:" + toNative("/tmp/builtin_path")));
}
} // namespace

View File

@@ -89,7 +89,6 @@ SOURCES += \
processcreator-test.cpp \ processcreator-test.cpp \
mocktimer.cpp \ mocktimer.cpp \
task.cpp \ task.cpp \
compileroptionsbuilder-test.cpp \
compilationdatabaseutils-test.cpp \ compilationdatabaseutils-test.cpp \
headerpathfilter-test.cpp \ headerpathfilter-test.cpp \
sqlitecolumn-test.cpp \ sqlitecolumn-test.cpp \

View File

@@ -173,7 +173,6 @@ Project {
"clientserveroutsideprocess-test.cpp", "clientserveroutsideprocess-test.cpp",
"compare-operators.h", "compare-operators.h",
"compilationdatabaseutils-test.cpp", "compilationdatabaseutils-test.cpp",
"compileroptionsbuilder-test.cpp",
"conditionally-disabled-tests.h", "conditionally-disabled-tests.h",
"cppprojectfilecategorizer-test.cpp", "cppprojectfilecategorizer-test.cpp",
"cppprojectinfogenerator-test.cpp", "cppprojectinfogenerator-test.cpp",
@@ -486,8 +485,6 @@ Project {
name: "sources from cpptools" name: "sources from cpptools"
prefix: "../../../src/plugins/cpptools/" prefix: "../../../src/plugins/cpptools/"
files: [ files: [
"compileroptionsbuilder.cpp",
"compileroptionsbuilder.h",
"cppprojectfile.cpp", "cppprojectfile.cpp",
"cppprojectfile.h", "cppprojectfile.h",
"cppprojectfilecategorizer.cpp", "cppprojectfilecategorizer.cpp",