From 76c8603bc7580f65ea2f2e13e171762c227ee411 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= <mosra@centrum.cz>
Date: Fri, 8 Mar 2019 22:35:59 +0100
Subject: [PATCH] Trade: clean up unnecessary cruft in the AbstractImporter
 test.

---
 .../Trade/Test/AbstractImporterTest.cpp       | 1277 +++++++----------
 1 file changed, 554 insertions(+), 723 deletions(-)

diff --git a/src/Magnum/Trade/Test/AbstractImporterTest.cpp b/src/Magnum/Trade/Test/AbstractImporterTest.cpp
index 7fef9a2e0..89ca890d3 100644
--- a/src/Magnum/Trade/Test/AbstractImporterTest.cpp
+++ b/src/Magnum/Trade/Test/AbstractImporterTest.cpp
@@ -47,200 +47,199 @@
 
 namespace Magnum { namespace Trade { namespace Test { namespace {
 
-class AbstractImporterTest: public TestSuite::Tester {
-    public:
-        explicit AbstractImporterTest();
-
-        void construct();
-        void constructWithPluginManagerReference();
-
-        void openFileAsData();
-        void openFileAsDataNotFound();
-
-        void openFileNotImplemented();
-        void openDataNotSupported();
-        void openDataNotImplemented();
-        void openStateNotSupported();
-        void openStateNotImplemented();
-
-        void setFileCallback();
-        void setFileCallbackTemplate();
-        void setFileCallbackTemplateNull();
-        void setFileCallbackFileOpened();
-        void setFileCallbackNotImplemented();
-        void setFileCallbackNotSupported();
-        void setFileCallbackOpenFileDirectly();
-        void setFileCallbackOpenFileThroughBaseImplementation();
-        void setFileCallbackOpenFileThroughBaseImplementationFailed();
-        void setFileCallbackOpenFileAsData();
-        void setFileCallbackOpenFileAsDataFailed();
-
-        void defaultScene();
-        void defaultSceneNotImplemented();
-        void defaultSceneNoFile();
-
-        void scene();
-        void sceneCountNotImplemented();
-        void sceneCountNoFile();
-        void sceneForNameNotImplemented();
-        void sceneForNameNoFile();
-        void sceneNameNotImplemented();
-        void sceneNameNoFile();
-        void sceneNameOutOfRange();
-        void sceneNotImplemented();
-        void sceneNoFile();
-        void sceneOutOfRange();
-
-        void animation();
-        void animationCountNotImplemented();
-        void animationCountNoFile();
-        void animationForNameNotImplemented();
-        void animationForNameNoFile();
-        void animationNameNotImplemented();
-        void animationNameNoFile();
-        void animationNameOutOfRange();
-        void animationNotImplemented();
-        void animationNoFile();
-        void animationOutOfRange();
-
-        void light();
-        void lightCountNotImplemented();
-        void lightCountNoFile();
-        void lightForNameNotImplemented();
-        void lightForNameNoFile();
-        void lightNameNotImplemented();
-        void lightNameNoFile();
-        void lightNameOutOfRange();
-        void lightNotImplemented();
-        void lightNoFile();
-        void lightOutOfRange();
-
-        void camera();
-        void cameraCountNotImplemented();
-        void cameraCountNoFile();
-        void cameraForNameNotImplemented();
-        void cameraForNameNoFile();
-        void cameraNameNotImplemented();
-        void cameraNameNoFile();
-        void cameraNameOutOfRange();
-        void cameraNotImplemented();
-        void cameraNoFile();
-        void cameraOutOfRange();
-
-        void object2D();
-        void object2DCountNotImplemented();
-        void object2DCountNoFile();
-        void object2DForNameNotImplemented();
-        void object2DForNameNoFile();
-        void object2DNameNotImplemented();
-        void object2DNameNoFile();
-        void object2DNameOutOfRange();
-        void object2DNotImplemented();
-        void object2DNoFile();
-        void object2DOutOfRange();
-
-        void object3D();
-        void object3DCountNotImplemented();
-        void object3DCountNoFile();
-        void object3DForNameNotImplemented();
-        void object3DForNameNoFile();
-        void object3DNameNotImplemented();
-        void object3DNameNoFile();
-        void object3DNameOutOfRange();
-        void object3DNotImplemented();
-        void object3DNoFile();
-        void object3DOutOfRange();
-
-        void mesh2D();
-        void mesh2DCountNotImplemented();
-        void mesh2DCountNoFile();
-        void mesh2DForNameNotImplemented();
-        void mesh2DForNameNoFile();
-        void mesh2DNameNotImplemented();
-        void mesh2DNameNoFile();
-        void mesh2DNameOutOfRange();
-        void mesh2DNotImplemented();
-        void mesh2DNoFile();
-        void mesh2DOutOfRange();
-
-        void mesh3D();
-        void mesh3DCountNotImplemented();
-        void mesh3DCountNoFile();
-        void mesh3DForNameNotImplemented();
-        void mesh3DForNameNoFile();
-        void mesh3DNameNotImplemented();
-        void mesh3DNameNoFile();
-        void mesh3DNameOutOfRange();
-        void mesh3DNotImplemented();
-        void mesh3DNoFile();
-        void mesh3DOutOfRange();
-
-        void material();
-        void materialCountNotImplemented();
-        void materialCountNoFile();
-        void materialForNameNotImplemented();
-        void materialForNameNoFile();
-        void materialNameNotImplemented();
-        void materialNameNoFile();
-        void materialNameOutOfRange();
-        void materialNotImplemented();
-        void materialNoFile();
-        void materialOutOfRange();
-
-        void texture();
-        void textureCountNotImplemented();
-        void textureCountNoFile();
-        void textureForNameNotImplemented();
-        void textureForNameNoFile();
-        void textureNameNotImplemented();
-        void textureNameNoFile();
-        void textureNameOutOfRange();
-        void textureNotImplemented();
-        void textureNoFile();
-        void textureOutOfRange();
-
-        void image1D();
-        void image1DCountNotImplemented();
-        void image1DCountNoFile();
-        void image1DForNameNotImplemented();
-        void image1DForNameNoFile();
-        void image1DNameNotImplemented();
-        void image1DNameNoFile();
-        void image1DNameOutOfRange();
-        void image1DNotImplemented();
-        void image1DNoFile();
-        void image1DOutOfRange();
-
-        void image2D();
-        void image2DCountNotImplemented();
-        void image2DCountNoFile();
-        void image2DForNameNotImplemented();
-        void image2DForNameNoFile();
-        void image2DNameNotImplemented();
-        void image2DNameNoFile();
-        void image2DNameOutOfRange();
-        void image2DNotImplemented();
-        void image2DNoFile();
-        void image2DOutOfRange();
-
-        void image3D();
-        void image3DCountNotImplemented();
-        void image3DCountNoFile();
-        void image3DForNameNotImplemented();
-        void image3DForNameNoFile();
-        void image3DNameNotImplemented();
-        void image3DNameNoFile();
-        void image3DNameOutOfRange();
-        void image3DNotImplemented();
-        void image3DNoFile();
-        void image3DOutOfRange();
-
-        void importerState();
-        void importerStateNotImplemented();
-        void importerStateNoFile();
-
-        void debugFeature();
-        void debugFeatures();
+struct AbstractImporterTest: TestSuite::Tester {
+    explicit AbstractImporterTest();
+
+    void construct();
+    void constructWithPluginManagerReference();
+
+    void openFileAsData();
+    void openFileAsDataNotFound();
+
+    void openFileNotImplemented();
+    void openDataNotSupported();
+    void openDataNotImplemented();
+    void openStateNotSupported();
+    void openStateNotImplemented();
+
+    void setFileCallback();
+    void setFileCallbackTemplate();
+    void setFileCallbackTemplateNull();
+    void setFileCallbackFileOpened();
+    void setFileCallbackNotImplemented();
+    void setFileCallbackNotSupported();
+    void setFileCallbackOpenFileDirectly();
+    void setFileCallbackOpenFileThroughBaseImplementation();
+    void setFileCallbackOpenFileThroughBaseImplementationFailed();
+    void setFileCallbackOpenFileAsData();
+    void setFileCallbackOpenFileAsDataFailed();
+
+    void defaultScene();
+    void defaultSceneNotImplemented();
+    void defaultSceneNoFile();
+
+    void scene();
+    void sceneCountNotImplemented();
+    void sceneCountNoFile();
+    void sceneForNameNotImplemented();
+    void sceneForNameNoFile();
+    void sceneNameNotImplemented();
+    void sceneNameNoFile();
+    void sceneNameOutOfRange();
+    void sceneNotImplemented();
+    void sceneNoFile();
+    void sceneOutOfRange();
+
+    void animation();
+    void animationCountNotImplemented();
+    void animationCountNoFile();
+    void animationForNameNotImplemented();
+    void animationForNameNoFile();
+    void animationNameNotImplemented();
+    void animationNameNoFile();
+    void animationNameOutOfRange();
+    void animationNotImplemented();
+    void animationNoFile();
+    void animationOutOfRange();
+
+    void light();
+    void lightCountNotImplemented();
+    void lightCountNoFile();
+    void lightForNameNotImplemented();
+    void lightForNameNoFile();
+    void lightNameNotImplemented();
+    void lightNameNoFile();
+    void lightNameOutOfRange();
+    void lightNotImplemented();
+    void lightNoFile();
+    void lightOutOfRange();
+
+    void camera();
+    void cameraCountNotImplemented();
+    void cameraCountNoFile();
+    void cameraForNameNotImplemented();
+    void cameraForNameNoFile();
+    void cameraNameNotImplemented();
+    void cameraNameNoFile();
+    void cameraNameOutOfRange();
+    void cameraNotImplemented();
+    void cameraNoFile();
+    void cameraOutOfRange();
+
+    void object2D();
+    void object2DCountNotImplemented();
+    void object2DCountNoFile();
+    void object2DForNameNotImplemented();
+    void object2DForNameNoFile();
+    void object2DNameNotImplemented();
+    void object2DNameNoFile();
+    void object2DNameOutOfRange();
+    void object2DNotImplemented();
+    void object2DNoFile();
+    void object2DOutOfRange();
+
+    void object3D();
+    void object3DCountNotImplemented();
+    void object3DCountNoFile();
+    void object3DForNameNotImplemented();
+    void object3DForNameNoFile();
+    void object3DNameNotImplemented();
+    void object3DNameNoFile();
+    void object3DNameOutOfRange();
+    void object3DNotImplemented();
+    void object3DNoFile();
+    void object3DOutOfRange();
+
+    void mesh2D();
+    void mesh2DCountNotImplemented();
+    void mesh2DCountNoFile();
+    void mesh2DForNameNotImplemented();
+    void mesh2DForNameNoFile();
+    void mesh2DNameNotImplemented();
+    void mesh2DNameNoFile();
+    void mesh2DNameOutOfRange();
+    void mesh2DNotImplemented();
+    void mesh2DNoFile();
+    void mesh2DOutOfRange();
+
+    void mesh3D();
+    void mesh3DCountNotImplemented();
+    void mesh3DCountNoFile();
+    void mesh3DForNameNotImplemented();
+    void mesh3DForNameNoFile();
+    void mesh3DNameNotImplemented();
+    void mesh3DNameNoFile();
+    void mesh3DNameOutOfRange();
+    void mesh3DNotImplemented();
+    void mesh3DNoFile();
+    void mesh3DOutOfRange();
+
+    void material();
+    void materialCountNotImplemented();
+    void materialCountNoFile();
+    void materialForNameNotImplemented();
+    void materialForNameNoFile();
+    void materialNameNotImplemented();
+    void materialNameNoFile();
+    void materialNameOutOfRange();
+    void materialNotImplemented();
+    void materialNoFile();
+    void materialOutOfRange();
+
+    void texture();
+    void textureCountNotImplemented();
+    void textureCountNoFile();
+    void textureForNameNotImplemented();
+    void textureForNameNoFile();
+    void textureNameNotImplemented();
+    void textureNameNoFile();
+    void textureNameOutOfRange();
+    void textureNotImplemented();
+    void textureNoFile();
+    void textureOutOfRange();
+
+    void image1D();
+    void image1DCountNotImplemented();
+    void image1DCountNoFile();
+    void image1DForNameNotImplemented();
+    void image1DForNameNoFile();
+    void image1DNameNotImplemented();
+    void image1DNameNoFile();
+    void image1DNameOutOfRange();
+    void image1DNotImplemented();
+    void image1DNoFile();
+    void image1DOutOfRange();
+
+    void image2D();
+    void image2DCountNotImplemented();
+    void image2DCountNoFile();
+    void image2DForNameNotImplemented();
+    void image2DForNameNoFile();
+    void image2DNameNotImplemented();
+    void image2DNameNoFile();
+    void image2DNameOutOfRange();
+    void image2DNotImplemented();
+    void image2DNoFile();
+    void image2DOutOfRange();
+
+    void image3D();
+    void image3DCountNotImplemented();
+    void image3DCountNoFile();
+    void image3DForNameNotImplemented();
+    void image3DForNameNoFile();
+    void image3DNameNotImplemented();
+    void image3DNameNoFile();
+    void image3DNameOutOfRange();
+    void image3DNotImplemented();
+    void image3DNoFile();
+    void image3DOutOfRange();
+
+    void importerState();
+    void importerStateNotImplemented();
+    void importerStateNoFile();
+
+    void debugFeature();
+    void debugFeatures();
 };
 
 AbstractImporterTest::AbstractImporterTest() {
@@ -437,13 +436,12 @@ AbstractImporterTest::AbstractImporterTest() {
 }
 
 void AbstractImporterTest::construct() {
-    class Importer: public AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.features(), AbstractImporter::Features{});
     CORRADE_VERIFY(!importer.isOpened());
 
@@ -452,23 +450,21 @@ void AbstractImporterTest::construct() {
 }
 
 void AbstractImporterTest::constructWithPluginManagerReference() {
-    class Importer: public AbstractImporter {
-        public:
-            explicit Importer(PluginManager::Manager<AbstractImporter>& manager): AbstractImporter{manager} {}
-
-        private:
-            Features doFeatures() const override { return {}; }
-            bool doIsOpened() const override { return false; }
-            void doClose() override {}
-    };
-
     PluginManager::Manager<AbstractImporter> manager;
-    Importer importer{manager};
+
+    struct Importer: AbstractImporter {
+        explicit Importer(PluginManager::Manager<AbstractImporter>& manager): AbstractImporter{manager} {}
+
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    } importer{manager};
+
     CORRADE_VERIFY(!importer.isOpened());
 }
 
 void AbstractImporterTest::openFileAsData() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return Feature::OpenData; }
         bool doIsOpened() const override { return _opened; }
         void doClose() override { _opened = false; }
@@ -478,12 +474,11 @@ void AbstractImporterTest::openFileAsData() {
         }
 
         bool _opened = false;
-    };
+    } importer;
 
     /* doOpenFile() should call doOpenData() */
-    Importer importer;
     CORRADE_VERIFY(!importer.isOpened());
-    importer.openFile(Utility::Directory::join(TRADE_TEST_DIR, "file.bin"));
+    CORRADE_VERIFY(importer.openFile(Utility::Directory::join(TRADE_TEST_DIR, "file.bin")));
     CORRADE_VERIFY(importer.isOpened());
 
     importer.close();
@@ -491,7 +486,7 @@ void AbstractImporterTest::openFileAsData() {
 }
 
 void AbstractImporterTest::openFileAsDataNotFound() {
-    class Importer: public Trade::AbstractImporter {
+    struct Importer: AbstractImporter {
         Features doFeatures() const override { return Feature::OpenData; }
         bool doIsOpened() const override { return _opened; }
         void doClose() override { _opened = false; }
@@ -501,104 +496,97 @@ void AbstractImporterTest::openFileAsDataNotFound() {
         }
 
         bool _opened = false;
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
-    importer.openFile("nonexistent.bin");
+    CORRADE_VERIFY(!importer.openFile("nonexistent.bin"));
     CORRADE_VERIFY(!importer.isOpened());
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::openFile(): cannot open file nonexistent.bin\n");
 }
 
 void AbstractImporterTest::openFileNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct Importer: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
-    importer.openFile("file.dat");
+    CORRADE_VERIFY(!importer.openFile("file.dat"));
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::openFile(): not implemented\n");
 }
 
 void AbstractImporterTest::openDataNotSupported() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
-    importer.openData(nullptr);
+    CORRADE_VERIFY(!importer.openData(nullptr));
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::openData(): feature not supported\n");
 }
 
 void AbstractImporterTest::openDataNotImplemented() {
-    class DataImporter: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return Feature::OpenData; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    DataImporter importer;
-    importer.openData(nullptr);
+    CORRADE_VERIFY(!importer.openData(nullptr));
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::openData(): feature advertised but not implemented\n");
 }
 
 void AbstractImporterTest::openStateNotSupported() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
-    importer.openState(nullptr);
+    CORRADE_VERIFY(!importer.openState(nullptr));
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::openState(): feature not supported\n");
 }
 
 void AbstractImporterTest::openStateNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return Feature::OpenState; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
-    importer.openState(nullptr);
+    CORRADE_VERIFY(!importer.openState(nullptr));
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::openState(): feature advertised but not implemented\n");
 }
 
 void AbstractImporterTest::setFileCallback() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return Feature::OpenData|Feature::FileCallback; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
         void doSetFileCallback(Containers::Optional<Containers::ArrayView<const char>>(*)(const std::string&, InputFileCallbackPolicy, void*), void* userData) override {
             *static_cast<int*>(userData) = 1337;
         }
-    };
+    } importer;
 
     int a = 0;
