qt 6.5.1 original

tests/auto/cmake/test_import_plugins/CMakeLists.txt

@@ -0,0 +1,180 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+cmake_minimum_required(VERSION 3.16)
+
+project(import_plugins_advanced)
+enable_testing()
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+find_package(Qt6 COMPONENTS REQUIRED MockPlugins1 MockPlugins2)
+# MockPlugins3 package is automatically found by the find_dependency call in
+# QMock5PluginConfig.cmake which depends on MockPlugins3.
+# QMock5Plugin itself is loaded by QtMockPlugins1Plugins.cmake, so via QtMockPlugins1Config.cmake.
+
+function(create_test_executable target)
+    cmake_parse_arguments(arg "FINALIZER_MODE;QT_WRAPPER" "" "ADD_EXECUTABLE_ARGS" ${ARGN})
+
+    set(target_name_adjusted "${target}")
+    if(arg_FINALIZER_MODE)
+        set(target_name_adjusted "${target}_finalizer")
+    endif()
+
+    set(CHECK_FILE ${CMAKE_BINARY_DIR}/${target_name_adjusted}_check.cpp)
+
+    set(EXPECTED_PLUGINS)
+    foreach(_p ${arg_UNPARSED_ARGUMENTS})
+        string(APPEND EXPECTED_PLUGINS "    \"${_p}\",\n")
+    endforeach()
+    configure_file("${CMAKE_SOURCE_DIR}/check.cpp.in" ${CHECK_FILE})
+
+    set(add_executable_args ${target_name_adjusted} main.cpp ${CHECK_FILE}
+        ${arg_ADD_EXECUTABLE_ARGS})
+
+    if(arg_QT_WRAPPER)
+        qt_add_executable(${add_executable_args})
+    else()
+        add_executable(${add_executable_args})
+    endif()
+    target_link_libraries(${target_name_adjusted} PRIVATE Qt6::MockPlugins1)
+    add_test(test_${target_name_adjusted} ${target_name_adjusted})
+
+    if(arg_FINALIZER_MODE)
+        set(finalizer_mode_state "ENABLE")
+    else()
+        set(finalizer_mode_state "DISABLE")
+    endif()
+
+    qt_set_finalizer_mode(${target_name_adjusted} ${finalizer_mode_state} MODES static_plugins)
+    set(target ${target_name_adjusted} PARENT_SCOPE)
+endfunction()
+
+# No call to qt_import_plugins() for the default case.
+create_test_executable(default
+    QMock1Plugin QMock2Plugin
+
+    QMock3Plugin # TODO: Should not be linked based on .pro file, see QTBUG-93501
+    ${import_mode}
+)
+
+# No call to qt_import_plugins() for the default_link case.
+create_test_executable(default_link QMock1Plugin QMock2Plugin
+
+    # TODO: in qmake QMock3Plugin should only be linked if the executable depends on MockPlugins2
+    #       module (based on .pro file PLUGIN_EXTENDS). Here it's accidentally linked because
+    #       we're missing PLUGIN_EXTENDS information in CMake land. Thus it's considered
+    #       a default plugin which is linked regardless of whether MockPlugins2 is linked.
+    #       It's possible the qmake behavior is also wrong, because the qmake qt5 test seems to
+    #       expect to link the plugin if both MockPlugins1 AND MockPlugins2 are linked, but qt.pf
+    #       suggests that MockPlugins1 OR MockPlugins2 is sufficient to link the plugin, not both.
+    #       See QTBUG-93501
+    QMock3Plugin
+    ${import_mode}
+)
+target_link_libraries(${target} PRIVATE Qt6::MockPlugins2)
+
+# Check that both regular and finalizer mode plugin importing pulls in the same set of plugins.
+# In regular mode, qt_finalize_target won't execute the finalizer plugin importing, because
+# we opt out via qt_set_finalizer_mode(target DISABLE MODES static_plugins).
+foreach(import_mode "" "FINALIZER_MODE")
+    create_test_executable(manual QMock1Plugin QMock2Plugin QMock3Plugin QMock4Plugin
+        ${import_mode})
+    qt_import_plugins(${target}
+        INCLUDE Qt6::QMock3Plugin Qt6::QMock4Plugin
+    )
+    qt_finalize_target(${target})
+
+    create_test_executable(manual_genex QMock1Plugin QMock2Plugin QMock3Plugin ${import_mode})
+    qt_import_plugins(${target}
+        INCLUDE $<1:Qt6::QMock3Plugin> $<0:Qt6::QMock4Plugin>
+    )
+    qt_finalize_target(${target})
+
+    create_test_executable(blacklist QMock1Plugin ${import_mode})
+    qt_import_plugins(${target}
+        EXCLUDE Qt6::QMock2Plugin Qt6::QMock3Plugin
+    )
+    qt_finalize_target(${target})
+
+    create_test_executable(blacklist_genex QMock1Plugin ${import_mode})
+    qt_import_plugins(${target}
+        EXCLUDE $<1:Qt6::QMock2Plugin> $<1:Qt6::QMock3Plugin> $<0:Qt6::QMock1Plugin>
+    )
+    qt_finalize_target(${target})
+
+    create_test_executable(override QMock3Plugin QMock4Plugin ${import_mode})
+    qt_import_plugins(${target}
+        INCLUDE_BY_TYPE mockplugin Qt6::QMock3Plugin Qt6::QMock4Plugin
+    )
+    qt_finalize_target(${target})
+
+    create_test_executable(override_genex QMock3Plugin ${import_mode})
+    qt_import_plugins(${target}
+        INCLUDE_BY_TYPE mockplugin $<1:Qt6::QMock3Plugin> $<0:Qt6::QMock4Plugin>
+    )
+    qt_finalize_target(${target})
+
+    create_test_executable(override_mix QMock2Plugin QMock3Plugin ${import_mode})
+    qt_import_plugins(${target}
+        INCLUDE Qt6::QMock2Plugin
+        INCLUDE_BY_TYPE mockplugin Qt6::QMock3Plugin
+    )
+    qt_finalize_target(${target})
+
+    if(NOT WIN32)
+        # Compiling an empty static array fails on Windows.
+        create_test_executable(none ${import_mode})
+        qt_import_plugins(${target}
+            EXCLUDE_BY_TYPE mockplugin
+        )
+        qt_finalize_target(${target})
+    endif()
+
+    create_test_executable(none_mix QMock3Plugin QMock4Plugin ${import_mode})
+    qt_import_plugins(${target}
+        INCLUDE Qt6::QMock3Plugin Qt6::QMock4Plugin
+        EXCLUDE_BY_TYPE mockplugin
+    )
+    qt_finalize_target(${target})
+
+    # QMock5Plugin links against the Qt::MockPlugins3 module, which provides the default plugin
+    # QMock6Plugin which is why it is pulled in.
+    create_test_executable(recursive QMock5Plugin QMock6Plugin ${import_mode})
+    qt_import_plugins(${target}
+        INCLUDE_BY_TYPE mockplugin Qt6::QMock5Plugin
+    )
+    qt_finalize_target(${target})
+endforeach()
+
+# No call to qt_finalize_target() in finalizer mode means nothing will be
+# linked.
+if(NOT WIN32)
+    # Compiling an empty static array fails on Windows.
+    create_test_executable(default_finalizer_missing_import_call FINALIZER_MODE)
+endif()
+
+# Empty call to qt_import_plugins() in finalizer mode means default plugins are linked.
+create_test_executable(default_finalizer
+    QMock1Plugin QMock2Plugin
+    QMock3Plugin # TODO: Should not be linked based on .pro file, see QTBUG-93501
+    FINALIZER_MODE)
+qt_import_plugins(${target})
+qt_finalize_target(${target})
+
+# Check that plugin importing with the qt_add_executable wrapper and manual finalization mode works.
+create_test_executable(default_qt_add_executable_manually_finalized
+    QMock1Plugin QMock2Plugin
+    QMock3Plugin # TODO: Should not be linked based on .pro file, see QTBUG-93501
+    FINALIZER_MODE QT_WRAPPER
+    ADD_EXECUTABLE_ARGS MANUAL_FINALIZATION)
+qt_finalize_target(${target})
+
+# Check that plugin importing with automatic deferred finalization works when the CMake version is
+# high enough.
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.19)
+    create_test_executable(default_qt_add_executable_auto_finalized
+        QMock1Plugin QMock2Plugin
+        QMock3Plugin # TODO: Should not be linked based on .pro file, see QTBUG-93501
+        FINALIZER_MODE QT_WRAPPER)
+endif()

