plugins: new testing workflow.

The current testing workflow had quite a few major flaws and it was no
longer possible after the move of Any* plugins to core. Among the flaws
is:

 * Every plugin was basically built twice, once as the real plugin and
   once as a static testing library. Most of the build shared common
   object files, but nevertheless it inflated build times and made the
   buildsystem extremely complex.
 * Because the actual plugin binary was never actually loaded during the
   test, it couldn't spot problems like:
    - undefined references
    - errors in metadata files
    - mismatched plugin interface/version, missing entry points
    - broken static plugin import files
 * Tests that made use of independent plugins (such as TgaImageConverter
   test using TgaImporter to verify the output) had a hardcoded
   dependency on such plugins, making a minimal setup very hard.
 * Dynamic loading of plugins from the Any* proxies was always directed
   to the install location on the filesystem with no possibility to
   load these directly from the build tree. That caused random ABI
   mismatch crashes, or, on the other hand, if no plugins were
   installed, particular portions of the codebase weren't tested at all.

Now the workflow is the following:

 * Every plugin is built exactly once, either as dynamic or as static.
 * The test always loads it via the plugin manager. If it's dynamic,
   it's loaded straight from the build directory; if it's static, it
   gets linked to the test executable directly.
 * Plugins used indirectly are always served from the build directory
   (if enabled) to ensure reproducibility and independence on what's
   installed on the filesystem. Missing presence of these plugins causes
   particular tests to be simply skipped.
 * Plugins that have extensive tests for internal functionality that's
   not exposed through the plugin interface are still built in two
   parts, but the internal tests are simply consuming the OBJECT files
   directly instead of linking to a static library.

src/MagnumPlugins/AnyAudioImporter/AnyImporter.cpp

@@ -82,3 +82,6 @@ UnsignedInt AnyImporter::doFrequency() const { return _in->frequency(); }
 Containers::Array<char> AnyImporter::doData() { return _in->data(); }
 
 }}
+
+CORRADE_PLUGIN_REGISTER(AnyAudioImporter, Magnum::Audio::AnyImporter,
+    "cz.mosra.magnum.Audio.AbstractImporter/0.1")

src/MagnumPlugins/AnyAudioImporter/AnyImporter.h

@@ -36,7 +36,7 @@
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 #ifndef MAGNUM_ANYAUDIOIMPORTER_BUILD_STATIC
-    #if defined(AnyAudioImporter_EXPORTS) || defined(AnyAudioImporterObjects_EXPORTS)
+    #ifdef AnyAudioImporter_EXPORTS
         #define MAGNUM_ANYAUDIOIMPORTER_EXPORT CORRADE_VISIBILITY_EXPORT
     #else
         #define MAGNUM_ANYAUDIOIMPORTER_EXPORT CORRADE_VISIBILITY_IMPORT

src/MagnumPlugins/AnyAudioImporter/CMakeLists.txt

@@ -30,42 +30,20 @@ endif()
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
                ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
 
-set(AnyAudioImporter_SRCS
-    AnyImporter.cpp)
-
-set(AnyAudioImporter_HEADERS
-    AnyImporter.h)
-
-# Objects shared between plugin and test library
-add_library(AnyAudioImporterObjects OBJECT
-    ${AnyAudioImporter_SRCS}
-    ${AnyAudioImporter_HEADERS})
-target_include_directories(AnyAudioImporterObjects PUBLIC
-    $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>
-    $<TARGET_PROPERTY:MagnumAudio,INTERFACE_INCLUDE_DIRECTORIES>)
-target_compile_definitions(AnyAudioImporterObjects PRIVATE "AnyAudioImporterObjects_EXPORTS")
-if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
-    set_target_properties(AnyAudioImporterObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
-endif()
-set_target_properties(AnyAudioImporterObjects PROPERTIES FOLDER "MagnumPlugins/AnyAudioImporter")
-
 # AnyAudioImporter plugin
 add_plugin(AnyAudioImporter
     "${MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_LIBRARY_INSTALL_DIR}"
     "${MAGNUM_PLUGINS_AUDIOIMPORTER_RELEASE_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_AUDIOIMPORTER_RELEASE_LIBRARY_INSTALL_DIR}"
     AnyAudioImporter.conf
-    $<TARGET_OBJECTS:AnyAudioImporterObjects>
-    pluginRegistration.cpp)
-if(BUILD_STATIC_PIC)
+    AnyImporter.cpp
+    AnyImporter.h)
+if(BUILD_PLUGINS_STATIC AND BUILD_STATIC_PIC)
     set_target_properties(AnyAudioImporter PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif()
-target_include_directories(AnyAudioImporter PUBLIC
-    ${PROJECT_SOURCE_DIR}/src
-    ${PROJECT_BINARY_DIR}/src)
 target_link_libraries(AnyAudioImporter PUBLIC Magnum MagnumAudio)
 
-install(FILES ${AnyAudioImporter_HEADERS} DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/AnyAudioImporter)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/configure.h DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/AnyAudioImporter)
+install(FILES AnyImporter.h ${CMAKE_CURRENT_BINARY_DIR}/configure.h
+    DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/AnyAudioImporter)
 
 # Automatic static plugin import
 if(BUILD_PLUGINS_STATIC)
@@ -76,14 +54,6 @@ if(BUILD_PLUGINS_STATIC)
 endif()
 
 if(BUILD_TESTS)
