Browse Source

Trade: test construction and assignments of the container classes.

pull/165/merge
Vladimír Vondruš 10 years ago
parent
commit
db18016ef0
  1. 12
      src/Magnum/Trade/CameraData.h
  2. 47
      src/Magnum/Trade/PhongMaterialData.cpp
  3. 32
      src/Magnum/Trade/PhongMaterialData.h
  4. 4
      src/Magnum/Trade/Test/CMakeLists.txt
  5. 121
      src/Magnum/Trade/Test/CameraDataTest.cpp
  6. 192
      src/Magnum/Trade/Test/MaterialDataTest.cpp
  7. 143
      src/Magnum/Trade/Test/MeshData2DTest.cpp
  8. 169
      src/Magnum/Trade/Test/MeshData3DTest.cpp
  9. 82
      src/Magnum/Trade/Test/ObjectData2DTest.cpp
  10. 94
      src/Magnum/Trade/Test/ObjectData3DTest.cpp
  11. 82
      src/Magnum/Trade/Test/SceneDataTest.cpp
  12. 77
      src/Magnum/Trade/Test/TextureDataTest.cpp

12
src/Magnum/Trade/CameraData.h

@ -54,6 +54,18 @@ class CameraData {
*/
explicit CameraData(Rad fov, Float near, Float far, const void* importerState = nullptr) noexcept;
/** @brief Copying is not allowed */
CameraData(const CameraData&) = delete;
/** @brief Move constructor */
CameraData(CameraData&&) noexcept = default;
/** @brief Copying is not allowed */
CameraData& operator=(const CameraData&) = delete;
/** @brief Move assignment */
CameraData& operator=(CameraData&&) noexcept = default;
/** @brief Field-of-view angle */
Rad fov() const { return _fov; }

47
src/Magnum/Trade/PhongMaterialData.cpp

@ -27,7 +27,48 @@
namespace Magnum { namespace Trade {
Vector3& PhongMaterialData::ambientColor() {
PhongMaterialData::PhongMaterialData(PhongMaterialData&& other) noexcept: AbstractMaterialData{std::move(other)}, _flags{std::move(other._flags)}, _shininess{std::move(other._shininess)} {
if(_flags & Flag::AmbientTexture)
_ambient.texture = other._ambient.texture;
else
_ambient.color = other._ambient.color;
if(_flags & Flag::DiffuseTexture)
_diffuse.texture = other._diffuse.texture;
else
_diffuse.color = other._diffuse.color;
if(_flags & Flag::SpecularTexture)
_specular.texture = other._specular.texture;
else
_specular.color = other._specular.color;
}
PhongMaterialData& PhongMaterialData::operator=(PhongMaterialData&& other) noexcept {
AbstractMaterialData::operator=(std::move(other));
_flags = other._flags;
_shininess = other._shininess;
if(_flags & Flag::AmbientTexture)
_ambient.texture = other._ambient.texture;
else
_ambient.color = other._ambient.color;
if(_flags & Flag::DiffuseTexture)
_diffuse.texture = other._diffuse.texture;
else
_diffuse.color = other._diffuse.color;
if(_flags & Flag::SpecularTexture)
_specular.texture = other._specular.texture;
else
_specular.color = other._specular.color;
return *this;
}
Color3& PhongMaterialData::ambientColor() {
CORRADE_ASSERT(!(_flags & Flag::AmbientTexture), "Trade::PhongMaterialData::ambientColor(): the material has ambient texture", _ambient.color);
return _ambient.color;
}
@ -37,7 +78,7 @@ UnsignedInt& PhongMaterialData::ambientTexture() {
return _ambient.texture;
}
Vector3& PhongMaterialData::diffuseColor() {
Color3& PhongMaterialData::diffuseColor() {
CORRADE_ASSERT(!(_flags & Flag::DiffuseTexture), "Trade::PhongMaterialData::diffuseColor(): the material has diffuse texture", _diffuse.color);
return _diffuse.color;
}
@ -47,7 +88,7 @@ UnsignedInt& PhongMaterialData::diffuseTexture() {
return _diffuse.texture;
}
Vector3& PhongMaterialData::specularColor() {
Color3& PhongMaterialData::specularColor() {
CORRADE_ASSERT(!(_flags & Flag::SpecularTexture), "Trade::PhongMaterialData::specularColor(): the material has specular texture", _specular.color);
return _specular.color;
}

32
src/Magnum/Trade/PhongMaterialData.h

@ -30,7 +30,7 @@
*/
#include "Magnum/Magnum.h"
#include "Magnum/Math/Vector3.h"
#include "Magnum/Math/Color.h"
#include "Magnum/Trade/AbstractMaterialData.h"
namespace Magnum { namespace Trade {
@ -75,6 +75,18 @@ class MAGNUM_EXPORT PhongMaterialData: public AbstractMaterialData {
*/
explicit PhongMaterialData(Flags flags, Float shininess, const void* importerState = nullptr) noexcept: AbstractMaterialData{MaterialType::Phong, importerState}, _flags{flags}, _shininess{shininess} {}
/** @brief Copying is not allowed */
PhongMaterialData(const PhongMaterialData&) = delete;
/** @brief Move constructor */
PhongMaterialData(PhongMaterialData&& other) noexcept;
/** @brief Copying is not allowed */
PhongMaterialData& operator=(const PhongMaterialData&) = delete;
/** @brief Move assignment */
PhongMaterialData& operator=(PhongMaterialData&& other) noexcept;
/** @brief Material flags */
Flags flags() const { return _flags; }
@ -84,8 +96,8 @@ class MAGNUM_EXPORT PhongMaterialData: public AbstractMaterialData {
* Available only if the material doesn't have @ref Flag::AmbientTexture.
* @see @ref flags()
*/
Vector3& ambientColor();
Vector3 ambientColor() const; /**< @overload */
Color3& ambientColor();
Color3 ambientColor() const; /**< @overload */
/**
* @brief Ambient texture ID
@ -102,8 +114,8 @@ class MAGNUM_EXPORT PhongMaterialData: public AbstractMaterialData {
* Available only if the material doesn't have @ref Flag::DiffuseTexture.
* @see @ref flags()
*/
Vector3& diffuseColor();
Vector3 diffuseColor() const; /**< @overload */
Color3& diffuseColor();
Color3 diffuseColor() const; /**< @overload */
/**
* @brief Diffuse texture ID
@ -120,8 +132,8 @@ class MAGNUM_EXPORT PhongMaterialData: public AbstractMaterialData {
* Available only if the material doesn't have @ref Flag::SpecularTexture.
* @see @ref flags()
*/
Vector3& specularColor();
Vector3 specularColor() const; /**< @overload */
Color3& specularColor();
Color3 specularColor() const; /**< @overload */
/**
* @brief Specular texture ID
@ -154,7 +166,7 @@ CORRADE_ENUMSET_OPERATORS(PhongMaterialData::Flags)
/* Ugly as hell. */
inline Vector3 PhongMaterialData::ambientColor() const {
inline Color3 PhongMaterialData::ambientColor() const {
return const_cast<PhongMaterialData*>(this)->ambientColor();
}
@ -162,7 +174,7 @@ inline UnsignedInt PhongMaterialData::ambientTexture() const {
return const_cast<PhongMaterialData*>(this)->ambientTexture();
}
inline Vector3 PhongMaterialData::diffuseColor() const {
inline Color3 PhongMaterialData::diffuseColor() const {
return const_cast<PhongMaterialData*>(this)->diffuseColor();
}
@ -170,7 +182,7 @@ inline UnsignedInt PhongMaterialData::diffuseTexture() const {
return const_cast<PhongMaterialData*>(this)->diffuseTexture();
}
inline Vector3 PhongMaterialData::specularColor() const {
inline Color3 PhongMaterialData::specularColor() const {
return const_cast<PhongMaterialData*>(this)->specularColor();
}

4
src/Magnum/Trade/Test/CMakeLists.txt

@ -38,10 +38,14 @@ corrade_add_test(TradeAbstractImageConverterTest AbstractImageConverterTest.cpp
target_include_directories(TradeAbstractImageConverterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
corrade_add_test(TradeAbstractImporterTest AbstractImporterTest.cpp LIBRARIES Magnum)
target_include_directories(TradeAbstractImporterTest PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
corrade_add_test(TradeCameraDataTest CameraDataTest.cpp LIBRARIES Magnum)
corrade_add_test(TradeImageDataTest ImageDataTest.cpp LIBRARIES Magnum)
corrade_add_test(TradeMaterialDataTest MaterialDataTest.cpp LIBRARIES Magnum)
corrade_add_test(TradeMeshData2DTest MeshData2DTest.cpp LIBRARIES Magnum)
corrade_add_test(TradeMeshData3DTest MeshData3DTest.cpp LIBRARIES Magnum)
corrade_add_test(TradeObjectData2DTest ObjectData2DTest.cpp LIBRARIES Magnum)
corrade_add_test(TradeObjectData3DTest ObjectData3DTest.cpp LIBRARIES Magnum)
corrade_add_test(TradeSceneDataTest SceneDataTest.cpp LIBRARIES Magnum)
corrade_add_test(TradeTextureDataTest TextureDataTest.cpp LIBRARIES Magnum)
if(CORRADE_TARGET_EMSCRIPTEN)

121
src/Magnum/Trade/Test/CameraDataTest.cpp

@ -0,0 +1,121 @@
/*
This file is part of Magnum.
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016
Vladimír Vondruš <mosra@centrum.cz>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <Corrade/TestSuite/Tester.h>
#include "Magnum/Trade/CameraData.h"
namespace Magnum { namespace Trade { namespace Test {
struct CameraDataTest: TestSuite::Tester {
explicit CameraDataTest();
void construct();
void constructDefaults();
void constructCopy();
void constructMove();
};
namespace {
using namespace Math::Literals;
enum: std::size_t { ConstructDefaultsDataCount = 3 };
struct {
const char* name;
Rad fov, expectedFov;
Float near, expectedNear;
Float far, expectedFar;
} ConstructDefaultsData[ConstructDefaultsDataCount]{
{"fov", Rad{Constants::nan()}, 35.0_degf, 0.5f, 0.5f, 120.0f, 120.0f},
{"near", 25.0_degf, 25.0_degf, Constants::nan(), 0.01f, 120.0f, 120.0f},
{"far", 25.0_degf, 25.0_degf, 0.5f, 0.5f, Constants::nan(), 100.0f}
};
}
CameraDataTest::CameraDataTest() {
addTests({&CameraDataTest::construct});
addInstancedTests({&CameraDataTest::constructDefaults}, ConstructDefaultsDataCount);
addTests({&CameraDataTest::constructCopy,
&CameraDataTest::constructMove});
}
void CameraDataTest::construct() {
const int a{};
CameraData data{25.0_degf, 0.001f, 1000.0f, &a};
CORRADE_COMPARE(data.fov(), 25.0_degf);
CORRADE_COMPARE(data.near(), 0.001f);
CORRADE_COMPARE(data.far(), 1000.0f);
CORRADE_COMPARE(data.importerState(), &a);
}
void CameraDataTest::constructDefaults() {
setTestCaseDescription(ConstructDefaultsData[testCaseInstanceId()].name);
const int a{};
CameraData data{
ConstructDefaultsData[testCaseInstanceId()].fov,
ConstructDefaultsData[testCaseInstanceId()].near,
ConstructDefaultsData[testCaseInstanceId()].far,
&a};
CORRADE_COMPARE(data.fov(), ConstructDefaultsData[testCaseInstanceId()].expectedFov);
CORRADE_COMPARE(data.near(), ConstructDefaultsData[testCaseInstanceId()].expectedNear);
CORRADE_COMPARE(data.far(), ConstructDefaultsData[testCaseInstanceId()].expectedFar);
CORRADE_COMPARE(data.importerState(), &a);
}
void CameraDataTest::constructCopy() {
CORRADE_VERIFY(!(std::is_constructible<CameraData, const CameraData&>{}));
CORRADE_VERIFY(!(std::is_assignable<CameraData, const CameraData&>{}));
}
void CameraDataTest::constructMove() {
const int a{};
CameraData data{25.0_degf, 0.001f, 1000.0f, &a};
CameraData b{std::move(data)};
CORRADE_COMPARE(b.fov(), 25.0_degf);
CORRADE_COMPARE(b.near(), 0.001f);
CORRADE_COMPARE(b.far(), 1000.0f);
CORRADE_COMPARE(b.importerState(), &a);
const int c{};
CameraData d{75.0_degf, 0.5f, 10.0f, &c};
d = std::move(b);
CORRADE_COMPARE(d.fov(), 25.0_degf);
CORRADE_COMPARE(d.near(), 0.001f);
CORRADE_COMPARE(d.far(), 1000.0f);
CORRADE_COMPARE(d.importerState(), &a);
}
}}}
CORRADE_TEST_MAIN(Magnum::Trade::Test::CameraDataTest)

192
src/Magnum/Trade/Test/MaterialDataTest.cpp

@ -34,11 +34,201 @@ class MaterialDataTest: public TestSuite::Tester {
public:
explicit MaterialDataTest();
void constructPhong();
void constructPhongAmbientTexture();
void constructPhongDiffuseTexture();
void constructPhongSpecularTexture();
void constructCopy();
void constructMovePhongNoAmbientTexture();
void constructMovePhongNoDiffuseTexture();
void constructMovePhongNoSpecularTexture();
void debugType();
};
MaterialDataTest::MaterialDataTest() {
addTests({&MaterialDataTest::debugType});
addTests({&MaterialDataTest::constructPhong,
&MaterialDataTest::constructPhongAmbientTexture,
&MaterialDataTest::constructPhongDiffuseTexture,
&MaterialDataTest::constructPhongSpecularTexture,
&MaterialDataTest::constructCopy,
&MaterialDataTest::constructMovePhongNoAmbientTexture,
&MaterialDataTest::constructMovePhongNoDiffuseTexture,
&MaterialDataTest::constructMovePhongNoSpecularTexture,
&MaterialDataTest::debugType});
}
void MaterialDataTest::constructPhong() {
using namespace Math::Literals;
const int a{};
PhongMaterialData data{{}, 80.0f, &a};
data.ambientColor() = 0xccffbb_rgbf;
data.diffuseColor() = 0xeebbff_rgbf;
data.specularColor() = 0xacabad_rgbf;
const PhongMaterialData& cdata = data;
CORRADE_VERIFY(cdata.flags() == PhongMaterialData::Flags{});
CORRADE_COMPARE(cdata.ambientColor(), 0xccffbb_rgbf);
CORRADE_COMPARE(cdata.diffuseColor(), 0xeebbff_rgbf);
CORRADE_COMPARE(cdata.specularColor(), 0xacabad_rgbf);
CORRADE_COMPARE(cdata.shininess(), 80.0f);
}
void MaterialDataTest::constructPhongAmbientTexture() {
using namespace Math::Literals;
const int a{};
PhongMaterialData data{PhongMaterialData::Flag::AmbientTexture, 80.0f, &a};
data.ambientTexture() = 42;
data.diffuseColor() = 0xeebbff_rgbf;
data.specularColor() = 0xacabad_rgbf;
const PhongMaterialData& cdata = data;
CORRADE_VERIFY(cdata.flags() == PhongMaterialData::Flag::AmbientTexture);
CORRADE_COMPARE(cdata.ambientTexture(), 42);
CORRADE_COMPARE(cdata.diffuseColor(), 0xeebbff_rgbf);
CORRADE_COMPARE(cdata.specularColor(), 0xacabad_rgbf);
CORRADE_COMPARE(cdata.shininess(), 80.0f);
}
void MaterialDataTest::constructPhongDiffuseTexture() {
using namespace Math::Literals;
const int a{};
PhongMaterialData data{PhongMaterialData::Flag::DiffuseTexture, 80.0f, &a};
data.ambientColor() = 0xccffbb_rgbf;
data.diffuseTexture() = 42;
data.specularColor() = 0xacabad_rgbf;
const PhongMaterialData& cdata = data;
CORRADE_VERIFY(cdata.flags() == PhongMaterialData::Flag::DiffuseTexture);
CORRADE_COMPARE(cdata.ambientColor(), 0xccffbb_rgbf);
CORRADE_COMPARE(cdata.diffuseTexture(), 42);
CORRADE_COMPARE(cdata.specularColor(), 0xacabad_rgbf);
CORRADE_COMPARE(cdata.shininess(), 80.0f);
}
void MaterialDataTest::constructPhongSpecularTexture() {
using namespace Math::Literals;
const int a{};
PhongMaterialData data{PhongMaterialData::Flag::SpecularTexture, 30.0f, &a};
data.ambientColor() = 0xccffbb_rgbf;
data.diffuseColor() = 0xeebbff_rgbf;
data.specularTexture() = 42;
const PhongMaterialData& cdata = data;
CORRADE_VERIFY(cdata.flags() == PhongMaterialData::Flag::SpecularTexture);
CORRADE_COMPARE(cdata.ambientColor(), 0xccffbb_rgbf);
CORRADE_COMPARE(cdata.diffuseColor(), 0xeebbff_rgbf);
CORRADE_COMPARE(cdata.specularTexture(), 42);
CORRADE_COMPARE(cdata.shininess(), 30.0f);
}
void MaterialDataTest::constructCopy() {
CORRADE_VERIFY(!(std::is_constructible<AbstractMaterialData, const AbstractMaterialData&>{}));
CORRADE_VERIFY(!(std::is_constructible<PhongMaterialData, const PhongMaterialData&>{}));
CORRADE_VERIFY(!(std::is_assignable<AbstractMaterialData, const AbstractMaterialData&>{}));
CORRADE_VERIFY(!(std::is_assignable<PhongMaterialData, const PhongMaterialData&>{}));
}
void MaterialDataTest::constructMovePhongNoAmbientTexture() {
using namespace Math::Literals;
const int a{};
PhongMaterialData data{PhongMaterialData::Flag::DiffuseTexture|PhongMaterialData::Flag::SpecularTexture, 80.0f, &a};
data.ambientColor() = 0xccffbb_rgbf;
data.diffuseTexture() = 42;
data.specularTexture() = 13;
PhongMaterialData b{std::move(data)};
CORRADE_VERIFY(b.flags() == (PhongMaterialData::Flag::DiffuseTexture|PhongMaterialData::Flag::SpecularTexture));
CORRADE_COMPARE(b.ambientColor(), 0xccffbb_rgbf);
CORRADE_COMPARE(b.diffuseTexture(), 42);
CORRADE_COMPARE(b.specularTexture(), 13);
CORRADE_COMPARE(b.shininess(), 80.0f);
const int c{};
PhongMaterialData d{PhongMaterialData::Flag::AmbientTexture, 100.0f, &c};
d.ambientTexture() = 42;
d.diffuseColor() = 0xeebbff_rgbf;
d.specularColor() = 0xacabad_rgbf;
d = std::move(b);
CORRADE_VERIFY(d.flags() == (PhongMaterialData::Flag::DiffuseTexture|PhongMaterialData::Flag::SpecularTexture));
CORRADE_COMPARE(d.ambientColor(), 0xccffbb_rgbf);
CORRADE_COMPARE(d.diffuseTexture(), 42);
CORRADE_COMPARE(d.specularTexture(), 13);
CORRADE_COMPARE(d.shininess(), 80.0f);
}
void MaterialDataTest::constructMovePhongNoDiffuseTexture() {
using namespace Math::Literals;
const int a{};
PhongMaterialData data{PhongMaterialData::Flag::AmbientTexture|PhongMaterialData::Flag::SpecularTexture, 80.0f, &a};
data.ambientTexture() = 42;
data.diffuseColor() = 0xeebbff_rgbf;
data.specularTexture() = 13;
PhongMaterialData b{std::move(data)};
CORRADE_VERIFY(b.flags() == (PhongMaterialData::Flag::AmbientTexture|PhongMaterialData::Flag::SpecularTexture));
CORRADE_COMPARE(b.ambientTexture(), 42);
CORRADE_COMPARE(b.diffuseColor(), 0xeebbff_rgbf);
CORRADE_COMPARE(b.specularTexture(), 13);
CORRADE_COMPARE(b.shininess(), 80.0f);
const int c{};
PhongMaterialData d{PhongMaterialData::Flag::DiffuseTexture, 100.0f, &c};
d.ambientColor() = 0xccffbb_rgbf;
d.diffuseTexture() = 42;
d.specularColor() = 0xacabad_rgbf;
d = std::move(b);
CORRADE_VERIFY(d.flags() == (PhongMaterialData::Flag::AmbientTexture|PhongMaterialData::Flag::SpecularTexture));
CORRADE_COMPARE(d.ambientTexture(), 42);
CORRADE_COMPARE(d.diffuseColor(), 0xeebbff_rgbf);
CORRADE_COMPARE(d.specularTexture(), 13);
CORRADE_COMPARE(d.shininess(), 80.0f);
}
void MaterialDataTest::constructMovePhongNoSpecularTexture() {
using namespace Math::Literals;
const int a{};
PhongMaterialData data{PhongMaterialData::Flag::AmbientTexture|PhongMaterialData::Flag::DiffuseTexture, 80.0f, &a};
data.ambientTexture() = 13;
data.diffuseTexture() = 42;
data.specularColor() = 0xacabad_rgbf;
PhongMaterialData b{std::move(data)};
CORRADE_VERIFY(b.flags() == (PhongMaterialData::Flag::AmbientTexture|PhongMaterialData::Flag::DiffuseTexture));
CORRADE_COMPARE(b.ambientTexture(), 13);
CORRADE_COMPARE(b.diffuseTexture(), 42);
CORRADE_COMPARE(b.specularColor(), 0xacabad_rgbf);
CORRADE_COMPARE(b.shininess(), 80.0f);
const int c{};
PhongMaterialData d{PhongMaterialData::Flag::SpecularTexture, 30.0f, &c};
d.ambientColor() = 0xccffbb_rgbf;
d.diffuseColor() = 0xeebbff_rgbf;
d.specularTexture() = 42;
d = std::move(b);
CORRADE_VERIFY(d.flags() == (PhongMaterialData::Flag::AmbientTexture|PhongMaterialData::Flag::DiffuseTexture));
CORRADE_COMPARE(d.ambientTexture(), 13);
CORRADE_COMPARE(d.diffuseTexture(), 42);
CORRADE_COMPARE(d.specularColor(), 0xacabad_rgbf);
CORRADE_COMPARE(d.shininess(), 80.0f);
}
void MaterialDataTest::debugType() {

143
src/Magnum/Trade/Test/MeshData2DTest.cpp

@ -0,0 +1,143 @@
/*
This file is part of Magnum.
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016
Vladimír Vondruš <mosra@centrum.cz>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <Corrade/TestSuite/Tester.h>
#include "Magnum/Mesh.h"
#include "Magnum/Math/Vector2.h"
#include "Magnum/Trade/MeshData2D.h"
namespace Magnum { namespace Trade { namespace Test {
struct MeshData2DTest: TestSuite::Tester {
explicit MeshData2DTest();
void construct();
void constructNonIndexed();
void constructNoTexCoords();
void constructCopy();
void constructMove();
};
MeshData2DTest::MeshData2DTest() {
addTests({&MeshData2DTest::construct,
&MeshData2DTest::constructNonIndexed,
&MeshData2DTest::constructNoTexCoords,
&MeshData2DTest::constructCopy,
&MeshData2DTest::constructMove});
}
void MeshData2DTest::construct() {
const int a{};
const MeshData2D data{MeshPrimitive::Lines, {12, 1, 0},
{{{0.5f, 1.0f}, {-1.0f, 0.3f}},
{{1.4f, 0.2f}, {1.1f, 0.13f}}},
{{{0.0f, 0.0f}, {0.3f, 0.7f}},
{{0.1f, 0.2f}, {0.7f, 1.0f}},
{{0.0f, 0.0f}, {1.0f, 1.0f}}},
&a};
CORRADE_COMPARE(data.primitive(), MeshPrimitive::Lines);
CORRADE_VERIFY(data.isIndexed());
CORRADE_COMPARE(data.indices(), (std::vector<UnsignedInt>{12, 1, 0}));
CORRADE_COMPARE(data.positionArrayCount(), 2);
CORRADE_COMPARE(data.positions(0), (std::vector<Vector2>{{0.5f, 1.0f}, {-1.0f, 0.3f}}));
CORRADE_COMPARE(data.positions(1), (std::vector<Vector2>{{1.4f, 0.2f}, {1.1f, 0.13f}}));
CORRADE_VERIFY(data.hasTextureCoords2D());
CORRADE_COMPARE(data.textureCoords2DArrayCount(), 3);
CORRADE_COMPARE(data.textureCoords2D(0), (std::vector<Vector2>{{0.0f, 0.0f}, {0.3f, 0.7f}}));
CORRADE_COMPARE(data.textureCoords2D(1), (std::vector<Vector2>{{0.1f, 0.2f}, {0.7f, 1.0f}}));
CORRADE_COMPARE(data.textureCoords2D(2), (std::vector<Vector2>{{0.0f, 0.0f}, {1.0f, 1.0f}}));
CORRADE_COMPARE(data.importerState(), &a);
}
void MeshData2DTest::constructNonIndexed() {
const int a{};
const MeshData2D data{MeshPrimitive::Lines, {},
{{{0.5f, 1.0f}, {-1.0f, 0.3f}}},
{{{0.0f, 0.0f}, {0.3f, 0.7f}}},
&a};
CORRADE_VERIFY(!data.isIndexed());
}
void MeshData2DTest::constructNoTexCoords() {
const int a{};
const MeshData2D data{MeshPrimitive::Lines, {12, 1, 0},
{{{0.5f, 1.0f}, {-1.0f, 0.3f}},
{{1.4f, 0.2f}, {1.1f, 0.13f}}},
{},
&a};
CORRADE_VERIFY(!data.hasTextureCoords2D());
CORRADE_COMPARE(data.textureCoords2DArrayCount(), 0);
}
void MeshData2DTest::constructCopy() {
CORRADE_VERIFY(!(std::is_constructible<MeshData2D, const MeshData2D&>{}));
CORRADE_VERIFY(!(std::is_assignable<MeshData2D, const MeshData2D&>{}));
}
void MeshData2DTest::constructMove() {
const int a{};
MeshData2D data{MeshPrimitive::LineStrip, {12, 1, 0},
{{{0.5f, 1.0f}, {-1.0f, 0.3f}}},
{{{0.0f, 0.0f}, {0.3f, 0.7f}}},
&a};
MeshData2D b{std::move(data)};
CORRADE_COMPARE(b.primitive(), MeshPrimitive::LineStrip);
CORRADE_VERIFY(b.isIndexed());
CORRADE_COMPARE(b.indices(), (std::vector<UnsignedInt>{12, 1, 0}));
CORRADE_COMPARE(b.positionArrayCount(), 1);
CORRADE_COMPARE(b.positions(0), (std::vector<Vector2>{{0.5f, 1.0f}, {-1.0f, 0.3f}}));
CORRADE_COMPARE(b.textureCoords2DArrayCount(), 1);
CORRADE_COMPARE(b.textureCoords2D(0), (std::vector<Vector2>{{0.0f, 0.0f}, {0.3f, 0.7f}}));
CORRADE_COMPARE(b.importerState(), &a);
const int c{};
MeshData2D d{MeshPrimitive::TriangleFan, {},
{{}},
{},
&c};
d = std::move(b);
CORRADE_COMPARE(d.primitive(), MeshPrimitive::LineStrip);
CORRADE_VERIFY(d.isIndexed());
CORRADE_COMPARE(d.indices(), (std::vector<UnsignedInt>{12, 1, 0}));
CORRADE_COMPARE(d.positionArrayCount(), 1);
CORRADE_COMPARE(d.positions(0), (std::vector<Vector2>{{0.5f, 1.0f}, {-1.0f, 0.3f}}));
CORRADE_COMPARE(d.textureCoords2DArrayCount(), 1);
CORRADE_COMPARE(d.textureCoords2D(0), (std::vector<Vector2>{{0.0f, 0.0f}, {0.3f, 0.7f}}));
CORRADE_COMPARE(d.importerState(), &a);
}
}}}
CORRADE_TEST_MAIN(Magnum::Trade::Test::MeshData2DTest)

169
src/Magnum/Trade/Test/MeshData3DTest.cpp

@ -0,0 +1,169 @@
/*
This file is part of Magnum.
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016
Vladimír Vondruš <mosra@centrum.cz>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <Corrade/TestSuite/Tester.h>
#include "Magnum/Mesh.h"
#include "Magnum/Math/Vector3.h"
#include "Magnum/Trade/MeshData3D.h"
namespace Magnum { namespace Trade { namespace Test {
struct MeshData3DTest: TestSuite::Tester {
explicit MeshData3DTest();
void construct();
void constructNonIndexed();
void constructNoNormals();
void constructNoTexCoords();
void constructCopy();
void constructMove();
};
MeshData3DTest::MeshData3DTest() {
addTests({&MeshData3DTest::construct,
&MeshData3DTest::constructNonIndexed,
&MeshData3DTest::constructNoNormals,
&MeshData3DTest::constructNoTexCoords,
&MeshData3DTest::constructCopy,
&MeshData3DTest::constructMove});
}
void MeshData3DTest::construct() {
const int a{};
const MeshData3D data{MeshPrimitive::Lines, {12, 1, 0},
{{{0.5f, 1.0f, 0.1f}, {-1.0f, 0.3f, -1.0f}},
{{1.4f, 0.2f, 0.5f}, {1.1f, 0.13f, -0.3f}}},
{{{0.0f, 1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}}},
{{{0.0f, 0.0f}, {0.3f, 0.7f}},
{{0.1f, 0.2f}, {0.7f, 1.0f}},
{{0.0f, 0.0f}, {1.0f, 1.0f}}},
&a};
CORRADE_COMPARE(data.primitive(), MeshPrimitive::Lines);
CORRADE_VERIFY(data.isIndexed());
CORRADE_COMPARE(data.indices(), (std::vector<UnsignedInt>{12, 1, 0}));
CORRADE_COMPARE(data.positionArrayCount(), 2);
CORRADE_COMPARE(data.positions(0), (std::vector<Vector3>{{0.5f, 1.0f, 0.1f}, {-1.0f, 0.3f, -1.0f}}));
CORRADE_COMPARE(data.positions(1), (std::vector<Vector3>{{1.4f, 0.2f, 0.5f}, {1.1f, 0.13f, -0.3f}}));
CORRADE_VERIFY(data.hasNormals());
CORRADE_COMPARE(data.normalArrayCount(), 1);
CORRADE_COMPARE(data.normals(0), (std::vector<Vector3>{{0.0f, 1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}}));
CORRADE_VERIFY(data.hasTextureCoords2D());
CORRADE_COMPARE(data.textureCoords2DArrayCount(), 3);
CORRADE_COMPARE(data.textureCoords2D(0), (std::vector<Vector2>{{0.0f, 0.0f}, {0.3f, 0.7f}}));
CORRADE_COMPARE(data.textureCoords2D(1), (std::vector<Vector2>{{0.1f, 0.2f}, {0.7f, 1.0f}}));
CORRADE_COMPARE(data.textureCoords2D(2), (std::vector<Vector2>{{0.0f, 0.0f}, {1.0f, 1.0f}}));
CORRADE_COMPARE(data.importerState(), &a);
}
void MeshData3DTest::constructNonIndexed() {
const int a{};
const MeshData3D data{MeshPrimitive::Lines, {},
{{{0.5f, 1.0f, 0.1f}, {-1.0f, 0.3f, -1.0f}}},
{{{0.0f, 1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}}},
{{{0.0f, 0.0f}, {0.3f, 0.7f}}},
&a};
CORRADE_VERIFY(!data.isIndexed());
}
void MeshData3DTest::constructNoNormals() {
const int a{};
const MeshData3D data{MeshPrimitive::Lines, {12, 1, 0},
{{{0.5f, 1.0f, 0.1f}, {-1.0f, 0.3f, -1.0f}}},
{},
{{{0.0f, 0.0f}, {0.3f, 0.7f}}},
&a};
CORRADE_VERIFY(!data.hasNormals());
CORRADE_COMPARE(data.normalArrayCount(), 0);
}
void MeshData3DTest::constructNoTexCoords() {
const int a{};
const MeshData3D data{MeshPrimitive::Lines, {12, 1, 0},
{{{0.5f, 1.0f, 0.1f}, {-1.0f, 0.3f, -1.0f}}},
{{{0.0f, 1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}}},
{},
&a};
CORRADE_VERIFY(!data.hasTextureCoords2D());
CORRADE_COMPARE(data.textureCoords2DArrayCount(), 0);
}
void MeshData3DTest::constructCopy() {
CORRADE_VERIFY(!(std::is_constructible<MeshData3D, const MeshData3D&>{}));
CORRADE_VERIFY(!(std::is_assignable<MeshData3D, const MeshData3D&>{}));
}
void MeshData3DTest::constructMove() {
const int a{};
MeshData3D data{MeshPrimitive::LineStrip, {12, 1, 0},
{{{0.5f, 1.0f, 0.1f}, {-1.0f, 0.3f, -1.0f}}},
{{{0.0f, 1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}}},
{{{0.0f, 0.0f}, {0.3f, 0.7f}}},
&a};
MeshData3D b{std::move(data)};
CORRADE_COMPARE(b.primitive(), MeshPrimitive::LineStrip);
CORRADE_VERIFY(b.isIndexed());
CORRADE_COMPARE(b.indices(), (std::vector<UnsignedInt>{12, 1, 0}));
CORRADE_COMPARE(b.positionArrayCount(), 1);
CORRADE_COMPARE(b.positions(0), (std::vector<Vector3>{{0.5f, 1.0f, 0.1f}, {-1.0f, 0.3f, -1.0f}}));
CORRADE_COMPARE(b.normalArrayCount(), 1);
CORRADE_COMPARE(b.normals(0), (std::vector<Vector3>{{0.0f, 1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}}));
CORRADE_COMPARE(b.textureCoords2DArrayCount(), 1);
CORRADE_COMPARE(b.textureCoords2D(0), (std::vector<Vector2>{{0.0f, 0.0f}, {0.3f, 0.7f}}));
CORRADE_COMPARE(b.importerState(), &a);
const int c{};
MeshData3D d{MeshPrimitive::TriangleFan, {},
{{}},
{},
{{}},
&c};
d = std::move(b);
CORRADE_COMPARE(d.primitive(), MeshPrimitive::LineStrip);
CORRADE_VERIFY(d.isIndexed());
CORRADE_COMPARE(d.indices(), (std::vector<UnsignedInt>{12, 1, 0}));
CORRADE_COMPARE(d.positionArrayCount(), 1);
CORRADE_COMPARE(d.positions(0), (std::vector<Vector3>{{0.5f, 1.0f, 0.1f}, {-1.0f, 0.3f, -1.0f}}));
CORRADE_COMPARE(d.normalArrayCount(), 1);
CORRADE_COMPARE(d.normals(0), (std::vector<Vector3>{{0.0f, 1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}}));
CORRADE_COMPARE(d.textureCoords2DArrayCount(), 1);
CORRADE_COMPARE(d.textureCoords2D(0), (std::vector<Vector2>{{0.0f, 0.0f}, {0.3f, 0.7f}}));
CORRADE_COMPARE(d.importerState(), &a);
}
}}}
CORRADE_TEST_MAIN(Magnum::Trade::Test::MeshData3DTest)

82
src/Magnum/Trade/Test/ObjectData2DTest.cpp

@ -26,7 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include "Magnum/Trade/ObjectData2D.h"
#include "Magnum/Trade/MeshObjectData2D.h"
namespace Magnum { namespace Trade { namespace Test {
@ -34,14 +34,88 @@ class ObjectData2DTest: public TestSuite::Tester {
public:
explicit ObjectData2DTest();
void debug();
void constructEmpty();
void constructMesh();
void constructCamera();
void constructCopy();
void constructMoveMesh();
void debugType();
};
ObjectData2DTest::ObjectData2DTest() {
addTests({&ObjectData2DTest::debug});
addTests({&ObjectData2DTest::constructEmpty,
&ObjectData2DTest::constructMesh,
&ObjectData2DTest::constructCamera,
&ObjectData2DTest::constructCopy,
&ObjectData2DTest::constructMoveMesh,
&ObjectData2DTest::debugType});
}
void ObjectData2DTest::constructEmpty() {
const int a{};
const ObjectData2D data{{0, 2, 3}, Matrix3::translation(Vector2::xAxis(-4.0f)), &a};
CORRADE_COMPARE(data.children(), (std::vector<UnsignedInt>{0, 2, 3}));
CORRADE_COMPARE(data.transformation(), Matrix3::translation(Vector2::xAxis(-4.0f)));
CORRADE_COMPARE(data.instanceType(), ObjectInstanceType2D::Empty);
CORRADE_COMPARE(data.instance(), -1);
}
void ObjectData2DTest::constructMesh() {
const int a{};
const MeshObjectData2D data{{1, 3}, Matrix3::translation(Vector2::yAxis(5.0f)), 13, 42, &a};
CORRADE_COMPARE(data.children(), (std::vector<UnsignedInt>{1, 3}));
CORRADE_COMPARE(data.transformation(), Matrix3::translation(Vector2::yAxis(5.0f)));
CORRADE_COMPARE(data.instanceType(), ObjectInstanceType2D::Mesh);
CORRADE_COMPARE(data.instance(), 13);
CORRADE_COMPARE(data.material(), 42);
}
void ObjectData2DTest::constructCamera() {
const int a{};
const ObjectData2D data{{1, 3}, Matrix3::translation(Vector2::yAxis(5.0f)), ObjectInstanceType2D::Camera, 42, &a};
CORRADE_COMPARE(data.children(), (std::vector<UnsignedInt>{1, 3}));
CORRADE_COMPARE(data.transformation(), Matrix3::translation(Vector2::yAxis(5.0f)));
CORRADE_COMPARE(data.instanceType(), ObjectInstanceType2D::Camera);
CORRADE_COMPARE(data.instance(), 42);
}
void ObjectData2DTest::constructCopy() {
CORRADE_VERIFY(!(std::is_constructible<ObjectData2D, const ObjectData2D&>{}));
CORRADE_VERIFY(!(std::is_constructible<MeshObjectData2D, const MeshObjectData2D&>{}));
CORRADE_VERIFY(!(std::is_assignable<ObjectData2D, const ObjectData2D&>{}));
CORRADE_VERIFY(!(std::is_assignable<MeshObjectData2D, const MeshObjectData2D&>{}));
}
void ObjectData2DTest::constructMoveMesh() {
const int a{};
MeshObjectData2D data{{1, 3}, Matrix3::translation(Vector2::yAxis(5.0f)), 13, 42, &a};
MeshObjectData2D b{std::move(data)};
CORRADE_COMPARE(b.children(), (std::vector<UnsignedInt>{1, 3}));
CORRADE_COMPARE(b.transformation(), Matrix3::translation(Vector2::yAxis(5.0f)));
CORRADE_COMPARE(b.instanceType(), ObjectInstanceType2D::Mesh);
CORRADE_COMPARE(b.instance(), 13);
CORRADE_COMPARE(b.material(), 42);
const int c{};
MeshObjectData2D d{{0, 1}, {}, 27, -1, &c};
d = std::move(b);
CORRADE_COMPARE(d.children(), (std::vector<UnsignedInt>{1, 3}));
CORRADE_COMPARE(d.transformation(), Matrix3::translation(Vector2::yAxis(5.0f)));
CORRADE_COMPARE(d.instanceType(), ObjectInstanceType2D::Mesh);
CORRADE_COMPARE(d.instance(), 13);
CORRADE_COMPARE(d.material(), 42);
}
void ObjectData2DTest::debug() {
void ObjectData2DTest::debugType() {
std::ostringstream o;
Debug(&o) << ObjectInstanceType2D::Empty << ObjectInstanceType2D(0xbe);
CORRADE_COMPARE(o.str(), "Trade::ObjectInstanceType2D::Empty Trade::ObjectInstanceType2D(0xbe)\n");

94
src/Magnum/Trade/Test/ObjectData3DTest.cpp

@ -26,7 +26,7 @@
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include "Magnum/Trade/ObjectData3D.h"
#include "Magnum/Trade/MeshObjectData3D.h"
namespace Magnum { namespace Trade { namespace Test {
@ -34,14 +34,100 @@ class ObjectData3DTest: public TestSuite::Tester {
public:
explicit ObjectData3DTest();
void debug();
void constructEmpty();
void constructMesh();
void constructCamera();
void constructLight();
void constructCopy();
void constructMoveMesh();
void debugType();
};
ObjectData3DTest::ObjectData3DTest() {
addTests({&ObjectData3DTest::debug});
addTests({&ObjectData3DTest::constructEmpty,
&ObjectData3DTest::constructMesh,
&ObjectData3DTest::constructCamera,
&ObjectData3DTest::constructLight,
&ObjectData3DTest::constructCopy,
&ObjectData3DTest::constructMoveMesh,
&ObjectData3DTest::debugType});
}
void ObjectData3DTest::constructEmpty() {
const int a{};
const ObjectData3D data{{0, 2, 3}, Matrix4::translation(Vector3::xAxis(-4.0f)), &a};
CORRADE_COMPARE(data.children(), (std::vector<UnsignedInt>{0, 2, 3}));
CORRADE_COMPARE(data.transformation(), Matrix4::translation(Vector3::xAxis(-4.0f)));
CORRADE_COMPARE(data.instanceType(), ObjectInstanceType3D::Empty);
CORRADE_COMPARE(data.instance(), -1);
}
void ObjectData3DTest::constructMesh() {
const int a{};
const MeshObjectData3D data{{1, 3}, Matrix4::translation(Vector3::yAxis(5.0f)), 13, 42, &a};
CORRADE_COMPARE(data.children(), (std::vector<UnsignedInt>{1, 3}));
CORRADE_COMPARE(data.transformation(), Matrix4::translation(Vector3::yAxis(5.0f)));
CORRADE_COMPARE(data.instanceType(), ObjectInstanceType3D::Mesh);
CORRADE_COMPARE(data.instance(), 13);
CORRADE_COMPARE(data.material(), 42);
}
void ObjectData3DTest::constructCamera() {
const int a{};
const ObjectData3D data{{1, 3}, Matrix4::translation(Vector3::yAxis(5.0f)), ObjectInstanceType3D::Camera, 42, &a};
CORRADE_COMPARE(data.children(), (std::vector<UnsignedInt>{1, 3}));
CORRADE_COMPARE(data.transformation(), Matrix4::translation(Vector3::yAxis(5.0f)));
CORRADE_COMPARE(data.instanceType(), ObjectInstanceType3D::Camera);
CORRADE_COMPARE(data.instance(), 42);
}
void ObjectData3DTest::constructLight() {
const int a{};
const ObjectData3D data{{1, 3}, Matrix4::translation(Vector3::yAxis(5.0f)), ObjectInstanceType3D::Light, 42, &a};
CORRADE_COMPARE(data.children(), (std::vector<UnsignedInt>{1, 3}));
CORRADE_COMPARE(data.transformation(), Matrix4::translation(Vector3::yAxis(5.0f)));
CORRADE_COMPARE(data.instanceType(), ObjectInstanceType3D::Light);
CORRADE_COMPARE(data.instance(), 42);
}
void ObjectData3DTest::constructCopy() {
CORRADE_VERIFY(!(std::is_constructible<ObjectData3D, const ObjectData3D&>{}));
CORRADE_VERIFY(!(std::is_constructible<MeshObjectData3D, const MeshObjectData3D&>{}));
CORRADE_VERIFY(!(std::is_assignable<ObjectData3D, const ObjectData3D&>{}));
CORRADE_VERIFY(!(std::is_assignable<MeshObjectData3D, const MeshObjectData3D&>{}));
}
void ObjectData3DTest::constructMoveMesh() {
const int a{};
MeshObjectData3D data{{1, 3}, Matrix4::translation(Vector3::yAxis(5.0f)), 13, 42, &a};
MeshObjectData3D b{std::move(data)};
CORRADE_COMPARE(b.children(), (std::vector<UnsignedInt>{1, 3}));
CORRADE_COMPARE(b.transformation(), Matrix4::translation(Vector3::yAxis(5.0f)));
CORRADE_COMPARE(b.instanceType(), ObjectInstanceType3D::Mesh);
CORRADE_COMPARE(b.instance(), 13);
CORRADE_COMPARE(b.material(), 42);
const int c{};
MeshObjectData3D d{{0, 1}, {}, 27, -1, &c};
d = std::move(b);
CORRADE_COMPARE(d.children(), (std::vector<UnsignedInt>{1, 3}));
CORRADE_COMPARE(d.transformation(), Matrix4::translation(Vector3::yAxis(5.0f)));
CORRADE_COMPARE(d.instanceType(), ObjectInstanceType3D::Mesh);
CORRADE_COMPARE(d.instance(), 13);
CORRADE_COMPARE(d.material(), 42);
}
void ObjectData3DTest::debug() {
void ObjectData3DTest::debugType() {
std::ostringstream o;
Debug(&o) << ObjectInstanceType3D::Light << ObjectInstanceType3D(0xbe);
CORRADE_COMPARE(o.str(), "Trade::ObjectInstanceType3D::Light Trade::ObjectInstanceType3D(0xbe)\n");

82
src/Magnum/Trade/Test/SceneDataTest.cpp

@ -0,0 +1,82 @@
/*
This file is part of Magnum.
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016
Vladimír Vondruš <mosra@centrum.cz>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <Corrade/TestSuite/Tester.h>
#include "Magnum/Trade/SceneData.h"
#include "Magnum/Magnum.h"
namespace Magnum { namespace Trade { namespace Test {
struct SceneDataTest: TestSuite::Tester {
explicit SceneDataTest();
void construct();
void constructCopy();
void constructMove();
};
SceneDataTest::SceneDataTest() {
addTests({&SceneDataTest::construct,
&SceneDataTest::constructCopy,
&SceneDataTest::constructMove});
}
void SceneDataTest::construct() {
const int a{};
const SceneData data{{0, 1, 4}, {2, 5}, &a};
CORRADE_COMPARE(data.children2D(), (std::vector<UnsignedInt>{0, 1, 4}));
CORRADE_COMPARE(data.children3D(), (std::vector<UnsignedInt>{2, 5}));
CORRADE_COMPARE(data.importerState(), &a);
}
void SceneDataTest::constructCopy() {
CORRADE_VERIFY(!(std::is_constructible<SceneData, const SceneData&>{}));
CORRADE_VERIFY(!(std::is_assignable<SceneData, const SceneData&>{}));
}
void SceneDataTest::constructMove() {
const int a{};
SceneData data{{0, 1, 4}, {2, 5}, &a};
SceneData b{std::move(data)};
CORRADE_COMPARE(b.children2D(), (std::vector<UnsignedInt>{0, 1, 4}));
CORRADE_COMPARE(b.children3D(), (std::vector<UnsignedInt>{2, 5}));
CORRADE_COMPARE(b.importerState(), &a);
const int c{};
SceneData d{{1, 3}, {1, 4, 5}, &c};
d = std::move(b);
CORRADE_COMPARE(d.children2D(), (std::vector<UnsignedInt>{0, 1, 4}));
CORRADE_COMPARE(d.children3D(), (std::vector<UnsignedInt>{2, 5}));
CORRADE_COMPARE(d.importerState(), &a);
}
}}}
CORRADE_TEST_MAIN(Magnum::Trade::Test::SceneDataTest)

77
src/Magnum/Trade/Test/TextureDataTest.cpp

@ -34,14 +34,85 @@ class TextureDataTest: public TestSuite::Tester {
public:
explicit TextureDataTest();
void debug();
void construct();
void constructCopy();
void constructMove();
void debugType();
};
TextureDataTest::TextureDataTest() {
addTests({&TextureDataTest::debug});
addTests({&TextureDataTest::construct,
&TextureDataTest::constructCopy,
&TextureDataTest::constructMove,
&TextureDataTest::debugType});
}
void TextureDataTest::construct() {
const int a{};
const TextureData data{TextureData::Type::Cube,
Sampler::Filter::Linear,
Sampler::Filter::Nearest,
Sampler::Mipmap::Nearest,
{Sampler::Wrapping::Repeat, Sampler::Wrapping::ClampToEdge, Sampler::Wrapping::MirroredRepeat},
42,
&a};
CORRADE_COMPARE(data.type(), TextureData::Type::Cube);
CORRADE_COMPARE(data.minificationFilter(), Sampler::Filter::Linear);
CORRADE_COMPARE(data.magnificationFilter(), Sampler::Filter::Nearest);
CORRADE_COMPARE(data.mipmapFilter(), Sampler::Mipmap::Nearest);
CORRADE_COMPARE(data.wrapping(), (Array3D<Sampler::Wrapping>{Sampler::Wrapping::Repeat, Sampler::Wrapping::ClampToEdge, Sampler::Wrapping::MirroredRepeat}));
CORRADE_COMPARE(data.image(), 42);
CORRADE_COMPARE(data.importerState(), &a);
}
void TextureDataTest::constructCopy() {
CORRADE_VERIFY(!(std::is_constructible<TextureData, const TextureData&>{}));
CORRADE_VERIFY(!(std::is_assignable<TextureData, const TextureData&>{}));
}
void TextureDataTest::constructMove() {
const int a{};
TextureData data{TextureData::Type::Cube,
Sampler::Filter::Linear,
Sampler::Filter::Nearest,
Sampler::Mipmap::Nearest,
{Sampler::Wrapping::Repeat, Sampler::Wrapping::ClampToEdge, Sampler::Wrapping::MirroredRepeat},
42,
&a};
TextureData b{std::move(data)};
CORRADE_COMPARE(b.type(), TextureData::Type::Cube);
CORRADE_COMPARE(b.minificationFilter(), Sampler::Filter::Linear);
CORRADE_COMPARE(b.magnificationFilter(), Sampler::Filter::Nearest);
CORRADE_COMPARE(b.mipmapFilter(), Sampler::Mipmap::Nearest);
CORRADE_COMPARE(b.wrapping(), (Array3D<Sampler::Wrapping>{Sampler::Wrapping::Repeat, Sampler::Wrapping::ClampToEdge, Sampler::Wrapping::MirroredRepeat}));
CORRADE_COMPARE(b.image(), 42);
CORRADE_COMPARE(b.importerState(), &a);
const int c{};
TextureData d{TextureData::Type::Texture2D,
Sampler::Filter::Nearest,
Sampler::Filter::Linear,
Sampler::Mipmap::Base,
Sampler::Wrapping::ClampToEdge,
13,
&c};
d = std::move(b);
CORRADE_COMPARE(d.type(), TextureData::Type::Cube);
CORRADE_COMPARE(d.minificationFilter(), Sampler::Filter::Linear);
CORRADE_COMPARE(d.magnificationFilter(), Sampler::Filter::Nearest);
CORRADE_COMPARE(d.mipmapFilter(), Sampler::Mipmap::Nearest);
CORRADE_COMPARE(d.wrapping(), (Array3D<Sampler::Wrapping>{Sampler::Wrapping::Repeat, Sampler::Wrapping::ClampToEdge, Sampler::Wrapping::MirroredRepeat}));
CORRADE_COMPARE(d.image(), 42);
CORRADE_COMPARE(d.importerState(), &a);
}
void TextureDataTest::debug() {
void TextureDataTest::debugType() {
std::ostringstream out;
Debug(&out) << TextureData::Type::Texture3D << TextureData::Type(0xbe);

Loading…
Cancel
Save