diff --git a/src/Magnum/Trade/AbstractImporter.cpp b/src/Magnum/Trade/AbstractImporter.cpp
index 81aa3e020..53117ba94 100644
--- a/src/Magnum/Trade/AbstractImporter.cpp
+++ b/src/Magnum/Trade/AbstractImporter.cpp
@@ -87,7 +87,7 @@ void AbstractImporter::doOpenData(Containers::ArrayView<const char>) {
 
 bool AbstractImporter::openState(const void* state, const std::string& filePath) {
     CORRADE_ASSERT(features() & Feature::OpenState,
-        "Trade::AbstractImporter::OpenState(): feature not supported", {});
+        "Trade::AbstractImporter::openState(): feature not supported", {});
 
     close();
     doOpenState(state, filePath);
@@ -158,7 +158,9 @@ Containers::Optional<SceneData> AbstractImporter::scene(const UnsignedInt id) {
     return doScene(id);
 }
 
-Containers::Optional<SceneData> AbstractImporter::doScene(UnsignedInt) { return Containers::NullOpt; }
+Containers::Optional<SceneData> AbstractImporter::doScene(UnsignedInt) {
+    CORRADE_ASSERT(false, "Trade::AbstractImporter::scene(): not implemented", {});
+}
 
 UnsignedInt AbstractImporter::lightCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::lightCount(): no file opened", {});
@@ -188,7 +190,9 @@ Containers::Optional<LightData> AbstractImporter::light(const UnsignedInt id) {
     return doLight(id);
 }
 
-Containers::Optional<LightData> AbstractImporter::doLight(UnsignedInt) { return Containers::NullOpt; }
+Containers::Optional<LightData> AbstractImporter::doLight(UnsignedInt) {
+    CORRADE_ASSERT(false, "Trade::AbstractImporter::light(): not implemented", {});
+}
 
 UnsignedInt AbstractImporter::cameraCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::cameraCount(): no file opened", {});
@@ -218,7 +222,9 @@ Containers::Optional<CameraData> AbstractImporter::camera(const UnsignedInt id)
     return doCamera(id);
 }
 
-Containers::Optional<CameraData> AbstractImporter::doCamera(UnsignedInt) { return Containers::NullOpt; }
+Containers::Optional<CameraData> AbstractImporter::doCamera(UnsignedInt) {
+    CORRADE_ASSERT(false, "Trade::AbstractImporter::camera(): not implemented", {});
+}
 
 UnsignedInt AbstractImporter::object2DCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::object2DCount(): no file opened", {});
@@ -248,7 +254,9 @@ std::unique_ptr<ObjectData2D> AbstractImporter::object2D(const UnsignedInt id) {
     return doObject2D(id);
 }
 
-std::unique_ptr<ObjectData2D> AbstractImporter::doObject2D(UnsignedInt) { return nullptr; }
+std::unique_ptr<ObjectData2D> AbstractImporter::doObject2D(UnsignedInt) {
+    CORRADE_ASSERT(false, "Trade::AbstractImporter::object2D(): not implemented", {});
+}
 
 UnsignedInt AbstractImporter::object3DCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::object3DCount(): no file opened", {});
@@ -278,7 +286,9 @@ std::unique_ptr<ObjectData3D> AbstractImporter::object3D(const UnsignedInt id) {
     return doObject3D(id);
 }
 
-std::unique_ptr<ObjectData3D> AbstractImporter::doObject3D(UnsignedInt) { return nullptr; }
+std::unique_ptr<ObjectData3D> AbstractImporter::doObject3D(UnsignedInt) {
+    CORRADE_ASSERT(false, "Trade::AbstractImporter::object3D(): not implemented", {});
+}
 
 UnsignedInt AbstractImporter::mesh2DCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::mesh2DCount(): no file opened", {});
@@ -296,7 +306,7 @@ Int AbstractImporter::doMesh2DForName(const std::string&) { return -1; }
 
 std::string AbstractImporter::mesh2DName(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::mesh2DName(): no file opened", {});
-    CORRADE_ASSERT(id < doMesh2DCount(), "Trade::AbstractImporter::object2DName(): index out of range", {});
+    CORRADE_ASSERT(id < doMesh2DCount(), "Trade::AbstractImporter::mesh2DName(): index out of range", {});
     return doMesh2DName(id);
 }
 
@@ -304,11 +314,13 @@ std::string AbstractImporter::doMesh2DName(UnsignedInt) { return {}; }
 
 Containers::Optional<MeshData2D> AbstractImporter::mesh2D(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::mesh2D(): no file opened", {});
-    CORRADE_ASSERT(id < doMesh2DCount(), "Trade::AbstractImporter::object2D(): index out of range", {});
+    CORRADE_ASSERT(id < doMesh2DCount(), "Trade::AbstractImporter::mesh2D(): index out of range", {});
     return doMesh2D(id);
 }
 