-    Importer importer;
     auto lambda = [](const std::string&, InputFileCallbackPolicy, void*) {
         return Containers::Optional<Containers::ArrayView<const char>>{};
     };
@@ -609,7 +597,7 @@ void AbstractImporterTest::setFileCallback() {
 }
 
 void AbstractImporterTest::setFileCallbackTemplate() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return Feature::OpenData|Feature::FileCallback; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
@@ -617,14 +605,13 @@ void AbstractImporterTest::setFileCallbackTemplate() {
             called = true;
         }
 
-        public: bool called = false;
-    };
+        bool called = false;
+    } importer;
 
     int a = 0;
     auto lambda = [](const std::string&, InputFileCallbackPolicy, int&) {
         return Containers::Optional<Containers::ArrayView<const char>>{};
     };
-    Importer importer;
     importer.setFileCallback(lambda, a);
     CORRADE_VERIFY(importer.fileCallback());
     CORRADE_VERIFY(importer.fileCallbackUserData());
@@ -636,7 +623,7 @@ void AbstractImporterTest::setFileCallbackTemplate() {
 }
 
 void AbstractImporterTest::setFileCallbackTemplateNull() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return Feature::OpenData|Feature::FileCallback; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
@@ -644,11 +631,10 @@ void AbstractImporterTest::setFileCallbackTemplateNull() {
             called = !callback && !userData;
         }
 