-    add_library(MagnumAnyAudioImporterTestLib STATIC
-        $<TARGET_OBJECTS:AnyAudioImporterObjects>
-        ${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details
-    target_include_directories(MagnumAnyAudioImporterTestLib PUBLIC
-        ${PROJECT_SOURCE_DIR}/src
-        ${PROJECT_BINARY_DIR}/src)
-    set_target_properties(MagnumAnyAudioImporterTestLib PROPERTIES FOLDER "MagnumPlugins/AnyAudioImporter")
-    target_link_libraries(MagnumAnyAudioImporterTestLib PUBLIC Magnum MagnumAudio)
     add_subdirectory(Test)
 endif()
 

src/MagnumPlugins/AnyAudioImporter/Test/CMakeLists.txt

@@ -29,19 +29,37 @@ else()
     set(WAV_FILE ${PROJECT_SOURCE_DIR}/src/MagnumPlugins/WavAudioImporter/Test/stereo8.wav)
 endif()
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
-               ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+# CMake before 3.8 has broken $<TARGET_FILE*> expressions for iOS (see
+# https://gitlab.kitware.com/cmake/cmake/merge_requests/404) and since Corrade
+# doesn't support dynamic plugins on iOS, this sorta works around that. Should
+# be revisited when updating Travis to newer Xcode (current has CMake 3.6).
+if(NOT BUILD_PLUGINS_STATIC)
+    set(ANYAUDIOIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:AnyAudioImporter>)
+    if(WITH_WAVAUDIOIMPORTER)
+        set(WAVAUDIOIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:WavAudioImporter>)
+    endif()
+
+    # First replace ${} variables, then $<> generator expressions
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+    file(GENERATE OUTPUT $<TARGET_FILE_DIR:AnyAudioImporterTest>/configure.h
+        INPUT ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+else()
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+endif()
 
 corrade_add_test(AnyAudioImporterTest Test.cpp
-    LIBRARIES MagnumAnyAudioImporterTestLib
+    LIBRARIES MagnumAudio
     FILES
         ../../WavAudioImporter/Test/stereo8.wav)
-target_include_directories(AnyAudioImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-# On Win32 we need to avoid dllimporting AnyAudioImporter symbols, because it
-# would search for the symbols in some DLL even when they were linked
-# statically. However it apparently doesn't matter that they were dllexported
-# when building the static library. EH.
-if(WIN32)
-    target_compile_definitions(AnyAudioImporterTest PRIVATE "MAGNUM_ANYAUDIOIMPORTER_BUILD_STATIC")
+if(NOT BUILD_PLUGINS_STATIC)
+    target_include_directories(AnyAudioImporterTest PRIVATE $<TARGET_FILE_DIR:AnyAudioImporterTest>)
+else()
+    target_include_directories(AnyAudioImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+    target_link_libraries(AnyAudioImporterTest PRIVATE AnyAudioImporter)
+    if(WITH_WAVAUDIOIMPORTER)
+        target_link_libraries(AnyAudioImporterTest PRIVATE WavAudioImporter)
+    endif()
 endif()
 set_target_properties(AnyAudioImporterTest PROPERTIES FOLDER "MagnumPlugins/AnyAudioImporter/Test")

src/MagnumPlugins/AnyAudioImporter/Test/Test.cpp

@@ -27,7 +27,7 @@
 #include <Corrade/PluginManager/Manager.h>
 #include <Corrade/TestSuite/Tester.h>
 
-#include "MagnumPlugins/AnyAudioImporter/AnyImporter.h"
+#include "Magnum/Audio/AbstractImporter.h"
 
 #include "configure.h"
 
@@ -40,34 +40,44 @@ struct AnyImporterTest: TestSuite::Tester {
 
     void unknown();
 
-private:
-    PluginManager::Manager<AbstractImporter> _manager;
+    /* Explicitly forbid system-wide plugin dependencies */
+    PluginManager::Manager<AbstractImporter> _manager{"nonexistent"};
 };
 
-AnyImporterTest::AnyImporterTest(): _manager{MAGNUM_PLUGINS_AUDIOIMPORTER_DIR} {
+AnyImporterTest::AnyImporterTest() {
     addTests({&AnyImporterTest::wav,
 
               &AnyImporterTest::unknown});
+
+    /* Load the plugin directly from the build tree. Otherwise it's static and
+       already loaded. */
+    #ifdef ANYAUDIOIMPORTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_manager.load(ANYAUDIOIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
+    /* Optional plugins that don't have to be here */
+    #ifdef WAVAUDIOIMPORTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_manager.load(WAVAUDIOIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
 }
 
 void AnyImporterTest::wav() {
-    if(_manager.loadState("WavAudioImporter") == PluginManager::LoadState::NotFound)
-        CORRADE_SKIP("WavAudioImporter plugin not found, cannot test");
+    if(!(_manager.loadState("WavAudioImporter") & PluginManager::LoadState::Loaded))
+        CORRADE_SKIP("WavAudioImporter plugin not enabled, cannot test");
 
-    AnyImporter importer{_manager};
-    CORRADE_VERIFY(importer.openFile(WAV_FILE));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnyAudioImporter");
+    CORRADE_VERIFY(importer->openFile(WAV_FILE));
 
     /* Check only parameters, as it is good enough proof that it is working */
-    CORRADE_COMPARE(importer.format(), Buffer::Format::Stereo8);
-    CORRADE_COMPARE(importer.frequency(), 96000);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::Stereo8);
+    CORRADE_COMPARE(importer->frequency(), 96000);
 }
 
 void AnyImporterTest::unknown() {
     std::ostringstream output;
     Error redirectError{&output};
 
-    AnyImporter importer{_manager};
-    CORRADE_VERIFY(!importer.openFile("sound.mid"));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnyAudioImporter");
+    CORRADE_VERIFY(!importer->openFile("sound.mid"));
 
     CORRADE_COMPARE(output.str(), "Audio::AnyImporter::openFile(): cannot determine type of file sound.mid\n");
 }

src/MagnumPlugins/AnyAudioImporter/Test/configure.h.cmake

@@ -23,10 +23,6 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#ifdef CORRADE_IS_DEBUG_BUILD
-#define MAGNUM_PLUGINS_AUDIOIMPORTER_DIR "${MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_DIR}"
-#else
-#define MAGNUM_PLUGINS_AUDIOIMPORTER_DIR "${MAGNUM_PLUGINS_AUDIOIMPORTER_DIR}"
-#endif
-
+#cmakedefine ANYAUDIOIMPORTER_PLUGIN_FILENAME "${ANYAUDIOIMPORTER_PLUGIN_FILENAME}"
+#cmakedefine WAVAUDIOIMPORTER_PLUGIN_FILENAME "${WAVAUDIOIMPORTER_PLUGIN_FILENAME}"
 #define WAV_FILE "${WAV_FILE}"

src/MagnumPlugins/AnyAudioImporter/pluginRegistration.cpp

@@ -1,29 +0,0 @@
-/*
-    This file is part of Magnum.
-
-    Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018
-              Vladimír Vondruš <mosra@centrum.cz>
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom the
-    Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included
-    in all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-    DEALINGS IN THE SOFTWARE.
-*/
-
-#include "MagnumPlugins/AnyAudioImporter/AnyImporter.h"
-
-CORRADE_PLUGIN_REGISTER(AnyAudioImporter, Magnum::Audio::AnyImporter,
-    "cz.mosra.magnum.Audio.AbstractImporter/0.1")

src/MagnumPlugins/AnyImageConverter/AnyImageConverter.cpp

@@ -86,3 +86,7 @@ bool AnyImageConverter::doExportToFile(const CompressedImageView2D&, const std::
 }
 
 }}
+
+
+CORRADE_PLUGIN_REGISTER(AnyImageConverter, Magnum::Trade::AnyImageConverter,
+    "cz.mosra.magnum.Trade.AbstractImageConverter/0.2.1")

src/MagnumPlugins/AnyImageConverter/AnyImageConverter.h

@@ -35,7 +35,7 @@
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 #ifndef MAGNUM_ANYIMAGECONVERTER_BUILD_STATIC
-    #if defined(AnyImageConverter_EXPORTS) || defined(AnyImageConverterObjects_EXPORTS)
+    #ifdef AnyImageConverter_EXPORTS
         #define MAGNUM_ANYIMAGECONVERTER_EXPORT CORRADE_VISIBILITY_EXPORT
     #else
         #define MAGNUM_ANYIMAGECONVERTER_EXPORT CORRADE_VISIBILITY_IMPORT

src/MagnumPlugins/AnyImageConverter/CMakeLists.txt

@@ -30,41 +30,20 @@ endif()
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
                ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
 
-set(AnyImageConverter_SRCS
-    AnyImageConverter.cpp)
-
-set(AnyImageConverter_HEADERS
-    AnyImageConverter.h)
-
-# Objects shared between plugin and test library
-add_library(AnyImageConverterObjects OBJECT
-    ${AnyImageConverter_SRCS}
-    ${AnyImageConverter_HEADERS})
-target_include_directories(AnyImageConverterObjects PUBLIC
-    $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
-target_compile_definitions(AnyImageConverterObjects PRIVATE "AnyImageConverterObjects_EXPORTS")
-if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
-    set_target_properties(AnyImageConverterObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
-endif()
-set_target_properties(AnyImageConverterObjects PROPERTIES FOLDER "MagnumPlugins/AnyImageConverter")
-
 # AnyImageConverter plugin
 add_plugin(AnyImageConverter
     "${MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_LIBRARY_INSTALL_DIR}"
     "${MAGNUM_PLUGINS_IMAGECONVERTER_RELEASE_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_IMAGECONVERTER_RELEASE_LIBRARY_INSTALL_DIR}"
     AnyImageConverter.conf
-    $<TARGET_OBJECTS:AnyImageConverterObjects>
-    pluginRegistration.cpp)
-if(BUILD_STATIC_PIC)
+    AnyImageConverter.cpp
+    AnyImageConverter.h)
+if(BUILD_PLUGINS_STATIC AND BUILD_STATIC_PIC)
     set_target_properties(AnyImageConverter PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif()
-target_include_directories(AnyImageConverter PUBLIC
-    ${PROJECT_SOURCE_DIR}/src
-    ${PROJECT_BINARY_DIR}/src)
 target_link_libraries(AnyImageConverter PUBLIC Magnum)
 
-install(FILES ${AnyImageConverter_HEADERS} DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/AnyImageConverter)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/configure.h DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/AnyImageConverter)
+install(FILES AnyImageConverter.h ${CMAKE_CURRENT_BINARY_DIR}/configure.h
+    DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/AnyImageConverter)
 
 # Automatic static plugin import
 if(BUILD_PLUGINS_STATIC)
@@ -75,14 +54,6 @@ if(BUILD_PLUGINS_STATIC)
 endif()
 
 if(BUILD_TESTS)
-    add_library(MagnumAnyImageConverterTestLib STATIC
-        $<TARGET_OBJECTS:AnyImageConverterObjects>
-        ${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details
-    target_include_directories(MagnumAnyImageConverterTestLib PUBLIC
-        ${PROJECT_SOURCE_DIR}/src
-        ${PROJECT_BINARY_DIR}/src)
-    set_target_properties(MagnumAnyImageConverterTestLib PROPERTIES FOLDER "MagnumPlugins/AnyImageConverter")
-    target_link_libraries(MagnumAnyImageConverterTestLib PUBLIC Magnum)
     add_subdirectory(Test)
 endif()
 

src/MagnumPlugins/AnyImageConverter/Test/CMakeLists.txt

@@ -29,17 +29,34 @@ else()
     set(ANYIMAGECONVERTER_TEST_DIR ${CMAKE_CURRENT_BINARY_DIR})
 endif()
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
-               ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+# CMake before 3.8 has broken $<TARGET_FILE*> expressions for iOS (see
+# https://gitlab.kitware.com/cmake/cmake/merge_requests/404) and since Corrade
+# doesn't support dynamic plugins on iOS, this sorta works around that. Should
+# be revisited when updating Travis to newer Xcode (current has CMake 3.6).
+if(NOT BUILD_PLUGINS_STATIC)
+    set(ANYIMAGECONVERTER_PLUGIN_FILENAME $<TARGET_FILE:AnyImageConverter>)
+    if(WITH_TGAIMAGECONVERTER)
+        set(TGAIMAGECONVERTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImageConverter>)
+    endif()
 
-corrade_add_test(AnyImageConverterTest Test.cpp
-    LIBRARIES MagnumAnyImageConverterTestLib)
-target_include_directories(AnyImageConverterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-# On Win32 we need to avoid dllimporting AnyImageConverter symbols, because it
-# would search for the symbols in some DLL even when they were linked
-# statically. However it apparently doesn't matter that they were dllexported
-# when building the static library. EH.
-if(WIN32)
-    target_compile_definitions(AnyImageConverterTest PRIVATE "MAGNUM_ANYIMAGECONVERTER_BUILD_STATIC")
+    # First replace ${} variables, then $<> generator expressions
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+    file(GENERATE OUTPUT $<TARGET_FILE_DIR:AnyImageConverterTest>/configure.h
+        INPUT ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+else()
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+endif()
+
+corrade_add_test(AnyImageConverterTest Test.cpp LIBRARIES Magnum)
+if(NOT BUILD_PLUGINS_STATIC)
+    target_include_directories(AnyImageConverterTest PRIVATE $<TARGET_FILE_DIR:AnyImageConverterTest>)
+else()
+    target_include_directories(AnyImageConverterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+    target_link_libraries(AnyImageConverterTest PRIVATE AnyImageConverter)
+    if(WITH_TGAIMAGECONVERTER)
+        target_link_libraries(AnyImageConverterTest PRIVATE TgaImageConverter)
+    endif()
 endif()
 set_target_properties(AnyImageConverterTest PROPERTIES FOLDER "MagnumPlugins/AnyImageConverter/Test")

src/MagnumPlugins/AnyImageConverter/Test/Test.cpp

@@ -29,10 +29,9 @@
 #include <Corrade/PluginManager/Manager.h>
 
 #include "Magnum/PixelFormat.h"
+#include "Magnum/Trade/AbstractImageConverter.h"
 #include "Magnum/Trade/ImageData.h"
 
-#include "MagnumPlugins/AnyImageConverter/AnyImageConverter.h"
-
 #include "configure.h"
 
 namespace Magnum { namespace Trade { namespace Test {
@@ -44,14 +43,27 @@ struct AnyImageConverterTest: TestSuite::Tester {
 
     void unknown();
 
-    private:
-        PluginManager::Manager<AbstractImageConverter> _manager;
+    /* Explicitly forbid system-wide plugin dependencies */
+    PluginManager::Manager<AbstractImageConverter> _manager{"nonexistent"};
 };
 
-AnyImageConverterTest::AnyImageConverterTest(): _manager{MAGNUM_PLUGINS_IMAGECONVERTER_DIR} {
+AnyImageConverterTest::AnyImageConverterTest() {
     addTests({&AnyImageConverterTest::tga,
 
               &AnyImageConverterTest::unknown});
+
+    /* Load the plugin directly from the build tree. Otherwise it's static and
+       already loaded. */
+    #ifdef ANYIMAGECONVERTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_manager.load(ANYIMAGECONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
+    /* Optional plugins that don't have to be here */
+    #ifdef TGAIMAGECONVERTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_manager.load(TGAIMAGECONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
+
+    /* Create the output directory if it doesn't exist yet */
+    CORRADE_INTERNAL_ASSERT(Utility::Directory::mkpath(ANYIMAGECONVERTER_TEST_DIR));
 }
 
 namespace {
@@ -65,8 +77,8 @@ namespace {
 }
 
 void AnyImageConverterTest::tga() {
-    if(_manager.loadState("TgaImageConverter") == PluginManager::LoadState::NotFound)
-        CORRADE_SKIP("TgaImageConverter plugin not found, cannot test");
+    if(!(_manager.loadState("TgaImageConverter") & PluginManager::LoadState::Loaded))
+        CORRADE_SKIP("TgaImageConverter plugin not enabled, cannot test");
 
     const std::string filename = Utility::Directory::join(ANYIMAGECONVERTER_TEST_DIR, "output.tga");
 
@@ -74,8 +86,8 @@ void AnyImageConverterTest::tga() {
         CORRADE_VERIFY(Utility::Directory::rm(filename));
 
     /* Just test that the exported file exists */
-    AnyImageConverter converter{_manager};
-    CORRADE_VERIFY(converter.exportToFile(Image, filename));
+    std::unique_ptr<AbstractImageConverter> converter = _manager.instantiate("AnyImageConverter");
+    CORRADE_VERIFY(converter->exportToFile(Image, filename));
     CORRADE_VERIFY(Utility::Directory::fileExists(filename));
 }
 
@@ -83,8 +95,8 @@ void AnyImageConverterTest::unknown() {
     std::ostringstream output;
     Error redirectError{&output};
 
-    AnyImageConverter converter{_manager};
-    CORRADE_VERIFY(!converter.exportToFile(Image, "image.xcf"));
+    std::unique_ptr<AbstractImageConverter> converter = _manager.instantiate("AnyImageConverter");
+    CORRADE_VERIFY(!converter->exportToFile(Image, "image.xcf"));
 
     CORRADE_COMPARE(output.str(), "Trade::AnyImageConverter::exportToFile(): cannot determine type of file image.xcf\n");
 }

src/MagnumPlugins/AnyImageConverter/Test/configure.h.cmake

@@ -23,10 +23,6 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#ifdef CORRADE_IS_DEBUG_BUILD
-#define MAGNUM_PLUGINS_IMAGECONVERTER_DIR "${MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_DIR}"
-#else
-#define MAGNUM_PLUGINS_IMAGECONVERTER_DIR "${MAGNUM_PLUGINS_IMAGECONVERTER_DIR}"
-#endif
-
+#cmakedefine ANYIMAGECONVERTER_PLUGIN_FILENAME "${ANYIMAGECONVERTER_PLUGIN_FILENAME}"
+#cmakedefine TGAIMAGECONVERTER_PLUGIN_FILENAME "${TGAIMAGECONVERTER_PLUGIN_FILENAME}"
 #define ANYIMAGECONVERTER_TEST_DIR "${ANYIMAGECONVERTER_TEST_DIR}"

src/MagnumPlugins/AnyImageConverter/pluginRegistration.cpp

@@ -1,29 +0,0 @@
-/*
-    This file is part of Magnum.
-
-    Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018
-              Vladimír Vondruš <mosra@centrum.cz>
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom the
-    Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included
-    in all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-    DEALINGS IN THE SOFTWARE.
-*/
-
-#include "MagnumPlugins/AnyImageConverter/AnyImageConverter.h"
-
-CORRADE_PLUGIN_REGISTER(AnyImageConverter, Magnum::Trade::AnyImageConverter,
-    "cz.mosra.magnum.Trade.AbstractImageConverter/0.2.1")

src/MagnumPlugins/AnyImageImporter/AnyImageImporter.cpp

@@ -123,3 +123,6 @@ UnsignedInt AnyImageImporter::doImage2DCount() const { return _in->image2DCount(
 Containers::Optional<ImageData2D> AnyImageImporter::doImage2D(const UnsignedInt id) { return _in->image2D(id); }
 
 }}
+
+CORRADE_PLUGIN_REGISTER(AnyImageImporter, Magnum::Trade::AnyImageImporter,
+    "cz.mosra.magnum.Trade.AbstractImporter/0.3")

src/MagnumPlugins/AnyImageImporter/AnyImageImporter.h

@@ -35,7 +35,7 @@
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 #ifndef MAGNUM_ANYIMAGEIMPORTER_BUILD_STATIC
-    #if defined(AnyImageImporter_EXPORTS) || defined(AnyImageImporterObjects_EXPORTS)
+    #ifdef AnyImageImporter_EXPORTS
         #define MAGNUM_ANYIMAGEIMPORTER_EXPORT CORRADE_VISIBILITY_EXPORT
     #else
         #define MAGNUM_ANYIMAGEIMPORTER_EXPORT CORRADE_VISIBILITY_IMPORT

src/MagnumPlugins/AnyImageImporter/CMakeLists.txt

@@ -30,41 +30,20 @@ endif()
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
                ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
 
-set(AnyImageImporter_SRCS
-    AnyImageImporter.cpp)
-
-set(AnyImageImporter_HEADERS
-    AnyImageImporter.h)
-
-# Objects shared between plugin and test library
-add_library(AnyImageImporterObjects OBJECT
-    ${AnyImageImporter_SRCS}
-    ${AnyImageImporter_HEADERS})
-target_include_directories(AnyImageImporterObjects PUBLIC
-    $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
-target_compile_definitions(AnyImageImporterObjects PRIVATE "AnyImageImporterObjects_EXPORTS")
-if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
-    set_target_properties(AnyImageImporterObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
-endif()
-set_target_properties(AnyImageImporterObjects PROPERTIES FOLDER "MagnumPlugins/AnyImageImporter")
-
 # AnyImageImporter plugin
 add_plugin(AnyImageImporter
     "${MAGNUM_PLUGINS_IMPORTER_DEBUG_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_IMPORTER_DEBUG_LIBRARY_INSTALL_DIR}"
     "${MAGNUM_PLUGINS_IMPORTER_RELEASE_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_IMPORTER_RELEASE_LIBRARY_INSTALL_DIR}"
     AnyImageImporter.conf
-    $<TARGET_OBJECTS:AnyImageImporterObjects>
-    pluginRegistration.cpp)
-if(BUILD_STATIC_PIC)
+    AnyImageImporter.cpp
+    AnyImageImporter.h)
+if(BUILD_PLUGINS_STATIC AND BUILD_STATIC_PIC)
     set_target_properties(AnyImageImporter PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif()
-target_include_directories(AnyImageImporter PUBLIC
-    ${PROJECT_SOURCE_DIR}/src
-    ${PROJECT_BINARY_DIR}/src)
 target_link_libraries(AnyImageImporter PUBLIC Magnum)
 
-install(FILES ${AnyImageImporter_HEADERS} DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/AnyImageImporter)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/configure.h DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/AnyImageImporter)
+install(FILES AnyImageImporter.h ${CMAKE_CURRENT_BINARY_DIR}/configure.h
+    DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/AnyImageImporter)
 
 # Automatic static plugin import
 if(BUILD_PLUGINS_STATIC)
@@ -75,14 +54,6 @@ if(BUILD_PLUGINS_STATIC)
 endif()
 
 if(BUILD_TESTS)
-    add_library(MagnumAnyImageImporterTestLib STATIC
-        $<TARGET_OBJECTS:AnyImageImporterObjects>
-        ${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details
-    target_include_directories(MagnumAnyImageImporterTestLib PUBLIC
-        ${PROJECT_SOURCE_DIR}/src
-        ${PROJECT_BINARY_DIR}/src)
-    set_target_properties(MagnumAnyImageImporterTestLib PROPERTIES FOLDER "MagnumPlugins/AnyImageImporter")
-    target_link_libraries(MagnumAnyImageImporterTestLib PUBLIC Magnum)
     add_subdirectory(Test)
 endif()
 

src/MagnumPlugins/AnyImageImporter/Test/CMakeLists.txt

@@ -29,19 +29,37 @@ else()
     set(TGA_FILE ${PROJECT_SOURCE_DIR}/src/MagnumPlugins/TgaImporter/Test/file.tga)
 endif()
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
-               ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+# CMake before 3.8 has broken $<TARGET_FILE*> expressions for iOS (see
+# https://gitlab.kitware.com/cmake/cmake/merge_requests/404) and since Corrade
+# doesn't support dynamic plugins on iOS, this sorta works around that. Should
+# be revisited when updating Travis to newer Xcode (current has CMake 3.6).
+if(NOT BUILD_PLUGINS_STATIC)
+    set(ANYIMAGEIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:AnyImageImporter>)
+    if(WITH_TGAIMPORTER)
+        set(TGAIMAGEIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
+    endif()
+
+    # First replace ${} variables, then $<> generator expressions
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+    file(GENERATE OUTPUT $<TARGET_FILE_DIR:AnyImageImporterTest>/configure.h
+        INPUT ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+else()
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+endif()
 
 corrade_add_test(AnyImageImporterTest Test.cpp
-    LIBRARIES MagnumAnyImageImporterTestLib
+    LIBRARIES Magnum
     FILES
         ../../TgaImporter/Test/file.tga)
-target_include_directories(AnyImageImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-# On Win32 we need to avoid dllimporting AnyImageImporter symbols, because it
-# would search for the symbols in some DLL even when they were linked
-# statically. However it apparently doesn't matter that they were dllexported
-# when building the static library. EH.
-if(WIN32)
-    target_compile_definitions(AnyImageImporterTest PRIVATE "MAGNUM_ANYIMAGEIMPORTER_BUILD_STATIC")
+if(NOT BUILD_PLUGINS_STATIC)
+    target_include_directories(AnyImageImporterTest PRIVATE $<TARGET_FILE_DIR:AnyImageImporterTest>)
+else()
+    target_include_directories(AnyImageImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+    target_link_libraries(AnyImageImporterTest PRIVATE AnyImageImporter)
+    if(WITH_TGAIMPORTER)
+        target_link_libraries(AnyImageImporterTest PRIVATE TgaImporter)
+    endif()
 endif()
 set_target_properties(AnyImageImporterTest PROPERTIES FOLDER "MagnumPlugins/AnyImageImporter/Test")

src/MagnumPlugins/AnyImageImporter/Test/Test.cpp

@@ -27,10 +27,9 @@
 #include <Corrade/PluginManager/Manager.h>
 #include <Corrade/TestSuite/Tester.h>
 
+#include "Magnum/Trade/AbstractImporter.h"
 #include "Magnum/Trade/ImageData.h"
 
-#include "MagnumPlugins/AnyImageImporter/AnyImageImporter.h"
-
 #include "configure.h"
 
 namespace Magnum { namespace Trade { namespace Test {
@@ -42,25 +41,35 @@ struct AnyImageImporterTest: TestSuite::Tester {
 
     void unknown();
 
-    private:
-        PluginManager::Manager<AbstractImporter> _manager;
+    /* Explicitly forbid system-wide plugin dependencies */
+    PluginManager::Manager<AbstractImporter> _manager{"nonexistent"};
 };
 
-AnyImageImporterTest::AnyImageImporterTest(): _manager{MAGNUM_PLUGINS_IMPORTER_DIR} {
+AnyImageImporterTest::AnyImageImporterTest() {
     addTests({&AnyImageImporterTest::tga,
 
               &AnyImageImporterTest::unknown});
+
+    /* Load the plugin directly from the build tree. Otherwise it's static and
+       already loaded. */
+    #ifdef ANYIMAGEIMPORTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_manager.load(ANYIMAGEIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
+    /* Optional plugins that don't have to be here */
+    #ifdef TGAIMPORTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_manager.load(TGAIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
 }
 
 void AnyImageImporterTest::tga() {
-    if(_manager.loadState("TgaImporter") == PluginManager::LoadState::NotFound)
-        CORRADE_SKIP("TgaImporter plugin not found, cannot test");
+    if(!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
+        CORRADE_SKIP("TgaImporter plugin not enabled, cannot test");
 
-    AnyImageImporter importer{_manager};
-    CORRADE_VERIFY(importer.openFile(TGA_FILE));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnyImageImporter");
+    CORRADE_VERIFY(importer->openFile(TGA_FILE));
 
     /* Check only size, as it is good enough proof that it is working */
-    Containers::Optional<ImageData2D> image = importer.image2D(0);
+    Containers::Optional<ImageData2D> image = importer->image2D(0);
     CORRADE_VERIFY(image);
     CORRADE_COMPARE(image->size(), Vector2i(2, 3));
 }
@@ -69,8 +78,8 @@ void AnyImageImporterTest::unknown() {
     std::ostringstream output;
     Error redirectError{&output};
 
-    AnyImageImporter importer{_manager};
-    CORRADE_VERIFY(!importer.openFile("image.xcf"));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnyImageImporter");
+    CORRADE_VERIFY(!importer->openFile("image.xcf"));
 
     CORRADE_COMPARE(output.str(), "Trade::AnyImageImporter::openFile(): cannot determine type of file image.xcf\n");
 }

src/MagnumPlugins/AnyImageImporter/Test/configure.h.cmake

@@ -23,10 +23,6 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#ifdef CORRADE_IS_DEBUG_BUILD
-#define MAGNUM_PLUGINS_IMPORTER_DIR "${MAGNUM_PLUGINS_IMPORTER_DEBUG_DIR}"
-#else
-#define MAGNUM_PLUGINS_IMPORTER_DIR "${MAGNUM_PLUGINS_IMPORTER_DIR}"
-#endif
-
+#cmakedefine ANYIMAGEIMPORTER_PLUGIN_FILENAME "${ANYIMAGEIMPORTER_PLUGIN_FILENAME}"
+#cmakedefine TGAIMPORTER_PLUGIN_FILENAME "${TGAIMPORTER_PLUGIN_FILENAME}"
 #define TGA_FILE "${TGA_FILE}"

src/MagnumPlugins/AnyImageImporter/pluginRegistration.cpp

@@ -1,29 +0,0 @@
-/*
-    This file is part of Magnum.
-
-    Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018
-              Vladimír Vondruš <mosra@centrum.cz>
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom the
-    Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included
-    in all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-    DEALINGS IN THE SOFTWARE.
-*/
-
-#include "MagnumPlugins/AnyImageImporter/AnyImageImporter.h"
-
-CORRADE_PLUGIN_REGISTER(AnyImageImporter, Magnum::Trade::AnyImageImporter,
-    "cz.mosra.magnum.Trade.AbstractImporter/0.3")

src/MagnumPlugins/AnySceneImporter/AnySceneImporter.cpp

@@ -198,3 +198,6 @@ std::string AnySceneImporter::doImage3DName(const UnsignedInt id) { return _in->
 Containers::Optional<ImageData3D> AnySceneImporter::doImage3D(const UnsignedInt id) { return _in->image3D(id); }
 
 }}
+
+CORRADE_PLUGIN_REGISTER(AnySceneImporter, Magnum::Trade::AnySceneImporter,
+    "cz.mosra.magnum.Trade.AbstractImporter/0.3")

src/MagnumPlugins/AnySceneImporter/AnySceneImporter.h

@@ -35,7 +35,7 @@
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 #ifndef MAGNUM_ANYSCENEIMPORTER_BUILD_STATIC
-    #if defined(AnySceneImporter_EXPORTS) || defined(AnySceneImporterObjects_EXPORTS)
+    #ifdef AnySceneImporter_EXPORTS
         #define MAGNUM_ANYSCENEIMPORTER_EXPORT CORRADE_VISIBILITY_EXPORT
     #else
         #define MAGNUM_ANYSCENEIMPORTER_EXPORT CORRADE_VISIBILITY_IMPORT

src/MagnumPlugins/AnySceneImporter/CMakeLists.txt

@@ -30,41 +30,20 @@ endif()
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
                ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
 
-set(AnySceneImporter_SRCS
-    AnySceneImporter.cpp)
-
-set(AnySceneImporter_HEADERS
-    AnySceneImporter.h)
-
-# Objects shared between plugin and test library
-add_library(AnySceneImporterObjects OBJECT
-    ${AnySceneImporter_SRCS}
-    ${AnySceneImporter_HEADERS})
-target_include_directories(AnySceneImporterObjects PUBLIC
-    $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
-target_compile_definitions(AnySceneImporterObjects PRIVATE "AnySceneImporterObjects_EXPORTS")
-if(NOT BUILD_STATIC OR BUILD_STATIC_PIC)
-    set_target_properties(AnySceneImporterObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
-endif()
-set_target_properties(AnySceneImporterObjects PROPERTIES FOLDER "MagnumPlugins/AnySceneImporter")
-
 # AnySceneImporter plugin
 add_plugin(AnySceneImporter
     "${MAGNUM_PLUGINS_IMPORTER_DEBUG_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_IMPORTER_DEBUG_LIBRARY_INSTALL_DIR}"
     "${MAGNUM_PLUGINS_IMPORTER_RELEASE_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_IMPORTER_RELEASE_LIBRARY_INSTALL_DIR}"
     AnySceneImporter.conf
-    $<TARGET_OBJECTS:AnySceneImporterObjects>
-    pluginRegistration.cpp)
-if(BUILD_STATIC_PIC)
+    AnySceneImporter.cpp
+    AnySceneImporter.h)
+if(BUILD_PLUGINS_STATIC AND BUILD_STATIC_PIC)
     set_target_properties(AnySceneImporter PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif()
-target_include_directories(AnySceneImporter PUBLIC
-    ${PROJECT_SOURCE_DIR}/src
-    ${PROJECT_BINARY_DIR}/src)
 target_link_libraries(AnySceneImporter PUBLIC Magnum)
 
-install(FILES ${AnySceneImporter_HEADERS} DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/AnySceneImporter)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/configure.h DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/AnySceneImporter)
+install(FILES AnySceneImporter.h ${CMAKE_CURRENT_BINARY_DIR}/configure.h
+    DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/AnySceneImporter)
 
 # Automatic static plugin import
 if(BUILD_PLUGINS_STATIC)
@@ -75,14 +54,6 @@ if(BUILD_PLUGINS_STATIC)
 endif()
 
 if(BUILD_TESTS)
-    add_library(MagnumAnySceneImporterTestLib STATIC
-        $<TARGET_OBJECTS:AnySceneImporterObjects>
-        ${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details
-    target_include_directories(MagnumAnySceneImporterTestLib PUBLIC
-        ${PROJECT_SOURCE_DIR}/src
-        ${PROJECT_BINARY_DIR}/src)
-    set_target_properties(MagnumAnySceneImporterTestLib PROPERTIES FOLDER "MagnumPlugins/AnySceneImporter")
-    target_link_libraries(MagnumAnySceneImporterTestLib PUBLIC Magnum)
     add_subdirectory(Test)
 endif()
 

src/MagnumPlugins/AnySceneImporter/Test/CMakeLists.txt

@@ -29,19 +29,37 @@ else()
     set(OBJ_FILE ${PROJECT_SOURCE_DIR}/src/MagnumPlugins/ObjImporter/Test/pointMesh.obj)
 endif()
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
-               ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+# CMake before 3.8 has broken $<TARGET_FILE*> expressions for iOS (see
+# https://gitlab.kitware.com/cmake/cmake/merge_requests/404) and since Corrade
+# doesn't support dynamic plugins on iOS, this sorta works around that. Should
+# be revisited when updating Travis to newer Xcode (current has CMake 3.6).
+if(NOT BUILD_PLUGINS_STATIC)
+    set(ANYSCENEIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:AnySceneImporter>)
+    if(WITH_OBJIMPORTER)
+        set(OBJIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:ObjImporter>)
+    endif()
+
+    # First replace ${} variables, then $<> generator expressions
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+    file(GENERATE OUTPUT $<TARGET_FILE_DIR:AnySceneImporterTest>/configure.h
+        INPUT ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+else()
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+endif()
 
 corrade_add_test(AnySceneImporterTest Test.cpp
-    LIBRARIES MagnumAnySceneImporterTestLib
+    LIBRARIES Magnum
     FILES
         ../../ObjImporter/Test/pointMesh.obj)
-target_include_directories(AnySceneImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-# On Win32 we need to avoid dllimporting AnySceneImporter symbols, because it
-# would search for the symbols in some DLL even when they were linked
-# statically. However it apparently doesn't matter that they were dllexported
-# when building the static library. EH.
-if(WIN32)
-    target_compile_definitions(AnySceneImporterTest PRIVATE "MAGNUM_ANYSCENEIMPORTER_BUILD_STATIC")
+if(NOT BUILD_PLUGINS_STATIC)
+    target_include_directories(AnySceneImporterTest PRIVATE $<TARGET_FILE_DIR:AnySceneImporterTest>)
+else()
+    target_include_directories(AnySceneImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+    target_link_libraries(AnySceneImporterTest PRIVATE AnySceneImporter)
+    if(WITH_OBJIMPORTER)
+        target_link_libraries(AnySceneImporterTest PRIVATE ObjImporter)
+    endif()
 endif()
 set_target_properties(AnySceneImporterTest PROPERTIES FOLDER "MagnumPlugins/AnySceneImporter/Test")

src/MagnumPlugins/AnySceneImporter/Test/Test.cpp

@@ -28,10 +28,9 @@
 #include <Corrade/TestSuite/Tester.h>
 
 #include "Magnum/Math/Vector3.h"
+#include "Magnum/Trade/AbstractImporter.h"
 #include "Magnum/Trade/MeshData3D.h"
 
-#include "MagnumPlugins/AnySceneImporter/AnySceneImporter.h"
-
 #include "configure.h"
 
 namespace Magnum { namespace Trade { namespace Test {
@@ -43,25 +42,35 @@ struct AnySceneImporterTest: TestSuite::Tester {
 
     void unknown();
 
-    private:
-        PluginManager::Manager<AbstractImporter> _manager;
+    /* Explicitly forbid system-wide plugin dependencies */
+    PluginManager::Manager<AbstractImporter> _manager{"nonexistent"};
 };
 
-AnySceneImporterTest::AnySceneImporterTest(): _manager{MAGNUM_PLUGINS_IMPORTER_DIR} {
+AnySceneImporterTest::AnySceneImporterTest() {
     addTests({&AnySceneImporterTest::obj,
 
               &AnySceneImporterTest::unknown});
+
+    /* Load the plugin directly from the build tree. Otherwise it's static and
+       already loaded. */
+    #ifdef ANYSCENEIMPORTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_manager.load(ANYSCENEIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
+    /* Optional plugins that don't have to be here */
+    #ifdef OBJIMPORTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_manager.load(OBJIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
 }
 
 void AnySceneImporterTest::obj() {
-    if(_manager.loadState("ObjImporter") == PluginManager::LoadState::NotFound)
-        CORRADE_SKIP("ObjImporter plugin not found, cannot test");
+    if(!(_manager.loadState("ObjImporter") & PluginManager::LoadState::Loaded))
+        CORRADE_SKIP("ObjImporter plugin not enabled, cannot test");
 
-    AnySceneImporter importer{_manager};
-    CORRADE_VERIFY(importer.openFile(OBJ_FILE));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnySceneImporter");
+    CORRADE_VERIFY(importer->openFile(OBJ_FILE));
 
     /* Check only size, as it is good enough proof that it is working */
-    Containers::Optional<MeshData3D> mesh = importer.mesh3D(0);
+    Containers::Optional<MeshData3D> mesh = importer->mesh3D(0);
     CORRADE_VERIFY(mesh);
     CORRADE_COMPARE(mesh->positions(0).size(), 3);
 }
@@ -70,8 +79,8 @@ void AnySceneImporterTest::unknown() {
     std::ostringstream output;
     Error redirectError{&output};
 
-    AnySceneImporter importer{_manager};
-    CORRADE_VERIFY(!importer.openFile("mesh.wtf"));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnySceneImporter");
+    CORRADE_VERIFY(!importer->openFile("mesh.wtf"));
 
     CORRADE_COMPARE(output.str(), "Trade::AnySceneImporter::openFile(): cannot determine type of file mesh.wtf\n");
 }

src/MagnumPlugins/AnySceneImporter/Test/configure.h.cmake

@@ -23,10 +23,6 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#ifdef CORRADE_IS_DEBUG_BUILD
-#define MAGNUM_PLUGINS_IMPORTER_DIR "${MAGNUM_PLUGINS_IMPORTER_DEBUG_DIR}"
-#else
-#define MAGNUM_PLUGINS_IMPORTER_DIR "${MAGNUM_PLUGINS_IMPORTER_DIR}"
-#endif
-
+#cmakedefine ANYSCENEIMPORTER_PLUGIN_FILENAME "${ANYSCENEIMPORTER_PLUGIN_FILENAME}"
+#cmakedefine OBJIMPORTER_PLUGIN_FILENAME "${OBJIMPORTER_PLUGIN_FILENAME}"
 #define OBJ_FILE "${OBJ_FILE}"

src/MagnumPlugins/AnySceneImporter/pluginRegistration.cpp

@@ -1,29 +0,0 @@
-/*
-    This file is part of Magnum.
-
-    Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018
-              Vladimír Vondruš <mosra@centrum.cz>
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom the
-    Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included
-    in all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-    DEALINGS IN THE SOFTWARE.
-*/
-
-#include "MagnumPlugins/AnySceneImporter/AnySceneImporter.h"
-
-CORRADE_PLUGIN_REGISTER(AnySceneImporter, Magnum::Trade::AnySceneImporter,
-    "cz.mosra.magnum.Trade.AbstractImporter/0.3")

src/MagnumPlugins/MagnumFont/CMakeLists.txt

@@ -30,44 +30,23 @@ endif()
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
                ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
 
-set(MagnumFont_SRCS
-    MagnumFont.cpp)
-
-set(MagnumFont_HEADERS
-    MagnumFont.h)
-
-# Objects shared between plugin and test library
-add_library(MagnumFontObjects OBJECT
-    ${MagnumFont_SRCS}
-    ${MagnumFont_HEADERS})
-target_include_directories(MagnumFontObjects PUBLIC
-    $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>
-    $<TARGET_PROPERTY:MagnumText,INTERFACE_INCLUDE_DIRECTORIES>)
-if(NOT BUILD_PLUGINS_STATIC)
-    target_compile_definitions(MagnumFontObjects PRIVATE "MagnumFontObjects_EXPORTS")
-endif()
-if(NOT BUILD_PLUGINS_STATIC OR BUILD_STATIC_PIC)
-    set_target_properties(MagnumFontObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
-endif()
-set_target_properties(MagnumFontObjects PROPERTIES FOLDER "MagnumPlugins/MagnumFont")
-
 # MagnumFont plugin
 add_plugin(MagnumFont
     "${MAGNUM_PLUGINS_FONT_DEBUG_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_FONT_DEBUG_LIBRARY_INSTALL_DIR}"
     "${MAGNUM_PLUGINS_FONT_RELEASE_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_FONT_RELEASE_LIBRARY_INSTALL_DIR}"
     MagnumFont.conf
-    $<TARGET_OBJECTS:MagnumFontObjects>
-    pluginRegistration.cpp)
-if(BUILD_STATIC_PIC)
+    MagnumFont.cpp
+    MagnumFont.h)
+if(BUILD_PLUGINS_STATIC AND BUILD_STATIC_PIC)
     set_target_properties(MagnumFont PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif()
-target_link_libraries(MagnumFont Magnum MagnumText)
+target_link_libraries(MagnumFont PUBLIC Magnum MagnumText)
 if(CORRADE_TARGET_WINDOWS)
-    target_link_libraries(MagnumFont TgaImporter)
+    target_link_libraries(MagnumFont PUBLIC TgaImporter)
 endif()
 
-install(FILES ${MagnumFont_HEADERS} DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/MagnumFont)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/configure.h DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/MagnumFont)
+install(FILES MagnumFont.h ${CMAKE_CURRENT_BINARY_DIR}/configure.h
+    DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/MagnumFont)
 
 # Automatic static plugin import
 if(BUILD_PLUGINS_STATIC)
@@ -78,25 +57,6 @@ if(BUILD_PLUGINS_STATIC)
 endif()
 
 if(BUILD_GL_TESTS)
-    # On Win32 we need to avoid dllimporting TgaImporter symbols, because it
-    # would search for the symbols in some DLL even when they were linked
-    # statically. However it apparently doesn't matter that they were
-    # dllexported when building the static library. EH.
-    if(WIN32)
-        add_library(MagnumMagnumFontTestLib STATIC
-            ${MagnumFont_SRCS}
-            ${MagnumFont_HEADERS})
-        target_compile_definitions(MagnumMagnumFontTestLib
-            PRIVATE "MAGNUM_TGAIMPORTER_BUILD_STATIC"
-            PUBLIC "MAGNUM_MAGNUMFONT_BUILD_STATIC")
-    else()
-        add_library(MagnumMagnumFontTestLib STATIC
-            $<TARGET_OBJECTS:MagnumFontObjects>
-            ${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details
-    endif()
-    set_target_properties(MagnumMagnumFontTestLib PROPERTIES FOLDER "MagnumPlugins/MagnumFont")
-    target_link_libraries(MagnumMagnumFontTestLib Magnum MagnumText MagnumTgaImporterTestLib)
-
     add_subdirectory(Test)
 endif()
 

src/MagnumPlugins/MagnumFont/MagnumFont.cpp

@@ -239,3 +239,6 @@ std::tuple<Range2D, Range2D, Vector2> MagnumFontLayouter::doRenderGlyph(const Un
 }
 
 }}
+
+CORRADE_PLUGIN_REGISTER(MagnumFont, Magnum::Text::MagnumFont,
+    "cz.mosra.magnum.Text.AbstractFont/0.2.4")

src/MagnumPlugins/MagnumFont/MagnumFont.h

@@ -36,7 +36,7 @@
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 #ifndef MAGNUM_MAGNUMFONT_BUILD_STATIC
-    #if defined(MagnumFont_EXPORTS) || defined(MagnumFontObjects_EXPORTS)
+    #ifdef MagnumFont_EXPORTS
         #define MAGNUM_MAGNUMFONT_EXPORT CORRADE_VISIBILITY_EXPORT
     #else
         #define MAGNUM_MAGNUMFONT_EXPORT CORRADE_VISIBILITY_IMPORT

src/MagnumPlugins/MagnumFont/Test/CMakeLists.txt

@@ -29,13 +29,33 @@ else()
     set(MAGNUMFONT_TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 endif()
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
-               ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+# CMake before 3.8 has broken $<TARGET_FILE*> expressions for iOS (see
+# https://gitlab.kitware.com/cmake/cmake/merge_requests/404) and since Corrade
+# doesn't support dynamic plugins on iOS, this sorta works around that. Should
+# be revisited when updating Travis to newer Xcode (current has CMake 3.6).
+if(NOT BUILD_PLUGINS_STATIC)
+    set(MAGNUMFONT_PLUGIN_FILENAME $<TARGET_FILE:MagnumFont>)
+    set(TGAIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
+
+    # First replace ${} variables, then $<> generator expressions
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+    file(GENERATE OUTPUT $<TARGET_FILE_DIR:MagnumFontGLTest>/configure.h
+        INPUT ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+else()
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+endif()
 
 corrade_add_test(MagnumFontGLTest MagnumFontGLTest.cpp
-    LIBRARIES MagnumMagnumFontTestLib MagnumOpenGLTester
+    LIBRARIES MagnumText MagnumOpenGLTester
     FILES
         font.conf
         font.tga)
+if(NOT BUILD_PLUGINS_STATIC)
+    target_include_directories(MagnumFontGLTest PRIVATE $<TARGET_FILE_DIR:MagnumFontGLTest>)
+else()
+    target_include_directories(MagnumFontGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+    target_link_libraries(MagnumFontGLTest PRIVATE MagnumFont TgaImporter)
+endif()
 set_target_properties(MagnumFontGLTest PROPERTIES FOLDER "MagnumPlugins/MagnumFont/Test")
-target_include_directories(MagnumFontGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})

src/MagnumPlugins/MagnumFont/Test/MagnumFontGLTest.cpp

@@ -27,8 +27,9 @@
 #include <Corrade/Utility/Directory.h>
 
 #include "Magnum/OpenGLTester.h"
+#include "Magnum/Text/AbstractFont.h"
 #include "Magnum/Text/GlyphCache.h"
-#include "MagnumPlugins/MagnumFont/MagnumFont.h"
+#include "Magnum/Trade/AbstractImporter.h"
 
 #include "configure.h"
 
@@ -41,6 +42,10 @@ struct MagnumFontGLTest: OpenGLTester {
     void properties();
     void layout();
     void createGlyphCache();
+
+    /* Explicitly forbid system-wide plugin dependencies */
+    PluginManager::Manager<Trade::AbstractImporter> _importerManager{"nonexistent"};
+    PluginManager::Manager<AbstractFont> _fontManager{"nonexistent"};
 };
 
 MagnumFontGLTest::MagnumFontGLTest() {
@@ -48,37 +53,46 @@ MagnumFontGLTest::MagnumFontGLTest() {
               &MagnumFontGLTest::properties,
               &MagnumFontGLTest::layout,
               &MagnumFontGLTest::createGlyphCache});
+
+    /* Load the plugins directly from the build tree. Otherwise they're static
+       and already loaded. */
+    #if defined(TGAIMPORTER_PLUGIN_FILENAME) && defined(MAGNUMFONT_PLUGIN_FILENAME)
+    CORRADE_INTERNAL_ASSERT(_importerManager.load(TGAIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    CORRADE_INTERNAL_ASSERT(_fontManager.load(MAGNUMFONT_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
 }
 
 void MagnumFontGLTest::nonexistent() {
-    MagnumFont font;
+    std::unique_ptr<AbstractFont> font = _fontManager.instantiate("MagnumFont");
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!font.openFile("nonexistent.conf", 0.0f));
+    CORRADE_VERIFY(!font->openFile("nonexistent.conf", 0.0f));
     CORRADE_COMPARE(out.str(), "Text::MagnumFont::openFile(): cannot open file nonexistent.conf\n");
 }
 
 void MagnumFontGLTest::properties() {
-    MagnumFont font;
-    CORRADE_VERIFY(font.openFile(Utility::Directory::join(MAGNUMFONT_TEST_DIR, "font.conf"), 0.0f));
-    CORRADE_COMPARE(font.size(), 16.0f);
-    CORRADE_COMPARE(font.ascent(), 25.0f);
-    CORRADE_COMPARE(font.descent(), -10.0f);
-    CORRADE_COMPARE(font.lineHeight(), 39.7333f);
-    CORRADE_COMPARE(font.glyphAdvance(font.glyphId(U'W')), Vector2(23.0f, 0.0f));
+    std::unique_ptr<AbstractFont> font = _fontManager.instantiate("MagnumFont");
+
+    CORRADE_VERIFY(font->openFile(Utility::Directory::join(MAGNUMFONT_TEST_DIR, "font.conf"), 0.0f));
+    CORRADE_COMPARE(font->size(), 16.0f);
+    CORRADE_COMPARE(font->ascent(), 25.0f);
+    CORRADE_COMPARE(font->descent(), -10.0f);
+    CORRADE_COMPARE(font->lineHeight(), 39.7333f);
+    CORRADE_COMPARE(font->glyphAdvance(font->glyphId(U'W')), Vector2(23.0f, 0.0f));
 }
 
 void MagnumFontGLTest::layout() {
-    MagnumFont font;
-    CORRADE_VERIFY(font.openFile(Utility::Directory::join(MAGNUMFONT_TEST_DIR, "font.conf"), 0.0f));
+    std::unique_ptr<AbstractFont> font = _fontManager.instantiate("MagnumFont");
+
+    CORRADE_VERIFY(font->openFile(Utility::Directory::join(MAGNUMFONT_TEST_DIR, "font.conf"), 0.0f));
 
     /* Fill the cache with some fake glyphs */
     GlyphCache cache(Vector2i(256));
-    cache.insert(font.glyphId(U'W'), {25, 34}, {{0, 8}, {16, 128}});
-    cache.insert(font.glyphId(U'e'), {25, 12}, {{16, 4}, {64, 32}});
+    cache.insert(font->glyphId(U'W'), {25, 34}, {{0, 8}, {16, 128}});
+    cache.insert(font->glyphId(U'e'), {25, 12}, {{16, 4}, {64, 32}});
 
-    auto layouter = font.layout(cache, 0.5f, "Wave");
+    auto layouter = font->layout(cache, 0.5f, "Wave");
     CORRADE_VERIFY(layouter);
     CORRADE_COMPARE(layouter->glyphCount(), 4);
 
@@ -113,11 +127,12 @@ void MagnumFontGLTest::layout() {
 }
 
 void MagnumFontGLTest::createGlyphCache() {
-    MagnumFont font;
-    CORRADE_VERIFY(font.openFile(Utility::Directory::join(MAGNUMFONT_TEST_DIR, "font.conf"), 0.0f));
+    std::unique_ptr<AbstractFont> font = _fontManager.instantiate("MagnumFont");
+
+    CORRADE_VERIFY(font->openFile(Utility::Directory::join(MAGNUMFONT_TEST_DIR, "font.conf"), 0.0f));
 
     /* Just testing that nothing crashes, asserts or errors */
-    std::unique_ptr<GlyphCache> cache = font.createGlyphCache();
+    std::unique_ptr<GlyphCache> cache = font->createGlyphCache();
 
     MAGNUM_VERIFY_NO_ERROR();
     CORRADE_VERIFY(cache);

src/MagnumPlugins/MagnumFont/Test/configure.h.cmake

@@ -23,4 +23,6 @@
     DEALINGS IN THE SOFTWARE.
 */
 
+#cmakedefine MAGNUMFONT_PLUGIN_FILENAME "${MAGNUMFONT_PLUGIN_FILENAME}"
+#cmakedefine TGAIMPORTER_PLUGIN_FILENAME "${TGAIMPORTER_PLUGIN_FILENAME}"
 #define MAGNUMFONT_TEST_DIR "${MAGNUMFONT_TEST_DIR}"

src/MagnumPlugins/MagnumFontConverter/CMakeLists.txt

@@ -30,44 +30,23 @@ endif()
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
                ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
 
-set(MagnumFontConverter_SRCS
-    MagnumFontConverter.cpp)
-
-set(MagnumFontConverter_HEADERS
-    MagnumFontConverter.h)
-
-# Objects shared between plugin and test library
-add_library(MagnumFontConverterObjects OBJECT
-    ${MagnumFontConverter_SRCS}
-    ${MagnumFontConverter_HEADERS})
-target_include_directories(MagnumFontConverterObjects PUBLIC
-    $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>
-    $<TARGET_PROPERTY:MagnumText,INTERFACE_INCLUDE_DIRECTORIES>)
-if(NOT BUILD_PLUGINS_STATIC)
-    target_compile_definitions(MagnumFontConverterObjects PRIVATE "MagnumFontConverterObjects_EXPORTS")
-endif()
-if(NOT BUILD_PLUGINS_STATIC OR BUILD_STATIC_PIC)
-    set_target_properties(MagnumFontConverterObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
-endif()
-set_target_properties(MagnumFontConverterObjects PROPERTIES FOLDER "MagnumPlugins/MagnumFontConverter")
-
 # MagnumFontConverter plugin
 add_plugin(MagnumFontConverter
     "${MAGNUM_PLUGINS_FONTCONVERTER_DEBUG_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_FONTCONVERTER_DEBUG_LIBRARY_INSTALL_DIR}"
     "${MAGNUM_PLUGINS_FONTCONVERTER_RELEASE_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_FONTCONVERTER_RELEASE_LIBRARY_INSTALL_DIR}"
     MagnumFontConverter.conf
-    $<TARGET_OBJECTS:MagnumFontConverterObjects>
-    pluginRegistration.cpp)
-if(BUILD_STATIC_PIC)
+    MagnumFontConverter.cpp
+    MagnumFontConverter.h)
+if(BUILD_PLUGINS_STATIC AND BUILD_STATIC_PIC)
     set_target_properties(MagnumFontConverter PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif()
-target_link_libraries(MagnumFontConverter Magnum MagnumText)
+target_link_libraries(MagnumFontConverter PUBLIC Magnum MagnumText)
 if(CORRADE_TARGET_WINDOWS)
-    target_link_libraries(MagnumFontConverter TgaImageConverter)
+    target_link_libraries(MagnumFontConverter PUBLIC TgaImageConverter)
 endif()
 
-install(FILES ${MagnumFontConverter_HEADERS} DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/MagnumFontConverter)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/configure.h DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/MagnumFontConverter)
+install(FILES MagnumFontConverter.h ${CMAKE_CURRENT_BINARY_DIR}/configure.h
+    DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/MagnumFontConverter)
 
 # Automatic static plugin import
 if(BUILD_PLUGINS_STATIC)
@@ -78,25 +57,6 @@ if(BUILD_PLUGINS_STATIC)
 endif()
 
 if(BUILD_GL_TESTS)
-    # On Win32 we need to avoid dllimporting TgaImageConverter symbols, because
-    # it would search for the symbols in some DLL even when they were linked
-    # statically. However it apparently doesn't matter that they were
-    # dllexported when building the static library. EH.
-    if(WIN32)
-        add_library(MagnumMagnumFontConverterTestLib STATIC
-            ${MagnumFontConverter_SRCS}
-            ${MagnumFontConverter_HEADERS})
-        target_compile_definitions(MagnumMagnumFontConverterTestLib
-            PRIVATE "MAGNUM_TGAIMAGECONVERTER_BUILD_STATIC"
-            PUBLIC "MAGNUM_MAGNUMFONTCONVERTER_BUILD_STATIC")
-    else()
-        add_library(MagnumMagnumFontConverterTestLib STATIC
-            $<TARGET_OBJECTS:MagnumFontConverterObjects>
-            ${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details
-    endif()
-    set_target_properties(MagnumMagnumFontConverterTestLib PROPERTIES FOLDER "MagnumPlugins/MagnumFontConverter")
-    target_link_libraries(MagnumMagnumFontConverterTestLib Magnum MagnumText MagnumTgaImageConverterTestLib)
-
     add_subdirectory(Test)
 endif()
 

src/MagnumPlugins/MagnumFontConverter/MagnumFontConverter.cpp

@@ -113,3 +113,6 @@ std::vector<std::pair<std::string, Containers::Array<char>>> MagnumFontConverter
 }
 
 }}
+
+CORRADE_PLUGIN_REGISTER(MagnumFontConverter, Magnum::Text::MagnumFontConverter,
+    "cz.mosra.magnum.Text.AbstractFontConverter/0.1.2")

src/MagnumPlugins/MagnumFontConverter/MagnumFontConverter.h

@@ -35,7 +35,7 @@
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 #ifndef MAGNUM_MAGNUMFONTCONVERTER_BUILD_STATIC
-    #if defined(MagnumFontConverter_EXPORTS) || defined(MagnumFontConverterObjects_EXPORTS)
+    #ifdef MagnumFontConverter_EXPORTS
         #define MAGNUM_MAGNUMFONTCONVERTER_EXPORT CORRADE_VISIBILITY_EXPORT
     #else
         #define MAGNUM_MAGNUMFONTCONVERTER_EXPORT CORRADE_VISIBILITY_IMPORT

src/MagnumPlugins/MagnumFontConverter/Test/CMakeLists.txt

@@ -23,19 +23,37 @@
 #   DEALINGS IN THE SOFTWARE.
 #
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
-               ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+# CMake before 3.8 has broken $<TARGET_FILE*> expressions for iOS (see
+# https://gitlab.kitware.com/cmake/cmake/merge_requests/404) and since Corrade
+# doesn't support dynamic plugins on iOS, this sorta works around that. Should
+# be revisited when updating Travis to newer Xcode (current has CMake 3.6).
+if(NOT BUILD_PLUGINS_STATIC)
+    set(MAGNUMFONTCONVERTER_PLUGIN_FILENAME $<TARGET_FILE:MagnumFontConverter>)
+    set(TGAIMAGECONVERTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImageConverter>)
+    if(WITH_TGAIMPORTER)
+        set(TGAIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
+    endif()
 
-corrade_add_test(MagnumFontConverterGLTest MagnumFontConverterGLTest.cpp LIBRARIES
-    MagnumMagnumFontConverterTestLib
-    MagnumTgaImporterTestLib
-    MagnumOpenGLTester)
-set_target_properties(MagnumFontConverterGLTest PROPERTIES FOLDER "MagnumPlugins/MagnumFontConverter/Test")
-target_include_directories(MagnumFontConverterGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-# On Win32 we need to avoid dllimporting TgaImporter symbols, because it would
-# search for the symbols in some DLL even though they were linked statically.
-# However it apparently doesn't matter that they were dllexported when building
-# the static library. EH.
-if(WIN32)
-    target_compile_definitions(MagnumFontConverterGLTest PRIVATE "MAGNUM_TGAIMPORTER_BUILD_STATIC")
+    # First replace ${} variables, then $<> generator expressions
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+    file(GENERATE OUTPUT $<TARGET_FILE_DIR:MagnumFontConverterGLTest>/configure.h
+        INPUT ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+else()
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+endif()
+
+corrade_add_test(MagnumFontConverterGLTest MagnumFontConverterGLTest.cpp
+    LIBRARIES MagnumText MagnumOpenGLTester)
+if(NOT BUILD_PLUGINS_STATIC)
+    target_include_directories(MagnumFontConverterGLTest PRIVATE $<TARGET_FILE_DIR:MagnumFontConverterGLTest>)
+else()
+    target_include_directories(MagnumFontConverterGLTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+    target_link_libraries(MagnumFontConverterGLTest PRIVATE
+        MagnumFontConverter) # TgaImageConverter should get linked transitively
+    if(WITH_TGAIMPORTER)
+        target_link_libraries(MagnumFontConverterGLTest PRIVATE TgaImporter)
+    endif()
 endif()
+set_target_properties(MagnumFontConverterGLTest PROPERTIES FOLDER "MagnumPlugins/MagnumFontConverter/Test")

src/MagnumPlugins/MagnumFontConverter/Test/MagnumFontConverterGLTest.cpp

@@ -33,11 +33,11 @@
 #include "Magnum/OpenGLTester.h"
 #include "Magnum/Text/GlyphCache.h"
 #include "Magnum/Text/AbstractFont.h"
+#include "Magnum/Text/AbstractFontConverter.h"
+#include "Magnum/Trade/AbstractImageConverter.h"
+#include "Magnum/Trade/AbstractImporter.h"
 #include "Magnum/Trade/ImageData.h"
-#include "MagnumPlugins/MagnumFontConverter/MagnumFontConverter.h"
-#include "MagnumPlugins/TgaImporter/TgaImporter.h"
 
-#include "../../MagnumFont/Test/configure.h"
 #include "configure.h"
 
 namespace Magnum { namespace Text { namespace Test {
@@ -46,10 +46,26 @@ struct MagnumFontConverterGLTest: OpenGLTester {
     explicit MagnumFontConverterGLTest();
 
     void exportFont();
+
+    /* Explicitly forbid system-wide plugin dependencies */
+    PluginManager::Manager<Trade::AbstractImageConverter> _imageConverterManager{"nonexistent"};
+    PluginManager::Manager<AbstractFontConverter> _fontConverterManager{"nonexistent"};
+    PluginManager::Manager<Trade::AbstractImporter> _importerManager{"nonexistent"};
 };
 
 MagnumFontConverterGLTest::MagnumFontConverterGLTest() {
     addTests({&MagnumFontConverterGLTest::exportFont});
+
+    /* Load the plugins directly from the build tree. Otherwise they are static
+       and already loaded. */
+    #if defined(TGAIMAGECONVERTER_PLUGIN_FILENAME) && defined(MAGNUMFONTCONVERTER_PLUGIN_FILENAME)
+    CORRADE_INTERNAL_ASSERT(_imageConverterManager.load(TGAIMAGECONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    CORRADE_INTERNAL_ASSERT(_fontConverterManager.load(MAGNUMFONTCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
+    /* Optional plugins that don't have to be here */
+    #ifdef TGAIMPORTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_importerManager.load(TGAIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
 }
 
 void MagnumFontConverterGLTest::exportFont() {
@@ -102,8 +118,8 @@ void MagnumFontConverterGLTest::exportFont() {
     cache.insert(font.glyphId(U'e'), {25, 12}, {{16, 4}, {64, 32}});
 
     /* Convert the file */
-    MagnumFontConverter converter;
-    converter.exportFontToFile(font, cache, Utility::Directory::join(MAGNUMFONTCONVERTER_TEST_WRITE_DIR, "font"), "Wave");
+    std::unique_ptr<AbstractFontConverter> converter = _fontConverterManager.instantiate("MagnumFontConverter");
+    converter->exportFontToFile(font, cache, Utility::Directory::join(MAGNUMFONTCONVERTER_TEST_WRITE_DIR, "font"), "Wave");
 
     /* Verify font parameters */
     /** @todo This might behave differently elsewhere due to unspecified order of glyphs in cache */
@@ -111,10 +127,13 @@ void MagnumFontConverterGLTest::exportFont() {
                        Utility::Directory::join(MAGNUMFONT_TEST_DIR, "font.conf"),
                        TestSuite::Compare::File);
 
+    if(!(_importerManager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
+        CORRADE_SKIP("TgaImporter plugin not enabled, not testing glyph cache contents");
+
     /* Verify font image, no need to test image contents, as the image is garbage anyway */
-    Trade::TgaImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(MAGNUMFONTCONVERTER_TEST_WRITE_DIR, "font.tga")));
-    Containers::Optional<Trade::ImageData2D> image = importer.image2D(0);
+    std::unique_ptr<Trade::AbstractImporter> importer = _importerManager.instantiate("TgaImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(MAGNUMFONTCONVERTER_TEST_WRITE_DIR, "font.tga")));
+    Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
     CORRADE_VERIFY(image);
     CORRADE_COMPARE(image->size(), Vector2i(256));
     CORRADE_COMPARE(image->format(), PixelFormat::Red);

src/MagnumPlugins/MagnumFontConverter/Test/configure.h.cmake

@@ -23,4 +23,8 @@
     DEALINGS IN THE SOFTWARE.
 */
 
+#cmakedefine MAGNUMFONTCONVERTER_PLUGIN_FILENAME "${MAGNUMFONTCONVERTER_PLUGIN_FILENAME}"
+#cmakedefine TGAIMAGECONVERTER_PLUGIN_FILENAME "${TGAIMAGECONVERTER_PLUGIN_FILENAME}"
+#cmakedefine TGAIMPORTER_PLUGIN_FILENAME "${TGAIMPORTER_PLUGIN_FILENAME}"
 #define MAGNUMFONTCONVERTER_TEST_WRITE_DIR "${CMAKE_CURRENT_BINARY_DIR}"
+#define MAGNUMFONT_TEST_DIR "${PROJECT_SOURCE_DIR}/src/MagnumPlugins/MagnumFont/Test"

src/MagnumPlugins/MagnumFontConverter/pluginRegistration.cpp

@@ -1,31 +0,0 @@
-/*
-    This file is part of Magnum.
-
-    Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018
-              Vladimír Vondruš <mosra@centrum.cz>
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom the
-    Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included
-    in all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-    DEALINGS IN THE SOFTWARE.
-*/
-
-#include <Corrade/PluginManager/AbstractManager.h>
-
-#include "MagnumPlugins/MagnumFontConverter/MagnumFontConverter.h"
-
-CORRADE_PLUGIN_REGISTER(MagnumFontConverter, Magnum::Text::MagnumFontConverter,
-    "cz.mosra.magnum.Text.AbstractFontConverter/0.1.2")

src/MagnumPlugins/ObjImporter/CMakeLists.txt

@@ -30,39 +30,20 @@ endif()
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
                ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
 
-set(ObjImporter_SRCS
-    ObjImporter.cpp)
-
-set(ObjImporter_HEADERS
-    ObjImporter.h)
-
-# Objects shared between plugin and test library
-add_library(ObjImporterObjects OBJECT
-    ${ObjImporter_SRCS}
-    ${ObjImporter_HEADERS})
-target_include_directories(ObjImporterObjects PUBLIC $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
-if(NOT BUILD_PLUGINS_STATIC)
-    target_compile_definitions(ObjImporterObjects PRIVATE "ObjImporterObjects_EXPORTS")
-endif()
-if(NOT BUILD_PLUGINS_STATIC OR BUILD_STATIC_PIC)
-    set_target_properties(ObjImporterObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
-endif()
-set_target_properties(ObjImporterObjects PROPERTIES FOLDER "MagnumPlugins/ObjImporter")
-
 # ObjImporter plugin
 add_plugin(ObjImporter
     "${MAGNUM_PLUGINS_IMPORTER_DEBUG_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_IMPORTER_DEBUG_LIBRARY_INSTALL_DIR}"
     "${MAGNUM_PLUGINS_IMPORTER_RELEASE_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_IMPORTER_RELEASE_LIBRARY_INSTALL_DIR}"
     ObjImporter.conf
-    $<TARGET_OBJECTS:ObjImporterObjects>
-    pluginRegistration.cpp)
-if(BUILD_STATIC_PIC)
+    ObjImporter.cpp
+    ObjImporter.h)
+if(BUILD_PLUGINS_STATIC AND BUILD_STATIC_PIC)
     set_target_properties(ObjImporter PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif()
-target_link_libraries(ObjImporter Magnum MagnumMeshTools)
+target_link_libraries(ObjImporter PUBLIC Magnum MagnumMeshTools)
 
-install(FILES ${ObjImporter_HEADERS} DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/ObjImporter)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/configure.h DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/ObjImporter)
+install(FILES ObjImporter.h ${CMAKE_CURRENT_BINARY_DIR}/configure.h
+    DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/ObjImporter)
 
 # Automatic static plugin import
 if(BUILD_PLUGINS_STATIC)
@@ -73,12 +54,6 @@ if(BUILD_PLUGINS_STATIC)
 endif()
 
 if(BUILD_TESTS)
-    add_library(MagnumObjImporterTestLib STATIC
-        $<TARGET_OBJECTS:ObjImporterObjects>
-        ${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details
-    set_target_properties(MagnumObjImporterTestLib PROPERTIES FOLDER "MagnumPlugins/ObjImporter")
-    target_link_libraries(MagnumObjImporterTestLib Magnum MagnumMeshTools)
-
     add_subdirectory(Test)
 endif()
 

src/MagnumPlugins/ObjImporter/ObjImporter.cpp

@@ -444,3 +444,6 @@ Containers::Optional<MeshData3D> ObjImporter::doMesh3D(UnsignedInt id) {
 }
 
 }}
+
+CORRADE_PLUGIN_REGISTER(ObjImporter, Magnum::Trade::ObjImporter,
+    "cz.mosra.magnum.Trade.AbstractImporter/0.3")

src/MagnumPlugins/ObjImporter/ObjImporter.h

@@ -35,7 +35,7 @@
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 #ifndef MAGNUM_OBJIMPORTER_BUILD_STATIC
-    #if defined(ObjImporter_EXPORTS) || defined(ObjImporterObjects_EXPORTS)
+    #ifdef ObjImporter_EXPORTS
         #define MAGNUM_OBJIMPORTER_EXPORT CORRADE_VISIBILITY_EXPORT
     #else
         #define MAGNUM_OBJIMPORTER_EXPORT CORRADE_VISIBILITY_IMPORT

src/MagnumPlugins/ObjImporter/Test/CMakeLists.txt

@@ -29,11 +29,25 @@ else()
     set(OBJIMPORTER_TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 endif()
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
-               ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+# CMake before 3.8 has broken $<TARGET_FILE*> expressions for iOS (see
+# https://gitlab.kitware.com/cmake/cmake/merge_requests/404) and since Corrade
+# doesn't support dynamic plugins on iOS, this sorta works around that. Should
+# be revisited when updating Travis to newer Xcode (current has CMake 3.6).
+if(NOT BUILD_PLUGINS_STATIC)
+    set(OBJIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:ObjImporter>)
+
+    # First replace ${} variables, then $<> generator expressions
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+    file(GENERATE OUTPUT $<TARGET_FILE_DIR:ObjImporterTest>/configure.h
+        INPUT ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+else()
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+endif()
 
 corrade_add_test(ObjImporterTest Test.cpp
-    LIBRARIES MagnumObjImporterTestLib
+    LIBRARIES Magnum
     FILES
         emptyFile.obj
         keywords.obj
@@ -52,12 +66,10 @@ corrade_add_test(ObjImporterTest Test.cpp
         wrongIndexCount.obj
         wrongNumberCount.obj
         wrongNumbers.obj)
-target_include_directories(ObjImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-set_target_properties(ObjImporterTest PROPERTIES FOLDER "MagnumPlugins/ObjImporter/Test")
-# On Win32 we need to avoid dllimporting ObjImporter symbols, because it would
-# search for the symbols in some DLL even though they were linked statically.
-# However it apparently doesn't matter that they were dllexported when building
-# the static library. EH.
-if(WIN32)
-    target_compile_definitions(ObjImporterTest PRIVATE "MAGNUM_OBJIMPORTER_BUILD_STATIC")
+if(NOT BUILD_PLUGINS_STATIC)
+    target_include_directories(ObjImporterTest PRIVATE $<TARGET_FILE_DIR:ObjImporterTest>)
+else()
+    target_include_directories(ObjImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+    target_link_libraries(ObjImporterTest PRIVATE ObjImporter)
 endif()
+set_target_properties(ObjImporterTest PROPERTIES FOLDER "MagnumPlugins/ObjImporter/Test")

src/MagnumPlugins/ObjImporter/Test/Test.cpp

@@ -29,8 +29,8 @@
 
 #include "Magnum/Mesh.h"
 #include "Magnum/Math/Vector3.h"
+#include "Magnum/Trade/AbstractImporter.h"
 #include "Magnum/Trade/MeshData3D.h"
-#include "MagnumPlugins/ObjImporter/ObjImporter.h"
 
 #include "configure.h"
 
@@ -88,6 +88,9 @@ struct ObjImporterTest: TestSuite::Tester {
 
     void unsupportedKeyword();
     void unknownKeyword();
+
+    /* Explicitly forbid system-wide plugin dependencies */
+    PluginManager::Manager<AbstractImporter> _manager{"nonexistent"};
 };
 
 ObjImporterTest::ObjImporterTest() {
@@ -139,14 +142,18 @@ ObjImporterTest::ObjImporterTest() {
 
               &ObjImporterTest::unsupportedKeyword,
               &ObjImporterTest::unknownKeyword});
+
+    #ifdef OBJIMPORTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_manager.load(OBJIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
 }
 
 void ObjImporterTest::pointMesh() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "pointMesh.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 1);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "pointMesh.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
-    const Containers::Optional<MeshData3D> data = importer.mesh3D(0);
+    const Containers::Optional<MeshData3D> data = importer->mesh3D(0);
     CORRADE_VERIFY(data);
     CORRADE_COMPARE(data->primitive(), MeshPrimitive::Points);
     CORRADE_COMPARE(data->positionArrayCount(), 1);
@@ -161,11 +168,11 @@ void ObjImporterTest::pointMesh() {
 }
 
 void ObjImporterTest::lineMesh() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "lineMesh.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 1);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "lineMesh.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
-    const Containers::Optional<MeshData3D> data = importer.mesh3D(0);
+    const Containers::Optional<MeshData3D> data = importer->mesh3D(0);
     CORRADE_VERIFY(data);
     CORRADE_COMPARE(data->primitive(), MeshPrimitive::Lines);
     CORRADE_COMPARE(data->positionArrayCount(), 1);
@@ -180,11 +187,11 @@ void ObjImporterTest::lineMesh() {
 }
 
 void ObjImporterTest::triangleMesh() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "triangleMesh.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 1);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "triangleMesh.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
-    const Containers::Optional<MeshData3D> data = importer.mesh3D(0);
+    const Containers::Optional<MeshData3D> data = importer->mesh3D(0);
     CORRADE_VERIFY(data);
     CORRADE_COMPARE(data->primitive(), MeshPrimitive::Triangles);
     CORRADE_COMPARE(data->positionArrayCount(), 1);
@@ -200,22 +207,22 @@ void ObjImporterTest::triangleMesh() {
 }
 
 void ObjImporterTest::mixedPrimitives() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "mixedPrimitives.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 1);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "mixedPrimitives.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(0));
+    CORRADE_VERIFY(!importer->mesh3D(0));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): mixed primitive MeshPrimitive::Points and MeshPrimitive::Lines\n");
 }
 
 void ObjImporterTest::positionsOnly() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "triangleMesh.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 1);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "triangleMesh.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
-    const Containers::Optional<MeshData3D> data = importer.mesh3D(0);
+    const Containers::Optional<MeshData3D> data = importer->mesh3D(0);
     CORRADE_VERIFY(data);
     CORRADE_COMPARE(data->positionArrayCount(), 1);
     CORRADE_VERIFY(!data->hasNormals());
@@ -223,11 +230,11 @@ void ObjImporterTest::positionsOnly() {
 }
 
 void ObjImporterTest::textureCoordinates() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "textureCoordinates.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 1);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "textureCoordinates.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
-    const Containers::Optional<MeshData3D> data = importer.mesh3D(0);
+    const Containers::Optional<MeshData3D> data = importer->mesh3D(0);
     CORRADE_VERIFY(data);
     CORRADE_COMPARE(data->primitive(), MeshPrimitive::Lines);
     CORRADE_COMPARE(data->positionArrayCount(), 1);
@@ -251,11 +258,11 @@ void ObjImporterTest::textureCoordinates() {
 }
 
 void ObjImporterTest::normals() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "normals.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 1);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "normals.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
-    const Containers::Optional<MeshData3D> data = importer.mesh3D(0);
+    const Containers::Optional<MeshData3D> data = importer->mesh3D(0);
     CORRADE_VERIFY(data);
     CORRADE_COMPARE(data->primitive(), MeshPrimitive::Lines);
     CORRADE_COMPARE(data->positionArrayCount(), 1);
@@ -279,11 +286,11 @@ void ObjImporterTest::normals() {
 }
 
 void ObjImporterTest::textureCoordinatesNormals() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "textureCoordinatesNormals.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 1);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "textureCoordinatesNormals.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
-    const Containers::Optional<MeshData3D> data = importer.mesh3D(0);
+    const Containers::Optional<MeshData3D> data = importer->mesh3D(0);
     CORRADE_VERIFY(data);
     CORRADE_COMPARE(data->primitive(), MeshPrimitive::Lines);
     CORRADE_COMPARE(data->positionArrayCount(), 1);
@@ -316,35 +323,35 @@ void ObjImporterTest::textureCoordinatesNormals() {
 }
 
 void ObjImporterTest::emptyFile() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "emptyFile.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 1);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "emptyFile.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 1);
 }
 
 void ObjImporterTest::unnamedMesh() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "emptyFile.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 1);
-    CORRADE_COMPARE(importer.mesh3DName(0), "");
-    CORRADE_COMPARE(importer.mesh3DForName(""), -1);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "emptyFile.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 1);
+    CORRADE_COMPARE(importer->mesh3DName(0), "");
+    CORRADE_COMPARE(importer->mesh3DForName(""), -1);
 }
 
 void ObjImporterTest::namedMesh() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "namedMesh.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 1);
-    CORRADE_COMPARE(importer.mesh3DName(0), "MyMesh");
-    CORRADE_COMPARE(importer.mesh3DForName("MyMesh"), 0);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "namedMesh.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 1);
+    CORRADE_COMPARE(importer->mesh3DName(0), "MyMesh");
+    CORRADE_COMPARE(importer->mesh3DForName("MyMesh"), 0);
 }
 
 void ObjImporterTest::moreMeshes() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "moreMeshes.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 3);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "moreMeshes.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 3);
 
-    CORRADE_COMPARE(importer.mesh3DName(0), "PointMesh");
-    CORRADE_COMPARE(importer.mesh3DForName("PointMesh"), 0);
-    const Containers::Optional<MeshData3D> data = importer.mesh3D(0);
+    CORRADE_COMPARE(importer->mesh3DName(0), "PointMesh");
+    CORRADE_COMPARE(importer->mesh3DForName("PointMesh"), 0);
+    const Containers::Optional<MeshData3D> data = importer->mesh3D(0);
     CORRADE_VERIFY(data);
     CORRADE_COMPARE(data->primitive(), MeshPrimitive::Points);
     CORRADE_COMPARE(data->positionArrayCount(), 1);
@@ -356,9 +363,9 @@ void ObjImporterTest::moreMeshes() {
         0, 1
     }));
 
-    CORRADE_COMPARE(importer.mesh3DName(1), "LineMesh");
-    CORRADE_COMPARE(importer.mesh3DForName("LineMesh"), 1);
-    const Containers::Optional<MeshData3D> data1 = importer.mesh3D(1);
+    CORRADE_COMPARE(importer->mesh3DName(1), "LineMesh");
+    CORRADE_COMPARE(importer->mesh3DForName("LineMesh"), 1);
+    const Containers::Optional<MeshData3D> data1 = importer->mesh3D(1);
     CORRADE_VERIFY(data1);
     CORRADE_COMPARE(data1->primitive(), MeshPrimitive::Lines);
     CORRADE_COMPARE(data1->positionArrayCount(), 1);
@@ -370,9 +377,9 @@ void ObjImporterTest::moreMeshes() {
         0, 1, 1, 0
     }));
 
-    CORRADE_COMPARE(importer.mesh3DName(2), "TriangleMesh");
-    CORRADE_COMPARE(importer.mesh3DForName("TriangleMesh"), 2);
-    const Containers::Optional<MeshData3D> data2 = importer.mesh3D(2);
+    CORRADE_COMPARE(importer->mesh3DName(2), "TriangleMesh");
+    CORRADE_COMPARE(importer->mesh3DForName("TriangleMesh"), 2);
+    const Containers::Optional<MeshData3D> data2 = importer->mesh3D(2);
     CORRADE_VERIFY(data2);
     CORRADE_COMPARE(data2->primitive(), MeshPrimitive::Triangles);
     CORRADE_COMPARE(data2->positionArrayCount(), 1);
@@ -387,84 +394,84 @@ void ObjImporterTest::moreMeshes() {
 }
 
 void ObjImporterTest::unnamedFirstMesh() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "unnamedFirstMesh.obj")));
-    CORRADE_COMPARE(importer.mesh3DCount(), 2);
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "unnamedFirstMesh.obj")));
+    CORRADE_COMPARE(importer->mesh3DCount(), 2);
 
-    CORRADE_COMPARE(importer.mesh3DName(0), "");
-    CORRADE_COMPARE(importer.mesh3DForName(""), -1);
+    CORRADE_COMPARE(importer->mesh3DName(0), "");
+    CORRADE_COMPARE(importer->mesh3DForName(""), -1);
 
-    CORRADE_COMPARE(importer.mesh3DName(1), "SecondMesh");
-    CORRADE_COMPARE(importer.mesh3DForName("SecondMesh"), 1);
+    CORRADE_COMPARE(importer->mesh3DName(1), "SecondMesh");
+    CORRADE_COMPARE(importer->mesh3DForName("SecondMesh"), 1);
 }
 
 void ObjImporterTest::wrongFloat() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
-    const Int id = importer.mesh3DForName("WrongFloat");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
+    const Int id = importer->mesh3DForName("WrongFloat");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): error while converting numeric data\n");
 }
 
 void ObjImporterTest::wrongInteger() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
-    const Int id = importer.mesh3DForName("WrongInteger");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
+    const Int id = importer->mesh3DForName("WrongInteger");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): error while converting numeric data\n");
 }
 
 void ObjImporterTest::unmergedIndexOutOfRange() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
-    const Int id = importer.mesh3DForName("PositionIndexOutOfRange");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
+    const Int id = importer->mesh3DForName("PositionIndexOutOfRange");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): index out of range\n");
 }
 
 void ObjImporterTest::mergedIndexOutOfRange() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
-    const Int id = importer.mesh3DForName("TextureIndexOutOfRange");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
+    const Int id = importer->mesh3DForName("TextureIndexOutOfRange");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): index out of range\n");
 }
 
 void ObjImporterTest::zeroIndex() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
-    const Int id = importer.mesh3DForName("ZeroIndex");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
+    const Int id = importer->mesh3DForName("ZeroIndex");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): index out of range\n");
 }
 
 void ObjImporterTest::explicitOptionalPositionCoordinate() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
-    const Int id = importer.mesh3DForName("SupportedPositionW");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
+    const Int id = importer->mesh3DForName("SupportedPositionW");
     CORRADE_VERIFY(id > -1);
 
-    const Containers::Optional<MeshData3D> data = importer.mesh3D(id);
+    const Containers::Optional<MeshData3D> data = importer->mesh3D(id);
     CORRADE_VERIFY(data);
     CORRADE_COMPARE(data->positionArrayCount(), 1);
     CORRADE_COMPARE(data->positions(0), (std::vector<Vector3>{
@@ -473,12 +480,12 @@ void ObjImporterTest::explicitOptionalPositionCoordinate() {
 }
 
 void ObjImporterTest::explicitOptionalTextureCoordinate() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
-    const Int id = importer.mesh3DForName("SupportedTextureW");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
+    const Int id = importer->mesh3DForName("SupportedTextureW");
     CORRADE_VERIFY(id > -1);
 
-    const Containers::Optional<MeshData3D> data = importer.mesh3D(id);
+    const Containers::Optional<MeshData3D> data = importer->mesh3D(id);
     CORRADE_VERIFY(data);
     CORRADE_COMPARE(data->textureCoords2DArrayCount(), 1);
     CORRADE_COMPARE(data->textureCoords2D(0), (std::vector<Vector2>{
@@ -487,229 +494,229 @@ void ObjImporterTest::explicitOptionalTextureCoordinate() {
 }
 
 void ObjImporterTest::unsupportedOptionalPositionCoordinate() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
-    const Int id = importer.mesh3DForName("UnsupportedPositionW");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
+    const Int id = importer->mesh3DForName("UnsupportedPositionW");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): homogeneous coordinates are not supported\n");
 }
 
 void ObjImporterTest::unsupportedOptionalTextureCoordinate() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
-    const Int id = importer.mesh3DForName("UnsupportedTextureW");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
+    const Int id = importer->mesh3DForName("UnsupportedTextureW");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): 3D texture coordinates are not supported\n");
 }
 
 void ObjImporterTest::shortFloatData() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer.mesh3DForName("ShortFloat");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    const Int id = importer->mesh3DForName("ShortFloat");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): invalid float array size\n");
 }
 
 void ObjImporterTest::longFloatData() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer.mesh3DForName("LongFloat");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    const Int id = importer->mesh3DForName("LongFloat");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): invalid float array size\n");
 }
 
 void ObjImporterTest::longOptionalFloatData() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer.mesh3DForName("LongOptionalFloat");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    const Int id = importer->mesh3DForName("LongOptionalFloat");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): invalid float array size\n");
 }
 
 void ObjImporterTest::longIndexData() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer.mesh3DForName("InvalidIndices");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    const Int id = importer->mesh3DForName("InvalidIndices");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): invalid index data\n");
 }
 
 void ObjImporterTest::wrongPointIndexData() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer.mesh3DForName("WrongPointIndices");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    const Int id = importer->mesh3DForName("WrongPointIndices");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): wrong index count for point\n");
 }
 
 void ObjImporterTest::wrongLineIndexData() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer.mesh3DForName("WrongLineIndices");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    const Int id = importer->mesh3DForName("WrongLineIndices");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): wrong index count for line\n");
 }
 
 void ObjImporterTest::wrongTriangleIndexData() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer.mesh3DForName("WrongTriangleIndices");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    const Int id = importer->mesh3DForName("WrongTriangleIndices");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): wrong index count for triangle\n");
 }
 
 void ObjImporterTest::polygonIndexData() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
-    const Int id = importer.mesh3DForName("PolygonIndices");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
+    const Int id = importer->mesh3DForName("PolygonIndices");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): polygons are not supported\n");
 }
 
 void ObjImporterTest::missingPositionData() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
-    const Int id = importer.mesh3DForName("MissingPositionData");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
+    const Int id = importer->mesh3DForName("MissingPositionData");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): incomplete position data\n");
 }
 
 void ObjImporterTest::missingPositionIndices() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
-    const Int id = importer.mesh3DForName("MissingPositionIndices");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
+    const Int id = importer->mesh3DForName("MissingPositionIndices");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): incomplete position data\n");
 }
 
 void ObjImporterTest::missingNormalData() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
-    const Int id = importer.mesh3DForName("MissingNormalData");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
+    const Int id = importer->mesh3DForName("MissingNormalData");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): incomplete normal data\n");
 }
 
 void ObjImporterTest::missingNormalIndices() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
-    const Int id = importer.mesh3DForName("MissingNormalIndices");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
+    const Int id = importer->mesh3DForName("MissingNormalIndices");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): incomplete normal data\n");
 }
 
 void ObjImporterTest::missingTextureCoordinateData() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
-    const Int id = importer.mesh3DForName("MissingTextureData");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
+    const Int id = importer->mesh3DForName("MissingTextureData");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): incomplete texture coordinate data\n");
 }
 
 void ObjImporterTest::missingTextureCoordinateIndices() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
-    const Int id = importer.mesh3DForName("MissingTextureIndices");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
+    const Int id = importer->mesh3DForName("MissingTextureIndices");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): incomplete texture coordinate data\n");
 }
 
 void ObjImporterTest::wrongNormalIndexCount() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongIndexCount.obj")));
-    const Int id = importer.mesh3DForName("ShortNormalIndices");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongIndexCount.obj")));
+    const Int id = importer->mesh3DForName("ShortNormalIndices");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): some normal indices are missing\n");
 }
 
 void ObjImporterTest::wrongTextureCoordinateIndexCount() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongIndexCount.obj")));
-    const Int id = importer.mesh3DForName("ShortTextureIndices");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongIndexCount.obj")));
+    const Int id = importer->mesh3DForName("ShortTextureIndices");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): some texture coordinate indices are missing\n");
 }
 
 void ObjImporterTest::unsupportedKeyword() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "keywords.obj")));
