leonetienne/Eule
1
0
Fork 0
Code Issues 2 Pull Requests Packages Projects Releases Wiki Activity

Translated tests for Vector/VectorConversion

Browse Source
This commit is contained in:
Leonetienne 2022-02-11 15:20:00 +01:00
parent fe212cd039
commit c5cf1c0061
3 changed files with 199 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Test/CMakeLists.txt
View File

@ -25,6 +25,7 @@ add_executable(Tests
Vector4.cpp Vector4.cpp
Quaternion.cpp Quaternion.cpp
Random__RandomFloat.cpp Random__RandomFloat.cpp
VectorConversion.cpp
) )
target_link_libraries(Tests Eule) target_link_libraries(Tests Eule)

1
Test/Vector4.cpp
View File

@ -4,7 +4,6 @@
#include <Eule/Math.h> #include <Eule/Math.h>
#include <_TestingUtilities/HandyMacros.h> #include <_TestingUtilities/HandyMacros.h>
#include <random> #include <random>
#include <sstream>
using namespace Eule; using namespace Eule;

411
Test/VectorConversion.cpp
View File

@ -1,220 +1,205 @@
#include "CppUnitTest.h" #include "Catch2.h"
#include "../Eule/Vector2.h" #include <Eule/Vector2.h>
#include "../Eule/Vector3.h" #include <Eule/Vector3.h>
#include "../Eule/Vector4.h" #include <Eule/Vector4.h>
#include "../_TestingUtilities/HandyMacros.h" #include "../_TestingUtilities/HandyMacros.h"
#include <random> #include <random>
#include <sstream> #include <sstream>
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace Eule; using namespace Eule;
namespace Vectors namespace {
{ static std::mt19937 rng = std::mt19937((std::random_device())());
TEST_CLASS(_VectorConversion) }
{
private: // Tests that conversion vector2 -> vector3 works
std::mt19937 rng; TEST_CASE(__FILE__"/Convert_Vector2_To_Vector3", "[Vector][VectorConversion]")
{
public: // Run test 100 times
// Constructor for (std::size_t i = 0; i < 100; i++)
_VectorConversion() {
{ const Vector2d v2(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE);
rng = std::mt19937((std::random_device())()); const Vector3d v3 = v2;
return;
REQUIRE(v2.x == v3.x);
} REQUIRE(v2.y == v3.y);
REQUIRE(0.0 == v3.z);
// Tests that conversion vector2 -> vector3 works }
TEST_METHOD(Convert_Vector2_To_Vector3)
{ return;
// Run test 100 times }
for (std::size_t i = 0; i < 100; i++)
{ // Tests that conversion vector2 -> vector4 works
Vector2d v2(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE); TEST_CASE(__FILE__"/Convert_Vector2_To_Vector4", "[Vector][VectorConversion]")
Vector3d v3 = v2; {
// Run test 100 times
Assert::AreEqual(v2.x, v3.x); for (std::size_t i = 0; i < 100; i++)
Assert::AreEqual(v2.y, v3.y); {
Assert::AreEqual(0.0, v3.z); const Vector2d v2(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE);
} const Vector4d v4 = v2;
return; REQUIRE(v2.x == v4.x);
} REQUIRE(v2.y == v4.y);
REQUIRE(0.0 == v4.z);
// Tests that conversion vector2 -> vector4 works REQUIRE(0.0 == v4.w);
TEST_METHOD(Convert_Vector2_To_Vector4) }
{
// Run test 100 times return;
for (std::size_t i = 0; i < 100; i++) }
{
Vector2d v2(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE); // Tests that conversion vector3 -> vector2 works
Vector4d v4 = v2; TEST_CASE(__FILE__"/Convert_Vector3_To_Vector2", "[Vector][VectorConversion]")
{
Assert::AreEqual(v2.x, v4.x); // Run test 100 times
Assert::AreEqual(v2.y, v4.y); for (std::size_t i = 0; i < 100; i++)
Assert::AreEqual(0.0, v4.z); {
Assert::AreEqual(0.0, v4.w); const Vector3d v3(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE);
} const Vector2d v2 = v3;
return; REQUIRE(v3.x == v2.x);
} REQUIRE(v3.y == v2.y);
}
// Tests that conversion vector3 -> vector2 works
TEST_METHOD(Convert_Vector3_To_Vector2) return;
{ }
// Run test 100 times
for (std::size_t i = 0; i < 100; i++) // Tests that conversion vector3 -> vector4 works
{ TEST_CASE(__FILE__"/Convert_Vector3_To_Vector4", "[Vector][VectorConversion]")
Vector3d v3(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE); {
Vector2d v2 = v3; // Run test 100 times
for (std::size_t i = 0; i < 100; i++)
Assert::AreEqual(v3.x, v2.x); {
Assert::AreEqual(v3.y, v2.y); const Vector3d v3(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE);
} const Vector4d v4 = v3;
return; REQUIRE(v3.x == v4.x);
} REQUIRE(v3.y == v4.y);
REQUIRE(v3.z == v4.z);
// Tests that conversion vector3 -> vector4 works REQUIRE(0.0 == v4.w);
TEST_METHOD(Convert_Vector3_To_Vector4) }
{
// Run test 100 times return;
for (std::size_t i = 0; i < 100; i++) }
{
Vector3d v3(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE); // Tests that conversion vector4 -> vector42 works
Vector4d v4 = v3; TEST_CASE(__FILE__"/Convert_Vector4_To_Vector2", "[Vector][VectorConversion]")
{
Assert::AreEqual(v3.x, v4.x); // Run tests 100 times
Assert::AreEqual(v3.y, v4.y); for (std::size_t i = 0; i < 100; i++)
Assert::AreEqual(v3.z, v4.z); {
Assert::AreEqual(0.0, v4.w); const Vector4d v4(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE);
} const Vector2d v2 = v4;
return; REQUIRE(v4.x == v2.x);
} REQUIRE(v4.y == v2.y);
}
// Tests that conversion vector4 -> vector42 works
TEST_METHOD(Convert_Vector4_To_Vector2) return;
{ }
// Run tests 100 times
for (std::size_t i = 0; i < 100; i++) // Tests that conversion vector4 -> vector3 works
{ TEST_CASE(__FILE__"/Convert_Vector4_To_Vector3", "[Vector][VectorConversion]")
Vector4d v4(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE); {
Vector2d v2 = v4; // Run tests 100 times
for (std::size_t i = 0; i < 100; i++)
Assert::AreEqual(v4.x, v2.x); {
Assert::AreEqual(v4.y, v2.y); const Vector4d v4(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE);
} const Vector3d v3 = v4;
return; REQUIRE(v4.x == v3.x);
} REQUIRE(v4.y == v3.y);
REQUIRE(v4.z == v3.z);
// Tests that conversion vector4 -> vector3 works }
TEST_METHOD(Convert_Vector4_To_Vector3)
{ return;
// Run tests 100 times }
for (std::size_t i = 0; i < 100; i++)
{ // Tests Vector2i -> Vector2d
Vector4d v4(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE); TEST_CASE(__FILE__"/Convert_Vector2i_To_Vector2d", "[Vector][VectorConversion]")
Vector3d v3 = v4; {
// Setup
Assert::AreEqual(v4.x, v3.x); const Vector2i vi(69, 70);
Assert::AreEqual(v4.y, v3.y);
Assert::AreEqual(v4.z, v3.z); // Exercise
} const Vector2d vd = vi.ToDouble();
return; // Verify
} REQUIRE(Vector2d(69, 70) == vd);
// Tests Vector2i -> Vector2d return;
TEST_METHOD(Convert_Vector2i_To_Vector2d) }
{
// Setup // Tests Vector2d -> Vector2i
Vector2i vi(69, 70); TEST_CASE(__FILE__"/Convert_Vector2d_To_Vector2i", "[Vector][VectorConversion]")
{
// Exercise // Setup
Vector2d vd = vi.ToDouble(); const Vector2d vd(69.2, 70.8);
// Verify // Exercise
Assert::IsTrue(Vector2d(69, 70) == vd); const Vector2i vi = vd.ToInt();
return; // Verify
} REQUIRE(Vector2i(69, 70) == vi);
// Tests Vector2d -> Vector2i return;
TEST_METHOD(Convert_Vector2d_To_Vector2i) }
{
// Setup // Tests Vector3i -> Vector3d
Vector2d vd(69.2, 70.8); TEST_CASE(__FILE__"/Convert_Vector3i_To_Vector3d", "[Vector][VectorConversion]")
{
// Exercise // Setup
Vector2i vi = vd.ToInt(); const Vector3i vi(69, 70, 122);
// Verify // Exercise
Assert::IsTrue(Vector2i(69, 70) == vi); const Vector3d vd = vi.ToDouble();
return; // Verify
} REQUIRE(Vector3d(69, 70, 122) == vd);
// Tests Vector3i -> Vector3d return;
TEST_METHOD(Convert_Vector3i_To_Vector3d) }
{
// Setup // Tests Vector3d -> Vector3i
Vector3i vi(69, 70, 122); TEST_CASE(__FILE__"/Convert_Vector3d_To_Vector3i", "[Vector][VectorConversion]")
{
// Exercise // Setup
Vector3d vd = vi.ToDouble(); const Vector3d vd(69.2, 70.8, 122);
// Verify // Exercise
Assert::IsTrue(Vector3d(69, 70, 122) == vd); const Vector3i vi = vd.ToInt();
return; // Verify
} REQUIRE(Vector3i(69, 70, 122) == vi);
// Tests Vector3d -> Vector3i return;
TEST_METHOD(Convert_Vector3d_To_Vector3i) }
{
// Setup // Tests Vector4i -> Vector4d
Vector3d vd(69.2, 70.8, 122); TEST_CASE(__FILE__"/Convert_Vector4i_To_Vector4d", "[Vector][VectorConversion]")
{
// Exercise // Setup
Vector3i vi = vd.ToInt(); const Vector4i vi(69, 70, 122, 199);
// Verify // Exercise
Assert::IsTrue(Vector3i(69, 70, 122) == vi); const Vector4d vd = vi.ToDouble();
return; // Verify
} REQUIRE(Vector4d(69, 70, 122, 199) == vd);
// Tests Vector4i -> Vector4d return;
TEST_METHOD(Convert_Vector4i_To_Vector4d) }
{
// Setup // Tests Vector4d -> Vector4i
Vector4i vi(69, 70, 122, 199); TEST_CASE(__FILE__"/Convert_Vector4d_To_Vector4i", "[Vector][VectorConversion]")
{
// Exercise // Setup
Vector4d vd = vi.ToDouble(); const Vector4d vd(69.2, 70.8, 122, 199.501);
// Verify // Exercise
Assert::IsTrue(Vector4d(69, 70, 122, 199) == vd); const Vector4i vi = vd.ToInt();
return; // Verify
} REQUIRE(Vector4i(69, 70, 122, 199) == vi);
// Tests Vector4d -> Vector4i return;
TEST_METHOD(Convert_Vector4d_To_Vector4i)
{
// Setup
Vector4d vd(69.2, 70.8, 122, 199.501);
// Exercise
Vector4i vi = vd.ToInt();
// Verify
Assert::IsTrue(Vector4i(69, 70, 122, 199) == vi);
return;
}
};
} }