-        public: bool called = false;
-    };
+        bool called = false;
+    } importer;
 
     int a = 0;
-    Importer importer;
     importer.setFileCallback(static_cast<Containers::Optional<Containers::ArrayView<const char>>(*)(const std::string&, InputFileCallbackPolicy, int&)>(nullptr), a);
     CORRADE_VERIFY(!importer.fileCallback());
     CORRADE_VERIFY(!importer.fileCallbackUserData());
@@ -656,16 +642,15 @@ void AbstractImporterTest::setFileCallbackTemplateNull() {
 }
 
 void AbstractImporterTest::setFileCallbackFileOpened() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.setFileCallback([](const std::string&, InputFileCallbackPolicy, void*) {
         return Containers::Optional<Containers::ArrayView<const char>>{};
     });
@@ -673,17 +658,16 @@ void AbstractImporterTest::setFileCallbackFileOpened() {
 }
 
 void AbstractImporterTest::setFileCallbackNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return Feature::FileCallback; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     int a;
     auto lambda = [](const std::string&, InputFileCallbackPolicy, void*) {
         return Containers::Optional<Containers::ArrayView<const char>>{};
     };
-    Importer importer;
     importer.setFileCallback(lambda, &a);
     CORRADE_COMPARE(importer.fileCallback(), lambda);
     CORRADE_COMPARE(importer.fileCallbackUserData(), &a);
