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

Translated tests for Quaternion

Browse Source
This commit is contained in:
Leonetienne 2022-02-11 14:47:33 +01:00
parent cd5e841ebd
commit b8b3005cb2
2 changed files with 288 additions and 302 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Test/CMakeLists.txt
View File

@ -23,6 +23,7 @@ add_executable(Tests
Vector2.cpp
Vector3.cpp
Vector4.cpp
Quaternion.cpp
)
target_link_libraries(Tests Eule)

165
Test/Quaternion.cpp
View File

@ -1,44 +1,32 @@
#include "CppUnitTest.h"
#include "../Eule/Quaternion.h"
#include "../Eule/Math.h"
#include "Catch2.h"
#include <Eule/Quaternion.h>
#include <Eule/Math.h>
#include "../_TestingUtilities/HandyMacros.h"
#include <random>
#include <sstream>
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace Eule;
namespace TransformRelated
{
TEST_CLASS(_Quaternion)
{
private:
std::mt19937 rng;
public:
// Constructor
_Quaternion()
{
rng = std::mt19937((std::random_device())());
return;
namespace {
static std::mt19937 rng = std::mt19937((std::random_device())());
}
// Tests that if constructed with the default constructor, that all values are 0 (but w should be 1)
TEST_METHOD(Default_Constructor_All_0)
TEST_CASE(__FILE__"/Default_Constructor_All_0", "[Quaternion]")
{
Quaternion q;
Assert::IsTrue(Vector4d(0, 0, 0, 1) == q.GetRawValues());
const Quaternion q;
REQUIRE(Vector4d(0, 0, 0, 1) == q.GetRawValues());
return;
}
// Tests that getting and setting raw values works
TEST_METHOD(Can_Set_Get_Raw_Values)
TEST_CASE(__FILE__"/Can_Set_Get_Raw_Values", "[Quaternion]")
{
// Test 1000 times
for (std::size_t i = 0; i < 1000; i++)
{
Vector4d v(
const Vector4d v(
rng() % 90,
rng() % 90,
rng() % 90,
@ -48,165 +36,164 @@ namespace TransformRelated
Quaternion q(Vector4d(0, 0, 0, 0)); // Garbage values
q.SetRawValues(v);
Assert::IsTrue(v.Similar(q.GetRawValues()));
REQUIRE(v.Similar(q.GetRawValues()));
}
return;
}
// Tests that retreiving euler angles (without gimbal lock) results in the same values as put in
TEST_METHOD(To_Euler_From_Euler)
// Tests that retrieving euler angles (without gimbal lock) results in the same values as put in
TEST_CASE(__FILE__"/To_Euler_From_Euler", "[Quaternion]")
{
// Test 1000 times
for (std::size_t i = 0; i < 1000; i++)
{
// Create vector
Vector3d eul(
const Vector3d eul(
rng() % 90,
rng() % 90,
rng() % 90
);
// Create quaternion from vector
Quaternion q(eul);
const Quaternion q(eul);
// Create debug output
std::wstringstream wss;
wss << std::endl
<< "Actual vals: " << q.ToEulerAngles() << std::endl
<< "Target vals: " << eul << std::endl;
INFO('\n'
<< "Actual vals: " << q.ToEulerAngles() << '\n'
<< "Target vals: " << eul << '\n'
);
// Assertion
Assert::IsTrue(eul.Similar(q.ToEulerAngles()), wss.str().c_str());
REQUIRE(eul.Similar(q.ToEulerAngles()));
}
return;
}
// Tests that adding angles (0,0,0) does not modify the quaternion
TEST_METHOD(Add_Angles_0_Does_Nothing)
TEST_CASE(__FILE__"/Add_Angles_0_Does_Nothing", "[Quaternion]")
{
Quaternion a(Vector3d(0, -45, 45));
Quaternion b(Vector3d(0, 0, 0));
const Quaternion a(Vector3d(0, -45, 45));
const Quaternion b(Vector3d(0, 0, 0));
Assert::IsTrue(Vector3d(0, -45, 45).Similar((a * b).ToEulerAngles()));
REQUIRE(Vector3d(0, -45, 45).Similar((a * b).ToEulerAngles()));
return;
}
// Tests that subtracting angles (0,0,0) does not modify the quaternion
TEST_METHOD(Sub_Angles_0_Does_Nothing)
TEST_CASE(__FILE__"/Sub_Angles_0_Does_Nothing", "[Quaternion]")
{
Quaternion a(Vector3d(0, -45, 45));
Quaternion b(Vector3d(0, 0, 0));
const Quaternion a(Vector3d(0, -45, 45));
const Quaternion b(Vector3d(0, 0, 0));
Assert::IsTrue(Vector3d(0, -45, 45).Similar((a / b).ToEulerAngles()));
REQUIRE(Vector3d(0, -45, 45).Similar((a / b).ToEulerAngles()));
return;
}
// Tests that subtracting by itself always returns (0,0,0)
TEST_METHOD(Sub_Itself_Is_0)
TEST_CASE(__FILE__"/Sub_Itself_Is_0", "[Quaternion]")
{
// Run test 100 times
for (std::size_t i = 0; i < 100; i++)
{
Quaternion a(Vector3d(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE));
Assert::IsTrue(Vector3d(0,0,0).Similar((a / a).ToEulerAngles()));
const Quaternion a(Vector3d(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE));
REQUIRE(Vector3d(0,0,0).Similar((a / a).ToEulerAngles()));
}
return;
}
// Tests that rotating a vector is equal to multiplying it with the inverted rotation matrix
TEST_METHOD(RotateVector_Equal_to_RotationMatrix)
TEST_CASE(__FILE__"/RotateVector_Equal_to_RotationMatrix", "[Quaternion]")
{
// Run test 1000 times
for (std::size_t i = 0; i < 1000; i++)
{
Quaternion a(Vector3d(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE));
const Quaternion a(Vector3d(LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE, LARGE_RAND_DOUBLE));
Vector3d point(32, 19, -14);
const Vector3d point(32, 19, -14);
// Generate debug output
std::wstringstream ss;
ss << (point * a.ToRotationMatrix()) << std::endl << L"===" << (a * point) << std::endl;
INFO((point * a.ToRotationMatrix()) << '\n' << "===" << (a * point) << '\n');
Assert::IsTrue((point * a.ToRotationMatrix()).Similar(a * point), ss.str().c_str());
REQUIRE((point * a.ToRotationMatrix()).Similar(a * point));
}
return;
}
// Tests that a *= b will result in the exact same outcome as a = a * b
TEST_METHOD(MultiplyEquals_Operator_Same_Result_As_Multiply_Operator)
TEST_CASE(__FILE__"/MultiplyEquals_Operator_Same_Result_As_Multiply_Operator", "[Quaternion]")
{
// Run tests 1000 times
for (std::size_t i = 0; i < 1000; i++)
{
// Setup
Quaternion a(Vector3d(rng() % 360, rng() % 360, rng() % 360));
Quaternion b(Vector3d(rng() % 360, rng() % 360, rng() % 360));
const Quaternion b(Vector3d(rng() % 360, rng() % 360, rng() % 360));
// Exercise
Quaternion ref = a * b;
a *= b;
// Verify
Assert::IsTrue(a.GetRawValues().Similar(ref.GetRawValues()));
REQUIRE(a.GetRawValues().Similar(ref.GetRawValues()));
}
return;
}
// Tests that a /= b will result in the exact same outcome as a = a / b
TEST_METHOD(DivideEquals_Operator_Same_Result_As_Divide_Operator)
TEST_CASE(__FILE__"/DivideEquals_Operator_Same_Result_As_Divide_Operator", "[Quaternion]")
{
// Run tests 1000 times
for (std::size_t i = 0; i < 1000; i++)
{
// Setup
Quaternion a(Vector3d(rng() % 360, rng() % 360, rng() % 360));
Quaternion b(Vector3d(rng() % 360, rng() % 360, rng() % 360));
const Quaternion b(Vector3d(rng() % 360, rng() % 360, rng() % 360));
// Exercise
Quaternion ref = a / b;
a /= b;
// Verify
Assert::IsTrue(a.GetRawValues().Similar(ref.GetRawValues()));
REQUIRE(a.GetRawValues().Similar(ref.GetRawValues()));
}
return;
}
// Tests basic equals comparison -> true
TEST_METHOD(Basic_EqualsComparison_True)
TEST_CASE(__FILE__"/Basic_EqualsComparison_True", "[Quaternion]")
{
// Run tests 1000 times
for (std::size_t i = 0; i < 1000; i++)
{
// Setup
Vector3d e(rng() % 360, rng() % 360, rng() % 360);
Quaternion a(e);
Quaternion b(e);
const Vector3d e(rng() % 360, rng() % 360, rng() % 360);
const Quaternion a(e);
const Quaternion b(e);
// Exercise and verify
Assert::IsTrue(a == b);
REQUIRE(a == b);
}
return;
}
// Tests basic equals comparison -> true
TEST_METHOD(Basic_EqualsComparison_False)
TEST_CASE(__FILE__"/Basic_EqualsComparison_False", "[Quaternion]")
{
// Run tests 1000 times
for (std::size_t i = 0; i < 1000; i++)
{
// Setup
Vector3d ae(rng() % 360, rng() % 360, rng() % 360);
Vector3d be(rng() % 360, rng() % 360, rng() % 360);
const Vector3d ae(rng() % 360, rng() % 360, rng() % 360);
const Vector3d be(rng() % 360, rng() % 360, rng() % 360);
// Abort if both vectors are equal
if (ae == be)
@ -215,11 +202,11 @@ namespace TransformRelated
continue;
}
Quaternion a(ae);
Quaternion b(be);
const Quaternion a(ae);
const Quaternion b(be);
// Exercise and verify
Assert::IsFalse(a == b);
REQUIRE_FALSE(a == b);
}
return;
@ -227,67 +214,67 @@ namespace TransformRelated
// Tests that different euler angles return true, if the angle is the same.
// Like [30, -10, 59] == [390, 350, 419]
TEST_METHOD(Equals_Comparison_Same_Rotation_Different_EulerAngles)
TEST_CASE(__FILE__"/Equals_Comparison_Same_Rotation_Different_EulerAngles", "[Quaternion]")
{
// Run tests 1000 times
for (std::size_t i = 0; i < 1000; i++)
{
// Setup
// Create random rotation
Vector3d ae(rng() % 360, rng() % 360, rng() % 360);
const Vector3d ae(rng() % 360, rng() % 360, rng() % 360);
// add or subtract a random multiple of 360
#define keep_rot_change_values (360.0 * (double)(rng() % 20) * ((rng()%2) ? 1.0 : -1.0))
Vector3d be(ae.x + keep_rot_change_values, ae.y + keep_rot_change_values, ae.z + keep_rot_change_values);
const Vector3d be(ae.x + keep_rot_change_values, ae.y + keep_rot_change_values, ae.z + keep_rot_change_values);
#undef keep_rot_change_values
// Create quaternions
Quaternion a(ae);
Quaternion b(be);
const Quaternion a(ae);
const Quaternion b(be);
// Exercise & Verify
// Create debug output
std::wstringstream wss;
wss << "ae: " << ae << std::endl
<< "be: " << be << std::endl
<< "a: " << a << std::endl
<< "b: " << b << std::endl;
INFO("ae: " << ae << '\n'
<< "be: " << be << '\n'
<< "a: " << a << '\n'
<< "b: " << b << '\n'
);
// Assertion
Assert::IsTrue(a == b, wss.str().c_str());
REQUIRE(a == b);
}
return;
}
// Tests basic not-equals comparison -> false
TEST_METHOD(Basic_NotEqualsComparison_False)
TEST_CASE(__FILE__"/Basic_NotEqualsComparison_False", "[Quaternion]")
{
// Run tests 1000 times
for (std::size_t i = 0; i < 1000; i++)
{
// Setup
Vector3d e(rng() % 360, rng() % 360, rng() % 360);
Quaternion a(e);
Quaternion b(e);
const Vector3d e(rng() % 360, rng() % 360, rng() % 360);
const Quaternion a(e);
const Quaternion b(e);
// Exercise and verify
Assert::IsFalse(a != b);
REQUIRE_FALSE(a != b);
}
return;
}
// Tests basic not-equals comparison -> true
TEST_METHOD(Basic_NotEqualsComparison_True)
TEST_CASE(__FILE__"/Basic_NotEqualsComparison_True", "[Quaternion]")
{
// Run tests 1000 times
for (std::size_t i = 0; i < 1000; i++)
{
// Setup
Vector3d ae(rng() % 360, rng() % 360, rng() % 360);
Vector3d be(rng() % 360, rng() % 360, rng() % 360);
const Vector3d ae(rng() % 360, rng() % 360, rng() % 360);
const Vector3d be(rng() % 360, rng() % 360, rng() % 360);
// Abort if both vectors are equal
if (ae == be)
@ -296,14 +283,12 @@ namespace TransformRelated
continue;
}
Quaternion a(ae);
Quaternion b(be);
const Quaternion a(ae);
const Quaternion b(be);
// Exercise and verify
Assert::IsTrue(a != b);
REQUIRE(a != b);
}
return;
}
};
}