void ConfigurationTest::parseHierarchic() { Configuration conf(Directory::join(CONFIGURATION_TEST_DIR, "hierarchic.conf")); conf.setFilename(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "hierarchic.conf")); CORRADE_VERIFY(conf.isValid()); /* Check parsing */ CORRADE_VERIFY(conf.hasGroup("z")); CORRADE_COMPARE(conf.group("z")->group("x")->group("c")->group("v")->value("key1"), "val1"); CORRADE_COMPARE(conf.groupCount("a"), 2); CORRADE_COMPARE(conf.group("a")->groupCount("b"), 2); CORRADE_COMPARE(conf.group("a")->group("b", 0)->value("key2"), "val2"); CORRADE_COMPARE(conf.group("a")->group("b", 1)->value("key2"), "val3"); CORRADE_COMPARE(conf.group("a", 1)->value("key3"), "val4"); CORRADE_COMPARE(conf.group("a", 1)->group("b")->value("key2"), "val5"); /* Expect no change */ CORRADE_VERIFY(conf.save()); CORRADE_COMPARE_AS(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "hierarchic.conf"), Directory::join(CONFIGURATION_TEST_DIR, "hierarchic.conf"), TestSuite::Compare::File); /* Modify */ conf.group("z")->group("x")->clear(); conf.group("a", 1)->addGroup("b")->setValue("key2", "val6"); conf.addGroup("q")->addGroup("w")->addGroup("e")->addGroup("r")->setValue("key4", "val7"); /* Verify changes */ CORRADE_VERIFY(conf.save()); CORRADE_COMPARE_AS(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "hierarchic.conf"), Directory::join(CONFIGURATION_TEST_DIR, "hierarchic-modified.conf"), TestSuite::Compare::File); }
void QuaternionTest::rotation() { std::ostringstream o; Error::setOutput(&o); Vector3 axis(1.0f/Constants<Float>::sqrt3()); CORRADE_COMPARE(Quaternion::rotation(Deg(-74.0f), {-1.0f, 2.0f, 2.0f}), Quaternion()); CORRADE_COMPARE(o.str(), "Math::Quaternion::rotation(): axis must be normalized\n"); Quaternion q = Quaternion::rotation(Deg(120.0f), axis); CORRADE_COMPARE(q.length(), 1.0f); CORRADE_COMPARE(q, Quaternion(Vector3(0.5f, 0.5f, 0.5f), 0.5f)); CORRADE_COMPARE_AS(q.angle(), Deg(120.0f), Deg); CORRADE_COMPARE(q.axis(), axis); CORRADE_COMPARE(q.axis().length(), 1.0f); /* Verify negative angle */ Quaternion q2 = Quaternion::rotation(Deg(-120.0f), axis); CORRADE_COMPARE(q2, Quaternion(Vector3(-0.5f, -0.5f, -0.5f), 0.5f)); CORRADE_COMPARE_AS(q2.angle(), Deg(120.0f), Deg); CORRADE_COMPARE(q2.axis(), -axis); /* Default-constructed quaternion has zero angle and NaN axis */ CORRADE_COMPARE_AS(Quaternion().angle(), Deg(0.0f), Deg); CORRADE_VERIFY(Quaternion().axis() != Quaternion().axis()); }
void StringTest::split() { /* Empty */ CORRADE_COMPARE_AS(String::split({}, '/'), std::vector<std::string>{}, TestSuite::Compare::Container); CORRADE_COMPARE_AS(String::splitWithoutEmptyParts({}, '/'), std::vector<std::string>{}, TestSuite::Compare::Container); /* Only delimiter */ CORRADE_COMPARE_AS(String::split("/", '/'), (std::vector<std::string>{"", ""}), TestSuite::Compare::Container); CORRADE_COMPARE_AS(String::splitWithoutEmptyParts("/", '/'), std::vector<std::string>{}, TestSuite::Compare::Container); /* No delimiters */ CORRADE_COMPARE_AS(String::split("abcdef", '/'), std::vector<std::string>{"abcdef"}, TestSuite::Compare::Container); CORRADE_COMPARE_AS(String::splitWithoutEmptyParts("abcdef", '/'), std::vector<std::string>{"abcdef"}, TestSuite::Compare::Container); /* Common case */ CORRADE_COMPARE_AS(String::split("ab/c/def", '/'), (std::vector<std::string>{"ab", "c", "def"}), TestSuite::Compare::Container); CORRADE_COMPARE_AS(String::splitWithoutEmptyParts("ab/c/def", '/'), (std::vector<std::string>{"ab", "c", "def"}), TestSuite::Compare::Container); /* Empty parts */ CORRADE_COMPARE_AS(String::split("ab//c/def//", '/'), (std::vector<std::string>{"ab", "", "c", "def", "", ""}), TestSuite::Compare::Container); CORRADE_COMPARE_AS(String::splitWithoutEmptyParts("ab//c/def//", '/'), (std::vector<std::string>{"ab", "c", "def"}), TestSuite::Compare::Container); }
void DdsImporterTest::rgbWithMips() { DdsImporter importer; CORRADE_VERIFY(importer.openFile(Utility::Directory::join(DDSIMPORTER_TEST_DIR, "rgb_uncompressed_mips.dds"))); const char pixels[] = {'\xde', '\xad', '\xb5', '\xca', '\xfe', '\x77', '\xde', '\xad', '\xb5', '\xca', '\xfe', '\x77', '\xde', '\xad', '\xb5', '\xca', '\xfe', '\x77'}; const char mipPixels[] = {'\xd4', '\xd5', '\x96'}; /* check image */ std::optional<Trade::ImageData2D> image = importer.image2D(0); CORRADE_VERIFY(image); CORRADE_VERIFY(!image->isCompressed()); CORRADE_COMPARE(image->storage().alignment(), 1); CORRADE_COMPARE(image->size(), Vector2i(3, 2)); CORRADE_COMPARE(image->format(), PixelFormat::RGB); CORRADE_COMPARE(image->type(), PixelType::UnsignedByte); CORRADE_COMPARE_AS(image->data(), Containers::ArrayView<const char>(pixels), TestSuite::Compare::Container); /* check mip 0 */ std::optional<Trade::ImageData2D> mip = importer.image2D(1); CORRADE_VERIFY(mip); CORRADE_VERIFY(!mip->isCompressed()); CORRADE_COMPARE(image->storage().alignment(), 1); CORRADE_COMPARE(mip->size(), Vector2i{1}); CORRADE_COMPARE(mip->format(), PixelFormat::RGB); CORRADE_COMPARE(mip->type(), PixelType::UnsignedByte); CORRADE_COMPARE_AS(mip->data(), Containers::ArrayView<const char>(mipPixels), TestSuite::Compare::Container); }
void ConfigurationTest::typesScientific() { Configuration conf(Directory::join(CONFIGURATION_TEST_DIR, "types-scientific.conf"), Configuration::Flag::ReadOnly); CORRADE_COMPARE(conf.value<double>("exp"), 2.1e7); CORRADE_COMPARE(conf.value<double>("expPos"), 2.1e+7); conf.setValue("expPos", 2.1e+7, 0, ConfigurationValueFlag::Scientific); CORRADE_COMPARE(conf.value<double>("expNeg"), -2.1e7); CORRADE_COMPARE(conf.value<double>("expNeg2"), 2.1e-7); CORRADE_COMPARE(conf.value<double>("expBig"), 2.1E7); conf.setValue<double>("expBig", 2.1E7, 0, ConfigurationValueFlag::Scientific|ConfigurationValueFlag::Uppercase); /* Nothing should be changed after saving */ CORRADE_VERIFY(conf.save(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "types-scientific.conf"))); /* MinGW32 has one zero more in scientific notation */ #if !defined(__MINGW32__) CORRADE_COMPARE_AS(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "types-scientific.conf"), Directory::join(CONFIGURATION_TEST_DIR, "types-scientific.conf"), TestSuite::Compare::File); #else CORRADE_COMPARE_AS(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "types-scientific.conf"), Directory::join(CONFIGURATION_TEST_DIR, "types-scientific-win.conf"), TestSuite::Compare::File); #endif }
void ResourceStaticTest::get() { Resource r("test"); CORRADE_COMPARE_AS(r.get("predisposition.bin"), Directory::join(RESOURCE_TEST_DIR, "predisposition.bin"), TestSuite::Compare::StringToFile); CORRADE_COMPARE_AS(r.get("consequence.bin"), Directory::join(RESOURCE_TEST_DIR, "consequence.bin"), TestSuite::Compare::StringToFile); }
void DualComplexTest::combinedTransformParts() { Vector2 translation = Vector2(-1.5f, 2.75f); DualComplex a = DualComplex::translation(translation)*DualComplex::rotation(Deg(23.0f)); DualComplex b = DualComplex::rotation(Deg(23.0f))*DualComplex::translation(translation); CORRADE_COMPARE_AS(a.rotation().angle(), Deg(23.0f), Rad); CORRADE_COMPARE_AS(b.rotation().angle(), Deg(23.0f), Rad); CORRADE_COMPARE(a.translation(), translation); CORRADE_COMPARE(b.translation(), Complex::rotation(Deg(23.0f)).transformVector(translation)); }
void ConfigurationTest::parse() { Configuration conf(Directory::join(CONFIGURATION_TEST_DIR, "parse.conf")); conf.setFilename(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "parse.conf")); CORRADE_VERIFY(conf.configuration() == &conf); CORRADE_VERIFY(conf.isValid()); CORRADE_VERIFY(!conf.isEmpty()); /* Groups */ CORRADE_VERIFY(conf.hasGroups()); CORRADE_COMPARE(conf.groupCount(), 4); CORRADE_VERIFY(!conf.hasGroup("groupNonexistent")); CORRADE_COMPARE(conf.groupCount("group"), 2); CORRADE_COMPARE(conf.groupCount("emptyGroup"), 1); CORRADE_VERIFY(conf.group("group")->configuration() == &conf); CORRADE_COMPARE_AS(conf.groups("group"), (std::vector<ConfigurationGroup*>{conf.group("group", 0), conf.group("group", 1)}), TestSuite::Compare::Container); std::string tmp; /* Values */ CORRADE_VERIFY(conf.hasValues()); CORRADE_COMPARE(conf.valueCount(), 1); CORRADE_VERIFY(conf.hasValue("key")); CORRADE_VERIFY(!conf.hasValue("keyNonexistent")); CORRADE_COMPARE(conf.value("key"), "value"); CORRADE_COMPARE(conf.group("group", 1)->value("c", 1), "value5"); CORRADE_COMPARE_AS(conf.group("group", 1)->values("c"), (std::vector<std::string>{"value4", "value5"}), TestSuite::Compare::Container); /* Default-constructed nonexistent values */ CORRADE_COMPARE(conf.value("nonexistent"), ""); CORRADE_COMPARE(conf.value<int>("nonexistent"), 0); CORRADE_COMPARE(conf.value<double>("nonexistent"), 0.0); /* Save file back - expecting no change */ CORRADE_VERIFY(conf.save()); /* Modify */ conf.addValue("new", "value"); conf.removeAllGroups("group"); conf.group("thirdGroup")->clear(); CORRADE_VERIFY(conf.removeGroup("emptyGroup")); CORRADE_VERIFY(conf.addGroup("newGroup")); conf.group("newGroup")->addValue("another", "value"); conf.addGroup("newGroupCopy", new ConfigurationGroup(*conf.group("newGroup"))); conf.removeAllValues("key"); /* Save again, verify changes */ CORRADE_VERIFY(conf.save()); CORRADE_COMPARE_AS(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "parse.conf"), Directory::join(CONFIGURATION_TEST_DIR, "parse-modified.conf"), TestSuite::Compare::File); }
void DirectoryTest::write() { constexpr unsigned char data[] = {0xCA, 0xFE, 0xBA, 0xBE, 0x0D, 0x0A, 0x00, 0xDE, 0xAD, 0xBE, 0xEF}; CORRADE_VERIFY(Directory::write(Directory::join(DIRECTORY_WRITE_TEST_DIR, "file"), data)); CORRADE_COMPARE_AS(Directory::join(DIRECTORY_WRITE_TEST_DIR, "file"), Directory::join(DIRECTORY_TEST_DIR, "file"), TestSuite::Compare::File); CORRADE_VERIFY(Directory::writeString(Directory::join(DIRECTORY_WRITE_TEST_DIR, "file"), std::string("\xCA\xFE\xBA\xBE\x0D\x0A\x00\xDE\xAD\xBE\xEF", 11))); CORRADE_COMPARE_AS(Directory::join(DIRECTORY_WRITE_TEST_DIR, "file"), Directory::join(DIRECTORY_TEST_DIR, "file"), TestSuite::Compare::File); }
void ComplexTest::rotation() { Complex a = Complex::rotation(Deg(120.0f)); CORRADE_COMPARE(a.length(), 1.0f); CORRADE_COMPARE(a, Complex(-0.5f, 0.8660254f)); CORRADE_COMPARE_AS(a.angle(), Deg(120.0f), Rad); /* Verify negative angle */ Complex b = Complex::rotation(Deg(-240.0f)); CORRADE_COMPARE(b, Complex(-0.5f, 0.8660254f)); CORRADE_COMPARE_AS(b.angle(), Deg(120.0f), Rad); /* Default-constructed complex number has zero angle */ CORRADE_COMPARE_AS(Complex().angle(), Deg(0.0f), Rad); }
void Test::reloadPluginDirectory() { #if defined(CORRADE_TARGET_NACL_NEWLIB) || defined(CORRADE_TARGET_EMSCRIPTEN) CORRADE_SKIP("Plugin directory is irrelevant for static plugins"); #else PluginManager::Manager<AbstractAnimal> manager(PLUGINS_DIR); /* Load Dog and rename the plugin */ CORRADE_COMPARE(manager.load("Dog"), LoadState::Loaded); Directory::move(Directory::join(PLUGINS_DIR, std::string("Dog") + PLUGIN_FILENAME_SUFFIX), Directory::join(PLUGINS_DIR, std::string("LostDog") + PLUGIN_FILENAME_SUFFIX)); Directory::move(Directory::join(PLUGINS_DIR, "Dog.conf"), Directory::join(PLUGINS_DIR, "LostDog.conf")); /* Rename Chihuahua */ Directory::move(Directory::join(PLUGINS_DIR, std::string("Chihuahua") + PLUGIN_FILENAME_SUFFIX), Directory::join(PLUGINS_DIR, std::string("LostChihuahua") + PLUGIN_FILENAME_SUFFIX)); Directory::move(Directory::join(PLUGINS_DIR, "Chihuahua.conf"), Directory::join(PLUGINS_DIR, "LostChihuahua.conf")); /* Reload plugin dir and check new name list */ manager.reloadPluginDirectory(); std::vector<std::string> actual1 = manager.pluginList(); /* Unload Dog and it should disappear from the list */ CORRADE_COMPARE(manager.unload("Dog"), LoadState::NotLoaded); manager.reloadPluginDirectory(); std::vector<std::string> actual2 = manager.pluginList(); /** @todo Also test that "WrongMetadataFile" plugins are reloaded */ /* Rename everything back and clean up */ Directory::move(Directory::join(PLUGINS_DIR, std::string("LostDog") + PLUGIN_FILENAME_SUFFIX), Directory::join(PLUGINS_DIR, std::string("Dog") + PLUGIN_FILENAME_SUFFIX)); Directory::move(Directory::join(PLUGINS_DIR, "LostDog.conf"), Directory::join(PLUGINS_DIR, "Dog.conf")); Directory::move(Directory::join(PLUGINS_DIR, std::string("LostChihuahua") + PLUGIN_FILENAME_SUFFIX), Directory::join(PLUGINS_DIR, std::string("Chihuahua") + PLUGIN_FILENAME_SUFFIX)); Directory::move(Directory::join(PLUGINS_DIR, "LostChihuahua.conf"), Directory::join(PLUGINS_DIR, "Chihuahua.conf")); manager.reloadPluginDirectory(); /* And now we can safely compare */ CORRADE_COMPARE_AS(actual1, (std::vector<std::string>{ "Canary", "Dog", "LostChihuahua", "LostDog", "Snail"}), TestSuite::Compare::Container); CORRADE_COMPARE_AS(actual2, (std::vector<std::string>{ "Canary", "LostChihuahua", "LostDog", "Snail"}), TestSuite::Compare::Container); #endif }
void CylinderTest::wireframe() { Trade::MeshData3D cylinder = Cylinder::wireframe(2, 8, 0.5f); CORRADE_COMPARE_AS(cylinder.positions(0), (std::vector<Vector3>{ {0.0f, -0.5f, 1.0f}, {1.0f, -0.5f, 0.0f}, {0.0f, -0.5f, -1.0f}, {-1.0f, -0.5f, 0.0f}, {0.707107f, -0.5f, 0.707107f}, {0.707107f, -0.5f, -0.707107f}, {-0.707107f, -0.5f, -0.707107f}, {-0.707107f, -0.5f, 0.707107f}, {0.0f, 0.0f, 1.0f}, {1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}, {-1.0f, 0.0f, 0.0f}, {0.707107f, 0.0f, 0.707107f}, {0.707107f, 0.0f, -0.707107f}, {-0.707107f, 0.0f, -0.707107f}, {-0.707107f, 0.0f, 0.707107f}, {0.0f, 0.5f, 1.0f}, {1.0f, 0.5f, 0.0f}, {0.0f, 0.5f, -1.0f}, {-1.0f, 0.5f, 0.0f}, {0.707107f, 0.5f, 0.707107f}, {0.707107f, 0.5f, -0.707107f}, {-0.707107f, 0.5f, -0.707107f}, {-0.707107f, 0.5f, 0.707107f} }), TestSuite::Compare::Container); CORRADE_COMPARE(cylinder.normalArrayCount(), 0); CORRADE_COMPARE_AS(cylinder.indices(), (std::vector<UnsignedInt>{ 0, 4, 1, 5, 2, 6, 3, 7, 4, 1, 5, 2, 6, 3, 7, 0, 0, 8, 1, 9, 2, 10, 3, 11, 8, 12, 9, 13, 10, 14, 11, 15, 12, 9, 13, 10, 14, 11, 15, 8, 8, 16, 9, 17, 10, 18, 11, 19, 16, 20, 17, 21, 18, 22, 19, 23, 20, 17, 21, 18, 22, 19, 23, 16 }), TestSuite::Compare::Container); }
void BufferImageGLTest::constructCompressed() { const char data[] = { 'a', 0, 0, 0, 'b', 0, 0, 0 }; CompressedBufferImage2D a{ #ifndef MAGNUM_TARGET_GLES CompressedPixelStorage{}.setCompressedBlockSize(Vector3i{4}), #endif CompressedPixelFormat::RGBAS3tcDxt1, {4, 4}, data, BufferUsage::StaticDraw}; #ifndef MAGNUM_TARGET_GLES const auto imageData = a.buffer().data(); #endif MAGNUM_VERIFY_NO_ERROR(); #ifndef MAGNUM_TARGET_GLES CORRADE_COMPARE(a.storage().compressedBlockSize(), Vector3i{4}); #endif CORRADE_COMPARE(a.format(), CompressedPixelFormat::RGBAS3tcDxt1); CORRADE_COMPARE(a.size(), Vector2i(4, 4)); CORRADE_COMPARE(a.dataSize(), 8); /** @todo How to verify the contents in ES? */ #ifndef MAGNUM_TARGET_GLES CORRADE_COMPARE_AS(imageData, Containers::ArrayView<const char>{data}, TestSuite::Compare::Container); #endif }
void TextureGLTest::subImageBuffer() { if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::texture_rectangle>()) CORRADE_SKIP(Extensions::GL::ARB::texture_rectangle::string() + std::string(" is not supported.")); constexpr UnsignedByte zero[4*4*4] = {}; constexpr UnsignedByte subData[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f }; RectangleTexture texture; texture.setImage(TextureFormat::RGBA8, ImageReference2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(4), zero)); texture.setSubImage(Vector2i(1), BufferImage2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(2), subData, BufferUsage::StaticDraw)); MAGNUM_VERIFY_NO_ERROR(); BufferImage2D image(ColorFormat::RGBA, ColorType::UnsignedByte); texture.image(image, BufferUsage::StaticRead); const auto imageData = image.buffer().data<UnsignedByte>(); MAGNUM_VERIFY_NO_ERROR(); CORRADE_COMPARE(image.size(), Vector2i(4)); CORRADE_COMPARE_AS(std::vector<UnsignedByte>(imageData.begin(), imageData.end()), (std::vector<UnsignedByte>{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }), TestSuite::Compare::Container); }
void MagnumFontConverterTest::exportFont() { /* Remove previously created files */ Utility::Directory::rm(Utility::Directory::join(MAGNUMFONTCONVERTER_TEST_WRITE_DIR, "font.conf")); Utility::Directory::rm(Utility::Directory::join(MAGNUMFONTCONVERTER_TEST_WRITE_DIR, "font.tga")); /* Open font */ FreeTypeFont font; CORRADE_VERIFY(font.openFile(Utility::Directory::join(FREETYPEFONT_TEST_DIR, "Oxygen.ttf"), 16.0f)); /* Create fake cache */ MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::ARB::texture_rg); GlyphCache cache(TextureFormat::R8, Vector2i(1536), Vector2i(256), Vector2i(24)); cache.insert(font.glyphId(U'W'), {25, 34}, {{0, 8}, {16, 128}}); cache.insert(font.glyphId(U'e'), {25, 12}, {{16, 4}, {64, 32}}); /* Convert the file */ MagnumFontConverter converter; converter.exportFontToFile(font, cache, Utility::Directory::join(MAGNUMFONTCONVERTER_TEST_WRITE_DIR, "font"), "Wave"); /* Verify font parameters */ /** @todo This might behave differently elsewhere due to unspecified order of glyphs in cache */ CORRADE_COMPARE_AS(Utility::Directory::join(MAGNUMFONTCONVERTER_TEST_WRITE_DIR, "font.conf"), Utility::Directory::join(MAGNUMFONT_TEST_DIR, "font.conf"), TestSuite::Compare::File); /* Verify font image, no need to test image contents, as the image is garbage anyway */ Trade::TgaImporter importer; CORRADE_VERIFY(importer.openFile(Utility::Directory::join(MAGNUMFONTCONVERTER_TEST_WRITE_DIR, "font.tga"))); std::optional<Trade::ImageData2D> image = importer.image2D(0); CORRADE_VERIFY(image); CORRADE_COMPARE(image->size(), Vector2i(256)); CORRADE_COMPARE(image->format(), ImageFormat::Red); CORRADE_COMPARE(image->type(), ImageType::UnsignedByte); }
void Test::nameList() { #if !defined(CORRADE_TARGET_NACL_NEWLIB) && !defined(CORRADE_TARGET_EMSCRIPTEN) { PluginManager::Manager<AbstractAnimal> manager(PLUGINS_DIR); CORRADE_COMPARE_AS(manager.pluginList(), (std::vector<std::string>{ "Canary", "Chihuahua", "Dog", "Snail"}), TestSuite::Compare::Container); } #endif /* Check if the list of dynamic plugins is cleared after destructing */ PluginManager::Manager<AbstractAnimal> manager(Directory::join(PLUGINS_DIR, "nonexistent")); CORRADE_COMPARE_AS(manager.pluginList(), std::vector<std::string>{ "Canary"}, TestSuite::Compare::Container); }
void BufferImageGLTest::setData() { const char data[4] = { 'a', 'b', 'c', 'd' }; BufferImage2D a{PixelStorage{}.setAlignment(1), PixelFormat::Red, PixelType::UnsignedByte, {4, 1}, data, BufferUsage::StaticDraw}; const UnsignedShort data2[2*4] = { 1, 2, 3, 4, 5, 6, 7, 8 }; a.setData(PixelFormat::RGBA, PixelType::UnsignedShort, {1, 2}, data2, BufferUsage::StaticDraw); #ifndef MAGNUM_TARGET_GLES const auto imageData = a.buffer().data<UnsignedShort>(); #endif MAGNUM_VERIFY_NO_ERROR(); CORRADE_COMPARE(a.storage().alignment(), 4); CORRADE_COMPARE(a.format(), PixelFormat::RGBA); CORRADE_COMPARE(a.type(), PixelType::UnsignedShort); CORRADE_COMPARE(a.size(), Vector2i(1, 2)); /** @todo How to verify the contents in ES? */ #ifndef MAGNUM_TARGET_GLES CORRADE_COMPARE_AS(imageData, Containers::ArrayView<const UnsignedShort>{data2}, TestSuite::Compare::Container); #endif }
namespace Magnum { namespace Trade { namespace Test { class AbstractImageConverterTest: public TestSuite::Tester { public: explicit AbstractImageConverterTest(); void exportToFile(); }; AbstractImageConverterTest::AbstractImageConverterTest() { addTests({&AbstractImageConverterTest::exportToFile}); } void AbstractImageConverterTest::exportToFile() { class DataExporter: public Trade::AbstractImageConverter { private: Features doFeatures() const override { return Feature::ConvertData; } Containers::Array<char> doExportToData(const ImageView2D& image) override { return Containers::Array<char>::from(char(image.size().x()), char(image.size().y())); }; }; /* Remove previous file */ Utility::Directory::rm(Utility::Directory::join(TRADE_TEST_OUTPUT_DIR, "image.out")); /* doExportToFile() should call doExportToData() */ DataExporter exporter; ImageView2D image(PixelFormat::RGBA, PixelType::UnsignedByte, {0xfe, 0xed}, {nullptr, 0xfe*0xed*4}); CORRADE_VERIFY(exporter.exportToFile(image, Utility::Directory::join(TRADE_TEST_OUTPUT_DIR, "image.out"))); CORRADE_COMPARE_AS(Utility::Directory::join(TRADE_TEST_OUTPUT_DIR, "image.out"), "\xFE\xED", TestSuite::Compare::FileToString); } }}}
void CubeMapTextureGLTest::subImageBuffer() { constexpr UnsignedByte zero[4*4*4] = {}; constexpr UnsignedByte subData[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f }; CubeMapTexture texture; texture.setImage(CubeMapTexture::Coordinate::PositiveX, 0, TextureFormat::RGBA8, ImageReference2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(4), zero)); texture.setSubImage(CubeMapTexture::Coordinate::PositiveX, 0, Vector2i(1), BufferImage2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(2), subData, BufferUsage::StaticDraw)); MAGNUM_VERIFY_NO_ERROR(); /** @todo How to test this on ES? */ #ifndef MAGNUM_TARGET_GLES BufferImage2D image(ColorFormat::RGBA, ColorType::UnsignedByte); texture.image(CubeMapTexture::Coordinate::PositiveX, 0, image, BufferUsage::StaticRead); MAGNUM_VERIFY_NO_ERROR(); CORRADE_COMPARE(image.size(), Vector2i(4)); const auto imageData = image.buffer().data<UnsignedByte>(); CORRADE_COMPARE_AS(std::vector<UnsignedByte>(imageData.begin(), imageData.end()), (std::vector<UnsignedByte>{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }), TestSuite::Compare::Container); #endif }
void JpegImporterTest::rgb() { JpegImporter importer; CORRADE_VERIFY(importer.openFile(Utility::Directory::join(JPEGIMPORTER_TEST_DIR, "rgb.jpg"))); std::optional<Trade::ImageData2D> image = importer.image2D(0); CORRADE_VERIFY(image); CORRADE_COMPARE(image->size(), Vector2i(3, 2)); CORRADE_COMPARE(image->format(), PixelFormat::RGB); CORRADE_COMPARE(image->type(), PixelType::UnsignedByte); /* The image has four-byte aligned rows, clear the padding to deterministic values */ CORRADE_COMPARE(image->data().size(), 24); image->data()[9] = image->data()[10] = image->data()[11] = image->data()[21] = image->data()[22] = image->data()[23] = 0; /* Data should be similar to the PNG */ CORRADE_COMPARE_AS(image->data(), Containers::Array<char>::from( '\xca', '\xfe', '\x76', '\xdf', '\xad', '\xb6', '\xca', '\xfe', '\x76', 0, 0, 0, '\xe0', '\xad', '\xb6', '\xc9', '\xff', '\x76', '\xdf', '\xad', '\xb6', 0, 0, 0), TestSuite::Compare::Container<Containers::ArrayView<const char>>); }
void ConfigurationTest::whitespaces() { Configuration conf(Directory::join(CONFIGURATION_TEST_DIR, "whitespaces.conf")); conf.setFilename(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "whitespaces.conf")); conf.save(); CORRADE_COMPARE_AS(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "whitespaces.conf"), Directory::join(CONFIGURATION_TEST_DIR, "whitespaces-saved.conf"), TestSuite::Compare::File); }
void WavImporterTest::mono16() { WavImporter importer; CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono16.wav"))); CORRADE_COMPARE(importer.format(), Buffer::Format::Mono16); CORRADE_COMPARE(importer.frequency(), 44000); CORRADE_COMPARE_AS(importer.data(), Containers::Array<char>::from('\x1d', '\x10', '\x71', '\xc5'), TestSuite::Compare::Container); }
void WavImporterTest::stereo8() { WavImporter importer; CORRADE_VERIFY(importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo8.wav"))); CORRADE_COMPARE(importer.format(), Buffer::Format::Stereo8); CORRADE_COMPARE(importer.frequency(), 96000); CORRADE_COMPARE_AS(importer.data(), Containers::Array<char>::from('\xde', '\xfe', '\xca', '\x7e'), TestSuite::Compare::Container); }
void ConfigurationTest::truncate() { Configuration conf(Directory::join(CONFIGURATION_TEST_DIR, "parse.conf"), Configuration::Flag::ReadOnly|Configuration::Flag::Truncate); /* File is truncated on saving */ CORRADE_VERIFY(conf.isValid()); CORRADE_VERIFY(conf.isEmpty()); CORRADE_VERIFY(conf.save(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "truncate.conf"))); CORRADE_COMPARE_AS(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "truncate.conf"), "", TestSuite::Compare::FileToString); }
void ConfigurationTest::stripComments() { Configuration conf(Directory::join(CONFIGURATION_TEST_DIR, "comments.conf"), Configuration::Flag::SkipComments); conf.setFilename(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "comments.conf")); /* Verify that comments were removed */ CORRADE_VERIFY(conf.save()); CORRADE_COMPARE_AS(Directory::join(CONFIGURATION_WRITE_TEST_DIR, "comments.conf"), Directory::join(CONFIGURATION_TEST_DIR, "comments-saved.conf"), TestSuite::Compare::File); }
void CapsuleTest::wireframe2D() { Trade::MeshData2D capsule = Capsule2D::wireframe(2, 4, 0.5f); CORRADE_COMPARE_AS(capsule.positions(0), (std::vector<Vector2>{ {0.0f, -1.5f}, {-0.707107f, -1.20711f}, {0.707107f, -1.20711f}, {-1.0f, -0.5f}, {1.0f, -0.5f}, {-1.0f, -0.25f}, {1.0f, -0.25f}, {-1.0f, 0.0f}, {1.0f, 0.0f}, {-1.0f, 0.25f}, {1.0f, 0.25f}, {-1.0f, 0.5f}, {1.0f, 0.5f}, {-0.707107f, 1.20711f}, {0.707107f, 1.20711f}, {0.0f, 1.5f} }), TestSuite::Compare::Container); CORRADE_COMPARE_AS(capsule.indices(), (std::vector<UnsignedInt>{ 0, 1, 0, 2, 1, 3, 2, 4, 3, 5, 4, 6, 5, 7, 6, 8, 7, 9, 8, 10, 9, 11, 10, 12, 11, 13, 12, 14, 13, 15, 14, 15 }), TestSuite::Compare::Container); }
void DualComplexTest::rotation() { DualComplex a = DualComplex::rotation(Deg(120.0f)); CORRADE_COMPARE(a.length(), 1.0f); CORRADE_COMPARE(a, DualComplex({-0.5f, 0.8660254f}, {0.0f, 0.0f})); CORRADE_COMPARE_AS(a.rotation().angle(), Deg(120.0f), Rad); /* Constexpr access to rotation */ constexpr DualComplex b({-1.0f, 2.0f}, {}); constexpr Complex c = b.rotation(); CORRADE_COMPARE(c, Complex(-1.0f, 2.0f)); }
void UVSphereTest::withTextureCoords() { Trade::MeshData3D sphere = UVSphere::solid(3, 3, UVSphere::TextureCoords::Generate); CORRADE_COMPARE_AS(*sphere.positions(0), (std::vector<Vector3>{ {0.0f, -1.0f, 0.0f}, {0.0f, -0.5f, 0.866025f}, {0.75f, -0.5f, -0.433013f}, {-0.75f, -0.5f, -0.433013f}, {0.0f, -0.5f, 0.866025f}, {0.0f, 0.5f, 0.866025f}, {0.75f, 0.5f, -0.433013f}, {-0.75f, 0.5f, -0.433013f}, {0.0f, 0.5f, 0.866025f}, {0.0f, 1.0f, 0.0f} }), TestSuite::Compare::Container); CORRADE_COMPARE_AS(*sphere.textureCoords2D(0), (std::vector<Vector2>{ {0.5f, 0.0f}, {0.0f, 0.333333f}, {0.333333f, 0.333333f}, {0.666667f, 0.333333f}, {1.0f, 0.333333f}, {0.0f, 0.666667f}, {0.333333f, 0.666667f}, {0.666667f, 0.666667f}, {1.0f, 0.666667f}, {0.5f, 1.0f} }), TestSuite::Compare::Container); CORRADE_COMPARE_AS(*sphere.indices(), (std::vector<UnsignedInt>{ 0, 2, 1, 0, 3, 2, 0, 4, 3, 1, 2, 6, 1, 6, 5, 2, 3, 7, 2, 7, 6, 3, 4, 8, 3, 8, 7, 5, 6, 9, 6, 7, 9, 7, 8, 9 }), TestSuite::Compare::Container); }
void UVSphereTest::wireframe() { Trade::MeshData3D sphere = UVSphere::wireframe(4, 8); CORRADE_COMPARE_AS(sphere.positions(0), (std::vector<Vector3>{ {0.0f, -1.0f, 0.0f}, {0.0f, -0.707107f, 0.707107f}, {0.707107f, -0.707107f, 0.0f}, {0.0f, -0.707107f, -0.707107f}, {-0.707107f, -0.707107f, 0.0f}, {0.0f, 0.0f, 1.0f}, {1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}, {-1.0f, 0.0f, 0.0f}, {0.707107f, 0.0f, 0.707107f}, {0.707107f, 0.0f, -0.707107f}, {-0.707107f, 0.0f, -0.707107f}, {-0.707107f, 0.0f, 0.707107f}, {0.0f, 0.707107f, 0.707107f}, {0.707107f, 0.707107f, 0.0f}, {0.0f, 0.707107f, -0.707107f}, {-0.707107f, 0.707107f, 0.0f}, {0.0f, 1.0f, 0.0f} }), TestSuite::Compare::Container); CORRADE_COMPARE(sphere.normalArrayCount(), 0); CORRADE_COMPARE_AS(sphere.indices(), (std::vector<UnsignedInt>{ 0, 1, 0, 2, 0, 3, 0, 4, 1, 5, 2, 6, 3, 7, 4, 8, 5, 9, 6, 10, 7, 11, 8, 12, 9, 6, 10, 7, 11, 8, 12, 5, 5, 13, 6, 14, 7, 15, 8, 16, 13, 17, 14, 17, 15, 17, 16, 17 }), TestSuite::Compare::Container); }
void StringTest::splitMultipleCharacters() { const std::string delimiters = ".:;"; /* Empty */ CORRADE_COMPARE_AS(String::splitWithoutEmptyParts({}, delimiters), std::vector<std::string>{}, TestSuite::Compare::Container); /* Only delimiters */ CORRADE_COMPARE_AS(String::splitWithoutEmptyParts(".::;", delimiters), std::vector<std::string>{}, TestSuite::Compare::Container); /* No delimiters */ CORRADE_COMPARE_AS(String::splitWithoutEmptyParts("abcdef", delimiters), std::vector<std::string>{"abcdef"}, TestSuite::Compare::Container); /* Common case */ CORRADE_COMPARE_AS(String::splitWithoutEmptyParts("ab:c;def", delimiters), (std::vector<std::string>{"ab", "c", "def"}), TestSuite::Compare::Container); /* Empty parts */ CORRADE_COMPARE_AS(String::splitWithoutEmptyParts("ab:c;;def.", delimiters), (std::vector<std::string>{"ab", "c", "def"}), TestSuite::Compare::Container); }