ShaderTools,Trade: properly test failure states of all plugin APIs.

Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago · ee27d42a37
4 changed files with 1215 additions and 0 deletions
--- a/src/Magnum/ShaderTools/Test/AbstractConverterTest.cpp
+++ b/src/Magnum/ShaderTools/Test/AbstractConverterTest.cpp
@ -70,12 +70,14 @@ struct AbstractConverterTest: TestSuite::Tester {
    void setDebugInfoLevelNotImplemented();
    void validateData();
    void validateDataFailed();
    void validateDataNotSupported();
    void validateDataNotImplemented();
    void validateDataPreprocessOnly();
    void validateDataCustomStringDeleter();
    void validateFile();
    void validateFileFailed();
    void validateFileAsData();
    void validateFileAsDataNotFound();
    void validateFileNotSupported();
@ -84,6 +86,7 @@ struct AbstractConverterTest: TestSuite::Tester {
    void validateFileCustomStringDeleter();
    void convertDataToData();
    void convertDataToDataFailed();
    void convertDataToDataNotSupported();
    void convertDataToDataNotImplemented();
    void convertDataToDataCustomDeleter();
@ -94,13 +97,16 @@ struct AbstractConverterTest: TestSuite::Tester {
    void convertDataToFileNotImplemented();
    void convertFileToFile();
    void convertFileToFileFailed();
    void convertFileToFileThroughData();
    void convertFileToFileThroughDataNotFound();
    void convertFileToFileThroughDataFailed();
    void convertFileToFileThroughDataNotWritable();
    void convertFileToFileNotSupported();
    void convertFileToFileNotImplemented();
    void convertFileToData();
    void convertFileToDataFailed();
    void convertFileToDataAsData();
    void convertFileToDataAsDataNotFound();
    void convertFileToDataNotSupported();
@ -108,6 +114,7 @@ struct AbstractConverterTest: TestSuite::Tester {
    void convertFileToDataCustomDeleter();
    void linkDataToData();
    void linkDataToDataFailed();
    void linkDataToDataNotSupported();
    void linkDataToDataNotImplemented();
    void linkDataToDataPreprocessOnly();
@ -122,6 +129,7 @@ struct AbstractConverterTest: TestSuite::Tester {
    void linkDataToFileNoData();
    void linkFilesToFile();
    void linkFilesToFileFailed();
    void linkFilesToFileThroughData();
    void linkFilesToFileThroughDataNotFound();
    void linkFilesToFileThroughDataFailed();
@ -130,7 +138,9 @@ struct AbstractConverterTest: TestSuite::Tester {
    void linkFilesToFileNotImplemented();
    void linkFilesToFilePreprocessOnly();
    void linkFilesToFileNoFile();
    void linkFilesToData();
    void linkFilesToDataFailed();
    void linkFilesToDataAsData();
    void linkFilesToDataAsDataNotFound();
    void linkFilesToDataNotSupported();
@ -210,12 +220,14 @@ AbstractConverterTest::AbstractConverterTest() {
              &AbstractConverterTest::setDebugInfoLevelNotImplemented,
              &AbstractConverterTest::validateData,
              &AbstractConverterTest::validateDataFailed,
              &AbstractConverterTest::validateDataNotSupported,
              &AbstractConverterTest::validateDataNotImplemented,
              &AbstractConverterTest::validateDataPreprocessOnly,
              &AbstractConverterTest::validateDataCustomStringDeleter,
              &AbstractConverterTest::validateFile,
              &AbstractConverterTest::validateFileFailed,
              &AbstractConverterTest::validateFileAsData,
              &AbstractConverterTest::validateFileAsDataNotFound,
              &AbstractConverterTest::validateFileNotSupported,
@ -224,6 +236,7 @@ AbstractConverterTest::AbstractConverterTest() {
              &AbstractConverterTest::validateFileCustomStringDeleter,
              &AbstractConverterTest::convertDataToData,
              &AbstractConverterTest::convertDataToDataFailed,
              &AbstractConverterTest::convertDataToDataNotSupported,
              &AbstractConverterTest::convertDataToDataNotImplemented,
              &AbstractConverterTest::convertDataToDataCustomDeleter,
@ -234,13 +247,16 @@ AbstractConverterTest::AbstractConverterTest() {
              &AbstractConverterTest::convertDataToFileNotImplemented,
              &AbstractConverterTest::convertFileToFile,
              &AbstractConverterTest::convertFileToFileFailed,
              &AbstractConverterTest::convertFileToFileThroughData,
              &AbstractConverterTest::convertFileToFileThroughDataNotFound,
              &AbstractConverterTest::convertFileToFileThroughDataFailed,
              &AbstractConverterTest::convertFileToFileThroughDataNotWritable,
              &AbstractConverterTest::convertFileToFileNotSupported,
              &AbstractConverterTest::convertFileToFileNotImplemented,
              &AbstractConverterTest::convertFileToData,
              &AbstractConverterTest::convertFileToDataFailed,
              &AbstractConverterTest::convertFileToDataAsData,
              &AbstractConverterTest::convertFileToDataAsDataNotFound,
              &AbstractConverterTest::convertFileToDataNotSupported,
@ -248,6 +264,7 @@ AbstractConverterTest::AbstractConverterTest() {
              &AbstractConverterTest::convertFileToDataCustomDeleter,
              &AbstractConverterTest::linkDataToData,
              &AbstractConverterTest::linkDataToDataFailed,
              &AbstractConverterTest::linkDataToDataNotSupported,
              &AbstractConverterTest::linkDataToDataNotImplemented,
              &AbstractConverterTest::linkDataToDataPreprocessOnly,
@ -262,6 +279,7 @@ AbstractConverterTest::AbstractConverterTest() {
              &AbstractConverterTest::linkDataToFileNoData,
              &AbstractConverterTest::linkFilesToFile,
              &AbstractConverterTest::linkFilesToFileFailed,
              &AbstractConverterTest::linkFilesToFileThroughData,
              &AbstractConverterTest::linkFilesToFileThroughDataNotFound,
              &AbstractConverterTest::linkFilesToFileThroughDataFailed,
@ -270,7 +288,9 @@ AbstractConverterTest::AbstractConverterTest() {
              &AbstractConverterTest::linkFilesToFileNotImplemented,
              &AbstractConverterTest::linkFilesToFilePreprocessOnly,
              &AbstractConverterTest::linkFilesToFileNoFile,
              &AbstractConverterTest::linkFilesToData,
              &AbstractConverterTest::linkFilesToDataFailed,
              &AbstractConverterTest::linkFilesToDataAsData,
              &AbstractConverterTest::linkFilesToDataAsDataNotFound,
              &AbstractConverterTest::linkFilesToDataNotSupported,
@ -690,6 +710,26 @@ void AbstractConverterTest::validateData() {
    CORRADE_COMPARE(out.second(), "Yes, this is valid");
 }
 void AbstractConverterTest::validateDataFailed() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
            return ConverterFeature::ValidateData;
        }
        void doSetInputFormat(Format, Containers::StringView) override {}
        void doSetOutputFormat(Format, Containers::StringView) override {}
        Containers::Pair<bool, Containers::String> doValidateData(Stage, Containers::ArrayView<const char>) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.validateData(Stage::MeshTask, nullptr).first());
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractConverterTest::validateDataNotSupported() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -789,6 +829,26 @@ void AbstractConverterTest::validateFile() {
    CORRADE_COMPARE(out.second(), "Yes, this is valid");
 }
 void AbstractConverterTest::validateFileFailed() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
            return ConverterFeature::ValidateFile;
        }
        void doSetInputFormat(Format, Containers::StringView) override {}
        void doSetOutputFormat(Format, Containers::StringView) override {}
        Containers::Pair<bool, Containers::String> doValidateFile(Stage, Containers::StringView) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.validateFile(Stage::MeshTask, {}).first());
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractConverterTest::validateFileAsData() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
@ -933,6 +993,26 @@ void AbstractConverterTest::convertDataToData() {
        TestSuite::Compare::Container);
 }
 void AbstractConverterTest::convertDataToDataFailed() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
            return ConverterFeature::ConvertData;
        }
        void doSetInputFormat(Format, Containers::StringView) override {}
        void doSetOutputFormat(Format, Containers::StringView) override {}
        Containers::Optional<Containers::Array<char>> doConvertDataToData(Stage, Containers::ArrayView<const char>) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertDataToData({}, nullptr));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractConverterTest::convertDataToDataNotSupported() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -1132,6 +1212,26 @@ void AbstractConverterTest::convertFileToFile() {
        TestSuite::Compare::FileToString);
 }
 void AbstractConverterTest::convertFileToFileFailed() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
            return ConverterFeature::ConvertFile;
        }
        void doSetInputFormat(Format, Containers::StringView) override {}
        void doSetOutputFormat(Format, Containers::StringView) override {}
        bool doConvertFileToFile(Stage, Containers::StringView, Containers::StringView) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertFileToFile({}, Utility::Path::join(SHADERTOOLS_TEST_DIR, "file.dat"), Utility::Path::join(SHADERTOOLS_TEST_OUTPUT_DIR, "file.dat")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractConverterTest::convertFileToFileThroughData() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
@ -1287,6 +1387,26 @@ void AbstractConverterTest::convertFileToData() {
        TestSuite::Compare::Container);
 }
 void AbstractConverterTest::convertFileToDataFailed() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
            return ConverterFeature::ConvertData;
        }
        void doSetInputFormat(Format, Containers::StringView) override {}
        void doSetOutputFormat(Format, Containers::StringView) override {}
        Containers::Optional<Containers::Array<char>> doConvertFileToData(Stage, Containers::StringView) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertFileToData({}, Utility::Path::join(SHADERTOOLS_TEST_DIR, "file.dat")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractConverterTest::convertFileToDataAsData() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
@ -1419,6 +1539,27 @@ void AbstractConverterTest::linkDataToData() {
        TestSuite::Compare::Container);
 }
 void AbstractConverterTest::linkDataToDataFailed() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
            return ConverterFeature::LinkData;
        }
        void doSetInputFormat(Format, Containers::StringView) override {}
        void doSetOutputFormat(Format, Containers::StringView) override {}
        Containers::Optional<Containers::Array<char>> doLinkDataToData(Containers::ArrayView<const Containers::Pair<Stage, Containers::ArrayView<const char>>>) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    /* {{}} makes GCC 4.8 warn about zero as null pointer constant */
    converter.linkDataToData({Containers::Pair<Stage, Containers::ArrayView<const void>>{}});
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractConverterTest::linkDataToDataNotSupported() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -1715,6 +1856,28 @@ void AbstractConverterTest::linkFilesToFile() {
        TestSuite::Compare::FileToString);
 }
 void AbstractConverterTest::linkFilesToFileFailed() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
            return ConverterFeature::LinkFile;
        }
        void doSetInputFormat(Format, Containers::StringView) override {}
        void doSetOutputFormat(Format, Containers::StringView) override {}
        bool doLinkFilesToFile(Containers::ArrayView<const Containers::Pair<Stage, Containers::StringView>>, Containers::StringView) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.linkFilesToFile({
        {Stage::Vertex, Utility::Path::join(SHADERTOOLS_TEST_DIR, "another.dat")}
    }, Utility::Path::join(SHADERTOOLS_TEST_OUTPUT_DIR, "file.dat")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractConverterTest::linkFilesToFileThroughData() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
@ -1933,6 +2096,28 @@ void AbstractConverterTest::linkFilesToData() {
        TestSuite::Compare::Container);
 }
 void AbstractConverterTest::linkFilesToDataFailed() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
            return ConverterFeature::LinkData;
        }
        void doSetInputFormat(Format, Containers::StringView) override {}
        void doSetOutputFormat(Format, Containers::StringView) override {}
        Containers::Optional<Containers::Array<char>> doLinkFilesToData(Containers::ArrayView<const Containers::Pair<Stage, Containers::StringView>>) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.linkFilesToData({
        {Stage::Vertex, Utility::Path::join(SHADERTOOLS_TEST_DIR, "another.dat")}
    }));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractConverterTest::linkFilesToDataAsData() {
    struct: AbstractConverter {
        ConverterFeatures doFeatures() const override {
--- a/src/Magnum/Trade/Test/AbstractImageConverterTest.cpp
+++ b/src/Magnum/Trade/Test/AbstractImageConverterTest.cpp
@ -59,6 +59,9 @@ struct AbstractImageConverterTest: TestSuite::Tester {
    void convert1D();
    void convert2D();
    void convert3D();
    void convert1DFailed();
    void convert2DFailed();
    void convert3DFailed();
    void convert1DNotImplemented();
    void convert2DNotImplemented();
    void convert3DNotImplemented();
@ -69,6 +72,9 @@ struct AbstractImageConverterTest: TestSuite::Tester {
    void convertCompressed1D();
    void convertCompressed2D();
    void convertCompressed3D();
    void convertCompressed1DFailed();
    void convertCompressed2DFailed();
    void convertCompressed3DFailed();
    void convertCompressed1DNotImplemented();
    void convertCompressed2DNotImplemented();
    void convertCompressed3DNotImplemented();
@ -83,6 +89,9 @@ struct AbstractImageConverterTest: TestSuite::Tester {
    void convert1DToData();
    void convert2DToData();
    void convert3DToData();
    void convert1DToDataFailed();
    void convert2DToDataFailed();
    void convert3DToDataFailed();
    /* 1D/2D/3D share the same image validity check function, so only verify
       one dimension thoroughly and for others just that the check is used */
    void convert1DToDataInvalidImage();
@ -99,6 +108,9 @@ struct AbstractImageConverterTest: TestSuite::Tester {
    void convertCompressed1DToData();
    void convertCompressed2DToData();
    void convertCompressed3DToData();
    void convertCompressed1DToDataFailed();
    void convertCompressed2DToDataFailed();
    void convertCompressed3DToDataFailed();
    /* Compressed share the same image validity check function with
       uncompressed, so only verify it's used */
    void convertCompressed1DToDataInvalidImage();
@ -118,6 +130,9 @@ struct AbstractImageConverterTest: TestSuite::Tester {
    void convertLevels1DToData();
    void convertLevels2DToData();
    void convertLevels3DToData();
    void convertLevels1DToDataFailed();
    void convertLevels2DToDataFailed();
    void convertLevels3DToDataFailed();
    /* 1D/2D/3D share the same image list validity check function, so only
       verify one dimension thoroughly and for others just that the check is
       used */
@ -138,6 +153,9 @@ struct AbstractImageConverterTest: TestSuite::Tester {
    void convertCompressedLevels1DToData();
    void convertCompressedLevels2DToData();
    void convertCompressedLevels3DToData();
    void convertCompressedLevels1DToDataFailed();
    void convertCompressedLevels2DToDataFailed();
    void convertCompressedLevels3DToDataFailed();
    /* Compressed have different format checks for uncompressed so it's tested
       again; 1D/2D/3D share the same image list validity check function, so
       only verify one dimension thoroughly and for others just that the check
@ -166,6 +184,9 @@ struct AbstractImageConverterTest: TestSuite::Tester {
    void convert1DToFile();
    void convert2DToFile();
    void convert3DToFile();
    void convert1DToFileFailed();
    void convert2DToFileFailed();
    void convert3DToFileFailed();
    void convert1DToFileThroughData();
    void convert2DToFileThroughData();
    void convert3DToFileThroughData();
@ -187,6 +208,9 @@ struct AbstractImageConverterTest: TestSuite::Tester {
    void convertCompressed1DToFile();
    void convertCompressed2DToFile();
    void convertCompressed3DToFile();
    void convertCompressed1DToFileFailed();
    void convertCompressed2DToFileFailed();
    void convertCompressed3DToFileFailed();
    void convertCompressed1DToFileThroughData();
    void convertCompressed2DToFileThroughData();
    void convertCompressed3DToFileThroughData();
@ -212,6 +236,9 @@ struct AbstractImageConverterTest: TestSuite::Tester {
    void convertLevels1DToFile();
    void convertLevels2DToFile();
    void convertLevels3DToFile();
    void convertLevels1DToFileFailed();
    void convertLevels2DToFileFailed();
    void convertLevels3DToFileFailed();
    void convertLevels1DToFileThroughData();
    void convertLevels2DToFileThroughData();
    void convertLevels3DToFileThroughData();
@ -233,6 +260,9 @@ struct AbstractImageConverterTest: TestSuite::Tester {
    void convertCompressedLevels1DToFile();
    void convertCompressedLevels2DToFile();
    void convertCompressedLevels3DToFile();
    void convertCompressedLevels1DToFileFailed();
    void convertCompressedLevels2DToFileFailed();
    void convertCompressedLevels3DToFileFailed();
    void convertCompressedLevels1DToFileThroughData();
    void convertCompressedLevels2DToFileThroughData();
    void convertCompressedLevels3DToFileThroughData();
@ -278,6 +308,9 @@ AbstractImageConverterTest::AbstractImageConverterTest() {
              &AbstractImageConverterTest::convert1D,
              &AbstractImageConverterTest::convert2D,
              &AbstractImageConverterTest::convert3D,
              &AbstractImageConverterTest::convert1DFailed,
              &AbstractImageConverterTest::convert2DFailed,
              &AbstractImageConverterTest::convert3DFailed,
              &AbstractImageConverterTest::convert1DNotImplemented,
              &AbstractImageConverterTest::convert2DNotImplemented,
              &AbstractImageConverterTest::convert3DNotImplemented,
@ -288,6 +321,9 @@ AbstractImageConverterTest::AbstractImageConverterTest() {
              &AbstractImageConverterTest::convertCompressed1D,
              &AbstractImageConverterTest::convertCompressed2D,
              &AbstractImageConverterTest::convertCompressed3D,
              &AbstractImageConverterTest::convertCompressed1DFailed,
              &AbstractImageConverterTest::convertCompressed2DFailed,
              &AbstractImageConverterTest::convertCompressed3DFailed,
              &AbstractImageConverterTest::convertCompressed1DNotImplemented,
              &AbstractImageConverterTest::convertCompressed2DNotImplemented,
              &AbstractImageConverterTest::convertCompressed3DNotImplemented,
@ -302,6 +338,9 @@ AbstractImageConverterTest::AbstractImageConverterTest() {
              &AbstractImageConverterTest::convert1DToData,
              &AbstractImageConverterTest::convert2DToData,
              &AbstractImageConverterTest::convert3DToData,
              &AbstractImageConverterTest::convert1DToDataFailed,
              &AbstractImageConverterTest::convert2DToDataFailed,
              &AbstractImageConverterTest::convert3DToDataFailed,
              &AbstractImageConverterTest::convert1DToDataInvalidImage,
              &AbstractImageConverterTest::convert2DToDataZeroSize,
              &AbstractImageConverterTest::convert2DToDataNullptr,
@ -316,6 +355,9 @@ AbstractImageConverterTest::AbstractImageConverterTest() {
              &AbstractImageConverterTest::convertCompressed1DToData,
              &AbstractImageConverterTest::convertCompressed2DToData,
              &AbstractImageConverterTest::convertCompressed3DToData,
              &AbstractImageConverterTest::convertCompressed1DToDataFailed,
              &AbstractImageConverterTest::convertCompressed2DToDataFailed,
              &AbstractImageConverterTest::convertCompressed3DToDataFailed,
              &AbstractImageConverterTest::convertCompressed1DToDataInvalidImage,
              &AbstractImageConverterTest::convertCompressed2DToDataInvalidImage,
              &AbstractImageConverterTest::convertCompressed3DToDataInvalidImage,
@ -333,6 +375,9 @@ AbstractImageConverterTest::AbstractImageConverterTest() {
              &AbstractImageConverterTest::convertLevels1DToData,
              &AbstractImageConverterTest::convertLevels2DToData,
              &AbstractImageConverterTest::convertLevels3DToData,
              &AbstractImageConverterTest::convertLevels1DToDataFailed,
              &AbstractImageConverterTest::convertLevels2DToDataFailed,
              &AbstractImageConverterTest::convertLevels3DToDataFailed,
              &AbstractImageConverterTest::convertLevels1DToDataInvalidImage,
              &AbstractImageConverterTest::convertLevels2DToDataNoLevels,
              &AbstractImageConverterTest::convertLevels2DToDataZeroSize,
@ -350,6 +395,9 @@ AbstractImageConverterTest::AbstractImageConverterTest() {
              &AbstractImageConverterTest::convertCompressedLevels1DToData,
              &AbstractImageConverterTest::convertCompressedLevels2DToData,
              &AbstractImageConverterTest::convertCompressedLevels3DToData,
              &AbstractImageConverterTest::convertCompressedLevels1DToDataFailed,
              &AbstractImageConverterTest::convertCompressedLevels2DToDataFailed,
              &AbstractImageConverterTest::convertCompressedLevels3DToDataFailed,
              &AbstractImageConverterTest::convertCompressedLevels1DToDataInvalidImage,
              &AbstractImageConverterTest::convertCompressedLevels2DToDataNoLevels,
              &AbstractImageConverterTest::convertCompressedLevels2DToDataZeroSize,
@ -374,6 +422,9 @@ AbstractImageConverterTest::AbstractImageConverterTest() {
              &AbstractImageConverterTest::convert1DToFile,
              &AbstractImageConverterTest::convert2DToFile,
              &AbstractImageConverterTest::convert3DToFile,
              &AbstractImageConverterTest::convert1DToFileFailed,
              &AbstractImageConverterTest::convert2DToFileFailed,
              &AbstractImageConverterTest::convert3DToFileFailed,
              &AbstractImageConverterTest::convert1DToFileThroughData,
              &AbstractImageConverterTest::convert2DToFileThroughData,
              &AbstractImageConverterTest::convert3DToFileThroughData,
@ -393,6 +444,9 @@ AbstractImageConverterTest::AbstractImageConverterTest() {
              &AbstractImageConverterTest::convertCompressed1DToFile,
              &AbstractImageConverterTest::convertCompressed2DToFile,
              &AbstractImageConverterTest::convertCompressed3DToFile,
              &AbstractImageConverterTest::convertCompressed1DToFileFailed,
              &AbstractImageConverterTest::convertCompressed2DToFileFailed,
              &AbstractImageConverterTest::convertCompressed3DToFileFailed,
              &AbstractImageConverterTest::convertCompressed1DToFileThroughData,
              &AbstractImageConverterTest::convertCompressed2DToFileThroughData,
              &AbstractImageConverterTest::convertCompressed3DToFileThroughData,
@ -416,6 +470,9 @@ AbstractImageConverterTest::AbstractImageConverterTest() {
              &AbstractImageConverterTest::convertLevels1DToFile,
              &AbstractImageConverterTest::convertLevels2DToFile,
              &AbstractImageConverterTest::convertLevels3DToFile,
              &AbstractImageConverterTest::convertLevels1DToFileFailed,
              &AbstractImageConverterTest::convertLevels2DToFileFailed,
              &AbstractImageConverterTest::convertLevels3DToFileFailed,
              &AbstractImageConverterTest::convertLevels1DToFileThroughData,
              &AbstractImageConverterTest::convertLevels2DToFileThroughData,
              &AbstractImageConverterTest::convertLevels3DToFileThroughData,
@ -435,6 +492,9 @@ AbstractImageConverterTest::AbstractImageConverterTest() {
              &AbstractImageConverterTest::convertCompressedLevels1DToFile,
              &AbstractImageConverterTest::convertCompressedLevels2DToFile,
              &AbstractImageConverterTest::convertCompressedLevels3DToFile,
              &AbstractImageConverterTest::convertCompressedLevels1DToFileFailed,
              &AbstractImageConverterTest::convertCompressedLevels2DToFileFailed,
              &AbstractImageConverterTest::convertCompressedLevels3DToFileFailed,
              &AbstractImageConverterTest::convertCompressedLevels1DToFileThroughData,
              &AbstractImageConverterTest::convertCompressedLevels2DToFileThroughData,
              &AbstractImageConverterTest::convertCompressedLevels3DToFileThroughData,
@ -645,6 +705,57 @@ void AbstractImageConverterTest::convert3D() {
    CORRADE_COMPARE(actual->size(), (Vector3i{4, 6, 1}));
 }
 void AbstractImageConverterTest::convert1DFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::Convert1D;
        }
        Containers::Optional<ImageData1D> doConvert(const ImageView1D&) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convert(ImageView1D{PixelFormat::RGBA8Unorm, 1, {nullptr, 4}}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convert2DFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::Convert2D;
        }
        Containers::Optional<ImageData2D> doConvert(const ImageView2D&) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convert(ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, {nullptr, 4}}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convert3DFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::Convert3D;
        }
        Containers::Optional<ImageData3D> doConvert(const ImageView3D&) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convert(ImageView3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {nullptr, 4}}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convert1DNotImplemented() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -789,6 +900,57 @@ void AbstractImageConverterTest::convertCompressed3D() {
    CORRADE_COMPARE(actual->size(), (Vector3i{16, 8, 1}));
 }
 void AbstractImageConverterTest::convertCompressed1DFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressed1D;
        }
        Containers::Optional<ImageData1D> doConvert(const CompressedImageView1D&) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convert(CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 1, {nullptr, 4*4}}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressed2DFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressed2D;
        }
        Containers::Optional<ImageData2D> doConvert(const CompressedImageView2D&) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convert(CompressedImageView2D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1}, {nullptr, 4*4}}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressed3DFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressed3D;
        }
        Containers::Optional<ImageData3D> doConvert(const CompressedImageView3D&) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convert(CompressedImageView3D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1, 1}, {nullptr, 4*4}}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressed1DNotImplemented() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -1026,6 +1188,63 @@ void AbstractImageConverterTest::convert3DToData() {
    CORRADE_COMPARE(actual->size(), 48);
 }
 void AbstractImageConverterTest::convert1DToDataFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::Convert1DToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(const ImageView1D&) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData(ImageView1D{PixelFormat::RGBA8Unorm, 1, imageData}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convert2DToDataFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::Convert2DToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(const ImageView2D&) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData(ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, imageData}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convert3DToDataFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::Convert3DToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(const ImageView3D&) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData(ImageView3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, imageData}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convert1DToDataInvalidImage() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -1234,6 +1453,63 @@ void AbstractImageConverterTest::convertCompressed3DToData() {
    CORRADE_COMPARE(actual->size(), 256);
 }
 void AbstractImageConverterTest::convertCompressed1DToDataFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressed1DToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(const CompressedImageView1D&) override {
            return {};
        }
    } converter;
    const char imageData[4*4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData(CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 1, imageData}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressed2DToDataFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressed2DToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(const CompressedImageView2D&) override {
            return {};
        }
    } converter;
    const char imageData[4*4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData(CompressedImageView2D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1}, imageData}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressed3DToDataFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressed3DToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(const CompressedImageView3D&) override {
            return {};
        }
    } converter;
    const char imageData[4*4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData(CompressedImageView3D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1, 1}, imageData}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressed1DToDataInvalidImage() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -1545,6 +1821,63 @@ void AbstractImageConverterTest::convertLevels3DToData() {
    CORRADE_COMPARE(actual->size(), 48*3);
 }
 void AbstractImageConverterTest::convertLevels1DToDataFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertLevels1DToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(Containers::ArrayView<const ImageView1D>) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData({ImageView1D{PixelFormat::RGBA8Unorm, 1, imageData}}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertLevels2DToDataFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertLevels2DToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(Containers::ArrayView<const ImageView2D>) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData({ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, imageData}}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertLevels3DToDataFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertLevels3DToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(Containers::ArrayView<const ImageView3D>) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData({ImageView3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, imageData}}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertLevels1DToDataInvalidImage() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -1830,6 +2163,63 @@ void AbstractImageConverterTest::convertCompressedLevels3DToData() {
    CORRADE_COMPARE(actual->size(), 256*3);
 }
 void AbstractImageConverterTest::convertCompressedLevels1DToDataFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressedLevels1DToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(Containers::ArrayView<const CompressedImageView1D>) override {
            return {};
        }
    } converter;
    const char imageData[4*4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData({CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 1, imageData}}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressedLevels2DToDataFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressedLevels2DToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(Containers::ArrayView<const CompressedImageView2D>) override {
            return {};
        }
    } converter;
    const char imageData[4*4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData({CompressedImageView2D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1}, imageData}}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressedLevels3DToDataFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressedLevels3DToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(Containers::ArrayView<const CompressedImageView3D>) override {
            return {};
        }
    } converter;
    const char imageData[4*4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData({CompressedImageView3D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1, 1}, imageData}}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressedLevels1DToDataInvalidImage() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -2179,6 +2569,63 @@ void AbstractImageConverterTest::convert3DToFile() {
        "\x0f\x0d\x02", TestSuite::Compare::FileToString);
 }
 void AbstractImageConverterTest::convert1DToFileFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::Convert1DToFile;
        }
        bool doConvertToFile(const ImageView1D&, Containers::StringView) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile(ImageView1D{PixelFormat::RGBA8Unorm, 1, imageData}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convert2DToFileFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::Convert2DToFile;
        }
        bool doConvertToFile(const ImageView2D&, Containers::StringView) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile(ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, imageData}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convert3DToFileFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::Convert3DToFile;
        }
        bool doConvertToFile(const ImageView3D&, Containers::StringView) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile(ImageView3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, imageData}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convert1DToFileThroughData() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert1DToData; }
@ -2518,6 +2965,63 @@ void AbstractImageConverterTest::convertCompressed3DToFile() {
        "\x0f\x0d\x02", TestSuite::Compare::FileToString);
 }
 void AbstractImageConverterTest::convertCompressed1DToFileFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressed1DToFile;
        }
        bool doConvertToFile(const CompressedImageView1D&, Containers::StringView) override {
            return {};
        }
    } converter;
    const char imageData[4*4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile(CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 1, imageData}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressed2DToFileFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressed2DToFile;
        }
        bool doConvertToFile(const CompressedImageView2D&, Containers::StringView) override {
            return {};
        }
    } converter;
    const char imageData[4*4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile(CompressedImageView2D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1}, imageData}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressed3DToFileFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressed3DToFile;
        }
        bool doConvertToFile(const CompressedImageView3D&, Containers::StringView) override {
            return {};
        }
    } converter;
    const char imageData[4*4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile(CompressedImageView3D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1, 1}, imageData}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressed1DToFileThroughData() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::ConvertCompressed1DToData; }
@ -2914,6 +3418,63 @@ void AbstractImageConverterTest::convertLevels3DToFile() {
        "\x0f\x0d\x0e\x02", TestSuite::Compare::FileToString);
 }
 void AbstractImageConverterTest::convertLevels1DToFileFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertLevels1DToFile;
        }
        bool doConvertToFile(Containers::ArrayView<const ImageView1D>, Containers::StringView) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile({ImageView1D{PixelFormat::RGBA8Unorm, 1, imageData}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertLevels2DToFileFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertLevels2DToFile;
        }
        bool doConvertToFile(Containers::ArrayView<const ImageView2D>, Containers::StringView) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile({ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, imageData}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertLevels3DToFileFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertLevels3DToFile;
        }
        bool doConvertToFile(Containers::ArrayView<const ImageView3D>, Containers::StringView) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile({ImageView3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, imageData}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertLevels1DToFileThroughData() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::ConvertLevels1DToData; }
@ -3280,6 +3841,63 @@ void AbstractImageConverterTest::convertCompressedLevels3DToFile() {
        "\x0f\x0d\x0e\x02", TestSuite::Compare::FileToString);
 }
 void AbstractImageConverterTest::convertCompressedLevels1DToFileFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressedLevels1DToFile;
        }
        bool doConvertToFile(Containers::ArrayView<const CompressedImageView1D>, Containers::StringView) override {
            return {};
        }
    } converter;
    const char imageData[4*4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile({CompressedImageView1D{CompressedPixelFormat::Bc1RGBAUnorm, 1, imageData}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressedLevels2DToFileFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressedLevels2DToFile;
        }
        bool doConvertToFile(Containers::ArrayView<const CompressedImageView2D>, Containers::StringView) override {
            return {};
        }
    } converter;
    const char imageData[4*4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile({CompressedImageView2D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1}, imageData}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressedLevels3DToFileFailed() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override {
            return ImageConverterFeature::ConvertCompressedLevels3DToFile;
        }
        bool doConvertToFile(Containers::ArrayView<const CompressedImageView3D>, Containers::StringView) override {
            return {};
        }
    } converter;
    const char imageData[4]{};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile({CompressedImageView3D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1, 1}, imageData}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImageConverterTest::convertCompressedLevels1DToFileThroughData() {
    struct: AbstractImageConverter {
        ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::ConvertCompressedLevels1DToData; }
--- a/src/Magnum/Trade/Test/AbstractImporterTest.cpp
+++ b/src/Magnum/Trade/Test/AbstractImporterTest.cpp
@ -80,14 +80,18 @@ struct AbstractImporterTest: TestSuite::Tester {
    void setFlagsNotImplemented();
    void openData();
    void openDataFailed();
    #ifdef MAGNUM_BUILD_DEPRECATED
    void openDataDeprecatedFallback();
    #endif
    void openMemory();
    void openMemoryFailed();
    void openFile();
    void openFileFailed();
    void openFileAsData();
    void openFileAsDataNotFound();
    void openState();
    void openStateFailed();
    void openFileNotImplemented();
    void openDataNotSupported();
@ -121,6 +125,7 @@ struct AbstractImporterTest: TestSuite::Tester {
    void defaultSceneOutOfRange();
    void scene();
    void sceneFailed();
    void object();
    #ifdef MAGNUM_BUILD_DEPRECATED
    void sceneDeprecatedFallback2D();
@ -155,6 +160,7 @@ struct AbstractImporterTest: TestSuite::Tester {
    void sceneFieldNameCustomDeleter();
    void animation();
    void animationFailed();
    void animationNameNotImplemented();
    void animationForNameOutOfRange();
    void animationNameOutOfRange();
@ -167,6 +173,7 @@ struct AbstractImporterTest: TestSuite::Tester {
    void animationCustomTrackDeleter();
    void light();
    void lightFailed();
    void lightNameNotImplemented();
    void lightForNameOutOfRange();
    void lightNameOutOfRange();
@ -175,6 +182,7 @@ struct AbstractImporterTest: TestSuite::Tester {
    void lightOutOfRange();
    void camera();
    void cameraFailed();
    void cameraNameNotImplemented();
    void cameraForNameOutOfRange();
    void cameraNameOutOfRange();
@ -213,6 +221,7 @@ struct AbstractImporterTest: TestSuite::Tester {
    #endif
    void skin2D();
    void skin2DFailed();
    void skin2DNameNotImplemented();
    void skin2DForNameOutOfRange();
    void skin2DNameOutOfRange();
@ -224,6 +233,7 @@ struct AbstractImporterTest: TestSuite::Tester {
    void skin2DCustomInverseBindMatrixDataDeleter();
    void skin3D();
    void skin3DFailed();
    void skin3DNameNotImplemented();
    void skin3DForNameOutOfRange();
    void skin3DNameOutOfRange();
@ -235,6 +245,7 @@ struct AbstractImporterTest: TestSuite::Tester {
    void skin3DCustomInverseBindMatrixDataDeleter();
    void mesh();
    void meshFailed();
    #ifdef MAGNUM_BUILD_DEPRECATED
    void meshDeprecatedFallback();
    #endif
@ -286,6 +297,7 @@ struct AbstractImporterTest: TestSuite::Tester {
    #endif
    void material();
    void materialFailed();
    #ifdef MAGNUM_BUILD_DEPRECATED
    void materialDeprecatedFallback();
    #endif
@ -300,6 +312,7 @@ struct AbstractImporterTest: TestSuite::Tester {
    void materialCustomLayerDataDeleter();
    void texture();
    void textureFailed();
    void textureForNameOutOfRange();
    void textureNameNotImplemented();
    void textureNameOutOfRange();
@ -308,6 +321,7 @@ struct AbstractImporterTest: TestSuite::Tester {
    void textureOutOfRange();
    void image1D();
    void image1DFailed();
    void image1DLevelCountNotImplemented();
    void image1DLevelCountOutOfRange();
    void image1DLevelCountZero();
@ -323,6 +337,7 @@ struct AbstractImporterTest: TestSuite::Tester {
    void image1DCustomDeleter();
    void image2D();
    void image2DFailed();
    void image2DLevelCountNotImplemented();
    void image2DLevelCountOutOfRange();
    void image2DLevelCountZero();
@ -338,6 +353,7 @@ struct AbstractImporterTest: TestSuite::Tester {
    void image2DCustomDeleter();
    void image3D();
    void image3DFailed();
    void image3DLevelCountNotImplemented();
    void image3DLevelCountOutOfRange();
    void image3DLevelCountZero();
@ -381,14 +397,18 @@ AbstractImporterTest::AbstractImporterTest() {
              &AbstractImporterTest::setFlagsNotImplemented,
              &AbstractImporterTest::openData,
              &AbstractImporterTest::openDataFailed,
              #ifdef MAGNUM_BUILD_DEPRECATED
              &AbstractImporterTest::openDataDeprecatedFallback,
              #endif
              &AbstractImporterTest::openMemory,
              &AbstractImporterTest::openMemoryFailed,
              &AbstractImporterTest::openFile,
              &AbstractImporterTest::openFileFailed,
              &AbstractImporterTest::openFileAsData,
              &AbstractImporterTest::openFileAsDataNotFound,
              &AbstractImporterTest::openState,
              &AbstractImporterTest::openStateFailed,
              &AbstractImporterTest::openFileNotImplemented,
              &AbstractImporterTest::openDataNotSupported,
@ -425,6 +445,7 @@ AbstractImporterTest::AbstractImporterTest() {
              &AbstractImporterTest::defaultSceneNotImplemented,
              &AbstractImporterTest::scene,
              &AbstractImporterTest::sceneFailed,
              &AbstractImporterTest::object,
              #ifdef MAGNUM_BUILD_DEPRECATED
              &AbstractImporterTest::sceneDeprecatedFallback2D,
@ -459,6 +480,7 @@ AbstractImporterTest::AbstractImporterTest() {
              &AbstractImporterTest::sceneFieldNameCustomDeleter,
              &AbstractImporterTest::animation,
              &AbstractImporterTest::animationFailed,
              &AbstractImporterTest::animationForNameOutOfRange,
              &AbstractImporterTest::animationNameNotImplemented,
              &AbstractImporterTest::animationNameOutOfRange,
@ -471,6 +493,7 @@ AbstractImporterTest::AbstractImporterTest() {
              &AbstractImporterTest::animationCustomTrackDeleter,
              &AbstractImporterTest::light,
              &AbstractImporterTest::lightFailed,
              &AbstractImporterTest::lightForNameOutOfRange,
              &AbstractImporterTest::lightNameNotImplemented,
              &AbstractImporterTest::lightNameOutOfRange,
@ -479,6 +502,7 @@ AbstractImporterTest::AbstractImporterTest() {
              &AbstractImporterTest::lightOutOfRange,
              &AbstractImporterTest::camera,
              &AbstractImporterTest::cameraFailed,
              &AbstractImporterTest::cameraForNameOutOfRange,
              &AbstractImporterTest::cameraNameNotImplemented,
              &AbstractImporterTest::cameraNameOutOfRange,
@ -523,6 +547,7 @@ AbstractImporterTest::AbstractImporterTest() {
    #endif
    addTests({&AbstractImporterTest::skin2D,
              &AbstractImporterTest::skin2DFailed,
              &AbstractImporterTest::skin2DForNameOutOfRange,
              &AbstractImporterTest::skin2DNameNotImplemented,
              &AbstractImporterTest::skin2DNameOutOfRange,
@ -534,6 +559,7 @@ AbstractImporterTest::AbstractImporterTest() {
              &AbstractImporterTest::skin2DCustomInverseBindMatrixDataDeleter,
              &AbstractImporterTest::skin3D,
              &AbstractImporterTest::skin3DFailed,
              &AbstractImporterTest::skin3DForNameOutOfRange,
              &AbstractImporterTest::skin3DNameNotImplemented,
              &AbstractImporterTest::skin3DNameOutOfRange,
@ -545,6 +571,7 @@ AbstractImporterTest::AbstractImporterTest() {
              &AbstractImporterTest::skin3DCustomInverseBindMatrixDataDeleter,
              &AbstractImporterTest::mesh,
              &AbstractImporterTest::meshFailed,
              #ifdef MAGNUM_BUILD_DEPRECATED
              &AbstractImporterTest::meshDeprecatedFallback,
              #endif
@ -596,6 +623,7 @@ AbstractImporterTest::AbstractImporterTest() {
              #endif
              &AbstractImporterTest::material,
              &AbstractImporterTest::materialFailed,
              #ifdef MAGNUM_BUILD_DEPRECATED
              &AbstractImporterTest::materialDeprecatedFallback,
              #endif
@ -610,6 +638,7 @@ AbstractImporterTest::AbstractImporterTest() {
              &AbstractImporterTest::materialCustomLayerDataDeleter,
              &AbstractImporterTest::texture,
              &AbstractImporterTest::textureFailed,
              &AbstractImporterTest::textureForNameOutOfRange,
              &AbstractImporterTest::textureNameNotImplemented,
              &AbstractImporterTest::textureNameOutOfRange,
@ -618,6 +647,7 @@ AbstractImporterTest::AbstractImporterTest() {
              &AbstractImporterTest::textureOutOfRange,
              &AbstractImporterTest::image1D,
              &AbstractImporterTest::image1DFailed,
              &AbstractImporterTest::image1DLevelCountNotImplemented,
              &AbstractImporterTest::image1DLevelCountOutOfRange,
              &AbstractImporterTest::image1DLevelCountZero,
@ -633,6 +663,7 @@ AbstractImporterTest::AbstractImporterTest() {
              &AbstractImporterTest::image1DCustomDeleter,
              &AbstractImporterTest::image2D,
              &AbstractImporterTest::image2DFailed,
              &AbstractImporterTest::image2DLevelCountNotImplemented,
              &AbstractImporterTest::image2DLevelCountOutOfRange,
              &AbstractImporterTest::image2DLevelCountZero,
@ -648,6 +679,7 @@ AbstractImporterTest::AbstractImporterTest() {
              &AbstractImporterTest::image2DCustomDeleter,
              &AbstractImporterTest::image3D,
              &AbstractImporterTest::image3DFailed,
              &AbstractImporterTest::image3DLevelCountNotImplemented,
              &AbstractImporterTest::image3DLevelCountOutOfRange,
              &AbstractImporterTest::image3DLevelCountZero,
@ -792,6 +824,24 @@ void AbstractImporterTest::openData() {
    CORRADE_VERIFY(!importer.isOpened());
 }
 void AbstractImporterTest::openDataFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override {
            return ImporterFeature::OpenData;
        }
        bool doIsOpened() const override { return false; }
        void doClose() override {}
        void doOpenData(Containers::Array<char>&&, DataFlags) override {}
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.openData(nullptr));
    CORRADE_COMPARE(out.str(), "");
 }
 #ifdef MAGNUM_BUILD_DEPRECATED
 void AbstractImporterTest::openDataDeprecatedFallback() {
    struct: AbstractImporter {
@ -847,6 +897,24 @@ void AbstractImporterTest::openMemory() {
    CORRADE_VERIFY(!importer.isOpened());
 }
 void AbstractImporterTest::openMemoryFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override {
            return ImporterFeature::OpenData;
        }
        bool doIsOpened() const override { return false; }
        void doClose() override {}
        void doOpenData(Containers::Array<char>&&, DataFlags) override {}
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.openMemory(nullptr));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::openFile() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
@ -869,6 +937,22 @@ void AbstractImporterTest::openFile() {
    CORRADE_VERIFY(!importer.isOpened());
 }
 void AbstractImporterTest::openFileFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return false; }
        void doClose() override {}
        void doOpenFile(Containers::StringView) override {}
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.openFile({}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::openFileAsData() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return ImporterFeature::OpenData; }
@ -946,6 +1030,24 @@ void AbstractImporterTest::openState() {
    CORRADE_VERIFY(!importer.isOpened());
 }
 void AbstractImporterTest::openStateFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override {
            return ImporterFeature::OpenState;
        }
        bool doIsOpened() const override { return false; }
        void doClose() override {}
        void doOpenState(const void*, Containers::StringView) override {}
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.openState({}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::openFileNotImplemented() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -1810,6 +1912,25 @@ void AbstractImporterTest::scene() {
    }
 }
 void AbstractImporterTest::sceneFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return true; }
        void doClose() override {}
        UnsignedInt doSceneCount() const override { return 1; }
        Containers::Optional<SceneData> doScene(UnsignedInt) override {
            return {};
        }
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.scene(0));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::object() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
@ -3789,6 +3910,25 @@ void AbstractImporterTest::animation() {
    }
 }
 void AbstractImporterTest::animationFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return true; }
        void doClose() override {}
        UnsignedInt doAnimationCount() const override { return 1; }
        Containers::Optional<AnimationData> doAnimation(UnsignedInt) override {
            return {};
        }
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.animation(0));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::animationForNameOutOfRange() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -4034,6 +4174,25 @@ void AbstractImporterTest::light() {
    }
 }
 void AbstractImporterTest::lightFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return true; }
        void doClose() override {}
        UnsignedInt doLightCount() const override { return 1; }
        Containers::Optional<LightData> doLight(UnsignedInt) override {
            return {};
        }
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.light(0));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::lightForNameOutOfRange() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -4184,6 +4343,25 @@ void AbstractImporterTest::camera() {
    }
 }
 void AbstractImporterTest::cameraFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return true; }
        void doClose() override {}
        UnsignedInt doCameraCount() const override { return 1; }
        Containers::Optional<CameraData> doCamera(UnsignedInt) override {
            return {};
        }
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.camera(0));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::cameraForNameOutOfRange() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -4898,6 +5076,25 @@ void AbstractImporterTest::skin2D() {
    }
 }
 void AbstractImporterTest::skin2DFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return true; }
        void doClose() override {}
        UnsignedInt doSkin2DCount() const override { return 1; }
        Containers::Optional<SkinData2D> doSkin2D(UnsignedInt) override {
            return {};
        }
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.skin2D(0));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::skin2DForNameOutOfRange() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -5132,6 +5329,25 @@ void AbstractImporterTest::skin3D() {
    }
 }
 void AbstractImporterTest::skin3DFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return true; }
        void doClose() override {}
        UnsignedInt doSkin3DCount() const override { return 1; }
        Containers::Optional<SkinData3D> doSkin3D(UnsignedInt) override {
            return {};
        }
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.skin3D(0));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::skin3DForNameOutOfRange() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -5371,6 +5587,25 @@ void AbstractImporterTest::mesh() {
    }
 }
 void AbstractImporterTest::meshFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return true; }
        void doClose() override {}
        UnsignedInt doMeshCount() const override { return 1; }
        Containers::Optional<MeshData> doMesh(UnsignedInt, UnsignedInt) override {
            return {};
        }
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.mesh(0));
    CORRADE_COMPARE(out.str(), "");
 }
 #ifdef MAGNUM_BUILD_DEPRECATED
 void AbstractImporterTest::meshDeprecatedFallback() {
    struct: AbstractImporter {
@ -6298,6 +6533,25 @@ void AbstractImporterTest::material() {
    }
 }
 void AbstractImporterTest::materialFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return true; }
        void doClose() override {}
        UnsignedInt doMaterialCount() const override { return 1; }
        Containers::Optional<MaterialData> doMaterial(UnsignedInt) override {
            return {};
        }
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.material(0));
    CORRADE_COMPARE(out.str(), "");
 }
 #ifdef MAGNUM_BUILD_DEPRECATED
 void AbstractImporterTest::materialDeprecatedFallback() {
    struct: AbstractImporter {
@ -6573,6 +6827,25 @@ void AbstractImporterTest::texture() {
    }
 }
 void AbstractImporterTest::textureFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return true; }
        void doClose() override {}
        UnsignedInt doTextureCount() const override { return 1; }
        Containers::Optional<TextureData> doTexture(UnsignedInt) override {
            return {};
        }
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.texture(0));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::textureForNameOutOfRange() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -6728,6 +7001,25 @@ void AbstractImporterTest::image1D() {
    }
 }
 void AbstractImporterTest::image1DFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return true; }
        void doClose() override {}
        UnsignedInt doImage1DCount() const override { return 1; }
        Containers::Optional<ImageData1D> doImage1D(UnsignedInt, UnsignedInt) override {
            return {};
        }
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.image1D(0));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::image1DLevelCountNotImplemented() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
@ -7031,6 +7323,25 @@ void AbstractImporterTest::image2D() {
    }
 }
 void AbstractImporterTest::image2DFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return true; }
        void doClose() override {}
        UnsignedInt doImage2DCount() const override { return 1; }
        Containers::Optional<ImageData2D> doImage2D(UnsignedInt, UnsignedInt) override {
            return {};
        }
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.image2D(0));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::image2DLevelCountNotImplemented() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
@ -7334,6 +7645,25 @@ void AbstractImporterTest::image3D() {
    }
 }
 void AbstractImporterTest::image3DFailed() {
    struct: AbstractImporter {
        ImporterFeatures doFeatures() const override { return {}; }
        bool doIsOpened() const override { return true; }
        void doClose() override {}
        UnsignedInt doImage3DCount() const override { return 1; }
        Containers::Optional<ImageData3D> doImage3D(UnsignedInt, UnsignedInt) override {
            return {};
        }
    } importer;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!importer.image3D(0));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractImporterTest::image3DForNameOutOfRange() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
--- a/src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp
+++ b/src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp
@ -54,6 +54,7 @@ struct AbstractSceneConverterTest: TestSuite::Tester {
    void thingNotSupported();
    void convertMesh();
    void convertMeshFailed();
    void convertMeshNotImplemented();
    void convertMeshNonOwningDeleters();
    void convertMeshGrowableDeleters();
@ -62,15 +63,18 @@ struct AbstractSceneConverterTest: TestSuite::Tester {
    void convertMeshCustomAttributeDataDeleter();
    void convertMeshInPlace();
    void convertMeshInPlaceFailed();
    void convertMeshInPlaceNotImplemented();
    void convertMeshToData();
    void convertMeshToDataFailed();
    void convertMeshToDataNotImplemented();
    void convertMeshToDataNonOwningDeleter();
    void convertMeshToDataGrowableDeleter();
    void convertMeshToDataCustomDeleter();
    void convertMeshToFile();
    void convertMeshToFileFailed();
    void convertMeshToFileThroughData();
    void convertMeshToFileThroughDataFailed();
    void convertMeshToFileThroughDataNotWritable();
@ -92,6 +96,7 @@ AbstractSceneConverterTest::AbstractSceneConverterTest() {
              &AbstractSceneConverterTest::thingNotSupported,
              &AbstractSceneConverterTest::convertMesh,
              &AbstractSceneConverterTest::convertMeshFailed,
              &AbstractSceneConverterTest::convertMeshNotImplemented,
              &AbstractSceneConverterTest::convertMeshNonOwningDeleters,
              &AbstractSceneConverterTest::convertMeshGrowableDeleters,
@ -100,15 +105,18 @@ AbstractSceneConverterTest::AbstractSceneConverterTest() {
              &AbstractSceneConverterTest::convertMeshCustomAttributeDataDeleter,
              &AbstractSceneConverterTest::convertMeshInPlace,
              &AbstractSceneConverterTest::convertMeshInPlaceFailed,
              &AbstractSceneConverterTest::convertMeshInPlaceNotImplemented,
              &AbstractSceneConverterTest::convertMeshToData,
              &AbstractSceneConverterTest::convertMeshToDataFailed,
              &AbstractSceneConverterTest::convertMeshToDataNotImplemented,
              &AbstractSceneConverterTest::convertMeshToDataNonOwningDeleter,
              &AbstractSceneConverterTest::convertMeshToDataGrowableDeleter,
              &AbstractSceneConverterTest::convertMeshToDataCustomDeleter,
              &AbstractSceneConverterTest::convertMeshToFile,
              &AbstractSceneConverterTest::convertMeshToFileFailed,
              &AbstractSceneConverterTest::convertMeshToFileThroughData,
              &AbstractSceneConverterTest::convertMeshToFileThroughDataFailed,
              &AbstractSceneConverterTest::convertMeshToFileThroughDataNotWritable,
@ -227,6 +235,24 @@ void AbstractSceneConverterTest::convertMesh() {
    CORRADE_COMPARE(out->vertexCount(), 12);
 }
 void AbstractSceneConverterTest::convertMeshFailed() {
    struct: AbstractSceneConverter {
        SceneConverterFeatures doFeatures() const override {
            return SceneConverterFeature::ConvertMesh;
        }
        Containers::Optional<MeshData> doConvert(const MeshData&) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convert(MeshData{MeshPrimitive::Triangles, 0}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractSceneConverterTest::convertMeshNotImplemented() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -380,6 +406,26 @@ void AbstractSceneConverterTest::convertMeshInPlace() {
        TestSuite::Compare::Container);
 }
 void AbstractSceneConverterTest::convertMeshInPlaceFailed() {
    struct: AbstractSceneConverter {
        SceneConverterFeatures doFeatures() const override {
            return SceneConverterFeature::ConvertMeshInPlace;
        }
        bool doConvertInPlace(MeshData&) override {
            return {};
        }
    } converter;
    MeshData mesh{MeshPrimitive::Triangles, 0};
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertInPlace(mesh));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractSceneConverterTest::convertMeshInPlaceNotImplemented() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -411,6 +457,24 @@ void AbstractSceneConverterTest::convertMeshToData() {
    CORRADE_COMPARE(data->size(), 6);
 }
 void AbstractSceneConverterTest::convertMeshToDataFailed() {
    struct: AbstractSceneConverter {
        SceneConverterFeatures doFeatures() const override {
            return SceneConverterFeature::ConvertMeshToData;
        }
        Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData&) override {
            return {};
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToData(MeshData{MeshPrimitive::Triangles, 0}));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractSceneConverterTest::convertMeshToDataNotImplemented() {
    #ifdef CORRADE_NO_ASSERT
    CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
@ -504,6 +568,24 @@ void AbstractSceneConverterTest::convertMeshToFile() {
        "\xef", TestSuite::Compare::FileToString);
 }
 void AbstractSceneConverterTest::convertMeshToFileFailed() {
    struct: AbstractSceneConverter {
        SceneConverterFeatures doFeatures() const override {
            return SceneConverterFeature::ConvertMeshToFile;
        }
        bool doConvertToFile(const MeshData&, Containers::StringView) override {
            return false;
        }
    } converter;
    /* The implementation is expected to print an error message on its own */
    std::ostringstream out;
    Error redirectError{&out};
    CORRADE_VERIFY(!converter.convertToFile(MeshData{MeshPrimitive::Triangles, 0}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out")));
    CORRADE_COMPARE(out.str(), "");
 }
 void AbstractSceneConverterTest::convertMeshToFileThroughData() {
    struct: AbstractSceneConverter {
        SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToData; }