-    const Int id = importer.mesh3DForName("UnsupportedKeyword");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "keywords.obj")));
+    const Int id = importer->mesh3DForName("UnsupportedKeyword");
     CORRADE_VERIFY(id > -1);
 
     /* Everything should be parsed properly */
-    const Containers::Optional<MeshData3D> data = importer.mesh3D(id);
+    const Containers::Optional<MeshData3D> data = importer->mesh3D(id);
     CORRADE_VERIFY(data);
     CORRADE_COMPARE(data->primitive(), MeshPrimitive::Points);
     CORRADE_COMPARE(data->positionArrayCount(), 1);
@@ -720,14 +727,14 @@ void ObjImporterTest::unsupportedKeyword() {
 }
 
 void ObjImporterTest::unknownKeyword() {
-    ObjImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "keywords.obj")));
-    const Int id = importer.mesh3DForName("UnknownKeyword");
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "keywords.obj")));
+    const Int id = importer->mesh3DForName("UnknownKeyword");
     CORRADE_VERIFY(id > -1);
 
     std::ostringstream out;
     Error redirectError{&out};
-    CORRADE_VERIFY(!importer.mesh3D(id));
+    CORRADE_VERIFY(!importer->mesh3D(id));
     CORRADE_COMPARE(out.str(), "Trade::ObjImporter::mesh3D(): unknown keyword bleh\n");
 }
 