-Containers::Optional<MeshData2D> AbstractImporter::doMesh2D(UnsignedInt) { return Containers::NullOpt; }
+Containers::Optional<MeshData2D> AbstractImporter::doMesh2D(UnsignedInt) {
+    CORRADE_ASSERT(false, "Trade::AbstractImporter::mesh2D(): not implemented", {});
+}
 
 UnsignedInt AbstractImporter::mesh3DCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::mesh3DCount(): no file opened", {});
@@ -326,7 +338,7 @@ Int AbstractImporter::doMesh3DForName(const std::string&) { return -1; }
 
 std::string AbstractImporter::mesh3DName(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::mesh3DName(): no file opened", {});
-    CORRADE_ASSERT(id < doMesh3DCount(), "Trade::AbstractImporter::object3DName(): index out of range", {});
+    CORRADE_ASSERT(id < doMesh3DCount(), "Trade::AbstractImporter::mesh3DName(): index out of range", {});
     return doMesh3DName(id);
 }
 
@@ -338,7 +350,9 @@ Containers::Optional<MeshData3D> AbstractImporter::mesh3D(const UnsignedInt id)
     return doMesh3D(id);
 }
 
-Containers::Optional<MeshData3D> AbstractImporter::doMesh3D(UnsignedInt) { return Containers::NullOpt; }
+Containers::Optional<MeshData3D> AbstractImporter::doMesh3D(UnsignedInt) {
+    CORRADE_ASSERT(false, "Trade::AbstractImporter::mesh3D(): not implemented", {});
+}
 
 UnsignedInt AbstractImporter::materialCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::materialCount(): no file opened", {});
@@ -368,7 +382,9 @@ std::unique_ptr<AbstractMaterialData> AbstractImporter::material(const UnsignedI
     return doMaterial(id);
 }
 
-std::unique_ptr<AbstractMaterialData> AbstractImporter::doMaterial(UnsignedInt) { return nullptr; }
+std::unique_ptr<AbstractMaterialData> AbstractImporter::doMaterial(UnsignedInt) {
+    CORRADE_ASSERT(false, "Trade::AbstractImporter::material(): not implemented", {});
+}
 
 UnsignedInt AbstractImporter::textureCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::textureCount(): no file opened", {});
@@ -398,7 +414,9 @@ Containers::Optional<TextureData> AbstractImporter::texture(const UnsignedInt id
     return doTexture(id);
 }
 
-Containers::Optional<TextureData> AbstractImporter::doTexture(UnsignedInt) { return Containers::NullOpt; }
+Containers::Optional<TextureData> AbstractImporter::doTexture(UnsignedInt) {
+    CORRADE_ASSERT(false, "Trade::AbstractImporter::texture(): not implemented", {});
+}
 
 UnsignedInt AbstractImporter::image1DCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::image1DCount(): no file opened", {});
@@ -428,7 +446,9 @@ Containers::Optional<ImageData1D> AbstractImporter::image1D(const UnsignedInt id
     return doImage1D(id);
 }
 
-Containers::Optional<ImageData1D> AbstractImporter::doImage1D(UnsignedInt) { return Containers::NullOpt; }
+Containers::Optional<ImageData1D> AbstractImporter::doImage1D(UnsignedInt) {
+    CORRADE_ASSERT(false, "Trade::AbstractImporter::image1D(): not implemented", {});
+}
 
 UnsignedInt AbstractImporter::image2DCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::image2DCount(): no file opened", {});