@@ -691,17 +675,16 @@ void AbstractImporterTest::setFileCallbackNotImplemented() {
 }
 
 void AbstractImporterTest::setFileCallbackNotSupported() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
     int a;
-    Importer importer;
     importer.setFileCallback([](const std::string&, InputFileCallbackPolicy, void*) {
         return Containers::Optional<Containers::ArrayView<const char>>{};
     }, &a);
@@ -709,7 +692,7 @@ void AbstractImporterTest::setFileCallbackNotSupported() {
 }
 
 void AbstractImporterTest::setFileCallbackOpenFileDirectly() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return Feature::FileCallback|Feature::OpenData; }
         bool doIsOpened() const override { return _opened; }
         void doClose() override { _opened = false; }
@@ -725,11 +708,10 @@ void AbstractImporterTest::setFileCallbackOpenFileDirectly() {
         }
 
         bool _opened = false;
-        public: bool openDataCalledNotSureWhy = false;
-    };
+        bool openDataCalledNotSureWhy = false;
+    } importer;
 
     bool calledNotSureWhy = false;
-    Importer importer;
     importer.setFileCallback([](const std::string&, InputFileCallbackPolicy, bool& calledNotSureWhy) -> Containers::Optional<Containers::ArrayView<const char>> {
         calledNotSureWhy = true;
         return {};
@@ -741,7 +723,7 @@ void AbstractImporterTest::setFileCallbackOpenFileDirectly() {
 }
 
 void AbstractImporterTest::setFileCallbackOpenFileThroughBaseImplementation() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return Feature::FileCallback|Feature::OpenData; }
         bool doIsOpened() const override { return _opened; }
         void doClose() override { _opened = false; }
@@ -756,8 +738,8 @@ void AbstractImporterTest::setFileCallbackOpenFileThroughBaseImplementation() {
         }
 
         bool _opened = false;
-        public: bool openFileCalled = false;
-    };
+        bool openFileCalled = false;
+    } importer;
 
     struct State {
         const char data = '\xb0';
@@ -765,7 +747,7 @@ void AbstractImporterTest::setFileCallbackOpenFileThroughBaseImplementation() {
         bool closed = false;
         bool calledNotSureWhy = false;
     } state;
-    Importer importer;
+
     importer.setFileCallback([](const std::string& filename, InputFileCallbackPolicy policy, State& state) -> Containers::Optional<Containers::ArrayView<const char>> {
         if(filename == "file.dat" && policy == InputFileCallbackPolicy::LoadTemporary) {
             state.loaded = true;
@@ -789,7 +771,7 @@ void AbstractImporterTest::setFileCallbackOpenFileThroughBaseImplementation() {
 }
 
 void AbstractImporterTest::setFileCallbackOpenFileThroughBaseImplementationFailed() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return Feature::FileCallback|Feature::OpenData; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
@@ -799,10 +781,9 @@ void AbstractImporterTest::setFileCallbackOpenFileThroughBaseImplementationFaile
             AbstractImporter::doOpenFile(filename);
         }
 
-        public: bool openFileCalled = false;
-    };
+        bool openFileCalled = false;
+    } importer;
 
-    Importer importer;
     importer.setFileCallback([](const std::string&, InputFileCallbackPolicy, void*) -> Containers::Optional<Containers::ArrayView<const char>> {
         return {};
     });
@@ -816,7 +797,7 @@ void AbstractImporterTest::setFileCallbackOpenFileThroughBaseImplementationFaile
 }
 
 void AbstractImporterTest::setFileCallbackOpenFileAsData() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return Feature::OpenData; }
         bool doIsOpened() const override { return _opened; }
         void doClose() override { _opened = false; }