src/MagnumPlugins/ObjImporter/Test/configure.h.cmake

@@ -23,4 +23,5 @@
     DEALINGS IN THE SOFTWARE.
 */
 
+#cmakedefine OBJIMPORTER_PLUGIN_FILENAME "${OBJIMPORTER_PLUGIN_FILENAME}"
 #define OBJIMPORTER_TEST_DIR "${OBJIMPORTER_TEST_DIR}"

src/MagnumPlugins/TgaImageConverter/CMakeLists.txt

@@ -30,38 +30,19 @@ endif()
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
                ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
 
-set(TgaImageConverter_SRCS
-    TgaImageConverter.cpp)
-
-set(TgaImageConverter_HEADERS
-    TgaImageConverter.h)
-
-# Objects shared between plugin and test library
-add_library(TgaImageConverterObjects OBJECT
-    ${TgaImageConverter_SRCS}
-    ${TgaImageConverter_HEADERS})
-target_include_directories(TgaImageConverterObjects PUBLIC $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
-if(NOT BUILD_PLUGINS_STATIC)
-    target_compile_definitions(TgaImageConverterObjects PRIVATE "TgaImageConverterObjects_EXPORTS")
-endif()
-if(NOT BUILD_PLUGINS_STATIC OR BUILD_STATIC_PIC)
-    set_target_properties(TgaImageConverterObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
-endif()
-set_target_properties(TgaImageConverterObjects PROPERTIES FOLDER "MagnumPlugins/TgaImageConverter")
-
 # TgaImageConverter plugin
 add_plugin(TgaImageConverter
     "${MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_LIBRARY_INSTALL_DIR}"
     "${MAGNUM_PLUGINS_IMAGECONVERTER_RELEASE_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_IMAGECONVERTER_RELEASE_LIBRARY_INSTALL_DIR}"
     TgaImageConverter.conf
-    $<TARGET_OBJECTS:TgaImageConverterObjects>
-    pluginRegistration.cpp)
-if(BUILD_STATIC_PIC)
+    TgaImageConverter.cpp
+    TgaImageConverter.h)
+if(BUILD_PLUGINS_STATIC AND BUILD_STATIC_PIC)
     set_target_properties(TgaImageConverter PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif()
-target_link_libraries(TgaImageConverter Magnum)
+target_link_libraries(TgaImageConverter PUBLIC Magnum)
 
-install(FILES ${TgaImageConverter_HEADERS} DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/TgaImageConverter)
+install(FILES TgaImageConverter.h DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/TgaImageConverter)
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/configure.h DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/TgaImageConverter)
 
 # Automatic static plugin import
@@ -73,12 +54,6 @@ if(BUILD_PLUGINS_STATIC)
 endif()
 
 if(BUILD_TESTS)
-    add_library(MagnumTgaImageConverterTestLib STATIC
-        $<TARGET_OBJECTS:TgaImageConverterObjects>
-        ${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details
-    set_target_properties(MagnumTgaImageConverterTestLib PROPERTIES FOLDER "MagnumPlugins/TgaImageConverter")
-    target_link_libraries(MagnumTgaImageConverterTestLib Magnum)
-
     add_subdirectory(Test)
 endif()
 

src/MagnumPlugins/TgaImageConverter/Test/CMakeLists.txt

@@ -23,14 +23,34 @@
 #   DEALINGS IN THE SOFTWARE.
 #
 
-corrade_add_test(TgaImageConverterTest TgaImageConverterTest.cpp LIBRARIES MagnumTgaImageConverterTestLib MagnumTgaImporterTestLib)
-set_target_properties(TgaImageConverterTest PROPERTIES FOLDER "MagnumPlugins/TgaImageConverter/Test")
-# On Win32 we need to avoid dllimporting TgaImporter and TgaImageConverterTest
-# symbols, because it would search for the symbols in some DLL even though they
-# were linked statically. However it apparently doesn't matter that they were
-# dllexported when building the static library. EH.
-if(WIN32)
-    target_compile_definitions(TgaImageConverterTest PRIVATE
-        "MAGNUM_TGAIMAGECONVERTER_BUILD_STATIC"
-        "MAGNUM_TGAIMPORTER_BUILD_STATIC")
+# CMake before 3.8 has broken $<TARGET_FILE*> expressions for iOS (see
+# https://gitlab.kitware.com/cmake/cmake/merge_requests/404) and since Corrade
+# doesn't support dynamic plugins on iOS, this sorta works around that. Should
+# be revisited when updating Travis to newer Xcode (current has CMake 3.6).
+if(NOT BUILD_PLUGINS_STATIC)
+    set(TGAIMAGECONVERTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImageConverter>)
+    if(WITH_TGAIMPORTER)
+        set(TGAIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
+    endif()
+
+    # First replace ${} variables, then $<> generator expressions
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+    file(GENERATE OUTPUT $<TARGET_FILE_DIR:TgaImageConverterTest>/configure.h
+        INPUT ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+else()
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
 endif()
+
+corrade_add_test(TgaImageConverterTest TgaImageConverterTest.cpp LIBRARIES Magnum)
+if(NOT BUILD_PLUGINS_STATIC)
+    target_include_directories(TgaImageConverterTest PRIVATE $<TARGET_FILE_DIR:TgaImageConverterTest>)
+else()
+    target_include_directories(TgaImageConverterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+    target_link_libraries(TgaImageConverterTest PRIVATE TgaImageConverter)
+    if(WITH_TGAIMPORTER)
+        target_link_libraries(TgaImageConverterTest PRIVATE TgaImporter)
+    endif()
+endif()
+set_target_properties(TgaImageConverterTest PROPERTIES FOLDER "MagnumPlugins/TgaImageConverter/Test")

src/MagnumPlugins/TgaImageConverter/Test/TgaImageConverterTest.cpp

@@ -33,8 +33,10 @@
 #include "Magnum/Image.h"
 #include "Magnum/PixelFormat.h"
 #include "Magnum/Trade/ImageData.h"
-#include "MagnumPlugins/TgaImageConverter/TgaImageConverter.h"
-#include "MagnumPlugins/TgaImporter/TgaImporter.h"
+#include "Magnum/Trade/AbstractImageConverter.h"
+#include "Magnum/Trade/AbstractImporter.h"
+
+#include "configure.h"
 
 namespace Magnum { namespace Trade { namespace Test {
 
@@ -46,6 +48,10 @@ struct TgaImageConverterTest: TestSuite::Tester {
 
     void rgb();
     void rgba();
+
+    /* Explicitly forbid system-wide plugin dependencies */
+    PluginManager::Manager<AbstractImageConverter> _converterManager{"nonexistent"};
+    PluginManager::Manager<AbstractImporter> _importerManager{"nonexistent"};
 };
 
 namespace {
@@ -81,6 +87,16 @@ TgaImageConverterTest::TgaImageConverterTest() {
 
               &TgaImageConverterTest::rgb,
               &TgaImageConverterTest::rgba});
+
+    /* Load the plugin directly from the build tree. Otherwise it's static and
+       already loaded. */
+    #ifdef TGAIMAGECONVERTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_converterManager.load(TGAIMAGECONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
+    /* Optional plugins that don't have to be here */
+    #ifdef TGAIMPORTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_importerManager.load(TGAIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
 }
 
 void TgaImageConverterTest::wrongFormat() {
@@ -95,7 +111,8 @@ void TgaImageConverterTest::wrongFormat() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    const auto data = TgaImageConverter().exportToData(image);
+    std::unique_ptr<AbstractImageConverter> converter = _converterManager.instantiate("TgaImageConverter");
+    const auto data = converter->exportToData(image);
     CORRADE_VERIFY(!data);
     #if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
     CORRADE_COMPARE(out.str(), "Trade::TgaImageConverter::exportToData(): unsupported color format PixelFormat::RG\n");
@@ -116,17 +133,23 @@ void TgaImageConverterTest::wrongType() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    const auto data = TgaImageConverter().exportToData(image);
+    std::unique_ptr<AbstractImageConverter> converter = _converterManager.instantiate("TgaImageConverter");
+    const auto data = converter->exportToData(image);
     CORRADE_VERIFY(!data);
     CORRADE_COMPARE(out.str(), "Trade::TgaImageConverter::exportToData(): unsupported color type PixelType::Float\n");
 }
 
 void TgaImageConverterTest::rgb() {
-    const auto data = TgaImageConverter().exportToData(OriginalRGB);
+    std::unique_ptr<AbstractImageConverter> converter = _converterManager.instantiate("TgaImageConverter");
+    const auto data = converter->exportToData(OriginalRGB);
+    CORRADE_VERIFY(data);
+
+    if(!(_importerManager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
+        CORRADE_SKIP("TgaImporter plugin not enabled, can't test the result");
 
-    TgaImporter importer;
-    CORRADE_VERIFY(importer.openData(data));
-    Containers::Optional<Trade::ImageData2D> converted = importer.image2D(0);
+    std::unique_ptr<AbstractImporter> importer = _importerManager.instantiate("TgaImporter");
+    CORRADE_VERIFY(importer->openData(data));
+    Containers::Optional<Trade::ImageData2D> converted = importer->image2D(0);
     CORRADE_VERIFY(converted);
 
     CORRADE_COMPARE(converted->storage().alignment(), 1);
@@ -138,11 +161,16 @@ void TgaImageConverterTest::rgb() {
 }
 
 void TgaImageConverterTest::rgba() {
-    const auto data = TgaImageConverter().exportToData(OriginalRGBA);
+    std::unique_ptr<AbstractImageConverter> converter = _converterManager.instantiate("TgaImageConverter");
+    const auto data = converter->exportToData(OriginalRGBA);
+    CORRADE_VERIFY(data);
+
+    if(!(_importerManager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
+        CORRADE_SKIP("TgaImporter plugin not enabled, can't test the result");
 
-    TgaImporter importer;
-    CORRADE_VERIFY(importer.openData(data));
-    Containers::Optional<Trade::ImageData2D> converted = importer.image2D(0);
+    std::unique_ptr<AbstractImporter> importer = _importerManager.instantiate("TgaImporter");
+    CORRADE_VERIFY(importer->openData(data));
+    Containers::Optional<Trade::ImageData2D> converted = importer->image2D(0);
     CORRADE_VERIFY(converted);
 
     CORRADE_COMPARE(converted->storage().alignment(), 4);

src/MagnumPlugins/TgaImageConverter/Test/configure.h.cmake

@@ -23,7 +23,5 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#include "MagnumPlugins/ObjImporter/ObjImporter.h"
-
-CORRADE_PLUGIN_REGISTER(ObjImporter, Magnum::Trade::ObjImporter,
-    "cz.mosra.magnum.Trade.AbstractImporter/0.3")
+#cmakedefine TGAIMAGECONVERTER_PLUGIN_FILENAME "${TGAIMAGECONVERTER_PLUGIN_FILENAME}"
+#cmakedefine TGAIMPORTER_PLUGIN_FILENAME "${TGAIMPORTER_PLUGIN_FILENAME}"

src/MagnumPlugins/TgaImageConverter/TgaImageConverter.cpp

@@ -115,3 +115,6 @@ Containers::Array<char> TgaImageConverter::doExportToData(const ImageView2D& ima
 }
 
 }}
+
+CORRADE_PLUGIN_REGISTER(TgaImageConverter, Magnum::Trade::TgaImageConverter,
+    "cz.mosra.magnum.Trade.AbstractImageConverter/0.2.1")

src/MagnumPlugins/TgaImageConverter/pluginRegistration.cpp

@@ -1,29 +0,0 @@
-/*
-    This file is part of Magnum.
-
-    Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018
-              Vladimír Vondruš <mosra@centrum.cz>
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom the
-    Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included
-    in all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-    DEALINGS IN THE SOFTWARE.
-*/
-
-#include "MagnumPlugins/TgaImageConverter/TgaImageConverter.h"
-
-CORRADE_PLUGIN_REGISTER(TgaImageConverter, Magnum::Trade::TgaImageConverter,
-    "cz.mosra.magnum.Trade.AbstractImageConverter/0.2.1")

src/MagnumPlugins/TgaImporter/CMakeLists.txt

@@ -30,43 +30,21 @@ endif()
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
                ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
 
-set(TgaImporter_SRCS
-    TgaImporter.cpp)
-
-set(TgaImporter_HEADERS
-    TgaImporter.h)
-
-set(TgaImporter_PRIVATE_HEADERS
-    TgaHeader.h)
-
-# Objects shared between plugin and test library
-add_library(TgaImporterObjects OBJECT
-    ${TgaImporter_SRCS}
-    ${TgaImporter_HEADERS}
-    ${TgaImporter_PRIVATE_HEADERS})
-target_include_directories(TgaImporterObjects PUBLIC $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>)
-if(NOT BUILD_PLUGINS_STATIC)
-    target_compile_definitions(TgaImporterObjects PRIVATE "TgaImporterObjects_EXPORTS")
-endif()
-if(NOT BUILD_PLUGINS_STATIC OR BUILD_STATIC_PIC)
-    set_target_properties(TgaImporterObjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
-endif()
-set_target_properties(TgaImporterObjects PROPERTIES FOLDER "MagnumPlugins/TgaImporter")
-
 # TgaImporter plugin
 add_plugin(TgaImporter
     "${MAGNUM_PLUGINS_IMPORTER_DEBUG_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_IMPORTER_DEBUG_LIBRARY_INSTALL_DIR}"
     "${MAGNUM_PLUGINS_IMPORTER_RELEASE_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_IMPORTER_RELEASE_LIBRARY_INSTALL_DIR}"
     TgaImporter.conf
-    $<TARGET_OBJECTS:TgaImporterObjects>
-    pluginRegistration.cpp)
-if(BUILD_STATIC_PIC)
+    TgaImporter.cpp
+    TgaImporter.h
+    TgaHeader.h)
+if(BUILD_PLUGINS_STATIC AND BUILD_STATIC_PIC)
     set_target_properties(TgaImporter PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif()
-target_link_libraries(TgaImporter Magnum)
+target_link_libraries(TgaImporter PUBLIC Magnum)
 
-install(FILES ${TgaImporter_HEADERS} DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/TgaImporter)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/configure.h DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/TgaImporter)
+install(FILES TgaImporter.h ${CMAKE_CURRENT_BINARY_DIR}/configure.h
+    DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/TgaImporter)
 
 # Automatic static plugin import
 if(BUILD_PLUGINS_STATIC)
@@ -77,12 +55,6 @@ if(BUILD_PLUGINS_STATIC)
 endif()
 
 if(BUILD_TESTS)
-    add_library(MagnumTgaImporterTestLib STATIC
-        $<TARGET_OBJECTS:TgaImporterObjects>
-        ${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details
-    set_target_properties(MagnumTgaImporterTestLib PROPERTIES FOLDER "MagnumPlugins/TgaImporter")
-    target_link_libraries(MagnumTgaImporterTestLib Magnum)
-
     add_subdirectory(Test)
 endif()
 

src/MagnumPlugins/TgaImporter/Test/CMakeLists.txt

@@ -29,18 +29,30 @@ else()
     set(TGAIMPORTER_TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 endif()
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
-               ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+# CMake before 3.8 has broken $<TARGET_FILE*> expressions for iOS (see
+# https://gitlab.kitware.com/cmake/cmake/merge_requests/404) and since Corrade
+# doesn't support dynamic plugins on iOS, this sorta works around that. Should
+# be revisited when updating Travis to newer Xcode (current has CMake 3.6).
+if(NOT BUILD_PLUGINS_STATIC)
+    set(TGAIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:TgaImporter>)
+
+    # First replace ${} variables, then $<> generator expressions
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+    file(GENERATE OUTPUT $<TARGET_FILE_DIR:TgaImporterTest>/configure.h
+        INPUT ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+else()
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+endif()
 
 corrade_add_test(TgaImporterTest TgaImporterTest.cpp
-    LIBRARIES MagnumTgaImporterTestLib
+    LIBRARIES Magnum
     FILES file.tga)
-target_include_directories(TgaImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-set_target_properties(TgaImporterTest PROPERTIES FOLDER "MagnumPlugins/TgaImporter/Test")
-# On Win32 we need to avoid dllimporting TgaImporter symbols, because it would
-# search for the symbols in some DLL even though they were linked statically.
-# However it apparently doesn't matter that they were dllexported when building
-# the static library. EH.
-if(WIN32)
-    target_compile_definitions(TgaImporterTest PRIVATE "MAGNUM_TGAIMPORTER_BUILD_STATIC")
+if(NOT BUILD_PLUGINS_STATIC)
+    target_include_directories(TgaImporterTest PRIVATE $<TARGET_FILE_DIR:TgaImporterTest>)
+else()
+    target_include_directories(TgaImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+    target_link_libraries(TgaImporterTest PRIVATE TgaImporter)
 endif()
+set_target_properties(TgaImporterTest PROPERTIES FOLDER "MagnumPlugins/TgaImporter/Test")

src/MagnumPlugins/TgaImporter/Test/TgaImporterTest.cpp

@@ -30,8 +30,8 @@
 #include <Corrade/Utility/Directory.h>
 
 #include "Magnum/PixelFormat.h"
+#include "Magnum/Trade/AbstractImporter.h"
 #include "Magnum/Trade/ImageData.h"
-#include "MagnumPlugins/TgaImporter/TgaImporter.h"
 
 #include "configure.h"
 
@@ -53,6 +53,9 @@ struct TgaImporterTest: TestSuite::Tester {
     void grayscaleBits16();
 
     void useTwice();
+
+    /* Explicitly forbid system-wide plugin dependencies */
+    PluginManager::Manager<AbstractImporter> _manager{"nonexistent"};
 };
 
 TgaImporterTest::TgaImporterTest() {
@@ -68,54 +71,60 @@ TgaImporterTest::TgaImporterTest() {
               &TgaImporterTest::grayscaleBits16,
 
               &TgaImporterTest::useTwice});
+
+    /* Load the plugin directly from the build tree. Otherwise it's static and
+       already loaded. */
+    #ifdef TGAIMPORTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_manager.load(TGAIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
 }
 
 void TgaImporterTest::openShort() {
-    TgaImporter importer;
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-    CORRADE_VERIFY(importer.openData(data));
+    CORRADE_VERIFY(importer->openData(data));
 
     std::ostringstream debug;
     Error redirectError{&debug};
-    CORRADE_VERIFY(!importer.image2D(0));
+    CORRADE_VERIFY(!importer->image2D(0));
     CORRADE_COMPARE(debug.str(), "Trade::TgaImporter::image2D(): the file is too short: 17 bytes\n");
 }
 
 void TgaImporterTest::paletted() {
-    TgaImporter importer;
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-    CORRADE_VERIFY(importer.openData(data));
+    CORRADE_VERIFY(importer->openData(data));
 
     std::ostringstream debug;
     Error redirectError{&debug};
-    CORRADE_VERIFY(!importer.image2D(0));
+    CORRADE_VERIFY(!importer->image2D(0));
     CORRADE_COMPARE(debug.str(), "Trade::TgaImporter::image2D(): paletted files are not supported\n");
 }
 
 void TgaImporterTest::compressed() {
-    TgaImporter importer;
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = { 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-    CORRADE_VERIFY(importer.openData(data));
+    CORRADE_VERIFY(importer->openData(data));
 
     std::ostringstream debug;
     Error redirectError{&debug};
-    CORRADE_VERIFY(!importer.image2D(0));
+    CORRADE_VERIFY(!importer->image2D(0));
     CORRADE_COMPARE(debug.str(), "Trade::TgaImporter::image2D(): unsupported (compressed?) image type: 9\n");
 }
 
 void TgaImporterTest::colorBits16() {
-    TgaImporter importer;
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = { 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0 };
-    CORRADE_VERIFY(importer.openData(data));
+    CORRADE_VERIFY(importer->openData(data));
 
     std::ostringstream debug;
     Error redirectError{&debug};
-    CORRADE_VERIFY(!importer.image2D(0));
+    CORRADE_VERIFY(!importer->image2D(0));
     CORRADE_COMPARE(debug.str(), "Trade::TgaImporter::image2D(): unsupported color bits-per-pixel: 16\n");
 }
 
 void TgaImporterTest::colorBits24() {
-    TgaImporter importer;
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = {
         0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 24, 0,
         1, 2, 3, 2, 3, 4,
@@ -127,9 +136,9 @@ void TgaImporterTest::colorBits24() {
         5, 4, 3, 6, 5, 4,
         7, 6, 5, 8, 7, 6
     };
-    CORRADE_VERIFY(importer.openData(data));
+    CORRADE_VERIFY(importer->openData(data));
 
-    Containers::Optional<Trade::ImageData2D> image = importer.image2D(0);
+    Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
     CORRADE_VERIFY(image);
     CORRADE_COMPARE(image->storage().alignment(), 1);
     CORRADE_COMPARE(image->format(), PixelFormat::RGB);
@@ -140,7 +149,7 @@ void TgaImporterTest::colorBits24() {
 }
 
 void TgaImporterTest::colorBits32() {
-    TgaImporter importer;
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = {
         0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 32, 0,
         1, 2, 3, 1, 2, 3, 4, 1,
@@ -152,9 +161,9 @@ void TgaImporterTest::colorBits32() {
         5, 4, 3, 1, 6, 5, 4, 1,
         7, 6, 5, 1, 8, 7, 6, 1
     };
-    CORRADE_VERIFY(importer.openData(data));
+    CORRADE_VERIFY(importer->openData(data));
 
-    Containers::Optional<Trade::ImageData2D> image = importer.image2D(0);
+    Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
     CORRADE_VERIFY(image);
     CORRADE_COMPARE(image->storage().alignment(), 4);
     CORRADE_COMPARE(image->format(), PixelFormat::RGBA);
@@ -165,16 +174,16 @@ void TgaImporterTest::colorBits32() {
 }
 
 void TgaImporterTest::grayscaleBits8() {
-    TgaImporter importer;
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = {
         0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 8, 0,
         1, 2,
         3, 4,
         5, 6
     };
-    CORRADE_VERIFY(importer.openData(data));
+    CORRADE_VERIFY(importer->openData(data));
 
-    Containers::Optional<Trade::ImageData2D> image = importer.image2D(0);
+    Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
     CORRADE_VERIFY(image);
     CORRADE_COMPARE(image->storage().alignment(), 1);
     #ifndef MAGNUM_TARGET_GLES2
@@ -189,27 +198,27 @@ void TgaImporterTest::grayscaleBits8() {
 }
 
 void TgaImporterTest::grayscaleBits16() {
-    TgaImporter importer;
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = { 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0 };
-    CORRADE_VERIFY(importer.openData(data));
+    CORRADE_VERIFY(importer->openData(data));
 
     std::ostringstream debug;
     Error redirectError{&debug};
-    CORRADE_VERIFY(!importer.image2D(0));
+    CORRADE_VERIFY(!importer->image2D(0));
     CORRADE_COMPARE(debug.str(), "Trade::TgaImporter::image2D(): unsupported grayscale bits-per-pixel: 16\n");
 }
 
 void TgaImporterTest::useTwice() {
-    TgaImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(TGAIMPORTER_TEST_DIR, "file.tga")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(TGAIMPORTER_TEST_DIR, "file.tga")));
 
     /* Verify that the file is rewinded for second use */
     {
-        Containers::Optional<Trade::ImageData2D> image = importer.image2D(0);
+        Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
         CORRADE_VERIFY(image);
         CORRADE_COMPARE(image->size(), (Vector2i{2, 3}));
     } {
-        Containers::Optional<Trade::ImageData2D> image = importer.image2D(0);
+        Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
         CORRADE_VERIFY(image);
         CORRADE_COMPARE(image->size(), (Vector2i{2, 3}));
     }

src/MagnumPlugins/TgaImporter/Test/configure.h.cmake

@@ -23,4 +23,5 @@
     DEALINGS IN THE SOFTWARE.
 */
 
+#cmakedefine TGAIMPORTER_PLUGIN_FILENAME "${TGAIMPORTER_PLUGIN_FILENAME}"
 #define TGAIMPORTER_TEST_DIR "${TGAIMPORTER_TEST_DIR}"

src/MagnumPlugins/TgaImporter/TgaImporter.cpp

@@ -140,3 +140,6 @@ Containers::Optional<ImageData2D> TgaImporter::doImage2D(UnsignedInt) {
 }
 
 }}
+
+CORRADE_PLUGIN_REGISTER(TgaImporter, Magnum::Trade::TgaImporter,
+    "cz.mosra.magnum.Trade.AbstractImporter/0.3")

src/MagnumPlugins/TgaImporter/TgaImporter.h

@@ -38,7 +38,7 @@
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 #ifndef MAGNUM_TGAIMPORTER_BUILD_STATIC
-    #if defined(TgaImporter_EXPORTS) || defined(TgaImporterObjects_EXPORTS)
+    #ifdef TgaImporter_EXPORTS
         #define MAGNUM_TGAIMPORTER_EXPORT CORRADE_VISIBILITY_EXPORT
     #else
         #define MAGNUM_TGAIMPORTER_EXPORT CORRADE_VISIBILITY_IMPORT

src/MagnumPlugins/TgaImporter/pluginRegistration.cpp

@@ -1,29 +0,0 @@
-/*
-    This file is part of Magnum.
-
-    Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018
-              Vladimír Vondruš <mosra@centrum.cz>
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom the
-    Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included
-    in all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-    DEALINGS IN THE SOFTWARE.
-*/
-
-#include "MagnumPlugins/TgaImporter/TgaImporter.h"
-
-CORRADE_PLUGIN_REGISTER(TgaImporter, Magnum::Trade::TgaImporter,
-    "cz.mosra.magnum.Trade.AbstractImporter/0.3")

src/MagnumPlugins/WavAudioImporter/CMakeLists.txt

@@ -30,21 +30,10 @@ endif()
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
                ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
 
-set(WavAudioImporter_SRCS
-    WavHeader.cpp
-    WavImporter.cpp)
-
-set(WavAudioImporter_HEADERS
-    WavImporter.h)
-
-set(WavAudioImporter_PRIVATE_HEADERS
-    WavHeader.h)
-
 # Objects shared between plugin and test library
 add_library(WavAudioImporterObjects OBJECT
-    ${WavAudioImporter_SRCS}
-    ${WavAudioImporter_HEADERS}
-    ${WavAudioImporter_PRIVATE_HEADERS})
+    WavHeader.cpp
+    WavHeader.h)
 target_include_directories(WavAudioImporterObjects PUBLIC
     $<TARGET_PROPERTY:Magnum,INTERFACE_INCLUDE_DIRECTORIES>
     $<TARGET_PROPERTY:MagnumAudio,INTERFACE_INCLUDE_DIRECTORIES>)
@@ -61,15 +50,16 @@ add_plugin(WavAudioImporter
     "${MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_LIBRARY_INSTALL_DIR}"
     "${MAGNUM_PLUGINS_AUDIOIMPORTER_RELEASE_BINARY_INSTALL_DIR};${MAGNUM_PLUGINS_AUDIOIMPORTER_RELEASE_LIBRARY_INSTALL_DIR}"
     WavAudioImporter.conf
-    $<TARGET_OBJECTS:WavAudioImporterObjects>
-    pluginRegistration.cpp)
-if(BUILD_STATIC_PIC)
+    WavImporter.cpp
+    WavImporter.h
+    $<TARGET_OBJECTS:WavAudioImporterObjects>)
+if(BUILD_PLUGINS_STATIC AND BUILD_STATIC_PIC)
     set_target_properties(WavAudioImporter PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif()
-target_link_libraries(WavAudioImporter Magnum MagnumAudio)
+target_link_libraries(WavAudioImporter PUBLIC Magnum MagnumAudio)
 
-install(FILES ${WavAudioImporter_HEADERS} DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/WavAudioImporter)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/configure.h DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/WavAudioImporter)
+install(FILES WavImporter.h ${CMAKE_CURRENT_BINARY_DIR}/configure.h
+    DESTINATION ${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}/WavAudioImporter)
 
 # Automatic static plugin import
 if(BUILD_PLUGINS_STATIC)
@@ -80,12 +70,6 @@ if(BUILD_PLUGINS_STATIC)
 endif()
 
 if(BUILD_TESTS)
-    add_library(MagnumWavAudioImporterTestLib STATIC
-        $<TARGET_OBJECTS:WavAudioImporterObjects>
-        ${PROJECT_SOURCE_DIR}/src/dummy.cpp) # XCode workaround, see file comment for details
-    set_target_properties(MagnumWavAudioImporterTestLib PROPERTIES FOLDER "MagnumPlugins/WavAudioImporter")
-    target_link_libraries(MagnumWavAudioImporterTestLib Magnum MagnumAudio)
-
     add_subdirectory(Test)
 endif()
 

src/MagnumPlugins/WavAudioImporter/Test/CMakeLists.txt

@@ -29,11 +29,25 @@ else()
     set(WAVAUDIOIMPORTER_TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 endif()
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
-               ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+# CMake before 3.8 has broken $<TARGET_FILE*> expressions for iOS (see
+# https://gitlab.kitware.com/cmake/cmake/merge_requests/404) and since Corrade
+# doesn't support dynamic plugins on iOS, this sorta works around that. Should
+# be revisited when updating Travis to newer Xcode (current has CMake 3.6).
+if(NOT BUILD_PLUGINS_STATIC)
+    set(WAVAUDIOIMPORTER_PLUGIN_FILENAME $<TARGET_FILE:WavAudioImporter>)
+
+    # First replace ${} variables, then $<> generator expressions
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+    file(GENERATE OUTPUT $<TARGET_FILE_DIR:WavAudioImporterTest>/configure.h
+        INPUT ${CMAKE_CURRENT_BINARY_DIR}/configure.h.in)
+else()
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
+                   ${CMAKE_CURRENT_BINARY_DIR}/configure.h)
+endif()
 
 corrade_add_test(WavAudioImporterTest WavImporterTest.cpp
-    LIBRARIES MagnumWavAudioImporterTestLib
+    LIBRARIES MagnumAudio
     FILES
         unsupportedChannelCount.wav
         unsupportedFormat.wav
@@ -67,12 +81,19 @@ corrade_add_test(WavAudioImporterTest WavImporterTest.cpp
 
         surround51Channel16.wav
         surround71Channel24.wav)
-target_include_directories(WavAudioImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-set_target_properties(WavAudioImporterTest PROPERTIES FOLDER "MagnumPlugins/WavAudioImporter/Test")
-# On Win32 we need to avoid dllimporting WavAudioImporter symbols, because it
-# would search for the symbols in some DLL even though they were linked
-# statically. However it apparently doesn't matter that they were dllexported
-# when building the static library. EH.
-if(WIN32)
-    target_compile_definitions(WavAudioImporterTest PRIVATE "MAGNUM_WAVAUDIOIMPORTER_BUILD_STATIC")
+if(NOT BUILD_PLUGINS_STATIC)
+    target_include_directories(WavAudioImporterTest PRIVATE $<TARGET_FILE_DIR:WavAudioImporterTest>)
+else()
+    target_include_directories(WavAudioImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+    target_link_libraries(WavAudioImporterTest PRIVATE WavAudioImporter)
 endif()
+
+corrade_add_test(WavAudioImporterWavHeaderTest
+    WavHeaderTest.cpp
+    $<TARGET_OBJECTS:WavAudioImporterObjects>
+    LIBRARIES MagnumAudio)
+
+set_target_properties(
+    WavAudioImporterTest
+    WavAudioImporterWavHeaderTest
+    PROPERTIES FOLDER "MagnumPlugins/WavAudioImporter/Test")

src/MagnumPlugins/WavAudioImporter/Test/WavHeaderTest.cpp

@@ -3,6 +3,7 @@
 
     Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018
               Vladimír Vondruš <mosra@centrum.cz>
+    Copyright © 2016 Alice Margatroid <loveoverwhelming@gmail.com>
 
     Permission is hereby granted, free of charge, to any person obtaining a
     copy of this software and associated documentation files (the "Software"),
@@ -23,9 +24,32 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#include <Corrade/PluginManager/AbstractManager.h>
+#include <sstream>
+#include <Corrade/TestSuite/Tester.h>
 
-#include "MagnumPlugins/MagnumFont/MagnumFont.h"
+#include "Magnum/Magnum.h"
+#include "MagnumPlugins/WavAudioImporter/WavHeader.h"
+
+namespace Magnum { namespace Audio { namespace Test {
+
+struct WavHeaderTest: TestSuite::Tester {
+    explicit WavHeaderTest();
+
+    void debugAudioFormat();
+};
+
+WavHeaderTest::WavHeaderTest() {
+    addTests({&WavHeaderTest::debugAudioFormat});
+}
+
+void WavHeaderTest::debugAudioFormat() {
+    std::ostringstream out;
+
+    Debug{&out} << Implementation::WavAudioFormat::IeeeFloat << Implementation::WavAudioFormat(0xdead);
+    CORRADE_COMPARE(out.str(), "Audio::WavAudioFormat::IeeeFloat Audio::WavAudioFormat(0xdead)\n");
+}
+
+}}}
+
+CORRADE_TEST_MAIN(Magnum::Audio::Test::WavHeaderTest)
 
-CORRADE_PLUGIN_REGISTER(MagnumFont, Magnum::Text::MagnumFont,
-    "cz.mosra.magnum.Text.AbstractFont/0.2.4")

src/MagnumPlugins/WavAudioImporter/Test/WavImporterTest.cpp

@@ -25,13 +25,12 @@
 */
 
 #include <sstream>
-#include <Corrade/Containers/ArrayView.h>
+#include <Corrade/Containers/Array.h>
 #include <Corrade/TestSuite/Tester.h>
 #include <Corrade/TestSuite/Compare/Container.h>
 #include <Corrade/Utility/Directory.h>
 
-#include "MagnumPlugins/WavAudioImporter/WavImporter.h"
-#include "MagnumPlugins/WavAudioImporter/WavHeader.h"
+#include "Magnum/Audio/AbstractImporter.h"
 
 #include "configure.h"
 
@@ -73,7 +72,8 @@ struct WavImporterTest: TestSuite::Tester {
     void surround51Channel16();
     void surround71Channel24();
 
-    void debugAudioFormat();
+    /* Explicitly forbid system-wide plugin dependencies */
+    PluginManager::Manager<AbstractImporter> _manager{"nonexistent"};
 };
 
 WavImporterTest::WavImporterTest() {
@@ -108,17 +108,21 @@ WavImporterTest::WavImporterTest() {
               &WavImporterTest::stereo64f,
 
               &WavImporterTest::surround51Channel16,
-              &WavImporterTest::surround71Channel24,
+              &WavImporterTest::surround71Channel24});
 
-              &WavImporterTest::debugAudioFormat});
+    /* Load the plugin directly from the build tree. Otherwise it's static and
+       already loaded. */
+    #ifdef WAVAUDIOIMPORTER_PLUGIN_FILENAME
+    CORRADE_INTERNAL_ASSERT(_manager.load(WAVAUDIOIMPORTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
+    #endif
 }
 
 void WavImporterTest::wrongSize() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-    CORRADE_VERIFY(!importer.openData(Containers::Array<char>(43)));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openData(Containers::Array<char>(43)));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): the file is too short: 43 bytes\n");
 }
 
@@ -126,8 +130,8 @@ void WavImporterTest::wrongSignature() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "wrongSignature.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "wrongSignature.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): the file signature is invalid\n");
 }
 
@@ -135,8 +139,8 @@ void WavImporterTest::unsupportedFormat() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "unsupportedFormat.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "unsupportedFormat.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported format Audio::WavAudioFormat::AdPcm\n");
 }
 
@@ -144,8 +148,8 @@ void WavImporterTest::unsupportedChannelCount() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "unsupportedChannelCount.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "unsupportedChannelCount.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): PCM with unsupported channel count 6 with 8 bits per sample\n");
 }
 
@@ -153,8 +157,8 @@ void WavImporterTest::invalidPadding() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "invalidPadding.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "invalidPadding.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): the file has improper size, expected 66 but got 73\n");
 }
 
@@ -162,8 +166,8 @@ void WavImporterTest::invalidLength() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "invalidLength.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "invalidLength.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): the file has improper size, expected 160844 but got 80444\n");
 }
 
@@ -171,20 +175,20 @@ void WavImporterTest::invalidDataChunk() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "invalidDataChunk.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "invalidDataChunk.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): the file contains no data chunk\n");
 }
 
 void WavImporterTest::invalidFactChunk() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "invalidFactChunk.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "invalidFactChunk.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::Mono16);
-    CORRADE_COMPARE(importer.frequency(), 22050);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::Mono16);
+    CORRADE_COMPARE(importer->frequency(), 22050);
 
-    CORRADE_COMPARE(importer.data().size(), 3724);
-    CORRADE_COMPARE_AS(importer.data().prefix(8),
+    CORRADE_COMPARE(importer->data().size(), 3724);
+    CORRADE_COMPARE_AS(importer->data().prefix(8),
         (Containers::Array<char>{Containers::InPlaceInit, {
             -27, -11, -1, -9, 24, -6, 127, -5}}),
         TestSuite::Compare::Container<Containers::ArrayView<const char>>);
@@ -194,72 +198,72 @@ void WavImporterTest::mono4() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono4.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono4.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported format Audio::WavAudioFormat::AdPcm\n");
 }
 
 void WavImporterTest::mono8() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono8.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono8.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::Mono8);
-    CORRADE_COMPARE(importer.frequency(), 22050);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::Mono8);
+    CORRADE_COMPARE(importer->frequency(), 22050);
 
-    CORRADE_COMPARE(importer.data().size(), 2136);
-    CORRADE_COMPARE_AS(importer.data().prefix(4),
+    CORRADE_COMPARE(importer->data().size(), 2136);
+    CORRADE_COMPARE_AS(importer->data().prefix(4),
         (Containers::Array<char>{Containers::InPlaceInit, {127, 127, 127, 127}}),
         TestSuite::Compare::Container<Containers::ArrayView<const char>>);
 }
 
 void WavImporterTest::mono8junk() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono8junk.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono8junk.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::Mono8);
-    CORRADE_COMPARE(importer.frequency(), 22050);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::Mono8);
+    CORRADE_COMPARE(importer->frequency(), 22050);
 
