diff --git a/src/Magnum/ShaderTools/Test/AbstractConverterTest.cpp b/src/Magnum/ShaderTools/Test/AbstractConverterTest.cpp index 4f9767366..4b49d7e9d 100644 --- 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 doValidateData(Stage, Containers::ArrayView) 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 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> doConvertDataToData(Stage, Containers::ArrayView) 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> 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> doLinkDataToData(Containers::ArrayView>>) 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>{}}); + 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>, 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> doLinkFilesToData(Containers::ArrayView>) 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 { diff --git a/src/Magnum/Trade/Test/AbstractImageConverterTest.cpp b/src/Magnum/Trade/Test/AbstractImageConverterTest.cpp index b8bb6c87e..745ffb21c 100644 --- 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 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 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 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 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 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 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> 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> 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> 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> 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> 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> 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> doConvertToData(Containers::ArrayView) 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> doConvertToData(Containers::ArrayView) 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> doConvertToData(Containers::ArrayView) 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> doConvertToData(Containers::ArrayView) 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> doConvertToData(Containers::ArrayView) 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> doConvertToData(Containers::ArrayView) 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, 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, 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, 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, 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, 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, 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; } diff --git a/src/Magnum/Trade/Test/AbstractImporterTest.cpp b/src/Magnum/Trade/Test/AbstractImporterTest.cpp index c60ee8285..81b2de7c0 100644 --- 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&&, 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&&, 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 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 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 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 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 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 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 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 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 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 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 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 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"); diff --git a/src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp b/src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp index 555bf13e4..6c2a2e287 100644 --- 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 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> 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; }