@@ -830,8 +811,8 @@ void AbstractImporterTest::setFileCallbackOpenFileAsData() {
         }
 
         bool _opened = false;
-        public: bool openFileCalled = false;
-    };
+        bool openFileCalled = false;
+    } importer;
 
     struct State {
         const char data = '\xb0';
@@ -839,7 +820,7 @@ void AbstractImporterTest::setFileCallbackOpenFileAsData() {
         bool closed = false;
         bool calledNotSureWhy = false;
     } state;
-    Importer importer;
+
     importer.setFileCallback([](const std::string& filename, InputFileCallbackPolicy policy, State& state) -> Containers::Optional<Containers::ArrayView<const char>> {
         if(filename == "file.dat" && policy == InputFileCallbackPolicy::LoadTemporary) {
             state.loaded = true;
@@ -863,7 +844,7 @@ void AbstractImporterTest::setFileCallbackOpenFileAsData() {
 }
 
 void AbstractImporterTest::setFileCallbackOpenFileAsDataFailed() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return Feature::OpenData; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
@@ -872,10 +853,9 @@ void AbstractImporterTest::setFileCallbackOpenFileAsDataFailed() {
             openFileCalled = true;
         }
 
-        public: bool openFileCalled = false;
-    };
+        bool openFileCalled = false;
+    } importer;
 
-    Importer importer;
     importer.setFileCallback([](const std::string&, InputFileCallbackPolicy, void*) {
         return Containers::Optional<Containers::ArrayView<const char>>{};
     });
@@ -889,40 +869,37 @@ void AbstractImporterTest::setFileCallbackOpenFileAsDataFailed() {
 }
 
 void AbstractImporterTest::defaultScene() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         Int doDefaultScene() override { return 42; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.defaultScene(), 42);
 }
 
 void AbstractImporterTest::defaultSceneNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.defaultScene(), -1);
 }
 
 void AbstractImporterTest::defaultSceneNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.defaultScene();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::defaultScene(): no file opened\n");
 }
@@ -930,7 +907,7 @@ void AbstractImporterTest::defaultSceneNoFile() {
 int state;
 
 void AbstractImporterTest::scene() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -948,12 +925,11 @@ void AbstractImporterTest::scene() {
             if(id == 7) return SceneData{{}, {}, &state};
             else return SceneData{{}, {}};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.sceneCount(), 8);
     CORRADE_COMPARE(importer.sceneForName("eighth"), 7);
     CORRADE_COMPARE(importer.sceneName(7), "eighth");
@@ -964,149 +940,139 @@ void AbstractImporterTest::scene() {
 }
 
 void AbstractImporterTest::sceneCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.sceneCount(), 0);
 }
 
 void AbstractImporterTest::sceneCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.sceneCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::sceneCount(): no file opened\n");
 }
 
 void AbstractImporterTest::sceneForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.sceneForName(""), -1);
 }
 
 void AbstractImporterTest::sceneForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.sceneForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::sceneForName(): no file opened\n");
 }
 
 void AbstractImporterTest::sceneNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doSceneCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.sceneName(7), "");
 }
 
 void AbstractImporterTest::sceneNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.sceneName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::sceneName(): no file opened\n");
 }
 
 void AbstractImporterTest::sceneNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.sceneName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::sceneName(): index out of range\n");
 }
 
 void AbstractImporterTest::sceneNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doSceneCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.scene(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::scene(): not implemented\n");
 }
 
 void AbstractImporterTest::sceneNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.scene(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::scene(): no file opened\n");
 }
 
 void AbstractImporterTest::sceneOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.scene(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::scene(): index out of range\n");
 }
 
 void AbstractImporterTest::animation() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -1124,12 +1090,11 @@ void AbstractImporterTest::animation() {
             if(id == 7) return AnimationData{{}, {}, &state};
             else return AnimationData{{}, {}};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.animationCount(), 8);
     CORRADE_COMPARE(importer.animationForName("eighth"), 7);
     CORRADE_COMPARE(importer.animationName(7), "eighth");
@@ -1140,149 +1105,139 @@ void AbstractImporterTest::animation() {
 }
 
 void AbstractImporterTest::animationCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.animationCount(), 0);
 }
 
 void AbstractImporterTest::animationCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.animationCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::animationCount(): no file opened\n");
 }
 
 void AbstractImporterTest::animationForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.animationForName(""), -1);
 }
 
 void AbstractImporterTest::animationForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.animationForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::animationForName(): no file opened\n");
 }
 
 void AbstractImporterTest::animationNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doAnimationCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.animationName(7), "");
 }
 
 void AbstractImporterTest::animationNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.animationName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::animationName(): no file opened\n");
 }
 
 void AbstractImporterTest::animationNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.animationName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::animationName(): index out of range\n");
 }
 
 void AbstractImporterTest::animationNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doAnimationCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.animation(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::animation(): not implemented\n");
 }
 
 void AbstractImporterTest::animationNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.animation(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::animation(): no file opened\n");
 }
 
 void AbstractImporterTest::animationOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.animation(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::animation(): index out of range\n");
 }
 
 void AbstractImporterTest::light() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -1300,12 +1255,11 @@ void AbstractImporterTest::light() {
             if(id == 7) return LightData{{}, {}, {}, &state};
             else return {};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.lightCount(), 8);
     CORRADE_COMPARE(importer.lightForName("eighth"), 7);
     CORRADE_COMPARE(importer.lightName(7), "eighth");