-    CORRADE_COMPARE_AS(importer.data().prefix(4),
+    CORRADE_COMPARE_AS(importer->data().prefix(4),
         (Containers::Array<char>{Containers::InPlaceInit, {127, 127, 127, 127}}),
         TestSuite::Compare::Container<Containers::ArrayView<const char>>);
 }
 
 void WavImporterTest::mono8ALaw() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono8ALaw.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono8ALaw.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::MonoALaw);
-    CORRADE_COMPARE(importer.frequency(), 8000);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::MonoALaw);
+    CORRADE_COMPARE(importer->frequency(), 8000);
 
-    CORRADE_COMPARE(importer.data().size(), 4096);
-    CORRADE_COMPARE_AS(importer.data().prefix(8),
+    CORRADE_COMPARE(importer->data().size(), 4096);
+    CORRADE_COMPARE_AS(importer->data().prefix(8),
         (Containers::Array<char>{Containers::InPlaceInit, {
             87, 84, 85, 85, 85, -43, -43, -43}}),
         TestSuite::Compare::Container<Containers::ArrayView<const char>>);
 }
 
 void WavImporterTest::mono8MuLaw() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono8MuLaw.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono8MuLaw.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::MonoMuLaw);
-    CORRADE_COMPARE(importer.frequency(), 8000);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::MonoMuLaw);
+    CORRADE_COMPARE(importer->frequency(), 8000);
 
