diff --git a/src/Magnum/Trade/Test/AbstractImageConverterTest.cpp b/src/Magnum/Trade/Test/AbstractImageConverterTest.cpp index 24cff1730..6a012e79d 100644 --- a/src/Magnum/Trade/Test/AbstractImageConverterTest.cpp +++ b/src/Magnum/Trade/Test/AbstractImageConverterTest.cpp @@ -41,6 +41,12 @@ #include "configure.h" +/** @todo remove once the deprecated overloads are gone */ +#ifdef MAGNUM_BUILD_DEPRECATED +#include +#include +#endif + namespace Magnum { namespace Trade { namespace Test { namespace { struct AbstractImageConverterTest: TestSuite::Tester { @@ -72,9 +78,19 @@ struct AbstractImageConverterTest: TestSuite::Tester { void convert1D(); void convert2D(); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Tests exportToImage() and exportToCompressedImage() */ + void convert2DDeprecated(); + void convert2DDeprecatedInvalid(); + void convert2DDeprecatedCompressed(); + void convert2DDeprecatedCompressedInvalid(); + #endif void convert3D(); void convert1DFailed(); void convert2DFailed(); + #ifdef MAGNUM_BUILD_DEPRECATED + void convert2DFailedDeprecated(); + #endif void convert3DFailed(); void convert1DNotImplemented(); void convert2DNotImplemented(); @@ -105,9 +121,16 @@ struct AbstractImageConverterTest: TestSuite::Tester { void convert1DToData(); void convert2DToData(); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Tests exportToData() taking ImageView2D */ + void convert2DToDataDeprecated(); + #endif void convert3DToData(); void convert1DToDataFailed(); void convert2DToDataFailed(); + #ifdef MAGNUM_BUILD_DEPRECATED + void convert2DToDataFailedDeprecated(); + #endif 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 */ @@ -124,9 +147,16 @@ struct AbstractImageConverterTest: TestSuite::Tester { void convertCompressed1DToData(); void convertCompressed2DToData(); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Tests exportToData() taking CompressedImageView2D */ + void convertCompressed2DToDataDeprecated(); + #endif void convertCompressed3DToData(); void convertCompressed1DToDataFailed(); void convertCompressed2DToDataFailed(); + #ifdef MAGNUM_BUILD_DEPRECATED + void convertCompressed2DToDataFailedDeprecated(); + #endif void convertCompressed3DToDataFailed(); /* Compressed share the same image validity check function with uncompressed, so only verify it's used */ @@ -142,9 +172,16 @@ struct AbstractImageConverterTest: TestSuite::Tester { void convertImageData1DToData(); void convertImageData2DToData(); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Tests exportToData() taking ImageData2D */ + void convertImageData2DToDataDeprecated(); + #endif void convertImageData3DToData(); void convertImageData1DToDataFailed(); void convertImageData2DToDataFailed(); + #ifdef MAGNUM_BUILD_DEPRECATED + void convertImageData2DToDataFailedDeprecated(); + #endif void convertImageData3DToDataFailed(); void convertLevels1DToData(); @@ -211,9 +248,16 @@ struct AbstractImageConverterTest: TestSuite::Tester { void convert1DToFile(); void convert2DToFile(); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Tests exportToFile() taking ImageView2D */ + void convert2DToFileDeprecated(); + #endif void convert3DToFile(); void convert1DToFileFailed(); void convert2DToFileFailed(); + #ifdef MAGNUM_BUILD_DEPRECATED + void convert2DToFileFailedDeprecated(); + #endif void convert3DToFileFailed(); void convert1DToFileThroughData(); void convert2DToFileThroughData(); @@ -235,9 +279,16 @@ struct AbstractImageConverterTest: TestSuite::Tester { void convertCompressed1DToFile(); void convertCompressed2DToFile(); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Tests exportToFile() taking CompressedImageView2D */ + void convertCompressed2DToFileDeprecated(); + #endif void convertCompressed3DToFile(); void convertCompressed1DToFileFailed(); void convertCompressed2DToFileFailed(); + #ifdef MAGNUM_BUILD_DEPRECATED + void convertCompressed2DToFileFailedDeprecated(); + #endif void convertCompressed3DToFileFailed(); void convertCompressed1DToFileThroughData(); void convertCompressed2DToFileThroughData(); @@ -259,9 +310,16 @@ struct AbstractImageConverterTest: TestSuite::Tester { void convertImageData1DToFile(); void convertImageData2DToFile(); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Tests exportToFile() taking ImageData2D */ + void convertImageData2DToFileDeprecated(); + #endif void convertImageData3DToFile(); void convertImageData1DToFileFailed(); void convertImageData2DToFileFailed(); + #ifdef MAGNUM_BUILD_DEPRECATED + void convertImageData2DToFileFailedDeprecated(); + #endif void convertImageData3DToFileFailed(); /* Conversion of ImageData to a file through data not tested, as that should just work transitively */ @@ -360,9 +418,18 @@ AbstractImageConverterTest::AbstractImageConverterTest() { &AbstractImageConverterTest::convert1D, &AbstractImageConverterTest::convert2D, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convert2DDeprecated, + &AbstractImageConverterTest::convert2DDeprecatedInvalid, + &AbstractImageConverterTest::convert2DDeprecatedCompressed, + &AbstractImageConverterTest::convert2DDeprecatedCompressedInvalid, + #endif &AbstractImageConverterTest::convert3D, &AbstractImageConverterTest::convert1DFailed, &AbstractImageConverterTest::convert2DFailed, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convert2DFailedDeprecated, + #endif &AbstractImageConverterTest::convert3DFailed, &AbstractImageConverterTest::convert1DNotImplemented, &AbstractImageConverterTest::convert2DNotImplemented, @@ -393,9 +460,15 @@ AbstractImageConverterTest::AbstractImageConverterTest() { &AbstractImageConverterTest::convert1DToData, &AbstractImageConverterTest::convert2DToData, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convert2DToDataDeprecated, + #endif &AbstractImageConverterTest::convert3DToData, &AbstractImageConverterTest::convert1DToDataFailed, &AbstractImageConverterTest::convert2DToDataFailed, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convert2DToDataFailedDeprecated, + #endif &AbstractImageConverterTest::convert3DToDataFailed, &AbstractImageConverterTest::convert1DToDataInvalidImage, &AbstractImageConverterTest::convert2DToDataZeroSize, @@ -410,9 +483,15 @@ AbstractImageConverterTest::AbstractImageConverterTest() { &AbstractImageConverterTest::convertCompressed1DToData, &AbstractImageConverterTest::convertCompressed2DToData, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convertCompressed2DToDataDeprecated, + #endif &AbstractImageConverterTest::convertCompressed3DToData, &AbstractImageConverterTest::convertCompressed1DToDataFailed, &AbstractImageConverterTest::convertCompressed2DToDataFailed, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convertCompressed2DToDataFailedDeprecated, + #endif &AbstractImageConverterTest::convertCompressed3DToDataFailed, &AbstractImageConverterTest::convertCompressed1DToDataInvalidImage, &AbstractImageConverterTest::convertCompressed2DToDataInvalidImage, @@ -426,9 +505,15 @@ AbstractImageConverterTest::AbstractImageConverterTest() { &AbstractImageConverterTest::convertImageData1DToData, &AbstractImageConverterTest::convertImageData2DToData, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convertImageData2DToDataDeprecated, + #endif &AbstractImageConverterTest::convertImageData3DToData, &AbstractImageConverterTest::convertImageData1DToDataFailed, &AbstractImageConverterTest::convertImageData2DToDataFailed, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convertImageData2DToDataFailedDeprecated, + #endif &AbstractImageConverterTest::convertImageData3DToDataFailed, &AbstractImageConverterTest::convertLevels1DToData, @@ -488,9 +573,15 @@ AbstractImageConverterTest::AbstractImageConverterTest() { &AbstractImageConverterTest::convert1DToFile, &AbstractImageConverterTest::convert2DToFile, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convert2DToFileDeprecated, + #endif &AbstractImageConverterTest::convert3DToFile, &AbstractImageConverterTest::convert1DToFileFailed, &AbstractImageConverterTest::convert2DToFileFailed, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convert2DToFileFailedDeprecated, + #endif &AbstractImageConverterTest::convert3DToFileFailed, &AbstractImageConverterTest::convert1DToFileThroughData, &AbstractImageConverterTest::convert2DToFileThroughData, @@ -510,9 +601,15 @@ AbstractImageConverterTest::AbstractImageConverterTest() { &AbstractImageConverterTest::convertCompressed1DToFile, &AbstractImageConverterTest::convertCompressed2DToFile, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convertCompressed2DToFileDeprecated, + #endif &AbstractImageConverterTest::convertCompressed3DToFile, &AbstractImageConverterTest::convertCompressed1DToFileFailed, &AbstractImageConverterTest::convertCompressed2DToFileFailed, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convertCompressed2DToFileFailedDeprecated, + #endif &AbstractImageConverterTest::convertCompressed3DToFileFailed, &AbstractImageConverterTest::convertCompressed1DToFileThroughData, &AbstractImageConverterTest::convertCompressed2DToFileThroughData, @@ -532,9 +629,15 @@ AbstractImageConverterTest::AbstractImageConverterTest() { &AbstractImageConverterTest::convertImageData1DToFile, &AbstractImageConverterTest::convertImageData2DToFile, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convertImageData2DToFileDeprecated, + #endif &AbstractImageConverterTest::convertImageData3DToFile, &AbstractImageConverterTest::convertImageData1DToFileFailed, &AbstractImageConverterTest::convertImageData2DToFileFailed, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImageConverterTest::convertImageData2DToFileFailedDeprecated, + #endif &AbstractImageConverterTest::convertImageData3DToFileFailed, &AbstractImageConverterTest::convertLevels1DToFile, @@ -890,6 +993,76 @@ void AbstractImageConverterTest::convert2D() { CORRADE_COMPARE(actual->size(), (Vector2i{4, 6})); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convert2DDeprecated() { + /* Like convert2D() but using the deprecated overload */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert2D; } + Containers::Optional doConvert(const ImageView2D& image) override { + return ImageData2D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array{96}}; + } + } converter; + + CORRADE_IGNORE_DEPRECATED_PUSH + Containers::Optional actual = converter.exportToImage(ImageView2D{PixelFormat::R8Unorm, {4, 6}, Containers::ArrayView{nullptr, 24}}); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_VERIFY(actual); + CORRADE_COMPARE(actual->data().size(), 96); + CORRADE_COMPARE(actual->size(), (Vector2i{4, 6})); +} + +void AbstractImageConverterTest::convert2DDeprecatedInvalid() { + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert2D; } + Containers::Optional doConvert(const ImageView2D& image) override { + return ImageData2D{CompressedPixelFormat::Bc1RGBAUnorm, image.size(), Containers::Array{96}}; + } + } converter; + + Containers::String out; + Error redirectError{&out}; + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(!converter.exportToImage(ImageView2D{PixelFormat::R8Unorm, {4, 6}, Containers::ArrayView{nullptr, 24}})); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_COMPARE(out, "Trade::AbstractImageConverter::exportToImage(): implementation returned a compressed image\n"); +} + +void AbstractImageConverterTest::convert2DDeprecatedCompressed() { + /* Like convert2D() but using the deprecated overload */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert2D; } + Containers::Optional doConvert(const ImageView2D& image) override { + return ImageData2D{CompressedPixelFormat::Bc1RGBAUnorm, image.size(), Containers::Array{96}}; + } + } converter; + + CORRADE_IGNORE_DEPRECATED_PUSH + Containers::Optional actual = converter.exportToCompressedImage(ImageView2D{PixelFormat::R8Unorm, {4, 6}, Containers::ArrayView{nullptr, 24}}); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_VERIFY(actual); + CORRADE_COMPARE(actual->data().size(), 96); + CORRADE_COMPARE(actual->size(), (Vector2i{4, 6})); +} + +void AbstractImageConverterTest::convert2DDeprecatedCompressedInvalid() { + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert2D; } + Containers::Optional doConvert(const ImageView2D& image) override { + return ImageData2D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array{96}}; + } + } converter; + + Containers::String out; + Error redirectError{&out}; + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(!converter.exportToCompressedImage(ImageView2D{PixelFormat::R8Unorm, {4, 6}, Containers::ArrayView{nullptr, 24}})); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_COMPARE(out, "Trade::AbstractImageConverter::exportToCompressedImage(): implementation returned an uncompressed image\n"); +} +#endif + void AbstractImageConverterTest::convert3D() { struct: AbstractImageConverter { ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert3D; } @@ -947,6 +1120,34 @@ void AbstractImageConverterTest::convert2DFailed() { CORRADE_COMPARE(out, ""); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convert2DFailedDeprecated() { + /* Like convert2DFailed() but testing the (two) deprecated overloads */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { + return ImageConverterFeature::Convert2D; + } + Containers::Optional doConvert(const ImageView2D&) override { + called = true; + return {}; + } + + bool called = false; + } converter; + + /* The implementation is expected to print an error message on its own */ + Containers::String out; + Error redirectError{&out}; + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(!converter.exportToImage(ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, {nullptr, 4}})); + CORRADE_VERIFY(!converter.exportToCompressedImage(ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, {nullptr, 4}})); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_VERIFY(converter.called); + CORRADE_COMPARE(out, ""); +} +#endif + void AbstractImageConverterTest::convert3DFailed() { struct: AbstractImageConverter { ImageConverterFeatures doFeatures() const override { @@ -1458,6 +1659,26 @@ void AbstractImageConverterTest::convert2DToData() { CORRADE_COMPARE(actual->size(), 24); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convert2DToDataDeprecated() { + /* Like convert2DToData() but using the deprecated overload */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert2DToData; } + Containers::Optional> doConvertToData(const ImageView2D& image) override { + return Containers::Array{nullptr, std::size_t(image.size().product())}; + } + } converter; + + const char data[96]{}; + CORRADE_IGNORE_DEPRECATED_PUSH + Containers::Array actual = converter.exportToData(ImageView2D{PixelFormat::RGBA8Unorm, {4, 6}, data}); + CORRADE_IGNORE_DEPRECATED_POP + /* The pointer is null but the size is not */ + CORRADE_COMPARE(actual.size(), 24); +} +#endif + void AbstractImageConverterTest::convert3DToData() { struct: AbstractImageConverter { ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert3DToData; } @@ -1518,6 +1739,35 @@ void AbstractImageConverterTest::convert2DToDataFailed() { CORRADE_COMPARE(out, ""); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convert2DToDataFailedDeprecated() { + /* Like convert2DToData() but using the deprecated overload */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { + return ImageConverterFeature::Convert2DToData; + } + Containers::Optional> doConvertToData(const ImageView2D&) override { + called = true; + return {}; + } + + bool called = false; + } converter; + + const char imageData[4]{}; + + /* The implementation is expected to print an error message on its own */ + Containers::String out; + Error redirectError{&out}; + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(!converter.exportToData(ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, imageData})); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_VERIFY(converter.called); + CORRADE_COMPARE(out, ""); +} +#endif + void AbstractImageConverterTest::convert3DToDataFailed() { struct: AbstractImageConverter { ImageConverterFeatures doFeatures() const override { @@ -1715,6 +1965,26 @@ void AbstractImageConverterTest::convertCompressed2DToData() { CORRADE_COMPARE(actual->size(), 128); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convertCompressed2DToDataDeprecated() { + /* Like convertCompressed2DToData() but using the deprecated overload */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::ConvertCompressed2DToData; } + Containers::Optional> doConvertToData(const CompressedImageView2D& image) override { + return Containers::Array{nullptr, std::size_t(image.size().product())}; + } + } converter; + + const char data[64]{}; + CORRADE_IGNORE_DEPRECATED_PUSH + Containers::Array actual = converter.exportToData(CompressedImageView2D{CompressedPixelFormat::Bc1RGBAUnorm, {16, 8}, data}); + CORRADE_IGNORE_DEPRECATED_POP + /* The pointer is null but the size is not */ + CORRADE_COMPARE(actual.size(), 128); +} +#endif + void AbstractImageConverterTest::convertCompressed3DToData() { struct: AbstractImageConverter { ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::ConvertCompressed3DToData; } @@ -1775,6 +2045,36 @@ void AbstractImageConverterTest::convertCompressed2DToDataFailed() { CORRADE_COMPARE(out, ""); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convertCompressed2DToDataFailedDeprecated() { + /* Like convertCompressed2DToDataFailed() but using the deprecated + overload */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { + return ImageConverterFeature::ConvertCompressed2DToData; + } + Containers::Optional> doConvertToData(const CompressedImageView2D&) override { + called = true; + return {}; + } + + bool called = false; + } converter; + + const char imageData[4*4]{}; + + /* The implementation is expected to print an error message on its own */ + Containers::String out; + Error redirectError{&out}; + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(!converter.exportToData(CompressedImageView2D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1}, imageData})); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_VERIFY(converter.called); + CORRADE_COMPARE(out, ""); +} +#endif + void AbstractImageConverterTest::convertCompressed3DToDataFailed() { struct: AbstractImageConverter { ImageConverterFeatures doFeatures() const override { @@ -2012,6 +2312,36 @@ void AbstractImageConverterTest::convertImageData2DToData() { } } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convertImageData2DToDataDeprecated() { + /* Like convertImageData2DToData() but using the deprecated overload */ + + ImageData2DConverter converter; + + /* Should get "B" when converting uncompressed */ + { + CORRADE_IGNORE_DEPRECATED_PUSH + Containers::Array out = converter.exportToData(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, Containers::Array{4}}); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_VERIFY(out); + CORRADE_COMPARE_AS(out, + Containers::arrayView({'B'}), + TestSuite::Compare::Container); + } + + /* Should get "C" when converting compressed */ + { + CORRADE_IGNORE_DEPRECATED_PUSH + Containers::Array out = converter.exportToData(ImageData2D{CompressedPixelFormat::Bc1RGBUnorm, {4, 4}, Containers::Array{NoInit, 8}}); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_VERIFY(out); + CORRADE_COMPARE_AS(out, + Containers::arrayView({'C'}), + TestSuite::Compare::Container); + } +} +#endif + void AbstractImageConverterTest::convertImageData3DToData() { ImageData3DConverter converter; @@ -2094,6 +2424,43 @@ void AbstractImageConverterTest::convertImageData2DToDataFailed() { CORRADE_COMPARE(out, ""); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convertImageData2DToDataFailedDeprecated() { + /* Like convertImageData2DToDataFailed() but using the deprecated + overload */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { + return ImageConverterFeature::Convert2DToData|ImageConverterFeature::ConvertCompressed2DToData; + } + Containers::Optional> doConvertToData(const ImageView2D&) override { + called = true; + return {}; + } + Containers::Optional> doConvertToData(const CompressedImageView2D&) override { + calledCompressed = true; + return {}; + } + + bool called = false; + bool calledCompressed = false; + } converter; + + const char imageData[4*4]{}; + + /* The implementation is expected to print an error message on its own */ + Containers::String out; + Error redirectError{&out}; + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(!converter.exportToData(ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, imageData})); + CORRADE_VERIFY(!converter.exportToData(CompressedImageView2D{CompressedPixelFormat::Bc1RGBUnorm, {1, 1}, imageData})); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_VERIFY(converter.called); + CORRADE_VERIFY(converter.calledCompressed); + CORRADE_COMPARE(out, ""); +} +#endif + void AbstractImageConverterTest::convertImageData3DToDataFailed() { struct: AbstractImageConverter { ImageConverterFeatures doFeatures() const override { @@ -3187,6 +3554,31 @@ void AbstractImageConverterTest::convert2DToFile() { "\x0f\x0d", TestSuite::Compare::FileToString); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convert2DToFileDeprecated() { + /* Like convert2DToFile() but using the deprecated overload */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert2DToFile; } + bool doConvertToFile(const ImageView2D& image, Containers::StringView filename) override { + return Utility::Path::write(filename, Containers::arrayView( + {char(image.size().x()), char(image.size().y())})); + } + } converter; + + /* Remove previous file, if any */ + Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out"); + if(Utility::Path::exists(filename)) + CORRADE_VERIFY(Utility::Path::remove(filename)); + + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(converter.exportToFile(ImageView2D{PixelFormat::RGBA8Unorm, {0x0f, 0x0d}, Containers::Array{0x0f*0x0d*4}}, filename)); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_COMPARE_AS(filename, + "\x0f\x0d", TestSuite::Compare::FileToString); +} +#endif + void AbstractImageConverterTest::convert3DToFile() { struct: AbstractImageConverter { ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::Convert3DToFile; } @@ -3252,6 +3644,35 @@ void AbstractImageConverterTest::convert2DToFileFailed() { CORRADE_COMPARE(out, ""); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convert2DToFileFailedDeprecated() { + /* Like convert2DToFileFailed() but using the deprecated overload */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { + return ImageConverterFeature::Convert2DToFile; + } + bool doConvertToFile(const ImageView2D&, Containers::StringView) override { + called = true; + return {}; + } + + bool called = false; + } converter; + + const char imageData[4]{}; + + /* The implementation is expected to print an error message on its own */ + Containers::String out; + Error redirectError{&out}; + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(!converter.exportToFile(ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, imageData}, "")); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_VERIFY(converter.called); + CORRADE_COMPARE(out, ""); +} +#endif + void AbstractImageConverterTest::convert3DToFileFailed() { struct: AbstractImageConverter { ImageConverterFeatures doFeatures() const override { @@ -3595,6 +4016,31 @@ void AbstractImageConverterTest::convertCompressed2DToFile() { "\x0f\x0d", TestSuite::Compare::FileToString); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convertCompressed2DToFileDeprecated() { + /* Like convertCompressed2DToFile() but using the deprecated overloads */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::ConvertCompressed2DToFile; } + bool doConvertToFile(const CompressedImageView2D& image, Containers::StringView filename) override { + return Utility::Path::write(filename, Containers::arrayView( + {char(image.size().x()), char(image.size().y())})); + } + } converter; + + /* Remove previous file, if any */ + Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out"); + if(Utility::Path::exists(filename)) + CORRADE_VERIFY(Utility::Path::remove(filename)); + + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(converter.exportToFile(CompressedImageView2D{CompressedPixelFormat::Bc1RGBAUnorm, {0x0f, 0x0d}, Containers::Array{NoInit, 128}}, filename)); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_COMPARE_AS(filename, + "\x0f\x0d", TestSuite::Compare::FileToString); +} +#endif + void AbstractImageConverterTest::convertCompressed3DToFile() { struct: AbstractImageConverter { ImageConverterFeatures doFeatures() const override { return ImageConverterFeature::ConvertCompressed3DToFile; } @@ -3660,6 +4106,36 @@ void AbstractImageConverterTest::convertCompressed2DToFileFailed() { CORRADE_COMPARE(out, ""); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convertCompressed2DToFileFailedDeprecated() { + /* Like convertCompressed2DToFileFailed() but using the deprecated + overload */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { + return ImageConverterFeature::ConvertCompressed2DToFile; + } + bool doConvertToFile(const CompressedImageView2D&, Containers::StringView) override { + called = true; + return {}; + } + + bool called = false; + } converter; + + const char imageData[4*4]{}; + + /* The implementation is expected to print an error message on its own */ + Containers::String out; + Error redirectError{&out}; + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(!converter.exportToFile(CompressedImageView2D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1}, imageData}, "")); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_VERIFY(converter.called); + CORRADE_COMPARE(out, ""); +} +#endif + void AbstractImageConverterTest::convertCompressed3DToFileFailed() { struct: AbstractImageConverter { ImageConverterFeatures doFeatures() const override { @@ -3993,6 +4469,28 @@ void AbstractImageConverterTest::convertImageData2DToFile() { "C", TestSuite::Compare::FileToString); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convertImageData2DToFileDeprecated() { + /* Like convertImageData2DToFile() but using the deprecated overload */ + + ImageData2DConverter converter; + + /* Should get "B" when converting uncompressed */ + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(converter.exportToFile(ImageData2D{PixelFormat::RGBA16F, {1, 1}, Containers::Array{8}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out"))); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_COMPARE_AS(Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out"), + "B", TestSuite::Compare::FileToString); + + /* Should get "C" when converting compressed */ + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(converter.exportToFile(ImageData2D{CompressedPixelFormat::Bc2RGBAUnorm, {4, 4}, Containers::Array{NoInit, 16}}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out"))); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_COMPARE_AS(Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "image.out"), + "C", TestSuite::Compare::FileToString); +} +#endif + void AbstractImageConverterTest::convertImageData3DToFile() { ImageData3DConverter converter; @@ -4067,6 +4565,43 @@ void AbstractImageConverterTest::convertImageData2DToFileFailed() { CORRADE_COMPARE(out, ""); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImageConverterTest::convertImageData2DToFileFailedDeprecated() { + /* Like convertImageData2DToFileFailed() but using the deprecated + overloads */ + + struct: AbstractImageConverter { + ImageConverterFeatures doFeatures() const override { + return ImageConverterFeature::Convert2DToFile|ImageConverterFeature::ConvertCompressed2DToFile; + } + bool doConvertToFile(const ImageView2D&, Containers::StringView) override { + called = true; + return false; + } + bool doConvertToFile(const CompressedImageView2D&, Containers::StringView) override { + calledCompressed = true; + return {}; + } + + bool called = false; + bool calledCompressed = false; + } converter; + + const char imageData[4*4]{}; + + /* The implementation is expected to print an error message on its own */ + Containers::String out; + Error redirectError{&out}; + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(!converter.exportToFile(ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, imageData}, "")); + CORRADE_VERIFY(!converter.exportToFile(CompressedImageView2D{CompressedPixelFormat::Bc1RGBUnorm, {1, 1}, imageData}, "")); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_VERIFY(converter.called); + CORRADE_VERIFY(converter.calledCompressed); + CORRADE_COMPARE(out, ""); +} +#endif + void AbstractImageConverterTest::convertImageData3DToFileFailed() { struct: AbstractImageConverter { ImageConverterFeatures doFeatures() const override { diff --git a/src/Magnum/Trade/Test/AbstractImporterTest.cpp b/src/Magnum/Trade/Test/AbstractImporterTest.cpp index 291939020..66359543a 100644 --- a/src/Magnum/Trade/Test/AbstractImporterTest.cpp +++ b/src/Magnum/Trade/Test/AbstractImporterTest.cpp @@ -82,6 +82,9 @@ struct AbstractImporterTest: TestSuite::Tester { void construct(); void constructWithPluginManagerReference(); + #ifdef MAGNUM_BUILD_DEPRECATED + void constructMoveDeprecated(); + #endif void setFlags(); void setFlagsFileOpened(); @@ -411,6 +414,9 @@ AbstractImporterTest::AbstractImporterTest() { &AbstractImporterTest::construct, &AbstractImporterTest::constructWithPluginManagerReference, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractImporterTest::constructMoveDeprecated, + #endif &AbstractImporterTest::setFlags, &AbstractImporterTest::setFlagsFileOpened, @@ -802,6 +808,25 @@ void AbstractImporterTest::constructWithPluginManagerReference() { CORRADE_VERIFY(!importer.isOpened()); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractImporterTest::constructMoveDeprecated() { + /* In the deprecated build there's an explicitly deinlined defaulted move + constructor to correctly move an array member with a private type. + Verify simply that a move compiles and links, that should be enough. */ + + struct Importer: AbstractImporter { + ImporterFeatures doFeatures() const override { + return ImporterFeature::FileCallback; + } + bool doIsOpened() const override { return false; } + void doClose() override {} + } importer; + + Importer b = Utility::move(importer); + CORRADE_COMPARE(b.features(), ImporterFeature::FileCallback); +} +#endif + void AbstractImporterTest::setFlags() { struct: AbstractImporter { ImporterFeatures doFeatures() const override { return {}; } diff --git a/src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp b/src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp index 92e988caf..76a26f0be 100644 --- a/src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp +++ b/src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp @@ -54,6 +54,12 @@ #include "configure.h" +/** @todo remove once the deprecated convertMeshToFile() is gone */ +#ifdef MAGNUM_BUILD_DEPRECATED +#include +#include +#endif + namespace Magnum { namespace Trade { namespace Test { namespace { struct AbstractSceneConverterTest: TestSuite::Tester { @@ -115,7 +121,13 @@ struct AbstractSceneConverterTest: TestSuite::Tester { void convertMeshToDataCustomDeleter(); void convertMeshToFile(); + #ifdef MAGNUM_BUILD_DEPRECATED + void convertMeshToFileDeprecated(); + #endif void convertMeshToFileFailed(); + #ifdef MAGNUM_BUILD_DEPRECATED + void convertMeshToFileFailedDeprecated(); + #endif void convertMeshToFileThroughData(); void convertMeshToFileThroughDataFailed(); void convertMeshToFileThroughDataNotWritable(); @@ -686,7 +698,13 @@ AbstractSceneConverterTest::AbstractSceneConverterTest() { &AbstractSceneConverterTest::convertMeshToDataCustomDeleter, &AbstractSceneConverterTest::convertMeshToFile, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractSceneConverterTest::convertMeshToFileDeprecated, + #endif &AbstractSceneConverterTest::convertMeshToFileFailed, + #ifdef MAGNUM_BUILD_DEPRECATED + &AbstractSceneConverterTest::convertMeshToFileFailedDeprecated, + #endif &AbstractSceneConverterTest::convertMeshToFileThroughData, &AbstractSceneConverterTest::convertMeshToFileThroughDataFailed, &AbstractSceneConverterTest::convertMeshToFileThroughDataNotWritable, @@ -1794,6 +1812,31 @@ void AbstractSceneConverterTest::convertMeshToFile() { "\xef", TestSuite::Compare::FileToString); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractSceneConverterTest::convertMeshToFileDeprecated() { + /* Like convertMeshToFile() but using the deprecated overload */ + + struct: AbstractSceneConverter { + SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToFile; } + + bool doConvertToFile(const MeshData& mesh, Containers::StringView filename) override { + return Utility::Path::write(filename, Containers::arrayView({char(mesh.vertexCount())})); + } + } converter; + + /* Remove previous file, if any */ + Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out"); + if(Utility::Path::exists(filename)) + CORRADE_VERIFY(Utility::Path::remove(filename)); + + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(converter.convertToFile(filename, MeshData{MeshPrimitive::Triangles, 0xef})); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_COMPARE_AS(filename, + "\xef", TestSuite::Compare::FileToString); +} +#endif + void AbstractSceneConverterTest::convertMeshToFileFailed() { struct: AbstractSceneConverter { SceneConverterFeatures doFeatures() const override { @@ -1816,6 +1859,34 @@ void AbstractSceneConverterTest::convertMeshToFileFailed() { CORRADE_COMPARE(out, ""); } +#ifdef MAGNUM_BUILD_DEPRECATED +void AbstractSceneConverterTest::convertMeshToFileFailedDeprecated() { + /* Like convertMeshToFileFailed() but using the deprecated overload */ + + struct: AbstractSceneConverter { + SceneConverterFeatures doFeatures() const override { + return SceneConverterFeature::ConvertMeshToFile; + } + + bool doConvertToFile(const MeshData&, Containers::StringView) override { + called = true; + return false; + } + + bool called = false; + } converter; + + /* The implementation is expected to print an error message on its own */ + Containers::String out; + Error redirectError{&out}; + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_VERIFY(!converter.convertToFile("", MeshData{MeshPrimitive::Triangles, 0})); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_VERIFY(converter.called); + CORRADE_COMPARE(out, ""); +} +#endif + void AbstractSceneConverterTest::convertMeshToFileThroughData() { struct: AbstractSceneConverter { SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToData; } @@ -3828,6 +3899,7 @@ void AbstractSceneConverterTest::addMeshThroughConvertMesh() { CORRADE_VERIFY(!converter.isConverting()); CORRADE_VERIFY(importer); CORRADE_VERIFY(importer->isOpened()); + CORRADE_COMPARE(importer->features(), ImporterFeatures{}); CORRADE_COMPARE(importer->meshCount(), 1); Containers::Optional mesh = importer->mesh(0); diff --git a/src/Magnum/Trade/Test/AnimationDataTest.cpp b/src/Magnum/Trade/Test/AnimationDataTest.cpp index f041237ee..6af844855 100644 --- a/src/Magnum/Trade/Test/AnimationDataTest.cpp +++ b/src/Magnum/Trade/Test/AnimationDataTest.cpp @@ -712,6 +712,12 @@ void AnimationDataTest::construct() { CORRADE_COMPARE(data.trackType(0), AnimationTrackType::Vector3); CORRADE_COMPARE(data.trackResultType(0), AnimationTrackType::Vector3); CORRADE_COMPARE(data.trackTargetName(0), AnimationTrackTarget::Translation3D); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Just to verify the deprecated overload returns what it should */ + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_COMPARE(data.trackTargetType(0), AnimationTrackTarget::Translation3D); + CORRADE_IGNORE_DEPRECATED_POP + #endif CORRADE_COMPARE(data.trackTarget(0), 42); Animation::TrackView track = data.track(0); @@ -729,6 +735,12 @@ void AnimationDataTest::construct() { CORRADE_COMPARE(data.trackType(1), AnimationTrackType::Quaternion); CORRADE_COMPARE(data.trackResultType(1), AnimationTrackType::Quaternion); CORRADE_COMPARE(data.trackTargetName(1), AnimationTrackTarget::Rotation3D); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Just to verify the deprecated overload returns what it should */ + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_COMPARE(data.trackTargetName(1), AnimationTrackTarget::Rotation3D); + CORRADE_IGNORE_DEPRECATED_POP + #endif CORRADE_COMPARE(data.trackTarget(1), 1337); Animation::TrackView track = data.track(1); diff --git a/src/Magnum/Trade/Test/ImageDataTest.cpp b/src/Magnum/Trade/Test/ImageDataTest.cpp index 80ba7106d..8bcddb933 100644 --- a/src/Magnum/Trade/Test/ImageDataTest.cpp +++ b/src/Magnum/Trade/Test/ImageDataTest.cpp @@ -45,14 +45,38 @@ struct ImageDataTest: TestSuite::Tester { explicit ImageDataTest(); void constructGeneric(); + #ifdef MAGNUM_BUILD_DEPRECATED + void constructGenericDeprecated(); + #endif void constructImplementationSpecific(); + #ifdef MAGNUM_BUILD_DEPRECATED + void constructImplementationSpecificDeprecated(); + #endif void constructCompressedGeneric(); + #ifdef MAGNUM_BUILD_DEPRECATED + void constructCompressedGenericDeprecated(); + #endif void constructCompressedImplementationSpecific(); + #ifdef MAGNUM_BUILD_DEPRECATED + void constructCompressedImplementationSpecificDeprecated(); + #endif void constructGenericNotOwned(); + #ifdef MAGNUM_BUILD_DEPRECATED + void constructGenericNotOwnedDeprecated(); + #endif void constructImplementationSpecificNotOwned(); + #ifdef MAGNUM_BUILD_DEPRECATED + void constructImplementationSpecificNotOwnedDeprecated(); + #endif void constructCompressedGenericNotOwned(); + #ifdef MAGNUM_BUILD_DEPRECATED + void constructCompressedGenericNotOwnedDeprecated(); + #endif void constructCompressedImplementationSpecificNotOwned(); + #ifdef MAGNUM_BUILD_DEPRECATED + void constructCompressedImplementationSpecificNotOwnedDeprecated(); + #endif void constructGenericNotOwnedFlagOwned(); void constructImplementationSpecificNotOwnedFlagOwned(); void constructCompressedGenericNotOwnedFlagOwned(); @@ -124,15 +148,41 @@ struct { ImageDataTest::ImageDataTest() { addTests({&ImageDataTest::constructGeneric, + #ifdef MAGNUM_BUILD_DEPRECATED + &ImageDataTest::constructGenericDeprecated, + #endif &ImageDataTest::constructImplementationSpecific, + #ifdef MAGNUM_BUILD_DEPRECATED + &ImageDataTest::constructImplementationSpecificDeprecated, + #endif &ImageDataTest::constructCompressedGeneric, - &ImageDataTest::constructCompressedImplementationSpecific}); - - addInstancedTests({&ImageDataTest::constructGenericNotOwned, - &ImageDataTest::constructImplementationSpecificNotOwned, - &ImageDataTest::constructCompressedGenericNotOwned, - &ImageDataTest::constructCompressedImplementationSpecificNotOwned}, - Containers::arraySize(NotOwnedData)); + #ifdef MAGNUM_BUILD_DEPRECATED + &ImageDataTest::constructCompressedGenericDeprecated, + #endif + &ImageDataTest::constructCompressedImplementationSpecific, + #ifdef MAGNUM_BUILD_DEPRECATED + &ImageDataTest::constructCompressedImplementationSpecificDeprecated + #endif + }); + + addInstancedTests({ + &ImageDataTest::constructGenericNotOwned, + #ifdef MAGNUM_BUILD_DEPRECATED + &ImageDataTest::constructGenericNotOwnedDeprecated, + #endif + &ImageDataTest::constructImplementationSpecificNotOwned, + #ifdef MAGNUM_BUILD_DEPRECATED + &ImageDataTest::constructImplementationSpecificNotOwnedDeprecated, + #endif + &ImageDataTest::constructCompressedGenericNotOwned, + #ifdef MAGNUM_BUILD_DEPRECATED + &ImageDataTest::constructCompressedGenericNotOwnedDeprecated, + #endif + &ImageDataTest::constructCompressedImplementationSpecificNotOwned, + #ifdef MAGNUM_BUILD_DEPRECATED + &ImageDataTest::constructCompressedImplementationSpecificNotOwnedDeprecated + #endif + }, Containers::arraySize(NotOwnedData)); addTests({&ImageDataTest::constructGenericNotOwnedFlagOwned, &ImageDataTest::constructImplementationSpecificNotOwnedFlagOwned, @@ -303,6 +353,50 @@ void ImageDataTest::constructGeneric() { } } +#ifdef MAGNUM_BUILD_DEPRECATED +void ImageDataTest::constructGenericDeprecated() { + /* Like constructGeneric() but using the deprecated overloads. Testing just + that the argumens are passed through correctly, not all getters. */ + + { + auto data = new char[4*4]; + int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */ + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{PixelFormat::RGBA8Unorm, {1, 3}, Containers::Array{data, 4*4}, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), DataFlag::Owned|DataFlag::Mutable); + CORRADE_VERIFY(!a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.storage().alignment(), 4); + CORRADE_COMPARE(a.format(), PixelFormat::RGBA8Unorm); + CORRADE_COMPARE(a.formatExtra(), 0); + CORRADE_COMPARE(a.pixelSize(), 4); + CORRADE_COMPARE(a.size(), (Vector2i{1, 3})); + CORRADE_COMPARE(a.data().size(), 4*4); + CORRADE_COMPARE(a.importerState(), &state); + } { + auto data = new char[3*2]; + int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */ + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{PixelStorage{}.setAlignment(1), + PixelFormat::R16UI, {1, 3}, Containers::Array{data, 3*2}, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), DataFlag::Owned|DataFlag::Mutable); + CORRADE_VERIFY(!a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.storage().alignment(), 1); + CORRADE_COMPARE(a.format(), PixelFormat::R16UI); + CORRADE_COMPARE(a.formatExtra(), 0); + CORRADE_COMPARE(a.pixelSize(), 2); + CORRADE_COMPARE(a.size(), (Vector2i{1, 3})); + CORRADE_COMPARE(a.data().size(), 3*2); + CORRADE_COMPARE(a.importerState(), &state); + } +} +#endif + void ImageDataTest::constructImplementationSpecific() { /* Single format */ { @@ -375,6 +469,97 @@ void ImageDataTest::constructImplementationSpecific() { } } +#ifdef MAGNUM_BUILD_DEPRECATED +void ImageDataTest::constructImplementationSpecificDeprecated() { + /* Like constructImplementationSpecific() but using the deprecated + overloads. Testing just that the argumens are passed through correctly, + not all getters. */ + + /* Single format */ + { + auto data = new char[3*12]; + int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */ + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{PixelStorage{}.setAlignment(1), + Vk::PixelFormat::R32G32B32F, {1, 3}, Containers::Array{data, 3*12}, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), DataFlag::Owned|DataFlag::Mutable); + CORRADE_VERIFY(!a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.storage().alignment(), 1); + CORRADE_COMPARE(a.format(), pixelFormatWrap(Vk::PixelFormat::R32G32B32F)); + CORRADE_COMPARE(a.formatExtra(), 0); + CORRADE_COMPARE(a.pixelSize(), 12); + CORRADE_COMPARE(a.size(), (Vector2i{1, 3})); + CORRADE_COMPARE(a.data().size(), 3*12); + CORRADE_COMPARE(a.importerState(), &state); + } + + /* Format + extra */ + { + auto data = new char[3*6]; + int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */ + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{PixelStorage{}.setAlignment(1), + GL::PixelFormat::RGB, GL::PixelType::UnsignedShort, {1, 3}, Containers::Array{data, 3*6}, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), DataFlag::Owned|DataFlag::Mutable); + CORRADE_VERIFY(!a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.format(), pixelFormatWrap(GL::PixelFormat::RGB)); + CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort)); + CORRADE_COMPARE(a.pixelSize(), 6); + CORRADE_COMPARE(a.size(), (Vector2i{1, 3})); + CORRADE_COMPARE(a.data().size(), 3*6); + CORRADE_COMPARE(a.importerState(), &state); + } + + /* Manual pixel size */ + { + auto data = new char[3*6]; + int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */ + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{PixelStorage{}.setAlignment(1), 666, 1337, 6, {1, 3}, Containers::Array{data, 3*6}, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), DataFlag::Owned|DataFlag::Mutable); + CORRADE_VERIFY(!a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.storage().alignment(), 1); + CORRADE_COMPARE(a.format(), pixelFormatWrap(GL::PixelFormat::RGB)); + CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort)); + CORRADE_COMPARE(a.pixelSize(), 6); + CORRADE_COMPARE(a.size(), (Vector2i{1, 3})); + CORRADE_COMPARE(a.data().size(), 3*6); + CORRADE_COMPARE(a.importerState(), &state); + } + + /* Manual pixel size, wrapped in PixelFormat already. Tested here and not + in constructImplementationSpecific() because there the UnsignedInt + overload delegates to the PixelFormat overload. */ + { + auto data = new char[3*6]; + int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */ + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{PixelStorage{}.setAlignment(1), pixelFormatWrap(666), 1337, 6, {1, 3}, Containers::Array{data, 3*6}, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), DataFlag::Owned|DataFlag::Mutable); + CORRADE_VERIFY(!a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.storage().alignment(), 1); + CORRADE_COMPARE(a.format(), pixelFormatWrap(GL::PixelFormat::RGB)); + CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort)); + CORRADE_COMPARE(a.pixelSize(), 6); + CORRADE_COMPARE(a.size(), (Vector2i{1, 3})); + CORRADE_COMPARE(a.data().size(), 3*6); + CORRADE_COMPARE(a.importerState(), &state); + } +} +#endif + void ImageDataTest::constructCompressedGeneric() { { auto data = new char[7*8]; @@ -420,6 +605,55 @@ void ImageDataTest::constructCompressedGeneric() { } } +#ifdef MAGNUM_BUILD_DEPRECATED +void ImageDataTest::constructCompressedGenericDeprecated() { + /* Like constructCompressedGeneric() but using the deprecated overloads. + Testing just that the argumens are passed through correctly, not all + getters. */ + + { + auto data = new char[7*8]; + int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */ + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{ + CompressedPixelFormat::Bc1RGBAUnorm, {12, 8}, + Containers::Array{data, 7*8}, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), DataFlag::Owned|DataFlag::Mutable); + CORRADE_VERIFY(a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.compressedStorage().rowLength(), 0); + CORRADE_COMPARE(a.compressedFormat(), CompressedPixelFormat::Bc1RGBAUnorm); + CORRADE_COMPARE(a.blockSize(), (Vector3i{4, 4, 1})); + CORRADE_COMPARE(a.blockDataSize(), 8); + CORRADE_COMPARE(a.size(), (Vector2i{12, 8})); + CORRADE_COMPARE(a.data().size(), 7*8); + CORRADE_COMPARE(a.importerState(), &state); + } { + auto data = new char[8*16]; + int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */ + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{ + CompressedPixelStorage{}.setRowLength(20), + CompressedPixelFormat::Astc5x5x4RGBAF, {15, 10}, + Containers::Array{data, 8*16}, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), DataFlag::Owned|DataFlag::Mutable); + CORRADE_VERIFY(a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.compressedStorage().rowLength(), 20); + CORRADE_COMPARE(a.compressedFormat(), CompressedPixelFormat::Astc5x5x4RGBAF); + CORRADE_COMPARE(a.blockSize(), (Vector3i{5, 5, 4})); + CORRADE_COMPARE(a.blockDataSize(), 16); + CORRADE_COMPARE(a.size(), (Vector2i{15, 10})); + CORRADE_COMPARE(a.data().size(), 8*16); + CORRADE_COMPARE(a.importerState(), &state); + } +} +#endif + void ImageDataTest::constructCompressedImplementationSpecific() { /* Format with autodetection */ { @@ -470,6 +704,40 @@ void ImageDataTest::constructCompressedImplementationSpecific() { } } +#ifdef MAGNUM_BUILD_DEPRECATED +void ImageDataTest::constructCompressedImplementationSpecificDeprecated() { + /* Like constructCompressedImplementationSpecific() but using the + deprecated overloads. Testing just that the argumens are passed through + correctly, not all getters. */ + + /* Format with autodetection */ + { + auto data = new char[8*8]; + int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */ + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{ + CompressedPixelStorage{}.setRowLength(16), + GL::CompressedPixelFormat::RGBS3tcDxt1, {12, 8}, + Containers::Array{data, 8*8}, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), DataFlag::Owned|DataFlag::Mutable); + CORRADE_VERIFY(a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.compressedStorage().rowLength(), 16); + CORRADE_COMPARE(a.compressedFormat(), compressedPixelFormatWrap(GL::CompressedPixelFormat::RGBS3tcDxt1)); + CORRADE_COMPARE(a.blockSize(), (Vector3i{4, 4, 1})); + CORRADE_COMPARE(a.blockDataSize(), 8); + CORRADE_COMPARE(a.size(), (Vector2i{12, 8})); + CORRADE_COMPARE(a.data().size(), 8*8); + CORRADE_COMPARE(a.importerState(), &state); + } + + /* Variant with manual block properties was added when ImageFlags were + present already, so there's no deprecated overload */ +} +#endif + void ImageDataTest::constructGenericNotOwned() { auto&& instanceData = NotOwnedData[testCaseInstanceId()]; setTestCaseDescription(instanceData.name); @@ -522,6 +790,54 @@ void ImageDataTest::constructGenericNotOwned() { } } +#ifdef MAGNUM_BUILD_DEPRECATED +void ImageDataTest::constructGenericNotOwnedDeprecated() { + auto&& instanceData = NotOwnedData[testCaseInstanceId()]; + setTestCaseDescription(instanceData.name); + + /* Like constructGenericNotOwned() but using the deprecated overloads. + Testing just that the argumens are passed through correctly, not all + getters. */ + + { + char data[4*4]; + int state; + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{PixelFormat::RGBA8Unorm, {1, 3}, instanceData.dataFlags, data, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), instanceData.dataFlags); + CORRADE_VERIFY(!a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.storage().alignment(), 4); + CORRADE_COMPARE(a.format(), PixelFormat::RGBA8Unorm); + CORRADE_COMPARE(a.formatExtra(), 0); + CORRADE_COMPARE(a.pixelSize(), 4); + CORRADE_COMPARE(a.size(), (Vector2i{1, 3})); + CORRADE_COMPARE(a.data().size(), 4*4); + CORRADE_COMPARE(a.importerState(), &state); + } { + char data[3*2]; + int state; + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{PixelStorage{}.setAlignment(1), + PixelFormat::R16UI, {1, 3}, instanceData.dataFlags, data, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), instanceData.dataFlags); + CORRADE_VERIFY(!a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.storage().alignment(), 1); + CORRADE_COMPARE(a.format(), PixelFormat::R16UI); + CORRADE_COMPARE(a.formatExtra(), 0); + CORRADE_COMPARE(a.pixelSize(), 2); + CORRADE_COMPARE(a.size(), (Vector2i{1, 3})); + CORRADE_COMPARE(a.data().size(), 3*2); + CORRADE_COMPARE(a.importerState(), &state); + } +} +#endif + void ImageDataTest::constructImplementationSpecificNotOwned() { auto&& instanceData = NotOwnedData[testCaseInstanceId()]; setTestCaseDescription(instanceData.name); @@ -603,6 +919,100 @@ void ImageDataTest::constructImplementationSpecificNotOwned() { } } +#ifdef MAGNUM_BUILD_DEPRECATED +void ImageDataTest::constructImplementationSpecificNotOwnedDeprecated() { + auto&& instanceData = NotOwnedData[testCaseInstanceId()]; + setTestCaseDescription(instanceData.name); + + /* Like constructImplementationSpecificNotOwned() but using the deprecated + overloads. Testing just that the argumens are passed through correctly, + not all getters. */ + + /* Single format */ + { + char data[3*12]; + int state; + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{PixelStorage{}.setAlignment(1), + Vk::PixelFormat::R32G32B32F, {1, 3}, instanceData.dataFlags, data, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), instanceData.dataFlags); + CORRADE_VERIFY(!a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.storage().alignment(), 1); + CORRADE_COMPARE(a.format(), pixelFormatWrap(Vk::PixelFormat::R32G32B32F)); + CORRADE_COMPARE(a.formatExtra(), 0); + CORRADE_COMPARE(a.pixelSize(), 12); + CORRADE_COMPARE(a.size(), (Vector2i{1, 3})); + CORRADE_COMPARE(a.data().size(), 3*12); + CORRADE_COMPARE(a.importerState(), &state); + } + + /* Format + extra */ + { + char data[3*6]; + int state; + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{PixelStorage{}.setAlignment(1), + GL::PixelFormat::RGB, GL::PixelType::UnsignedShort, {1, 3}, instanceData.dataFlags, data, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), instanceData.dataFlags); + CORRADE_VERIFY(!a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.format(), pixelFormatWrap(GL::PixelFormat::RGB)); + CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort)); + CORRADE_COMPARE(a.pixelSize(), 6); + CORRADE_COMPARE(a.size(), (Vector2i{1, 3})); + CORRADE_COMPARE(a.data().size(), 3*6); + CORRADE_COMPARE(a.importerState(), &state); + } + + /* Manual pixel size */ + { + char data[3*6]; + int state; + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{PixelStorage{}.setAlignment(1), 666, 1337, 6, {1, 3}, instanceData.dataFlags, data, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), instanceData.dataFlags); + CORRADE_VERIFY(!a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.storage().alignment(), 1); + CORRADE_COMPARE(a.format(), pixelFormatWrap(GL::PixelFormat::RGB)); + CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort)); + CORRADE_COMPARE(a.pixelSize(), 6); + CORRADE_COMPARE(a.size(), (Vector2i{1, 3})); + CORRADE_COMPARE(a.data().size(), 3*6); + CORRADE_COMPARE(a.importerState(), &state); + } + + /* Manual pixel size, wrapped in PixelFormat already. Tested here and not + in constructImplementationSpecificNonOwned() because there the + UnsignedInt overload delegates to the PixelFormat overload. */ + { + char data[3*6]; + int state; + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{PixelStorage{}.setAlignment(1), pixelFormatWrap(666), 1337, 6, {1, 3}, instanceData.dataFlags, data, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), instanceData.dataFlags); + CORRADE_VERIFY(!a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.storage().alignment(), 1); + CORRADE_COMPARE(a.format(), pixelFormatWrap(GL::PixelFormat::RGB)); + CORRADE_COMPARE(a.formatExtra(), UnsignedInt(GL::PixelType::UnsignedShort)); + CORRADE_COMPARE(a.pixelSize(), 6); + CORRADE_COMPARE(a.size(), (Vector2i{1, 3})); + CORRADE_COMPARE(a.data().size(), 3*6); + CORRADE_COMPARE(a.importerState(), &state); + } +} +#endif + void ImageDataTest::constructCompressedGenericNotOwned() { auto&& instanceData = NotOwnedData[testCaseInstanceId()]; setTestCaseDescription(instanceData.name); @@ -655,6 +1065,58 @@ void ImageDataTest::constructCompressedGenericNotOwned() { } } +#ifdef MAGNUM_BUILD_DEPRECATED +void ImageDataTest::constructCompressedGenericNotOwnedDeprecated() { + auto&& instanceData = NotOwnedData[testCaseInstanceId()]; + setTestCaseDescription(instanceData.name); + + /* Like constructCompressedGenericNotOwned() but using the deprecated + overloads. Testing just that the argumens are passed through correctly, + not all getters. */ + + { + char data[6*8]; + int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */ + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{ + CompressedPixelFormat::Bc1RGBAUnorm, {12, 8}, + instanceData.dataFlags, data, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), instanceData.dataFlags); + CORRADE_VERIFY(a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.compressedStorage().rowLength(), 0); + CORRADE_COMPARE(a.compressedFormat(), CompressedPixelFormat::Bc1RGBAUnorm); + CORRADE_COMPARE(a.blockSize(), (Vector3i{4, 4, 1})); + CORRADE_COMPARE(a.blockDataSize(), 8); + CORRADE_COMPARE(a.size(), (Vector2i{12, 8})); + CORRADE_COMPARE(a.data().size(), 6*8); + CORRADE_COMPARE(a.importerState(), &state); + } { + char data[8*16]; + int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */ + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{ + CompressedPixelStorage{}.setRowLength(20), + CompressedPixelFormat::Astc5x5x4RGBAF, {15, 10}, + instanceData.dataFlags, data, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), instanceData.dataFlags); + CORRADE_VERIFY(a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.compressedStorage().rowLength(), 20); + CORRADE_COMPARE(a.compressedFormat(), CompressedPixelFormat::Astc5x5x4RGBAF); + CORRADE_COMPARE(a.blockSize(), (Vector3i{5, 5, 4})); + CORRADE_COMPARE(a.blockDataSize(), 16); + CORRADE_COMPARE(a.size(), (Vector2i{15, 10})); + CORRADE_COMPARE(a.data().size(), 8*16); + CORRADE_COMPARE(a.importerState(), &state); + } +} +#endif + void ImageDataTest::constructCompressedImplementationSpecificNotOwned() { auto&& instanceData = NotOwnedData[testCaseInstanceId()]; setTestCaseDescription(instanceData.name); @@ -712,6 +1174,43 @@ void ImageDataTest::constructCompressedImplementationSpecificNotOwned() { } } +#ifdef MAGNUM_BUILD_DEPRECATED +void ImageDataTest::constructCompressedImplementationSpecificNotOwnedDeprecated() { + auto&& instanceData = NotOwnedData[testCaseInstanceId()]; + setTestCaseDescription(instanceData.name); + + /* Like constructCompressedImplementationSpecificNotOwned() but using the + deprecated overloads. Testing just that the argumens are passed through + correctly, not all getters. */ + + /* Format with autodetection */ + { + char data[8*8]; + int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */ + CORRADE_IGNORE_DEPRECATED_PUSH + ImageData2D a{ + CompressedPixelStorage{}.setRowLength(16), + GL::CompressedPixelFormat::RGBS3tcDxt1, {12, 8}, + instanceData.dataFlags, data, &state}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(a.dataFlags(), instanceData.dataFlags); + CORRADE_VERIFY(a.isCompressed()); + CORRADE_COMPARE(a.flags(), ImageFlags2D{}); + CORRADE_COMPARE(a.compressedStorage().rowLength(), 16); + CORRADE_COMPARE(a.compressedFormat(), compressedPixelFormatWrap(GL::CompressedPixelFormat::RGBS3tcDxt1)); + CORRADE_COMPARE(a.blockSize(), (Vector3i{4, 4, 1})); + CORRADE_COMPARE(a.blockDataSize(), 8); + CORRADE_COMPARE(a.size(), (Vector2i{12, 8})); + CORRADE_COMPARE(a.data().size(), 8*8); + CORRADE_COMPARE(a.importerState(), &state); + } + + /* Variant with manual block properties was added when ImageFlags were + present already, so there's no deprecated overload */ +} +#endif + void ImageDataTest::constructGenericNotOwnedFlagOwned() { CORRADE_SKIP_IF_NO_ASSERT(); diff --git a/src/Magnum/Trade/Test/MaterialDataTest.cpp b/src/Magnum/Trade/Test/MaterialDataTest.cpp index f3630bcdf..63692f7fb 100644 --- a/src/Magnum/Trade/Test/MaterialDataTest.cpp +++ b/src/Magnum/Trade/Test/MaterialDataTest.cpp @@ -124,6 +124,9 @@ struct MaterialDataTest: TestSuite::Tester { void accessTextureSwizzle(); void accessMutable(); void accessOptional(); + #ifdef MAGNUM_BUILD_DEPRECATED + void accessOptionalDeprecated(); + #endif void accessOutOfRange(); void accessNotFound(); void accessInvalidAttributeName(); @@ -146,8 +149,17 @@ struct MaterialDataTest: TestSuite::Tester { void accessLayerNameMutable(); void accessLayerStringMutable(); void accessLayerIndexOptional(); + #ifdef MAGNUM_BUILD_DEPRECATED + void accessLayerIndexOptionalDeprecated(); + #endif void accessLayerNameOptional(); + #ifdef MAGNUM_BUILD_DEPRECATED + void accessLayerNameOptionalDeprecated(); + #endif void accessLayerStringOptional(); + #ifdef MAGNUM_BUILD_DEPRECATED + void accessLayerStringOptionalDeprecated(); + #endif void accessLayerOutOfRange(); void accessLayerNotFound(); void accessInvalidLayerName(); @@ -161,6 +173,9 @@ struct MaterialDataTest: TestSuite::Tester { void releaseLayers(); void templateLayerAccess(); + #ifdef MAGNUM_BUILD_DEPRECATED + void templateLayerAccessDeprecated(); + #endif void templateLayerAccessMutable(); void debugLayer(); @@ -293,6 +308,9 @@ MaterialDataTest::MaterialDataTest() { &MaterialDataTest::accessTextureSwizzle, &MaterialDataTest::accessMutable, &MaterialDataTest::accessOptional, + #ifdef MAGNUM_BUILD_DEPRECATED + &MaterialDataTest::accessOptionalDeprecated, + #endif &MaterialDataTest::accessOutOfRange, &MaterialDataTest::accessNotFound, &MaterialDataTest::accessInvalidAttributeName, @@ -315,8 +333,17 @@ MaterialDataTest::MaterialDataTest() { &MaterialDataTest::accessLayerNameMutable, &MaterialDataTest::accessLayerStringMutable, &MaterialDataTest::accessLayerIndexOptional, + #ifdef MAGNUM_BUILD_DEPRECATED + &MaterialDataTest::accessLayerIndexOptionalDeprecated, + #endif &MaterialDataTest::accessLayerNameOptional, + #ifdef MAGNUM_BUILD_DEPRECATED + &MaterialDataTest::accessLayerNameOptionalDeprecated, + #endif &MaterialDataTest::accessLayerStringOptional, + #ifdef MAGNUM_BUILD_DEPRECATED + &MaterialDataTest::accessLayerStringOptionalDeprecated, + #endif &MaterialDataTest::accessLayerOutOfRange, &MaterialDataTest::accessLayerNotFound, &MaterialDataTest::accessInvalidLayerName, @@ -330,6 +357,9 @@ MaterialDataTest::MaterialDataTest() { &MaterialDataTest::releaseLayers, &MaterialDataTest::templateLayerAccess, + #ifdef MAGNUM_BUILD_DEPRECATED + &MaterialDataTest::templateLayerAccessDeprecated, + #endif &MaterialDataTest::templateLayerAccessMutable, &MaterialDataTest::debugLayer, @@ -2005,6 +2035,33 @@ void MaterialDataTest::accessOptional() { CORRADE_COMPARE(data.attributeOr(MaterialAttribute::DiffuseTexture, 5u), 5); } +#ifdef MAGNUM_BUILD_DEPRECATED +void MaterialDataTest::accessOptionalDeprecated() { + /* Like accessOptional() but using the deprecated tryAttribute() */ + + MaterialData data{{}, { + {MaterialAttribute::AlphaMask, 0.5f}, + {MaterialAttribute::SpecularTexture, 3u} + }}; + + CORRADE_IGNORE_DEPRECATED_PUSH + /* This exists */ + CORRADE_VERIFY(data.tryAttribute("SpecularTexture")); + CORRADE_VERIFY(data.tryAttribute(MaterialAttribute::SpecularTexture)); + CORRADE_COMPARE(*static_cast(data.tryAttribute("SpecularTexture")), 3); + CORRADE_COMPARE(*static_cast(data.tryAttribute(MaterialAttribute::SpecularTexture)), 3); + CORRADE_COMPARE(data.tryAttribute("SpecularTexture"), 3); + CORRADE_COMPARE(data.tryAttribute(MaterialAttribute::SpecularTexture), 3); + + /* This doesn't */ + CORRADE_VERIFY(!data.tryAttribute("DiffuseTexture")); + CORRADE_VERIFY(!data.tryAttribute(MaterialAttribute::DiffuseTexture)); + CORRADE_VERIFY(!data.tryAttribute("DiffuseTexture")); + CORRADE_VERIFY(!data.tryAttribute(MaterialAttribute::DiffuseTexture)); + CORRADE_IGNORE_DEPRECATED_POP +} +#endif + void MaterialDataTest::accessOutOfRange() { CORRADE_SKIP_IF_NO_ASSERT(); @@ -2565,6 +2622,35 @@ void MaterialDataTest::accessLayerIndexOptional() { CORRADE_COMPARE(data.attributeOr(1, MaterialAttribute::DiffuseTexture, 5u), 5); } +#ifdef MAGNUM_BUILD_DEPRECATED +void MaterialDataTest::accessLayerIndexOptionalDeprecated() { + /* Like accessLayerIndexOptional() but using the deprecated + tryAttribute() */ + + MaterialData data{{}, { + {MaterialAttribute::DiffuseColor, 0x335566ff_rgbaf}, + {MaterialAttribute::AlphaMask, 0.5f}, + {MaterialAttribute::SpecularTexture, 3u} + }, {1, 3}}; + + CORRADE_IGNORE_DEPRECATED_PUSH + /* This exists */ + CORRADE_VERIFY(data.tryAttribute(1, "SpecularTexture")); + CORRADE_VERIFY(data.tryAttribute(1, MaterialAttribute::SpecularTexture)); + CORRADE_COMPARE(*static_cast(data.tryAttribute(1, "SpecularTexture")), 3); + CORRADE_COMPARE(*static_cast(data.tryAttribute(1, MaterialAttribute::SpecularTexture)), 3); + CORRADE_COMPARE(data.tryAttribute(1, "SpecularTexture"), 3); + CORRADE_COMPARE(data.tryAttribute(1, MaterialAttribute::SpecularTexture), 3); + + /* This doesn't */ + CORRADE_VERIFY(!data.tryAttribute(1, "DiffuseTexture")); + CORRADE_VERIFY(!data.tryAttribute(1, MaterialAttribute::DiffuseTexture)); + CORRADE_VERIFY(!data.tryAttribute(1, "DiffuseTexture")); + CORRADE_VERIFY(!data.tryAttribute(1, MaterialAttribute::DiffuseTexture)); + CORRADE_IGNORE_DEPRECATED_POP +} +#endif + void MaterialDataTest::accessLayerNameOptional() { MaterialData data{{}, { {MaterialAttribute::DiffuseColor, 0x335566ff_rgbaf}, @@ -2592,6 +2678,36 @@ void MaterialDataTest::accessLayerNameOptional() { CORRADE_COMPARE(data.attributeOr(MaterialLayer::ClearCoat, MaterialAttribute::DiffuseTexture, 5u), 5); } +#ifdef MAGNUM_BUILD_DEPRECATED +void MaterialDataTest::accessLayerNameOptionalDeprecated() { + /* Like accessLayerNameOptional() but using the deprecated + tryAttribute() */ + + MaterialData data{{}, { + {MaterialAttribute::DiffuseColor, 0x335566ff_rgbaf}, + {MaterialLayer::ClearCoat}, + {MaterialAttribute::AlphaMask, 0.5f}, + {MaterialAttribute::SpecularTexture, 3u} + }, {1, 4}}; + + CORRADE_IGNORE_DEPRECATED_PUSH + /* This exists */ + CORRADE_VERIFY(data.tryAttribute(MaterialLayer::ClearCoat, "SpecularTexture")); + CORRADE_VERIFY(data.tryAttribute(MaterialLayer::ClearCoat, MaterialAttribute::SpecularTexture)); + CORRADE_COMPARE(*static_cast(data.tryAttribute(MaterialLayer::ClearCoat, "SpecularTexture")), 3); + CORRADE_COMPARE(*static_cast(data.tryAttribute(MaterialLayer::ClearCoat, MaterialAttribute::SpecularTexture)), 3); + CORRADE_COMPARE(data.tryAttribute(MaterialLayer::ClearCoat, "SpecularTexture"), 3); + CORRADE_COMPARE(data.tryAttribute(MaterialLayer::ClearCoat, MaterialAttribute::SpecularTexture), 3); + + /* This doesn't */ + CORRADE_VERIFY(!data.tryAttribute(MaterialLayer::ClearCoat, "DiffuseTexture")); + CORRADE_VERIFY(!data.tryAttribute(MaterialLayer::ClearCoat, MaterialAttribute::DiffuseTexture)); + CORRADE_VERIFY(!data.tryAttribute(MaterialLayer::ClearCoat, "DiffuseTexture")); + CORRADE_VERIFY(!data.tryAttribute(MaterialLayer::ClearCoat, MaterialAttribute::DiffuseTexture)); + CORRADE_IGNORE_DEPRECATED_POP +} +#endif + void MaterialDataTest::accessLayerStringOptional() { MaterialData data{{}, { {MaterialAttribute::DiffuseColor, 0x335566ff_rgbaf}, @@ -2619,6 +2735,36 @@ void MaterialDataTest::accessLayerStringOptional() { CORRADE_COMPARE(data.attributeOr("ClearCoat", MaterialAttribute::DiffuseTexture, 5u), 5); } +#ifdef MAGNUM_BUILD_DEPRECATED +void MaterialDataTest::accessLayerStringOptionalDeprecated() { + /* Like accessLayerStringOptional() but using the deprecated + tryAttribute() */ + + MaterialData data{{}, { + {MaterialAttribute::DiffuseColor, 0x335566ff_rgbaf}, + {MaterialAttribute::LayerName, "ClearCoat"}, + {MaterialAttribute::AlphaMask, 0.5f}, + {MaterialAttribute::SpecularTexture, 3u} + }, {1, 4}}; + + CORRADE_IGNORE_DEPRECATED_PUSH + /* This exists */ + CORRADE_VERIFY(data.tryAttribute("ClearCoat", "SpecularTexture")); + CORRADE_VERIFY(data.tryAttribute("ClearCoat", MaterialAttribute::SpecularTexture)); + CORRADE_COMPARE(*static_cast(data.tryAttribute("ClearCoat", "SpecularTexture")), 3); + CORRADE_COMPARE(*static_cast(data.tryAttribute("ClearCoat", MaterialAttribute::SpecularTexture)), 3); + CORRADE_COMPARE(data.tryAttribute("ClearCoat", "SpecularTexture"), 3); + CORRADE_COMPARE(data.tryAttribute("ClearCoat", MaterialAttribute::SpecularTexture), 3); + + /* This doesn't */ + CORRADE_VERIFY(!data.tryAttribute("ClearCoat", "DiffuseTexture")); + CORRADE_VERIFY(!data.tryAttribute("ClearCoat", MaterialAttribute::DiffuseTexture)); + CORRADE_VERIFY(!data.tryAttribute("ClearCoat", "DiffuseTexture")); + CORRADE_VERIFY(!data.tryAttribute("ClearCoat", MaterialAttribute::DiffuseTexture)); + CORRADE_IGNORE_DEPRECATED_POP +} +#endif + void MaterialDataTest::accessLayerOutOfRange() { CORRADE_SKIP_IF_NO_ASSERT(); @@ -3282,6 +3428,29 @@ void MaterialDataTest::templateLayerAccess() { CORRADE_COMPARE(data.attributeOr("LayerFactorTexture", 5u), 3); } +#ifdef MAGNUM_BUILD_DEPRECATED +void MaterialDataTest::templateLayerAccessDeprecated() { + /* Subset of templateLayerAccess() testing the deprecated tryAttribute() + overload */ + + MaterialLayerData data{{}, { + {MaterialAttribute::BaseColor, 0x335566ff_rgbaf}, + + {MaterialLayer::ClearCoat}, + {MaterialAttribute::LayerFactor, 0.35f}, + {MaterialAttribute::LayerFactorTexture, 3u}, + }, {1, 4}}; + + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_COMPARE(*static_cast(data.tryAttribute(MaterialAttribute::LayerFactorTexture)), 3); + CORRADE_COMPARE(*static_cast(data.tryAttribute("LayerFactorTexture")), 3); + + CORRADE_COMPARE(data.tryAttribute(MaterialAttribute::LayerFactorTexture), 3); + CORRADE_COMPARE(data.tryAttribute("LayerFactorTexture"), 3); + CORRADE_IGNORE_DEPRECATED_POP +} +#endif + void MaterialDataTest::templateLayerAccessMutable() { MaterialLayerData data{{}, { {MaterialLayer::ClearCoat}, diff --git a/src/Magnum/Trade/Test/PhongMaterialDataTest.cpp b/src/Magnum/Trade/Test/PhongMaterialDataTest.cpp index aee4c0de6..c3a5bc451 100644 --- a/src/Magnum/Trade/Test/PhongMaterialDataTest.cpp +++ b/src/Magnum/Trade/Test/PhongMaterialDataTest.cpp @@ -41,6 +41,7 @@ struct PhongMaterialDataTest: TestSuite::Tester { void constructDeprecatedTextured(); void constructDeprecatedTexturedTextureTransform(); void constructDeprecatedTexturedCoordinates(); + void constructDeprecatedNoColor(); void constructDeprecatedTextureTransformNoTextures(); void constructDeprecatedNoTextureTransformationFlag(); void constructDeprecatedNoTextureCoordinatesFlag(); @@ -79,6 +80,7 @@ PhongMaterialDataTest::PhongMaterialDataTest() { &PhongMaterialDataTest::constructDeprecatedTextured, &PhongMaterialDataTest::constructDeprecatedTexturedTextureTransform, &PhongMaterialDataTest::constructDeprecatedTexturedCoordinates, + &PhongMaterialDataTest::constructDeprecatedNoColor, &PhongMaterialDataTest::constructDeprecatedTextureTransformNoTextures, &PhongMaterialDataTest::constructDeprecatedNoTextureTransformationFlag, &PhongMaterialDataTest::constructDeprecatedNoTextureCoordinatesFlag, @@ -240,6 +242,30 @@ void PhongMaterialDataTest::constructDeprecatedTexturedCoordinates() { CORRADE_COMPARE(data.importerState(), &a); } +void PhongMaterialDataTest::constructDeprecatedNoColor() { + const int a{}; + CORRADE_IGNORE_DEPRECATED_PUSH + PhongMaterialData data{PhongMaterialData::Flag::DoubleSided, + MaterialAlphaMode::Mask, 0.3f, 80.0f, &a}; + CORRADE_IGNORE_DEPRECATED_POP + + CORRADE_COMPARE(data.types(), MaterialType::Phong); + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_COMPARE(data.type(), MaterialType::Phong); + CORRADE_COMPARE(data.flags(), PhongMaterialData::Flag::DoubleSided); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_COMPARE(data.ambientColor(), 0x000000ff_rgbaf); + CORRADE_COMPARE(data.diffuseColor(), 0xffffff_rgbf); + CORRADE_COMPARE(data.specularColor(), 0xffffff_rgbf); + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_COMPARE(data.textureMatrix(), Matrix3{}); + CORRADE_IGNORE_DEPRECATED_POP + CORRADE_COMPARE(data.alphaMode(), MaterialAlphaMode::Mask); + CORRADE_COMPARE(data.alphaMask(), 0.3f); + CORRADE_COMPARE(data.shininess(), 80.0f); + CORRADE_COMPARE(data.importerState(), &a); +} + void PhongMaterialDataTest::constructDeprecatedTextureTransformNoTextures() { CORRADE_SKIP_IF_NO_ASSERT(); @@ -360,23 +386,47 @@ void PhongMaterialDataTest::textured() { CORRADE_COMPARE(data.ambientTexture(), 42); CORRADE_COMPARE(data.ambientTextureMatrix(), Matrix3::scaling({0.5f, 1.0f})); CORRADE_COMPARE(data.ambientTextureCoordinates(), 2); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Just to verify the deprecated overload returns what it should */ + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_COMPARE(data.ambientCoordinateSet(), 2); + CORRADE_IGNORE_DEPRECATED_POP + #endif CORRADE_COMPARE(data.ambientTextureLayer(), 6); CORRADE_COMPARE(data.diffuseColor(), 0xeebbff_rgbf); CORRADE_COMPARE(data.diffuseTexture(), 33); CORRADE_COMPARE(data.diffuseTextureMatrix(), Matrix3::scaling({0.5f, 0.5f})); CORRADE_COMPARE(data.diffuseTextureCoordinates(), 3); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Just to verify the deprecated overload returns what it should */ + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_COMPARE(data.diffuseCoordinateSet(), 3); + CORRADE_IGNORE_DEPRECATED_POP + #endif CORRADE_COMPARE(data.diffuseTextureLayer(), 7); CORRADE_COMPARE(data.specularColor(), 0xacabad_rgbf); CORRADE_COMPARE(data.specularTexture(), 17); CORRADE_COMPARE(data.specularTextureSwizzle(), MaterialTextureSwizzle::RGBA); CORRADE_COMPARE(data.specularTextureMatrix(), Matrix3::scaling({1.0f, 1.0f})); CORRADE_COMPARE(data.specularTextureCoordinates(), 4); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Just to verify the deprecated overload returns what it should */ + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_COMPARE(data.specularCoordinateSet(), 4); + CORRADE_IGNORE_DEPRECATED_POP + #endif CORRADE_COMPARE(data.specularTextureLayer(), 8); CORRADE_COMPARE(data.normalTexture(), 0); CORRADE_COMPARE(data.normalTextureScale(), 0.5f); CORRADE_COMPARE(data.normalTextureSwizzle(), MaterialTextureSwizzle::GB); CORRADE_COMPARE(data.normalTextureMatrix(), Matrix3::scaling({1.0f, 0.5f})); CORRADE_COMPARE(data.normalTextureCoordinates(), 5); + #ifdef MAGNUM_BUILD_DEPRECATED + /* Just to verify the deprecated overload returns what it should */ + CORRADE_IGNORE_DEPRECATED_PUSH + CORRADE_COMPARE(data.normalCoordinateSet(), 5); + CORRADE_IGNORE_DEPRECATED_POP + #endif CORRADE_COMPARE(data.normalTextureLayer(), 9); }