@@ -1316,149 +1270,139 @@ void AbstractImporterTest::light() {
 }
 
 void AbstractImporterTest::lightCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.lightCount(), 0);
 }
 
 void AbstractImporterTest::lightCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.lightCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::lightCount(): no file opened\n");
 }
 
 void AbstractImporterTest::lightForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.lightForName(""), -1);
 }
 
 void AbstractImporterTest::lightForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.lightForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::lightForName(): no file opened\n");
 }
 
 void AbstractImporterTest::lightNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doLightCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.lightName(7), "");
 }
 
 void AbstractImporterTest::lightNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.lightName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::lightName(): no file opened\n");
 }
 
 void AbstractImporterTest::lightNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.lightName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::lightName(): index out of range\n");
 }
 
 void AbstractImporterTest::lightNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doLightCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.light(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::light(): not implemented\n");
 }
 
 void AbstractImporterTest::lightNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.light(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::light(): no file opened\n");
 }
 
 void AbstractImporterTest::lightOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.light(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::light(): index out of range\n");
 }
 
 void AbstractImporterTest::camera() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -1476,12 +1420,11 @@ void AbstractImporterTest::camera() {
             if(id == 7) return CameraData{{}, Vector2{}, {}, {}, &state};
             else return {};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.cameraCount(), 8);
     CORRADE_COMPARE(importer.cameraForName("eighth"), 7);
     CORRADE_COMPARE(importer.cameraName(7), "eighth");
@@ -1492,149 +1435,139 @@ void AbstractImporterTest::camera() {
 }
 
 void AbstractImporterTest::cameraCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.cameraCount(), 0);
 }
 
 void AbstractImporterTest::cameraCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.cameraCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::cameraCount(): no file opened\n");
 }
 
 void AbstractImporterTest::cameraForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.cameraForName(""), -1);
 }
 
 void AbstractImporterTest::cameraForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.cameraForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::cameraForName(): no file opened\n");
 }
 
 void AbstractImporterTest::cameraNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doCameraCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.cameraName(7), "");
 }
 
 void AbstractImporterTest::cameraNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.cameraName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::cameraName(): no file opened\n");
 }
 
 void AbstractImporterTest::cameraNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.cameraName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::cameraName(): index out of range\n");
 }
 
 void AbstractImporterTest::cameraNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doCameraCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.camera(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::camera(): not implemented\n");
 }
 
 void AbstractImporterTest::cameraNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.camera(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::camera(): no file opened\n");
 }
 
 void AbstractImporterTest::cameraOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.camera(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::camera(): index out of range\n");
 }
 
 void AbstractImporterTest::object2D() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -1652,12 +1585,11 @@ void AbstractImporterTest::object2D() {
             if(id == 7) return Containers::pointer(new ObjectData2D{{}, {}, &state});
             else return {};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.object2DCount(), 8);
     CORRADE_COMPARE(importer.object2DForName("eighth"), 7);
     CORRADE_COMPARE(importer.object2DName(7), "eighth");
@@ -1668,149 +1600,139 @@ void AbstractImporterTest::object2D() {
 }
 
 void AbstractImporterTest::object2DCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.object2DCount(), 0);
 }
 
 void AbstractImporterTest::object2DCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object2DCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object2DCount(): no file opened\n");
 }
 
 void AbstractImporterTest::object2DForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.object2DForName(""), -1);
 }
 
 void AbstractImporterTest::object2DForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object2DForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object2DForName(): no file opened\n");
 }
 
 void AbstractImporterTest::object2DNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doObject2DCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.object2DName(7), "");
 }
 
 void AbstractImporterTest::object2DNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object2DName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object2DName(): no file opened\n");
 }
 
 void AbstractImporterTest::object2DNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object2DName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object2DName(): index out of range\n");
 }
 
 void AbstractImporterTest::object2DNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doObject2DCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object2D(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object2D(): not implemented\n");
 }
 
 void AbstractImporterTest::object2DNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object2D(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object2D(): no file opened\n");
 }
 
 void AbstractImporterTest::object2DOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object2D(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object2D(): index out of range\n");
 }
 
 void AbstractImporterTest::object3D() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -1828,12 +1750,11 @@ void AbstractImporterTest::object3D() {
             if(id == 7) return Containers::pointer(new ObjectData3D{{}, {}, &state});
             else return {};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.object3DCount(), 8);
     CORRADE_COMPARE(importer.object3DForName("eighth"), 7);
     CORRADE_COMPARE(importer.object3DName(7), "eighth");
@@ -1844,149 +1765,139 @@ void AbstractImporterTest::object3D() {
 }
 
 void AbstractImporterTest::object3DCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.object3DCount(), 0);
 }
 
 void AbstractImporterTest::object3DCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object3DCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object3DCount(): no file opened\n");
 }
 
 void AbstractImporterTest::object3DForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.object3DForName(""), -1);
 }
 
 void AbstractImporterTest::object3DForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object3DForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object3DForName(): no file opened\n");
 }
 
 void AbstractImporterTest::object3DNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doObject3DCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.object3DName(7), "");
 }
 
 void AbstractImporterTest::object3DNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object3DName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object3DName(): no file opened\n");
 }
 
 void AbstractImporterTest::object3DNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object3DName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object3DName(): index out of range\n");
 }
 
 void AbstractImporterTest::object3DNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doObject3DCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object3D(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object3D(): not implemented\n");
 }
 
 void AbstractImporterTest::object3DNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object3D(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object3D(): no file opened\n");
 }
 
 void AbstractImporterTest::object3DOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.object3D(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::object3D(): index out of range\n");
 }
 
 void AbstractImporterTest::mesh2D() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -2004,12 +1915,11 @@ void AbstractImporterTest::mesh2D() {
             if(id == 7) return MeshData2D{{}, {}, {{}}, {}, {}, &state};
             else return {};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.mesh2DCount(), 8);
     CORRADE_COMPARE(importer.mesh2DForName("eighth"), 7);
     CORRADE_COMPARE(importer.mesh2DName(7), "eighth");