-    CORRADE_COMPARE(importer.data().size(), 4096);
-    CORRADE_COMPARE_AS(importer.data().prefix(8),
+    CORRADE_COMPARE(importer->data().size(), 4096);
+    CORRADE_COMPARE_AS(importer->data().prefix(8),
         (Containers::Array<char>{Containers::InPlaceInit, {
             -5, -3, -1, -2, -1, 127, 127, 126}}),
         TestSuite::Compare::Container<Containers::ArrayView<const char>>);
 }
 
 void WavImporterTest::mono16() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono16.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono16.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::Mono16);
-    CORRADE_COMPARE(importer.frequency(), 44000);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::Mono16);
+    CORRADE_COMPARE(importer->frequency(), 44000);
 
-    CORRADE_COMPARE_AS(importer.data(),
+    CORRADE_COMPARE_AS(importer->data(),
         (Containers::Array<char>{Containers::InPlaceInit, {
             '\x1d', '\x10', '\x71', '\xc5'}}),
         TestSuite::Compare::Container<Containers::ArrayView<const char>>);
@@ -269,47 +273,47 @@ void WavImporterTest::stereo4() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo4.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo4.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported format Audio::WavAudioFormat::AdPcm\n");
 }
 
 void WavImporterTest::stereo8() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo8.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo8.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::Stereo8);
