summaryrefslogtreecommitdiff
path: root/src/plugins/cpptools
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins/cpptools')
-rw-r--r--src/plugins/cpptools/CMakeLists.txt1
-rw-r--r--src/plugins/cpptools/compileroptionsbuilder_test.cpp719
-rw-r--r--src/plugins/cpptools/cpptools.pro1
-rw-r--r--src/plugins/cpptools/cpptools.qbs1
-rw-r--r--src/plugins/cpptools/cpptoolsplugin.h42
-rw-r--r--src/plugins/cpptools/cpptoolsunittestfiles.pri2
6 files changed, 764 insertions, 2 deletions
diff --git a/src/plugins/cpptools/CMakeLists.txt b/src/plugins/cpptools/CMakeLists.txt
index fe481af941..4f5dbf7fee 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 0000000000..fde8fab926
--- /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 <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
diff --git a/src/plugins/cpptools/cpptools.pro b/src/plugins/cpptools/cpptools.pro
index 7052d01ab6..576d308745 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 13382138bf..5418f1cd04 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 24f981d15f..51eea65dec 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 5d09a1d130..c7b54eb7f8 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 \
View Lorry Controller Status