@@ -2020,149 +1930,139 @@ void AbstractImporterTest::mesh2D() {
 }
 
 void AbstractImporterTest::mesh2DCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.mesh2DCount(), 0);
 }
 
 void AbstractImporterTest::mesh2DCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh2DCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh2DCount(): no file opened\n");
 }
 
 void AbstractImporterTest::mesh2DForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.mesh2DForName(""), -1);
 }
 
 void AbstractImporterTest::mesh2DForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh2DForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh2DForName(): no file opened\n");
 }
 
 void AbstractImporterTest::mesh2DNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doMesh2DCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.mesh2DName(7), "");
 }
 
 void AbstractImporterTest::mesh2DNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh2DName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh2DName(): no file opened\n");
 }
 
 void AbstractImporterTest::mesh2DNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh2DName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh2DName(): index out of range\n");
 }
 
 void AbstractImporterTest::mesh2DNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doMesh2DCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh2D(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh2D(): not implemented\n");
 }
 
 void AbstractImporterTest::mesh2DNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh2D(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh2D(): no file opened\n");
 }
 
 void AbstractImporterTest::mesh2DOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh2D(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh2D(): index out of range\n");
 }
 
 void AbstractImporterTest::mesh3D() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -2180,12 +2080,11 @@ void AbstractImporterTest::mesh3D() {
             if(id == 7) return MeshData3D{{}, {}, {{}}, {}, {}, {}, &state};
             else return {};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.mesh3DCount(), 8);
     CORRADE_COMPARE(importer.mesh3DForName("eighth"), 7);
     CORRADE_COMPARE(importer.mesh3DName(7), "eighth");
@@ -2196,149 +2095,139 @@ void AbstractImporterTest::mesh3D() {
 }
 
 void AbstractImporterTest::mesh3DCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.mesh3DCount(), 0);
 }
 
 void AbstractImporterTest::mesh3DCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh3DCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh3DCount(): no file opened\n");
 }
 
 void AbstractImporterTest::mesh3DForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.mesh3DForName(""), -1);
 }
 
 void AbstractImporterTest::mesh3DForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh3DForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh3DForName(): no file opened\n");
 }
 
 void AbstractImporterTest::mesh3DNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doMesh3DCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.mesh3DName(7), "");
 }
 
 void AbstractImporterTest::mesh3DNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh3DName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh3DName(): no file opened\n");
 }
 
 void AbstractImporterTest::mesh3DNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh3DName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh3DName(): index out of range\n");
 }
 
 void AbstractImporterTest::mesh3DNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doMesh3DCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh3D(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh3D(): not implemented\n");
 }
 
 void AbstractImporterTest::mesh3DNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh3D(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh3D(): no file opened\n");
 }
 
 void AbstractImporterTest::mesh3DOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.mesh3D(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::mesh3D(): index out of range\n");
 }
 
 void AbstractImporterTest::material() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -2356,12 +2245,11 @@ void AbstractImporterTest::material() {
             if(id == 7) return Containers::pointer(new PhongMaterialData{{}, {}, {}, {}, &state});
             else return {};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.materialCount(), 8);
     CORRADE_COMPARE(importer.materialForName("eighth"), 7);
     CORRADE_COMPARE(importer.materialName(7), "eighth");
@@ -2372,149 +2260,139 @@ void AbstractImporterTest::material() {
 }
 
 void AbstractImporterTest::materialCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.materialCount(), 0);
 }
 
 void AbstractImporterTest::materialCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.materialCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::materialCount(): no file opened\n");
 }
 
 void AbstractImporterTest::materialForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.materialForName(""), -1);
 }
 
 void AbstractImporterTest::materialForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.materialForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::materialForName(): no file opened\n");
 }
 
 void AbstractImporterTest::materialNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doMaterialCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.materialName(7), "");
 }
 
 void AbstractImporterTest::materialNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.materialName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::materialName(): no file opened\n");
 }
 
 void AbstractImporterTest::materialNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.materialName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::materialName(): index out of range\n");
 }
 
 void AbstractImporterTest::materialNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doMaterialCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.material(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::material(): not implemented\n");
 }
 
 void AbstractImporterTest::materialNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.material(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::material(): no file opened\n");
 }
 
 void AbstractImporterTest::materialOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.material(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::material(): index out of range\n");
 }
 
 void AbstractImporterTest::texture() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -2532,12 +2410,11 @@ void AbstractImporterTest::texture() {
             if(id == 7) return TextureData{{}, {}, {}, {}, {}, {}, &state};
             else return {};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.textureCount(), 8);
     CORRADE_COMPARE(importer.textureForName("eighth"), 7);
     CORRADE_COMPARE(importer.textureName(7), "eighth");
@@ -2548,149 +2425,139 @@ void AbstractImporterTest::texture() {
 }
 
 void AbstractImporterTest::textureCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.textureCount(), 0);
 }
 
 void AbstractImporterTest::textureCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.textureCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::textureCount(): no file opened\n");
 }
 
 void AbstractImporterTest::textureForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.textureForName(""), -1);
 }
 
 void AbstractImporterTest::textureForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.textureForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::textureForName(): no file opened\n");
 }
 
 void AbstractImporterTest::textureNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doTextureCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.textureName(7), "");
 }
 
 void AbstractImporterTest::textureNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.textureName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::textureName(): no file opened\n");
 }
 
 void AbstractImporterTest::textureNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.textureName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::textureName(): index out of range\n");
 }
 
 void AbstractImporterTest::textureNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doTextureCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.texture(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::texture(): not implemented\n");
 }
 
 void AbstractImporterTest::textureNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.texture(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::texture(): no file opened\n");
 }
 
 void AbstractImporterTest::textureOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.texture(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::texture(): index out of range\n");
 }
 
 void AbstractImporterTest::image1D() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -2708,12 +2575,11 @@ void AbstractImporterTest::image1D() {
             if(id == 7) return ImageData1D{PixelStorage{}, {}, {}, {}, &state};
             else return {};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.image1DCount(), 8);
     CORRADE_COMPARE(importer.image1DForName("eighth"), 7);
     CORRADE_COMPARE(importer.image1DName(7), "eighth");