-    CORRADE_COMPARE(importer.frequency(), 96000);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::Stereo8);
+    CORRADE_COMPARE(importer->frequency(), 96000);
 
-    CORRADE_COMPARE_AS(importer.data(),
+    CORRADE_COMPARE_AS(importer->data(),
         (Containers::Array<char>{Containers::InPlaceInit, {
             '\xde', '\xfe', '\xca', '\x7e'}}),
         TestSuite::Compare::Container<Containers::ArrayView<const char>>);
 }
 
 void WavImporterTest::stereo8ALaw() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo8ALaw.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo8ALaw.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::StereoALaw);
-    CORRADE_COMPARE(importer.frequency(), 8000);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::StereoALaw);
+    CORRADE_COMPARE(importer->frequency(), 8000);
 
-    CORRADE_COMPARE(importer.data().size(), 4096);
-    CORRADE_COMPARE_AS(importer.data().prefix(8),
+    CORRADE_COMPARE(importer->data().size(), 4096);
+    CORRADE_COMPARE_AS(importer->data().prefix(8),
         (Containers::Array<char>{Containers::InPlaceInit, {
             -43, -43, -43, -43, -43, -43, 85, -43}}),
         TestSuite::Compare::Container<Containers::ArrayView<const char>>);
 }
 
 void WavImporterTest::stereo8MuLaw() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo8MuLaw.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo8MuLaw.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::StereoMuLaw);