@@ -438,7 +458,7 @@ UnsignedInt AbstractImporter::image2DCount() const {
 UnsignedInt AbstractImporter::doImage2DCount() const { return 0; }
 
 Int AbstractImporter::image2DForName(const std::string& name) {
-    CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::image1DForName(): no file opened", {});
+    CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::image2DForName(): no file opened", {});
     return doImage2DForName(name);
 }
 
@@ -458,7 +478,9 @@ Containers::Optional<ImageData2D> AbstractImporter::image2D(const UnsignedInt id
     return doImage2D(id);
 }
 
-Containers::Optional<ImageData2D> AbstractImporter::doImage2D(UnsignedInt) { return Containers::NullOpt; }
+Containers::Optional<ImageData2D> AbstractImporter::doImage2D(UnsignedInt) {
+    CORRADE_ASSERT(false, "Trade::AbstractImporter::image2D(): not implemented", {});
+}
 
 UnsignedInt AbstractImporter::image3DCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::image3DCount(): no file opened", {});
@@ -488,7 +510,9 @@ Containers::Optional<ImageData3D> AbstractImporter::image3D(const UnsignedInt id
     return doImage3D(id);
 }
 
-Containers::Optional<ImageData3D> AbstractImporter::doImage3D(UnsignedInt) { return Containers::NullOpt; }
+Containers::Optional<ImageData3D> AbstractImporter::doImage3D(UnsignedInt) {
+    CORRADE_ASSERT(false, "Trade::AbstractImporter::image3D(): not implemented", {});
+}
 
 const void* AbstractImporter::importerState() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::importerState(): no file opened", {});
diff --git a/src/Magnum/Trade/CMakeLists.txt b/src/Magnum/Trade/CMakeLists.txt
index 9eb0e14b9..ec57ae010 100644
--- a/src/Magnum/Trade/CMakeLists.txt
+++ b/src/Magnum/Trade/CMakeLists.txt
@@ -27,7 +27,6 @@ find_package(Corrade REQUIRED PluginManager)
 
 set(MagnumTrade_SRCS
     AbstractImageConverter.cpp
-    AbstractImporter.cpp
     AbstractMaterialData.cpp
     LightData.cpp
     MeshData2D.cpp
@@ -38,6 +37,7 @@ set(MagnumTrade_SRCS
     TextureData.cpp)
 
 set(MagnumTrade_GracefulAssert_SRCS
+    AbstractImporter.cpp
     ImageData.cpp
     ObjectData2D.cpp
     ObjectData3D.cpp
diff --git a/src/Magnum/Trade/Test/AbstractImporterTest.cpp b/src/Magnum/Trade/Test/AbstractImporterTest.cpp
index b5843ea83..5b508085d 100644
--- a/src/Magnum/Trade/Test/AbstractImporterTest.cpp
+++ b/src/Magnum/Trade/Test/AbstractImporterTest.cpp
@@ -29,6 +29,16 @@
 #include <Corrade/Utility/Directory.h>
 
 #include "Magnum/Trade/AbstractImporter.h"
+#include "Magnum/Trade/CameraData.h"
+#include "Magnum/Trade/ImageData.h"
+#include "Magnum/Trade/LightData.h"
+#include "Magnum/Trade/MeshData2D.h"
+#include "Magnum/Trade/MeshData3D.h"
+#include "Magnum/Trade/MeshObjectData2D.h"
+#include "Magnum/Trade/MeshObjectData3D.h"
+#include "Magnum/Trade/PhongMaterialData.h"
+#include "Magnum/Trade/SceneData.h"
+#include "Magnum/Trade/TextureData.h"
 
 #include "configure.h"
 
@@ -38,41 +48,2686 @@ class AbstractImporterTest: public TestSuite::Tester {
     public:
         explicit AbstractImporterTest();
 
-        void openFile();
+        void construct();
+        void constructWithPluginManagerReference();
+
+        void openFileAsData();
+        void openFileAsDataNotFound();
+
+        void openFileNotImplemented();
+        void openDataNotSupported();
+        void openDataNotImplemented();
+        void openStateNotSupported();
+        void openStateNotImplemented();
+
+        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 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() {
-    addTests({&AbstractImporterTest::openFile,
+    addTests({&AbstractImporterTest::construct,
+              &AbstractImporterTest::constructWithPluginManagerReference,
+
+              &AbstractImporterTest::openFileAsData,
+              &AbstractImporterTest::openFileAsDataNotFound,
+
+              &AbstractImporterTest::openFileNotImplemented,
+              &AbstractImporterTest::openDataNotSupported,
+              &AbstractImporterTest::openDataNotImplemented,
+              &AbstractImporterTest::openStateNotSupported,
+              &AbstractImporterTest::openStateNotImplemented,
+
+              &AbstractImporterTest::defaultScene,
+              &AbstractImporterTest::defaultSceneNotImplemented,
+              &AbstractImporterTest::defaultSceneNoFile,
+
+              &AbstractImporterTest::scene,
+              &AbstractImporterTest::sceneCountNotImplemented,
+              &AbstractImporterTest::sceneCountNoFile,
+              &AbstractImporterTest::sceneForNameNotImplemented,
+              &AbstractImporterTest::sceneForNameNoFile,
+              &AbstractImporterTest::sceneNameNotImplemented,
+              &AbstractImporterTest::sceneNameNoFile,
+              &AbstractImporterTest::sceneNameOutOfRange,
+              &AbstractImporterTest::sceneNotImplemented,
+              &AbstractImporterTest::sceneNoFile,
+              &AbstractImporterTest::sceneOutOfRange,
+
+              &AbstractImporterTest::light,
+              &AbstractImporterTest::lightCountNotImplemented,
+              &AbstractImporterTest::lightCountNoFile,
+              &AbstractImporterTest::lightForNameNotImplemented,
+              &AbstractImporterTest::lightForNameNoFile,
+              &AbstractImporterTest::lightNameNotImplemented,
+              &AbstractImporterTest::lightNameNoFile,
+              &AbstractImporterTest::lightNameOutOfRange,
+              &AbstractImporterTest::lightNotImplemented,
+              &AbstractImporterTest::lightNoFile,
+              &AbstractImporterTest::lightOutOfRange,
+
+              &AbstractImporterTest::camera,
+              &AbstractImporterTest::cameraCountNotImplemented,
+              &AbstractImporterTest::cameraCountNoFile,
+              &AbstractImporterTest::cameraForNameNotImplemented,
+              &AbstractImporterTest::cameraForNameNoFile,
+              &AbstractImporterTest::cameraNameNotImplemented,
+              &AbstractImporterTest::cameraNameNoFile,
+              &AbstractImporterTest::cameraNameOutOfRange,
+              &AbstractImporterTest::cameraNotImplemented,
+              &AbstractImporterTest::cameraNoFile,
+              &AbstractImporterTest::cameraOutOfRange,
+
+              &AbstractImporterTest::object2D,
+              &AbstractImporterTest::object2DCountNotImplemented,
+              &AbstractImporterTest::object2DCountNoFile,
+              &AbstractImporterTest::object2DForNameNotImplemented,
+              &AbstractImporterTest::object2DForNameNoFile,
+              &AbstractImporterTest::object2DNameNotImplemented,
+              &AbstractImporterTest::object2DNameNoFile,
+              &AbstractImporterTest::object2DNameOutOfRange,
+              &AbstractImporterTest::object2DNotImplemented,
+              &AbstractImporterTest::object2DNoFile,
+              &AbstractImporterTest::object2DOutOfRange,
+
+              &AbstractImporterTest::object3D,
+              &AbstractImporterTest::object3DCountNotImplemented,
+              &AbstractImporterTest::object3DCountNoFile,
+              &AbstractImporterTest::object3DForNameNotImplemented,
+              &AbstractImporterTest::object3DForNameNoFile,
+              &AbstractImporterTest::object3DNameNotImplemented,
+              &AbstractImporterTest::object3DNameNoFile,
+              &AbstractImporterTest::object3DNameOutOfRange,
+              &AbstractImporterTest::object3DNotImplemented,
+              &AbstractImporterTest::object3DNoFile,
+              &AbstractImporterTest::object3DOutOfRange,
+
+              &AbstractImporterTest::mesh2D,
+              &AbstractImporterTest::mesh2DCountNotImplemented,
+              &AbstractImporterTest::mesh2DCountNoFile,
+              &AbstractImporterTest::mesh2DForNameNotImplemented,
+              &AbstractImporterTest::mesh2DForNameNoFile,
+              &AbstractImporterTest::mesh2DNameNotImplemented,
+              &AbstractImporterTest::mesh2DNameNoFile,
+              &AbstractImporterTest::mesh2DNameOutOfRange,
+              &AbstractImporterTest::mesh2DNotImplemented,
+              &AbstractImporterTest::mesh2DNoFile,
+              &AbstractImporterTest::mesh2DOutOfRange,
+
+              &AbstractImporterTest::mesh3D,
+              &AbstractImporterTest::mesh3DCountNotImplemented,
+              &AbstractImporterTest::mesh3DCountNoFile,
+              &AbstractImporterTest::mesh3DForNameNotImplemented,
+              &AbstractImporterTest::mesh3DForNameNoFile,
+              &AbstractImporterTest::mesh3DNameNotImplemented,
+              &AbstractImporterTest::mesh3DNameNoFile,
+              &AbstractImporterTest::mesh3DNameOutOfRange,
+              &AbstractImporterTest::mesh3DNotImplemented,
+              &AbstractImporterTest::mesh3DNoFile,
+              &AbstractImporterTest::mesh3DOutOfRange,
+
+              &AbstractImporterTest::material,
+              &AbstractImporterTest::materialCountNotImplemented,
+              &AbstractImporterTest::materialCountNoFile,
+              &AbstractImporterTest::materialForNameNotImplemented,
+              &AbstractImporterTest::materialForNameNoFile,
+              &AbstractImporterTest::materialNameNotImplemented,
+              &AbstractImporterTest::materialNameNoFile,
+              &AbstractImporterTest::materialNameOutOfRange,
+              &AbstractImporterTest::materialNotImplemented,
+              &AbstractImporterTest::materialNoFile,
+              &AbstractImporterTest::materialOutOfRange,
+
+              &AbstractImporterTest::texture,
+              &AbstractImporterTest::textureCountNotImplemented,
+              &AbstractImporterTest::textureCountNoFile,
+              &AbstractImporterTest::textureForNameNotImplemented,
+              &AbstractImporterTest::textureForNameNoFile,
+              &AbstractImporterTest::textureNameNotImplemented,
+              &AbstractImporterTest::textureNameNoFile,
+              &AbstractImporterTest::textureNameOutOfRange,
+              &AbstractImporterTest::textureNotImplemented,
+              &AbstractImporterTest::textureNoFile,
+              &AbstractImporterTest::textureOutOfRange,
+
+              &AbstractImporterTest::image1D,
+              &AbstractImporterTest::image1DCountNotImplemented,
+              &AbstractImporterTest::image1DCountNoFile,
+              &AbstractImporterTest::image1DForNameNotImplemented,
+              &AbstractImporterTest::image1DForNameNoFile,
+              &AbstractImporterTest::image1DNameNotImplemented,
+              &AbstractImporterTest::image1DNameNoFile,
+              &AbstractImporterTest::image1DNameOutOfRange,
+              &AbstractImporterTest::image1DNotImplemented,
+              &AbstractImporterTest::image1DNoFile,
+              &AbstractImporterTest::image1DOutOfRange,
+
+              &AbstractImporterTest::image2D,
+              &AbstractImporterTest::image2DCountNotImplemented,
+              &AbstractImporterTest::image2DCountNoFile,
+              &AbstractImporterTest::image2DForNameNotImplemented,
+              &AbstractImporterTest::image2DForNameNoFile,
+              &AbstractImporterTest::image2DNameNotImplemented,
+              &AbstractImporterTest::image2DNameNoFile,
+              &AbstractImporterTest::image2DNameOutOfRange,
+              &AbstractImporterTest::image2DNotImplemented,
+              &AbstractImporterTest::image2DNoFile,
+              &AbstractImporterTest::image2DOutOfRange,
+
+              &AbstractImporterTest::image3D,
+              &AbstractImporterTest::image3DCountNotImplemented,
+              &AbstractImporterTest::image3DCountNoFile,
+              &AbstractImporterTest::image3DForNameNotImplemented,
+              &AbstractImporterTest::image3DForNameNoFile,
+              &AbstractImporterTest::image3DNameNotImplemented,
+              &AbstractImporterTest::image3DNameNoFile,
+              &AbstractImporterTest::image3DNameOutOfRange,
+              &AbstractImporterTest::image3DNotImplemented,
+              &AbstractImporterTest::image3DNoFile,
+              &AbstractImporterTest::image3DOutOfRange,
+
+              &AbstractImporterTest::importerState,
+              &AbstractImporterTest::importerStateNotImplemented,
+              &AbstractImporterTest::importerStateNoFile,
 
               &AbstractImporterTest::debugFeature,
               &AbstractImporterTest::debugFeatures});
 }
 
-void AbstractImporterTest::openFile() {
-    class DataImporter: public Trade::AbstractImporter {
+void AbstractImporterTest::construct() {
+    class Importer: public AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.features(), AbstractImporter::Features{});
+    CORRADE_VERIFY(!importer.isOpened());
+
+    importer.close();
+    CORRADE_VERIFY(!importer.isOpened());
+}
+
+void AbstractImporterTest::constructWithPluginManagerReference() {
+    class Importer: public AbstractImporter {
         public:
-            explicit DataImporter(): opened(false) {}
+            explicit Importer(PluginManager::Manager<AbstractImporter>& manager): AbstractImporter{manager} {}
 
         private:
-            Features doFeatures() const override { return Feature::OpenData; }
-            bool doIsOpened() const override { return opened; }
+            Features doFeatures() const override { return {}; }
+            bool doIsOpened() const override { return false; }
             void doClose() override {}
+    };
+
+    PluginManager::Manager<AbstractImporter> manager;
+    Importer importer{manager};
+    CORRADE_VERIFY(!importer.isOpened());
+}
 
-            void doOpenData(Containers::ArrayView<const char> data) override {
-                opened = (data.size() == 1 && data[0] == '\xa5');
-            }
+void AbstractImporterTest::openFileAsData() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return Feature::OpenData; }
+        bool doIsOpened() const override { return _opened; }
+        void doClose() override { _opened = false; }
 
-            bool opened;
+        void doOpenData(Containers::ArrayView<const char> data) override {
+            _opened = (data.size() == 1 && data[0] == '\xa5');
+        }
+
+        bool _opened = false;
     };
 
     /* doOpenFile() should call doOpenData() */
-    DataImporter importer;
+    Importer importer;
     CORRADE_VERIFY(!importer.isOpened());
     importer.openFile(Utility::Directory::join(TRADE_TEST_DIR, "file.bin"));
     CORRADE_VERIFY(importer.isOpened());
+
+    importer.close();
+    CORRADE_VERIFY(!importer.isOpened());
+}
+
+void AbstractImporterTest::openFileAsDataNotFound() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return Feature::OpenData; }
+        bool doIsOpened() const override { return _opened; }
+        void doClose() override { _opened = false; }
+
+        void doOpenData(Containers::ArrayView<const char>) override {
+            _opened = true;
+        }
+
+        bool _opened = false;
+    };
+
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    Importer importer;
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    Importer importer;
+    importer.openFile("file.dat");
+    CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::openFile(): not implemented\n");
+}
+
+void AbstractImporterTest::openDataNotSupported() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    Importer importer;
+    importer.openData(nullptr);
+    CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::openData(): feature not supported\n");
+}
+
+void AbstractImporterTest::openDataNotImplemented() {
+    class DataImporter: public Trade::AbstractImporter {
+        Features doFeatures() const override { return Feature::OpenData; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    DataImporter importer;
+    importer.openData(nullptr);
+    CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::openData(): feature advertised but not implemented\n");
+}
+
+void AbstractImporterTest::openStateNotSupported() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    Importer importer;
+    importer.openState(nullptr);
+    CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::openState(): feature not supported\n");
+}
+
+void AbstractImporterTest::openStateNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return Feature::OpenState; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    Importer importer;
+    importer.openState(nullptr);
+    CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::openState(): feature advertised but not implemented\n");
+}
+
+void AbstractImporterTest::defaultScene() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        Int doDefaultScene() override { return 42; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.defaultScene(), 42);
+}
+
+void AbstractImporterTest::defaultSceneNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.defaultScene(), -1);
+}
+
+void AbstractImporterTest::defaultSceneNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    Importer importer;
+    importer.defaultScene();
+    CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::defaultScene(): no file opened\n");
+}
+
+namespace {
+    int state;
+}
+
+void AbstractImporterTest::scene() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doSceneCount() const override { return 8; }
+        Int doSceneForName(const std::string& name) override {
+            if(name == "eighth") return 7;
+            else return -1;
+        }
+        std::string doSceneName(UnsignedInt id) override {
+            if(id == 7) return "eighth";
+            else return {};
+        }
+        Containers::Optional<SceneData> doScene(UnsignedInt id) override {
+            if(id == 7) return SceneData{{}, {}, &state};
+            else return SceneData{{}, {}};
+        }
+    };
+
+    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");
+
+    auto data = importer.scene(7);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->importerState(), &state);
+}
+
+void AbstractImporterTest::sceneCountNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.sceneCount(), 0);
+}
+
+void AbstractImporterTest::sceneCountNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.sceneForName(""), -1);
+}
+
+void AbstractImporterTest::sceneForNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doSceneCount() const override { return 8; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.sceneName(7), "");
+}
+
+void AbstractImporterTest::sceneNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doSceneCount() const override { return 8; }
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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::light() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doLightCount() const override { return 8; }
+        Int doLightForName(const std::string& name) override {
+            if(name == "eighth") return 7;
+            else return -1;
+        }
+        std::string doLightName(UnsignedInt id) override {
+            if(id == 7) return "eighth";
+            else return {};
+        }
+        Containers::Optional<LightData> doLight(UnsignedInt id) override {
+            if(id == 7) return LightData{{}, {}, {}, &state};
+            else return {};
+        }
+    };
+
+    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");
+
+    auto data = importer.light(7);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->importerState(), &state);
+}
+
+void AbstractImporterTest::lightCountNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.lightCount(), 0);
+}
+
+void AbstractImporterTest::lightCountNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.lightForName(""), -1);
+}
+
+void AbstractImporterTest::lightForNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doLightCount() const override { return 8; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.lightName(7), "");
+}
+
+void AbstractImporterTest::lightNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doLightCount() const override { return 8; }
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doCameraCount() const override { return 8; }
+        Int doCameraForName(const std::string& name) override {
+            if(name == "eighth") return 7;
+            else return -1;
+        }
+        std::string doCameraName(UnsignedInt id) override {
+            if(id == 7) return "eighth";
+            else return {};
+        }
+        Containers::Optional<CameraData> doCamera(UnsignedInt id) override {
+            if(id == 7) return CameraData{{}, {}, {}, &state};
+            else return {};
+        }
+    };
+
+    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");
+
+    auto data = importer.camera(7);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->importerState(), &state);
+}
+
+void AbstractImporterTest::cameraCountNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.cameraCount(), 0);
+}
+
+void AbstractImporterTest::cameraCountNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.cameraForName(""), -1);
+}
+
+void AbstractImporterTest::cameraForNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doCameraCount() const override { return 8; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.cameraName(7), "");
+}
+
+void AbstractImporterTest::cameraNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doCameraCount() const override { return 8; }
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doObject2DCount() const override { return 8; }
+        Int doObject2DForName(const std::string& name) override {
+            if(name == "eighth") return 7;
+            else return -1;
+        }
+        std::string doObject2DName(UnsignedInt id) override {
+            if(id == 7) return "eighth";
+            else return {};
+        }
+        std::unique_ptr<ObjectData2D> doObject2D(UnsignedInt id) override {
+            if(id == 7) return std::unique_ptr<ObjectData2D>{new ObjectData2D{{}, {}, &state}};
+            else return {};
+        }
+    };
+
+    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");
+
+    auto data = importer.object2D(7);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->importerState(), &state);
+}
+
+void AbstractImporterTest::object2DCountNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.object2DCount(), 0);
+}
+
+void AbstractImporterTest::object2DCountNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.object2DForName(""), -1);
+}
+
+void AbstractImporterTest::object2DForNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doObject2DCount() const override { return 8; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.object2DName(7), "");
+}
+
+void AbstractImporterTest::object2DNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doObject2DCount() const override { return 8; }
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doObject3DCount() const override { return 8; }
+        Int doObject3DForName(const std::string& name) override {
+            if(name == "eighth") return 7;
+            else return -1;
+        }
+        std::string doObject3DName(UnsignedInt id) override {
+            if(id == 7) return "eighth";
+            else return {};
+        }
+        std::unique_ptr<ObjectData3D> doObject3D(UnsignedInt id) override {
+            if(id == 7) return std::unique_ptr<ObjectData3D>{new ObjectData3D{{}, {}, &state}};
+            else return {};
+        }
+    };
+
+    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");
+
+    auto data = importer.object3D(7);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->importerState(), &state);
+}
+
+void AbstractImporterTest::object3DCountNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.object3DCount(), 0);
+}
+
+void AbstractImporterTest::object3DCountNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.object3DForName(""), -1);
+}
+
+void AbstractImporterTest::object3DForNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doObject3DCount() const override { return 8; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.object3DName(7), "");
+}
+
+void AbstractImporterTest::object3DNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doObject3DCount() const override { return 8; }
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doMesh2DCount() const override { return 8; }
+        Int doMesh2DForName(const std::string& name) override {
+            if(name == "eighth") return 7;
+            else return -1;
+        }
+        std::string doMesh2DName(UnsignedInt id) override {
+            if(id == 7) return "eighth";
+            else return {};
+        }
+        Containers::Optional<MeshData2D> doMesh2D(UnsignedInt id) override {
+            if(id == 7) return MeshData2D{{}, {}, {{}}, {}, {}, &state};
+            else return {};
+        }
+    };
+
+    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");
+
+    auto data = importer.mesh2D(7);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->importerState(), &state);
+}
+
+void AbstractImporterTest::mesh2DCountNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.mesh2DCount(), 0);
+}
+
+void AbstractImporterTest::mesh2DCountNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.mesh2DForName(""), -1);
+}
+
+void AbstractImporterTest::mesh2DForNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doMesh2DCount() const override { return 8; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.mesh2DName(7), "");
+}
+
+void AbstractImporterTest::mesh2DNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doMesh2DCount() const override { return 8; }
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doMesh3DCount() const override { return 8; }
+        Int doMesh3DForName(const std::string& name) override {
+            if(name == "eighth") return 7;
+            else return -1;
+        }
+        std::string doMesh3DName(UnsignedInt id) override {
+            if(id == 7) return "eighth";
+            else return {};
+        }
+        Containers::Optional<MeshData3D> doMesh3D(UnsignedInt id) override {
+            if(id == 7) return MeshData3D{{}, {}, {{}}, {}, {}, {}, &state};
+            else return {};
+        }
+    };
+
+    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");
+
+    auto data = importer.mesh3D(7);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->importerState(), &state);
+}
+
+void AbstractImporterTest::mesh3DCountNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.mesh3DCount(), 0);
+}
+
+void AbstractImporterTest::mesh3DCountNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.mesh3DForName(""), -1);
+}
+
+void AbstractImporterTest::mesh3DForNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doMesh3DCount() const override { return 8; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.mesh3DName(7), "");
+}
+
+void AbstractImporterTest::mesh3DNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doMesh3DCount() const override { return 8; }
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doMaterialCount() const override { return 8; }
+        Int doMaterialForName(const std::string& name) override {
+            if(name == "eighth") return 7;
+            else return -1;
+        }
+        std::string doMaterialName(UnsignedInt id) override {
+            if(id == 7) return "eighth";
+            else return {};
+        }
+        std::unique_ptr<AbstractMaterialData> doMaterial(UnsignedInt id) override {
+            if(id == 7) return std::unique_ptr<PhongMaterialData>{new PhongMaterialData{{}, {}, &state}};
+            else return {};
+        }
+    };
+
+    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");
+
+    auto data = importer.material(7);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->importerState(), &state);
+}
+
+void AbstractImporterTest::materialCountNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.materialCount(), 0);
+}
+
+void AbstractImporterTest::materialCountNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.materialForName(""), -1);
+}
+
+void AbstractImporterTest::materialForNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doMaterialCount() const override { return 8; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.materialName(7), "");
+}
+
+void AbstractImporterTest::materialNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doMaterialCount() const override { return 8; }
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doTextureCount() const override { return 8; }
+        Int doTextureForName(const std::string& name) override {
+            if(name == "eighth") return 7;
+            else return -1;
+        }
+        std::string doTextureName(UnsignedInt id) override {
+            if(id == 7) return "eighth";
+            else return {};
+        }
+        Containers::Optional<TextureData> doTexture(UnsignedInt id) override {
+            if(id == 7) return TextureData{{}, {}, {}, {}, {}, {}, &state};
+            else return {};
+        }
+    };
+
+    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");
+
+    auto data = importer.texture(7);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->importerState(), &state);
+}
+
+void AbstractImporterTest::textureCountNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.textureCount(), 0);
+}
+
+void AbstractImporterTest::textureCountNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.textureForName(""), -1);
+}
+
+void AbstractImporterTest::textureForNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doTextureCount() const override { return 8; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.textureName(7), "");
+}
+
+void AbstractImporterTest::textureNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doTextureCount() const override { return 8; }
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doImage1DCount() const override { return 8; }
+        Int doImage1DForName(const std::string& name) override {
+            if(name == "eighth") return 7;
+            else return -1;
+        }
+        std::string doImage1DName(UnsignedInt id) override {
+            if(id == 7) return "eighth";
+            else return {};
+        }
+        Containers::Optional<ImageData1D> doImage1D(UnsignedInt id) override {
+            if(id == 7) return ImageData1D{PixelStorage{}, {}, {}, {}, &state};
+            else return {};
+        }
+    };
+
+    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");
+
+    auto data = importer.image1D(7);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->importerState(), &state);
+}
+
+void AbstractImporterTest::image1DCountNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.image1DCount(), 0);
+}
+
+void AbstractImporterTest::image1DCountNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.image1DForName(""), -1);
+}
+
+void AbstractImporterTest::image1DForNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doImage1DCount() const override { return 8; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.image1DName(7), "");
+}
+
+void AbstractImporterTest::image1DNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doImage1DCount() const override { return 8; }
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doImage2DCount() const override { return 8; }
+        Int doImage2DForName(const std::string& name) override {
+            if(name == "eighth") return 7;
+            else return -1;
+        }
+        std::string doImage2DName(UnsignedInt id) override {
+            if(id == 7) return "eighth";
+            else return {};
+        }
+        Containers::Optional<ImageData2D> doImage2D(UnsignedInt id) override {
+            if(id == 7) return ImageData2D{PixelStorage{}, {}, {}, {}, &state};
+            else return {};
+        }
+    };
+
+    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");
+
+    auto data = importer.image2D(7);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->importerState(), &state);
+}
+
+void AbstractImporterTest::image2DCountNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.image2DCount(), 0);
+}
+
+void AbstractImporterTest::image2DCountNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.image2DForName(""), -1);
+}
+
+void AbstractImporterTest::image2DForNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doImage2DCount() const override { return 8; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.image2DName(7), "");
+}
+
+void AbstractImporterTest::image2DNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doImage2DCount() const override { return 8; }
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doImage3DCount() const override { return 8; }
+        Int doImage3DForName(const std::string& name) override {
+            if(name == "eighth") return 7;
+            else return -1;
+        }
+        std::string doImage3DName(UnsignedInt id) override {
+            if(id == 7) return "eighth";
+            else return {};
+        }
+        Containers::Optional<ImageData3D> doImage3D(UnsignedInt id) override {
+            if(id == 7) return ImageData3D{PixelStorage{}, {}, {}, {}, &state};
+            else return {};
+        }
+    };
+
+    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");
+
+    auto data = importer.image3D(7);
+    CORRADE_VERIFY(data);
+    CORRADE_COMPARE(data->importerState(), &state);
+}
+
+void AbstractImporterTest::image3DCountNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.image3DCount(), 0);
+}
+
+void AbstractImporterTest::image3DCountNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.image3DForName(""), -1);
+}
+
+void AbstractImporterTest::image3DForNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doImage3DCount() const override { return 8; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.image3DName(7), "");
+}
+
+void AbstractImporterTest::image3DNameNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        UnsignedInt doImage3DCount() const override { return 8; }
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    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 {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+
+        const void* doImporterState() const override { return &state; }
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.importerState(), &state);
+}
+
+void AbstractImporterTest::importerStateNotImplemented() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return true; }
+        void doClose() override {}
+    };
+
+    Importer importer;
+    CORRADE_COMPARE(importer.importerState(), nullptr);
+}
+
+void AbstractImporterTest::importerStateNoFile() {
+    class Importer: public Trade::AbstractImporter {
+        Features doFeatures() const override { return {}; }
+        bool doIsOpened() const override { return false; }
+        void doClose() override {}
+    };
+
+    std::ostringstream out;
+    Error redirectError{&out};
+
+    Importer importer;
+    importer.importerState();
+    CORRADE_COMPARE(out.str(), "Trade::AbstractImporter::importerState(): no file opened\n");
 }
 
 void AbstractImporterTest::debugFeature() {
diff --git a/src/Magnum/Trade/Test/CMakeLists.txt b/src/Magnum/Trade/Test/CMakeLists.txt
index 9a8c0e5de..cd05cbfab 100644
--- a/src/Magnum/Trade/Test/CMakeLists.txt
+++ b/src/Magnum/Trade/Test/CMakeLists.txt
@@ -37,7 +37,7 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure.h.cmake
 corrade_add_test(TradeAbstractImageConverterTest AbstractImageConverterTest.cpp LIBRARIES MagnumTrade)
 target_include_directories(TradeAbstractImageConverterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
 corrade_add_test(TradeAbstractImporterTest AbstractImporterTest.cpp
-    LIBRARIES MagnumTrade
+    LIBRARIES MagnumTradeTestLib
     FILES file.bin)
 target_include_directories(TradeAbstractImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
 corrade_add_test(TradeCameraDataTest CameraDataTest.cpp LIBRARIES MagnumTrade)