j3ml/tests/LinearAlgebra/Vector3Tests.cpp

#include <gtest/gtest.h>
#include <J3ML/LinearAlgebra/Vector3.h>

using J3ML::LinearAlgebra::Vector3;

void EXPECT_V3_EQ(const Vector3& lhs, const Vector3& rhs)
{
    EXPECT_FLOAT_EQ(lhs.x, rhs.x);
    EXPECT_FLOAT_EQ(lhs.y, rhs.y);
    EXPECT_FLOAT_EQ(lhs.z, rhs.z);
}

TEST(Vector3Test, V3_Constructor_Default)
{
    EXPECT_V3_EQ(Vector3(), Vector3::Zero);
}

TEST(Vector3Test, V3_Constructor_XYZ)
{
    Vector3 Input {0, 1, 0};

    EXPECT_V3_EQ(Input, Vector3::Down);
}

TEST(Vector3Test, V3_Addition_Op) {
    Vector3 A {1,1,1};
    Vector3 B {2,2,2};

    Vector3 ExpectedResult {3,3,3};

    EXPECT_V3_EQ(A + B, ExpectedResult);
}
TEST(Vector3Test, V3_Addition_Method) {
    Vector3 A {1,1,1};
    Vector3 B {2,2,2};

    Vector3 ExpectedResult {3,3,3};

    EXPECT_V3_EQ(A.Add(B), ExpectedResult);
}
TEST(Vector3Test, V3_Addition_Static) {
    Vector3 A {1,1,1};
    Vector3 B {3,3,3};

    Vector3 ExpectedResult {4,4,4};

    EXPECT_V3_EQ(Vector3::Add(A, B), ExpectedResult);
}
TEST(Vector3Test, V3_Subtract_Op) {
    Vector3 A {2,2,2};
    Vector3 B {.5f, .5f, .5f};

    Vector3 ExpectedResult {1.5f, 1.5f, 1.5f};

    EXPECT_V3_EQ(A - B, ExpectedResult);
}
TEST(Vector3Test, V3_Subtract_Method) {
    Vector3 A {3,3,3};
    Vector3 B {1,1,1};

    Vector3 ExpectedResult {2,2,2};

    EXPECT_V3_EQ(A.Sub(B), ExpectedResult);
}
TEST(Vector3Test, V3_Subtract_Static) {
    Vector3 A {4,4,4};
    Vector3 B {1,1,1};

    Vector3 ExpectedResult {3,3,3};

    EXPECT_V3_EQ(Vector3::Sub(A, B), ExpectedResult);
}
TEST(Vector3Test, V3_Scalar_Mult_Op) {
    Vector3 A { 1,1,1};
    float B = 1.5f;

    Vector3 ExpectedResult {1.5f, 1.5f, 1.5f};

    EXPECT_V3_EQ(A * B, ExpectedResult);
}
TEST(Vector3Test, V3_Scalar_Mult_Method) {
    Vector3 A {3,3,3};
    float B = 1.5f;

    Vector3 ExpectedResult {4.5f, 4.5f, 4.5f};

    EXPECT_V3_EQ(A.Mul(B), ExpectedResult);
}
TEST(Vector3Test, V3_Scalar_Mult_Static) {
    Vector3 A {2,2,2};
    float B = 1.5f;

    Vector3 ExpectedResult {3.f, 3.f, 3.f};

    EXPECT_V3_EQ(Vector3::Mul(A, B), ExpectedResult);
}
TEST(Vector3Test, V3_Scalar_Div_Op) {
    Vector3 A {4,4,4};
    float B = 2.f;

    Vector3 ExpectedResult {2,2,2};
    EXPECT_V3_EQ(A / B, ExpectedResult);
}
TEST(Vector3Test, V3_Scalar_Div_Method) {
    Vector3 A {6,6,6};
    float B = 2.f;
    Vector3 ExpectedResult { 3,3,3};

    EXPECT_V3_EQ(A.Div(B), ExpectedResult);
}
TEST(Vector3Test, V3_Scalar_Div_Static) {
    Vector3 A {3,3,3};
    float B = 1.5f;

    Vector3 ExpectedResult { 2.f, 2.f, 2.f};

    EXPECT_V3_EQ(Vector3::Div(A, B), ExpectedResult);
}
TEST(Vector3Test, V3_Sizeof) {
    EXPECT_EQ(sizeof(Vector3), 12);
}
TEST(Vector3Test, V3_NaN) {
    EXPECT_NE(Vector3(0, 0, 0), Vector3::NaN);

}
TEST(Vector3Test, V3_Min) {
    Vector3 Input {2,2,2};
    Vector3 Minimum {3,3,3};
    Vector3 ExpectedResult {2,2,2};

    EXPECT_V3_EQ(Input.Min(Minimum), ExpectedResult);
}
TEST(Vector3Test, V3_Max) {
    Vector3 Input {2,2,2};
    Vector3 Maximum {3,3,3};
    Vector3 ExpectedResult {3,3,3};

    EXPECT_V3_EQ(Input.Max(Maximum), ExpectedResult);
}
TEST(Vector3Test, V3_Clamp) {
    Vector3 Input {5,-1,8};
    Vector3 Minimum {1,1,1};
    Vector3 Maximum {5,5,5};

    Vector3 ExpectedResult {5,1,5};

    EXPECT_V3_EQ(Input.Clamp(Minimum, Maximum), ExpectedResult);

}
TEST(Vector3Test, V3_DotProduct) {
    Vector3 A{6,6,6};
    Vector3 B{1,1,1};


    float ExpectedResult = 18;

    EXPECT_FLOAT_EQ(A.Dot(B), ExpectedResult);
}
TEST(Vector3Test, V3_CrossProduct) {
    Vector3 A{1,1,1};
    Vector3 B{2,2,2};

    Vector3 ExpectedResult {0,0,0};

    EXPECT_V3_EQ(A.Cross(B), ExpectedResult);

}
TEST(Vector3Test, V3_Project) {
    Vector3 Base {};
    Vector3 Projection {};
    Vector3 ExpectedResult {};
}
TEST(Vector3Test, V3_Normalize) {
    Vector3 Input {2, 0, 0};
    Vector3 ExpectedResult {1, 0, 0};

    EXPECT_V3_EQ(Input.Normalized(), ExpectedResult);
}
TEST(Vector3Test, V3_Lerp)
{
    Vector3 Start {};
    Vector3 Finish {};
    float Percent = 50;
    Vector3 ExpectedResult {};
    EXPECT_V3_EQ(Start.Lerp(Finish, Percent), ExpectedResult);
}
TEST(Vector3Test, V3_AngleBetween) {
    using J3ML::LinearAlgebra::Angle2D;
    Vector3 A{ .5f, .5f, .5f};
    Vector3 B {.25f, .75f, .25f};
    A = A.Normalized();
    B = B.Normalized();
    Angle2D ExpectedResult {-0.69791365, -2.3561945};
    std::cout << A.AngleBetween(B).x << ", " << A.AngleBetween(B).y << "";
    auto angle = A.AngleBetween(B);
    EXPECT_FLOAT_EQ(angle.x, ExpectedResult.x);
    EXPECT_FLOAT_EQ(angle.y, ExpectedResult.y);
}