ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Trade: test also the deprecated APIs. 

They're now uncovered, which only makes it harder to spot missing
coverage in non-deprecated code. And testing is simply a matter of
copypasting the existing tests.
pull/482/merge
Vladimír Vondruš 2 weeks ago
parent
eb81fa48e4
commit
4885f9e54c
7 changed files with 1369 additions and 7 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 535
      src/Magnum/Trade/Test/AbstractImageConverterTest.cpp
  2. 25
      src/Magnum/Trade/Test/AbstractImporterTest.cpp
  3. 72
      src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp
  4. 12
      src/Magnum/Trade/Test/AnimationDataTest.cpp
  5. 507
      src/Magnum/Trade/Test/ImageDataTest.cpp
  6. 169
      src/Magnum/Trade/Test/MaterialDataTest.cpp
  7. 50
      src/Magnum/Trade/Test/PhongMaterialDataTest.cpp

535
src/Magnum/Trade/Test/AbstractImageConverterTest.cpp
Unescape View File

@ -41,6 +41,12 @@
#include "configure.h"
/** @todo remove once the deprecated overloads are gone */
#ifdef MAGNUM_BUILD_DEPRECATED
#include <string>
#include <Corrade/Containers/StringStl.h>
#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<ImageData2D> doConvert(const ImageView2D& image) override {
return ImageData2D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array<char>{96}};
}
} converter;
CORRADE_IGNORE_DEPRECATED_PUSH
Containers::Optional<Image2D> actual = converter.exportToImage(ImageView2D{PixelFormat::R8Unorm, {4, 6}, Containers::ArrayView<char>{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<ImageData2D> doConvert(const ImageView2D& image) override {
return ImageData2D{CompressedPixelFormat::Bc1RGBAUnorm, image.size(), Containers::Array<char>{96}};
}
} converter;
Containers::String out;
Error redirectError{&out};
CORRADE_IGNORE_DEPRECATED_PUSH
CORRADE_VERIFY(!converter.exportToImage(ImageView2D{PixelFormat::R8Unorm, {4, 6}, Containers::ArrayView<char>{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<ImageData2D> doConvert(const ImageView2D& image) override {
return ImageData2D{CompressedPixelFormat::Bc1RGBAUnorm, image.size(), Containers::Array<char>{96}};
}
} converter;
CORRADE_IGNORE_DEPRECATED_PUSH
Containers::Optional<CompressedImage2D> actual = converter.exportToCompressedImage(ImageView2D{PixelFormat::R8Unorm, {4, 6}, Containers::ArrayView<char>{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<ImageData2D> doConvert(const ImageView2D& image) override {
return ImageData2D{PixelFormat::RGBA8Unorm, image.size(), Containers::Array<char>{96}};
}
} converter;
Containers::String out;
Error redirectError{&out};
CORRADE_IGNORE_DEPRECATED_PUSH
CORRADE_VERIFY(!converter.exportToCompressedImage(ImageView2D{PixelFormat::R8Unorm, {4, 6}, Containers::ArrayView<char>{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<ImageData2D> 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<Containers::Array<char>> doConvertToData(const ImageView2D& image) override {
return Containers::Array<char>{nullptr, std::size_t(image.size().product())};
}
} converter;
const char data[96]{};
CORRADE_IGNORE_DEPRECATED_PUSH
Containers::Array<char> 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<Containers::Array<char>> 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<Containers::Array<char>> doConvertToData(const CompressedImageView2D& image) override {
return Containers::Array<char>{nullptr, std::size_t(image.size().product())};
}
} converter;
const char data[64]{};
CORRADE_IGNORE_DEPRECATED_PUSH
Containers::Array<char> 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<Containers::Array<char>> 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<char> out = converter.exportToData(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, Containers::Array<char>{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<char> out = converter.exportToData(ImageData2D{CompressedPixelFormat::Bc1RGBUnorm, {4, 4}, Containers::Array<char>{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<Containers::Array<char>> doConvertToData(const ImageView2D&) override {
called = true;
return {};
}
Containers::Optional<Containers::Array<char>> 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<char>{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<char>{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<char>{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<char>{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 {

25
src/Magnum/Trade/Test/AbstractImporterTest.cpp
Unescape View File

@ -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 {}; }

72
src/Magnum/Trade/Test/AbstractSceneConverterTest.cpp
Unescape View File

@ -54,6 +54,12 @@
#include "configure.h"
/** @todo remove once the deprecated convertMeshToFile() is gone */
#ifdef MAGNUM_BUILD_DEPRECATED
#include <string>
#include <Corrade/Containers/StringStl.h>
#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<MeshData> mesh = importer->mesh(0);

12
src/Magnum/Trade/Test/AnimationDataTest.cpp
Unescape View File

@ -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<const Float, const Vector3> track = data.track<Vector3>(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<const Float, const Quaternion> track = data.track<Quaternion>(1);

507
src/Magnum/Trade/Test/ImageDataTest.cpp
Unescape View File

@ -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});
#ifdef MAGNUM_BUILD_DEPRECATED
&ImageDataTest::constructCompressedGenericDeprecated,
#endif
&ImageDataTest::constructCompressedImplementationSpecific,
#ifdef MAGNUM_BUILD_DEPRECATED
&ImageDataTest::constructCompressedImplementationSpecificDeprecated
#endif
});
addInstancedTests({&ImageDataTest::constructGenericNotOwned,
addInstancedTests({
&ImageDataTest::constructGenericNotOwned,
#ifdef MAGNUM_BUILD_DEPRECATED
&ImageDataTest::constructGenericNotOwnedDeprecated,
#endif
&ImageDataTest::constructImplementationSpecificNotOwned,
#ifdef MAGNUM_BUILD_DEPRECATED
&ImageDataTest::constructImplementationSpecificNotOwnedDeprecated,
#endif
&ImageDataTest::constructCompressedGenericNotOwned,
&ImageDataTest::constructCompressedImplementationSpecificNotOwned},
Containers::arraySize(NotOwnedData));
#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<char>{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<char>{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<char>{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<char>{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<char>{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<char>{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<char>{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<char>{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<char>{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();

169
src/Magnum/Trade/Test/MaterialDataTest.cpp
Unescape View File

@ -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<const Int*>(data.tryAttribute("SpecularTexture")), 3);
CORRADE_COMPARE(*static_cast<const Int*>(data.tryAttribute(MaterialAttribute::SpecularTexture)), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>("SpecularTexture"), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>(MaterialAttribute::SpecularTexture), 3);
/* This doesn't */
CORRADE_VERIFY(!data.tryAttribute("DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute(MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>("DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>(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<const UnsignedInt*>(data.tryAttribute(1, "SpecularTexture")), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute(1, MaterialAttribute::SpecularTexture)), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>(1, "SpecularTexture"), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>(1, MaterialAttribute::SpecularTexture), 3);
/* This doesn't */
CORRADE_VERIFY(!data.tryAttribute(1, "DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute(1, MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>(1, "DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>(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<const UnsignedInt*>(data.tryAttribute(MaterialLayer::ClearCoat, "SpecularTexture")), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute(MaterialLayer::ClearCoat, MaterialAttribute::SpecularTexture)), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>(MaterialLayer::ClearCoat, "SpecularTexture"), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>(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<UnsignedInt>(MaterialLayer::ClearCoat, "DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>(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<const UnsignedInt*>(data.tryAttribute("ClearCoat", "SpecularTexture")), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute("ClearCoat", MaterialAttribute::SpecularTexture)), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>("ClearCoat", "SpecularTexture"), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>("ClearCoat", MaterialAttribute::SpecularTexture), 3);
/* This doesn't */
CORRADE_VERIFY(!data.tryAttribute("ClearCoat", "DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute("ClearCoat", MaterialAttribute::DiffuseTexture));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>("ClearCoat", "DiffuseTexture"));
CORRADE_VERIFY(!data.tryAttribute<UnsignedInt>("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<MaterialLayer::ClearCoat> data{{}, {
{MaterialAttribute::BaseColor, 0x335566ff_rgbaf},
{MaterialLayer::ClearCoat},
{MaterialAttribute::LayerFactor, 0.35f},
{MaterialAttribute::LayerFactorTexture, 3u},
}, {1, 4}};
CORRADE_IGNORE_DEPRECATED_PUSH
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute(MaterialAttribute::LayerFactorTexture)), 3);
CORRADE_COMPARE(*static_cast<const UnsignedInt*>(data.tryAttribute("LayerFactorTexture")), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>(MaterialAttribute::LayerFactorTexture), 3);
CORRADE_COMPARE(data.tryAttribute<UnsignedInt>("LayerFactorTexture"), 3);
CORRADE_IGNORE_DEPRECATED_POP
}
#endif
void MaterialDataTest::templateLayerAccessMutable() {
MaterialLayerData<MaterialLayer::ClearCoat> data{{}, {
{MaterialLayer::ClearCoat},

50
src/Magnum/Trade/Test/PhongMaterialDataTest.cpp
Unescape View File

@ -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);
}

Write Preview
Loading…
Cancel
Save