From 85797068bb3956bb5f0f7e080e32079c11dcbb0d Mon Sep 17 00:00:00 2001 From: Christian Kandeler Date: Wed, 30 Jun 2021 17:44:22 +0200 Subject: [PATCH] CppTools: Move CompilerOptionsBuilder tests to plugin ... where they belong. Change-Id: Ifc6aebc218f9f85ffeb6a4b7121f97379b53b69d Reviewed-by: Christian Stenger --- src/plugins/cpptools/CMakeLists.txt | 1 + .../cpptools/compileroptionsbuilder_test.cpp | 719 +++++++++++++++++ src/plugins/cpptools/cpptools.pro | 1 + src/plugins/cpptools/cpptools.qbs | 1 + src/plugins/cpptools/cpptoolsplugin.h | 42 + .../cpptools/cpptoolsunittestfiles.pri | 2 - tests/unit/unittest/CMakeLists.txt | 2 - .../unittest/compileroptionsbuilder-test.cpp | 740 ------------------ .../unittest/data/compileroptionsbuilder.pch | 0 tests/unit/unittest/unittest.pro | 1 - tests/unit/unittest/unittest.qbs | 3 - 11 files changed, 764 insertions(+), 748 deletions(-) create mode 100644 src/plugins/cpptools/compileroptionsbuilder_test.cpp delete mode 100644 tests/unit/unittest/compileroptionsbuilder-test.cpp delete mode 100644 tests/unit/unittest/data/compileroptionsbuilder.pch diff --git a/src/plugins/cpptools/CMakeLists.txt b/src/plugins/cpptools/CMakeLists.txt index fe481af9418..4f5dbf7fee3 100644 --- a/src/plugins/cpptools/CMakeLists.txt +++ b/src/plugins/cpptools/CMakeLists.txt @@ -110,6 +110,7 @@ add_qtc_plugin(CppTools extend_qtc_plugin(CppTools CONDITION WITH_TESTS SOURCES + compileroptionsbuilder_test.cpp cppcodegen_test.cpp cppcompletion_test.cpp cppheadersource_test.cpp diff --git a/src/plugins/cpptools/compileroptionsbuilder_test.cpp b/src/plugins/cpptools/compileroptionsbuilder_test.cpp new file mode 100644 index 00000000000..fde8fab9262 --- /dev/null +++ b/src/plugins/cpptools/compileroptionsbuilder_test.cpp @@ -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 +#include +#include +#include + +#include + +#include + +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{std::make_unique(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 diff --git a/src/plugins/cpptools/cpptools.pro b/src/plugins/cpptools/cpptools.pro index 7052d01ab6b..576d3087454 100644 --- a/src/plugins/cpptools/cpptools.pro +++ b/src/plugins/cpptools/cpptools.pro @@ -214,6 +214,7 @@ equals(TEST, 1) { cppsourceprocessertesthelper.cpp \ cppsourceprocessor_test.cpp \ cpptoolstestcase.cpp \ + compileroptionsbuilder_test.cpp \ modelmanagertesthelper.cpp \ symbolsearcher_test.cpp \ typehierarchybuilder_test.cpp diff --git a/src/plugins/cpptools/cpptools.qbs b/src/plugins/cpptools/cpptools.qbs index 13382138bfb..5418f1cd040 100644 --- a/src/plugins/cpptools/cpptools.qbs +++ b/src/plugins/cpptools/cpptools.qbs @@ -229,6 +229,7 @@ Project { name: "Tests" condition: qtc.testsEnabled files: [ + "compileroptionsbuilder_test.cpp", "cppcodegen_test.cpp", "cppcompletion_test.cpp", "cppheadersource_test.cpp", diff --git a/src/plugins/cpptools/cpptoolsplugin.h b/src/plugins/cpptools/cpptoolsplugin.h index 24f981d15f3..51eea65deca 100644 --- a/src/plugins/cpptools/cpptoolsplugin.h +++ b/src/plugins/cpptools/cpptoolsplugin.h @@ -168,6 +168,48 @@ private slots: void test_includeGroups_detectIncludeGroupsByNewLines(); void test_includeGroups_detectIncludeGroupsByIncludeDir(); 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 private: diff --git a/src/plugins/cpptools/cpptoolsunittestfiles.pri b/src/plugins/cpptools/cpptoolsunittestfiles.pri index 5d09a1d1305..c7b54eb7f85 100644 --- a/src/plugins/cpptools/cpptoolsunittestfiles.pri +++ b/src/plugins/cpptools/cpptoolsunittestfiles.pri @@ -8,7 +8,6 @@ HEADERS += \ $$PWD/cppprojectfile.h \ $$PWD/senddocumenttracker.h \ $$PWD/projectpart.h \ - $$PWD/compileroptionsbuilder.h \ $$PWD/cppprojectfilecategorizer.h \ $$PWD/projectinfo.h \ $$PWD/cppprojectinfogenerator.cpp \ @@ -19,7 +18,6 @@ SOURCES += \ $$PWD/cppprojectfile.cpp \ $$PWD/senddocumenttracker.cpp \ $$PWD/projectpart.cpp \ - $$PWD/compileroptionsbuilder.cpp \ $$PWD/cppprojectfilecategorizer.cpp \ $$PWD/projectinfo.cpp \ $$PWD/cppprojectinfogenerator.cpp \ diff --git a/tests/unit/unittest/CMakeLists.txt b/tests/unit/unittest/CMakeLists.txt index 2d018644b6e..6ea6ee7bd0d 100644 --- a/tests/unit/unittest/CMakeLists.txt +++ b/tests/unit/unittest/CMakeLists.txt @@ -42,7 +42,6 @@ add_qtc_test(unittest GTEST clientserverinprocess-test.cpp clientserveroutsideprocess-test.cpp compare-operators.h - compileroptionsbuilder-test.cpp conditionally-disabled-tests.h cppprojectfilecategorizer-test.cpp cppprojectinfogenerator-test.cpp @@ -456,7 +455,6 @@ extend_qtc_test(unittest cppprojectfile.cpp cppprojectfile.h senddocumenttracker.cpp senddocumenttracker.h projectpart.cpp projectpart.h - compileroptionsbuilder.cpp compileroptionsbuilder.h cppprojectfilecategorizer.cpp cppprojectfilecategorizer.h projectinfo.cpp projectinfo.h cppprojectinfogenerator.cpp cppprojectinfogenerator.cpp diff --git a/tests/unit/unittest/compileroptionsbuilder-test.cpp b/tests/unit/unittest/compileroptionsbuilder-test.cpp deleted file mode 100644 index 5cc01800a4a..00000000000 --- a/tests/unit/unittest/compileroptionsbuilder-test.cpp +++ /dev/null @@ -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 -#include -#include - -#include -#include - -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{std::make_unique()}; - 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 diff --git a/tests/unit/unittest/data/compileroptionsbuilder.pch b/tests/unit/unittest/data/compileroptionsbuilder.pch deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/tests/unit/unittest/unittest.pro b/tests/unit/unittest/unittest.pro index 55774712c30..a0d678a17b5 100644 --- a/tests/unit/unittest/unittest.pro +++ b/tests/unit/unittest/unittest.pro @@ -89,7 +89,6 @@ SOURCES += \ processcreator-test.cpp \ mocktimer.cpp \ task.cpp \ - compileroptionsbuilder-test.cpp \ compilationdatabaseutils-test.cpp \ headerpathfilter-test.cpp \ sqlitecolumn-test.cpp \ diff --git a/tests/unit/unittest/unittest.qbs b/tests/unit/unittest/unittest.qbs index 436bb3080bf..9ea0be3cbda 100644 --- a/tests/unit/unittest/unittest.qbs +++ b/tests/unit/unittest/unittest.qbs @@ -173,7 +173,6 @@ Project { "clientserveroutsideprocess-test.cpp", "compare-operators.h", "compilationdatabaseutils-test.cpp", - "compileroptionsbuilder-test.cpp", "conditionally-disabled-tests.h", "cppprojectfilecategorizer-test.cpp", "cppprojectinfogenerator-test.cpp", @@ -486,8 +485,6 @@ Project { name: "sources from cpptools" prefix: "../../../src/plugins/cpptools/" files: [ - "compileroptionsbuilder.cpp", - "compileroptionsbuilder.h", "cppprojectfile.cpp", "cppprojectfile.h", "cppprojectfilecategorizer.cpp",