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;

147
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:
std::mt19937 rng;
public:
// Constructor
_VectorConversion()
{
rng = std::mt19937((std::random_device())());
return;
} }
// Tests that conversion vector2 -> vector3 works // Tests that conversion vector2 -> vector3 works
TEST_METHOD(Convert_Vector2_To_Vector3) TEST_CASE(__FILE__"/Convert_Vector2_To_Vector3", "[Vector][VectorConversion]")
{ {
// Run test 100 times // Run test 100 times
for (std::size_t i = 0; i < 100; i++) for (std::size_t i = 0; i < 100; i++)
{ {
Vector2d v2(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE); const Vector2d v2(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE);
Vector3d v3 = v2; const Vector3d v3 = v2;
Assert::AreEqual(v2.x, v3.x); REQUIRE(v2.x == v3.x);
Assert::AreEqual(v2.y, v3.y); REQUIRE(v2.y == v3.y);
Assert::AreEqual(0.0, v3.z); REQUIRE(0.0 == v3.z);
} }
return; return;
} }
// Tests that conversion vector2 -> vector4 works // Tests that conversion vector2 -> vector4 works
TEST_METHOD(Convert_Vector2_To_Vector4) TEST_CASE(__FILE__"/Convert_Vector2_To_Vector4", "[Vector][VectorConversion]")
{ {
// Run test 100 times // Run test 100 times
for (std::size_t i = 0; i < 100; i++) for (std::size_t i = 0; i < 100; i++)
{ {
Vector2d v2(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE); const Vector2d v2(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE);
Vector4d v4 = v2; const Vector4d v4 = v2;
Assert::AreEqual(v2.x, v4.x); REQUIRE(v2.x == v4.x);
Assert::AreEqual(v2.y, v4.y); REQUIRE(v2.y == v4.y);
Assert::AreEqual(0.0, v4.z); REQUIRE(0.0 == v4.z);
Assert::AreEqual(0.0, v4.w); REQUIRE(0.0 == v4.w);
} }
return; return;
} }
// Tests that conversion vector3 -> vector2 works // Tests that conversion vector3 -> vector2 works
TEST_METHOD(Convert_Vector3_To_Vector2) TEST_CASE(__FILE__"/Convert_Vector3_To_Vector2", "[Vector][VectorConversion]")
{ {
// Run test 100 times // Run test 100 times
for (std::size_t i = 0; i < 100; i++) for (std::size_t i = 0; i < 100; i++)
{ {
Vector3d v3(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE); const Vector3d v3(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE);
Vector2d v2 = v3; const Vector2d v2 = v3;
Assert::AreEqual(v3.x, v2.x); REQUIRE(v3.x == v2.x);
Assert::AreEqual(v3.y, v2.y); REQUIRE(v3.y == v2.y);
} }
return; return;
} }
// Tests that conversion vector3 -> vector4 works // Tests that conversion vector3 -> vector4 works
TEST_METHOD(Convert_Vector3_To_Vector4) TEST_CASE(__FILE__"/Convert_Vector3_To_Vector4", "[Vector][VectorConversion]")
{ {
// Run test 100 times // Run test 100 times
for (std::size_t i = 0; i < 100; i++) for (std::size_t i = 0; i < 100; i++)
{ {
Vector3d v3(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE); const Vector3d v3(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE);
Vector4d v4 = v3; const Vector4d v4 = v3;
Assert::AreEqual(v3.x, v4.x); REQUIRE(v3.x == v4.x);
Assert::AreEqual(v3.y, v4.y); REQUIRE(v3.y == v4.y);
Assert::AreEqual(v3.z, v4.z); REQUIRE(v3.z == v4.z);
Assert::AreEqual(0.0, v4.w); REQUIRE(0.0 == v4.w);
} }
return; return;
} }
// Tests that conversion vector4 -> vector42 works // Tests that conversion vector4 -> vector42 works
TEST_METHOD(Convert_Vector4_To_Vector2) TEST_CASE(__FILE__"/Convert_Vector4_To_Vector2", "[Vector][VectorConversion]")
{ {
// Run tests 100 times // Run tests 100 times
for (std::size_t i = 0; i < 100; i++) for (std::size_t i = 0; i < 100; i++)
{ {
Vector4d v4(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE); const Vector4d v4(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE);
Vector2d v2 = v4; const Vector2d v2 = v4;
Assert::AreEqual(v4.x, v2.x); REQUIRE(v4.x == v2.x);
Assert::AreEqual(v4.y, v2.y); REQUIRE(v4.y == v2.y);
} }
return; return;
} }
// Tests that conversion vector4 -> vector3 works // Tests that conversion vector4 -> vector3 works
TEST_METHOD(Convert_Vector4_To_Vector3) TEST_CASE(__FILE__"/Convert_Vector4_To_Vector3", "[Vector][VectorConversion]")
{ {
// Run tests 100 times // Run tests 100 times
for (std::size_t i = 0; i < 100; i++) for (std::size_t i = 0; i < 100; i++)
{ {
Vector4d v4(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE); const Vector4d v4(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE);
Vector3d v3 = v4; const Vector3d v3 = v4;
Assert::AreEqual(v4.x, v3.x); REQUIRE(v4.x == v3.x);
Assert::AreEqual(v4.y, v3.y); REQUIRE(v4.y == v3.y);
Assert::AreEqual(v4.z, v3.z); REQUIRE(v4.z == v3.z);
} }
return; return;
} }
// Tests Vector2i -> Vector2d // Tests Vector2i -> Vector2d
TEST_METHOD(Convert_Vector2i_To_Vector2d) TEST_CASE(__FILE__"/Convert_Vector2i_To_Vector2d", "[Vector][VectorConversion]")
{ {
// Setup // Setup
Vector2i vi(69, 70); const Vector2i vi(69, 70);
// Exercise // Exercise
Vector2d vd = vi.ToDouble(); const Vector2d vd = vi.ToDouble();
// Verify // Verify
Assert::IsTrue(Vector2d(69, 70) == vd); REQUIRE(Vector2d(69, 70) == vd);
return; return;
} }
// Tests Vector2d -> Vector2i // Tests Vector2d -> Vector2i
TEST_METHOD(Convert_Vector2d_To_Vector2i) TEST_CASE(__FILE__"/Convert_Vector2d_To_Vector2i", "[Vector][VectorConversion]")
{ {
// Setup // Setup
Vector2d vd(69.2, 70.8); const Vector2d vd(69.2, 70.8);
// Exercise // Exercise
Vector2i vi = vd.ToInt(); const Vector2i vi = vd.ToInt();
// Verify // Verify
Assert::IsTrue(Vector2i(69, 70) == vi); REQUIRE(Vector2i(69, 70) == vi);
return; return;
} }
// Tests Vector3i -> Vector3d // Tests Vector3i -> Vector3d
TEST_METHOD(Convert_Vector3i_To_Vector3d) TEST_CASE(__FILE__"/Convert_Vector3i_To_Vector3d", "[Vector][VectorConversion]")
{ {
// Setup // Setup
Vector3i vi(69, 70, 122); const Vector3i vi(69, 70, 122);
// Exercise // Exercise
Vector3d vd = vi.ToDouble(); const Vector3d vd = vi.ToDouble();
// Verify // Verify
Assert::IsTrue(Vector3d(69, 70, 122) == vd); REQUIRE(Vector3d(69, 70, 122) == vd);
return; return;
} }
// Tests Vector3d -> Vector3i // Tests Vector3d -> Vector3i
TEST_METHOD(Convert_Vector3d_To_Vector3i) TEST_CASE(__FILE__"/Convert_Vector3d_To_Vector3i", "[Vector][VectorConversion]")
{ {
// Setup // Setup
Vector3d vd(69.2, 70.8, 122); const Vector3d vd(69.2, 70.8, 122);
// Exercise // Exercise
Vector3i vi = vd.ToInt(); const Vector3i vi = vd.ToInt();
// Verify // Verify
Assert::IsTrue(Vector3i(69, 70, 122) == vi); REQUIRE(Vector3i(69, 70, 122) == vi);
return; return;
} }
// Tests Vector4i -> Vector4d // Tests Vector4i -> Vector4d
TEST_METHOD(Convert_Vector4i_To_Vector4d) TEST_CASE(__FILE__"/Convert_Vector4i_To_Vector4d", "[Vector][VectorConversion]")
{ {
// Setup // Setup
Vector4i vi(69, 70, 122, 199); const Vector4i vi(69, 70, 122, 199);
// Exercise // Exercise
Vector4d vd = vi.ToDouble(); const Vector4d vd = vi.ToDouble();
// Verify // Verify
Assert::IsTrue(Vector4d(69, 70, 122, 199) == vd); REQUIRE(Vector4d(69, 70, 122, 199) == vd);
return; return;
} }
// Tests Vector4d -> Vector4i // Tests Vector4d -> Vector4i
TEST_METHOD(Convert_Vector4d_To_Vector4i) TEST_CASE(__FILE__"/Convert_Vector4d_To_Vector4i", "[Vector][VectorConversion]")
{ {
// Setup // Setup
Vector4d vd(69.2, 70.8, 122, 199.501); const Vector4d vd(69.2, 70.8, 122, 199.501);
// Exercise // Exercise
Vector4i vi = vd.ToInt(); const Vector4i vi = vd.ToInt();
// Verify // Verify
Assert::IsTrue(Vector4i(69, 70, 122, 199) == vi); REQUIRE(Vector4i(69, 70, 122, 199) == vi);
return; return;
} }
};
}