tests/auto/cmake/test_import_plugins/check.cpp.in

@@ -0,0 +1,8 @@
+#include <QString>
+#include <cstddef>
+
+QString expectedPlugins[] = {
+@EXPECTED_PLUGINS@
+};
+
+std::size_t numExpectedPlugins = sizeof(expectedPlugins) / sizeof(*expectedPlugins);

tests/auto/cmake/test_import_plugins/main.cpp

@@ -0,0 +1,54 @@
+// Copyright (C) 2018 Kitware, Inc.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#include <QList>
+#include <QPluginLoader>
+#include <QSet>
+#include <QString>
+
+#include <cstddef>
+#include <iostream>
+
+extern QString expectedPlugins[];
+extern std::size_t numExpectedPlugins;
+
+int main(int argc, char **argv)
+{
+#ifdef QT_STATIC
+    QSet<QString> expectedPluginSet;
+    for (std::size_t i = 0; i < numExpectedPlugins; i++) {
+        expectedPluginSet.insert(expectedPlugins[i]);
+    }
+
+    QList<QStaticPlugin> plugins = QPluginLoader::staticPlugins();
+    QSet<QString> actualPluginSet;
+    for (QStaticPlugin plugin : plugins) {
+        actualPluginSet.insert(plugin.metaData()["className"].toString());
+    }
+
+    if (expectedPluginSet != actualPluginSet) {
+        std::cerr << "Loaded plugins do not match what was expected!" << std::endl
+                  << "Expected plugins:" << std::endl;
+
+        QList<QString> expectedPluginList = expectedPluginSet.values();
+        expectedPluginList.sort();
+        for (QString plugin : expectedPluginList) {
+            std::cerr << (actualPluginSet.contains(plugin) ? "  " : "- ")
+                      << plugin.toStdString() << std::endl;
+        }
+
+        std::cerr << std::endl << "Actual plugins:" << std::endl;
+
+        QList<QString> actualPluginList = actualPluginSet.values();
+        actualPluginList.sort();
+        for (QString plugin : actualPluginList) {
+            std::cerr << (expectedPluginSet.contains(plugin) ? "  " : "+ ")
+                      << plugin.toStdString() << std::endl;
+        }
+
+        return 1;
+    }
+
+#endif
+    return 0;
+}