@@ -2724,149 +2590,139 @@ void AbstractImporterTest::image1D() {
 }
 
 void AbstractImporterTest::image1DCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.image1DCount(), 0);
 }
 
 void AbstractImporterTest::image1DCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image1DCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image1DCount(): no file opened\n");
 }
 
 void AbstractImporterTest::image1DForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.image1DForName(""), -1);
 }
 
 void AbstractImporterTest::image1DForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image1DForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image1DForName(): no file opened\n");
 }
 
 void AbstractImporterTest::image1DNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doImage1DCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.image1DName(7), "");
 }
 
 void AbstractImporterTest::image1DNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image1DName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image1DName(): no file opened\n");
 }
 
 void AbstractImporterTest::image1DNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image1DName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image1DName(): index out of range\n");
 }
 
 void AbstractImporterTest::image1DNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doImage1DCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image1D(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image1D(): not implemented\n");
 }
 
 void AbstractImporterTest::image1DNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image1D(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image1D(): no file opened\n");
 }
 
 void AbstractImporterTest::image1DOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image1D(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image1D(): index out of range\n");
 }
 
 void AbstractImporterTest::image2D() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -2884,12 +2740,11 @@ void AbstractImporterTest::image2D() {
             if(id == 7) return ImageData2D{PixelStorage{}, {}, {}, {}, &state};
             else return {};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.image2DCount(), 8);
     CORRADE_COMPARE(importer.image2DForName("eighth"), 7);
     CORRADE_COMPARE(importer.image2DName(7), "eighth");
@@ -2900,149 +2755,139 @@ void AbstractImporterTest::image2D() {
 }
 
 void AbstractImporterTest::image2DCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.image2DCount(), 0);
 }
 
 void AbstractImporterTest::image2DCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image2DCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image2DCount(): no file opened\n");
 }
 
 void AbstractImporterTest::image2DForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.image2DForName(""), -1);
 }
 
 void AbstractImporterTest::image2DForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image2DForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image2DForName(): no file opened\n");
 }
 
 void AbstractImporterTest::image2DNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doImage2DCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.image2DName(7), "");
 }
 
 void AbstractImporterTest::image2DNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image2DName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image2DName(): no file opened\n");
 }
 
 void AbstractImporterTest::image2DNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image2DName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image2DName(): index out of range\n");
 }
 
 void AbstractImporterTest::image2DNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doImage2DCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image2D(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image2D(): not implemented\n");
 }
 
 void AbstractImporterTest::image2DNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image2D(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image2D(): no file opened\n");
 }
 
 void AbstractImporterTest::image2DOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image2D(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image2D(): index out of range\n");
 }
 
 void AbstractImporterTest::image3D() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
@@ -3060,12 +2905,11 @@ void AbstractImporterTest::image3D() {
             if(id == 7) return ImageData3D{PixelStorage{}, {}, {}, {}, &state};
             else return {};
         }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     CORRADE_COMPARE(importer.image3DCount(), 8);
     CORRADE_COMPARE(importer.image3DForName("eighth"), 7);
     CORRADE_COMPARE(importer.image3DName(7), "eighth");
@@ -3076,182 +2920,169 @@ void AbstractImporterTest::image3D() {
 }
 
 void AbstractImporterTest::image3DCountNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.image3DCount(), 0);
 }
 
 void AbstractImporterTest::image3DCountNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image3DCount();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image3DCount(): no file opened\n");
 }
 
 void AbstractImporterTest::image3DForNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.image3DForName(""), -1);
 }
 
 void AbstractImporterTest::image3DForNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image3DForName("");
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image3DForName(): no file opened\n");
 }
 
 void AbstractImporterTest::image3DNameNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doImage3DCount() const override { return 8; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.image3DName(7), "");
 }
 
 void AbstractImporterTest::image3DNameNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image3DName(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image3DName(): no file opened\n");
 }
 
 void AbstractImporterTest::image3DNameOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image3DName(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image3DName(): index out of range\n");
 }
 
 void AbstractImporterTest::image3DNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         UnsignedInt doImage3DCount() const override { return 8; }
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image3D(7);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image3D(): not implemented\n");
 }
 
 void AbstractImporterTest::image3DNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image3D(42);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image3D(): no file opened\n");
 }
 
 void AbstractImporterTest::image3DOutOfRange() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.image3D(0);
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::image3D(): index out of range\n");
 }
 
 void AbstractImporterTest::importerState() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
 
         const void* doImporterState() const override { return &state; }
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.importerState(), &state);
 }
 
 void AbstractImporterTest::importerStateNotImplemented() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return true; }
         void doClose() override {}
-    };
+    } importer;
 
-    Importer importer;
     CORRADE_COMPARE(importer.importerState(), nullptr);
 }
 
 void AbstractImporterTest::importerStateNoFile() {
-    class Importer: public Trade::AbstractImporter {
+    struct: AbstractImporter {
         Features doFeatures() const override { return {}; }
         bool doIsOpened() const override { return false; }
         void doClose() override {}
-    };
+    } importer;
 
     std::ostringstream out;
     Error redirectError{&out};
 
-    Importer importer;
     importer.importerState();
     CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::importerState(): no file opened\n");
 }