-    CORRADE_COMPARE(importer.frequency(), 8000);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::StereoMuLaw);
+    CORRADE_COMPARE(importer->frequency(), 8000);
 
-    CORRADE_COMPARE(importer.data().size(), 4096);
-    CORRADE_COMPARE_AS(importer.data().prefix(8),
+    CORRADE_COMPARE(importer->data().size(), 4096);
+    CORRADE_COMPARE_AS(importer->data().prefix(8),
         (Containers::Array<char>{Containers::InPlaceInit, {
             -1, -1, -1, -1, -1, -1, 127, -1}}),
         TestSuite::Compare::Container<Containers::ArrayView<const char>>);
@@ -319,20 +323,19 @@ void WavImporterTest::stereo12() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo12.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo12.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): PCM with unsupported channel count 2 with 12 bits per sample\n");
 }
 
 void WavImporterTest::stereo16() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo16.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo16.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::Stereo16);
-    CORRADE_COMPARE(importer.frequency(), 44100);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::Stereo16);
+    CORRADE_COMPARE(importer->frequency(), 44100);
 
-    CORRADE_COMPARE_AS(importer.data(),
+    CORRADE_COMPARE_AS(importer->data(),
         (Containers::Array<char>{Containers::InPlaceInit, {39, 79, 39, 79}}),
         TestSuite::Compare::Container<Containers::ArrayView<const char>>);
 }
@@ -341,9 +344,8 @@ void WavImporterTest::stereo24() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo24.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo24.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): PCM with unsupported channel count 2 with 24 bits per sample\n");
 }
 
@@ -351,49 +353,48 @@ void WavImporterTest::stereo32() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo32.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo32.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): PCM with unsupported channel count 2 with 32 bits per sample\n");
 }
 
 void WavImporterTest::mono32f() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono32f.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono32f.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::MonoFloat);
-    CORRADE_COMPARE(importer.frequency(), 48000);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::MonoFloat);
+    CORRADE_COMPARE(importer->frequency(), 48000);
 
-    CORRADE_COMPARE(importer.data().size(), 3920);
-    CORRADE_COMPARE_AS(importer.data().prefix(16),
+    CORRADE_COMPARE(importer->data().size(), 3920);
+    CORRADE_COMPARE_AS(importer->data().prefix(16),
         (Containers::Array<char>{Containers::InPlaceInit, {
             0, 0, 0, 0, 108, 57, -103, 59, 3, 63, 42, 60, -33, -81, -120, 60}}),
         TestSuite::Compare::Container<Containers::ArrayView<const char>>);
 }
 
 void WavImporterTest::stereo32f() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo32f.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo32f.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::StereoFloat);
-    CORRADE_COMPARE(importer.frequency(), 44100);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::StereoFloat);
+    CORRADE_COMPARE(importer->frequency(), 44100);
 
-    CORRADE_COMPARE(importer.data().size(), 1352);
-    CORRADE_COMPARE_AS(importer.data().prefix(8),
+    CORRADE_COMPARE(importer->data().size(), 1352);
+    CORRADE_COMPARE_AS(importer->data().prefix(8),
         (Containers::Array<char>{Containers::InPlaceInit, {
             17, -77, -103, 56, 5, 50, 72, 56}}),
         TestSuite::Compare::Container<Containers::ArrayView<const char>>);
 }
 
 void WavImporterTest::stereo64f() {
-    WavImporter importer;
-    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo64f.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo64f.wav")));
 
-    CORRADE_COMPARE(importer.format(), Buffer::Format::StereoDouble);
-    CORRADE_COMPARE(importer.frequency(), 8000);
+    CORRADE_COMPARE(importer->format(), Buffer::Format::StereoDouble);
+    CORRADE_COMPARE(importer->frequency(), 8000);
 
-    CORRADE_COMPARE(importer.data().size(), 375888);
-    CORRADE_COMPARE_AS(importer.data().prefix(64),
+    CORRADE_COMPARE(importer->data().size(), 375888);
+    CORRADE_COMPARE_AS(importer->data().prefix(64),
         (Containers::Array<char>{Containers::InPlaceInit, {
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -406,9 +407,8 @@ void WavImporterTest::surround51Channel16() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "surround51Channel16.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "surround51Channel16.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported format Audio::WavAudioFormat::Extensible\n");
 }
 
@@ -416,19 +416,11 @@ void WavImporterTest::surround71Channel24() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    WavImporter importer;
-
-    CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "surround71Channel24.wav")));
+    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "surround71Channel24.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported format Audio::WavAudioFormat::Extensible\n");
 }
 
-void WavImporterTest::debugAudioFormat() {
-    std::ostringstream out;
-
-    Debug{&out} << Implementation::WavAudioFormat::IeeeFloat << Implementation::WavAudioFormat(0xdead);
-    CORRADE_COMPARE(out.str(), "Audio::WavAudioFormat::IeeeFloat Audio::WavAudioFormat(0xdead)\n");
-}
-
 }}}
 
 CORRADE_TEST_MAIN(Magnum::Audio::Test::WavImporterTest)

src/MagnumPlugins/WavAudioImporter/Test/configure.h.cmake

@@ -23,4 +23,5 @@
     DEALINGS IN THE SOFTWARE.
 */
 
+#cmakedefine WAVAUDIOIMPORTER_PLUGIN_FILENAME "${WAVAUDIOIMPORTER_PLUGIN_FILENAME}"
 #define WAVAUDIOIMPORTER_TEST_DIR "${WAVAUDIOIMPORTER_TEST_DIR}"

src/MagnumPlugins/WavAudioImporter/WavImporter.cpp

@@ -230,3 +230,6 @@ Containers::Array<char> WavImporter::doData() {
 }
 
 }}
+
+CORRADE_PLUGIN_REGISTER(WavAudioImporter, Magnum::Audio::WavImporter,
+    "cz.mosra.magnum.Audio.AbstractImporter/0.1")

src/MagnumPlugins/WavAudioImporter/pluginRegistration.cpp

@@ -1,29 +0,0 @@
-/*
-    This file is part of Magnum.
-
-    Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018
-              Vladimír Vondruš <mosra@centrum.cz>
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom the
-    Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included
-    in all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-    DEALINGS IN THE SOFTWARE.
-*/
-
-#include "MagnumPlugins/WavAudioImporter/WavImporter.h"
-
-CORRADE_PLUGIN_REGISTER(WavAudioImporter, Magnum::Audio::WavImporter,
-    "cz.mosra.magnum.Audio.AbstractImporter/0.1")