j3ml/tests/LinearAlgebra/Vector3Tests.hpp

#include <J3ML/LinearAlgebra/Vector3.h>

using J3ML::LinearAlgebra::Vector3;

inline void EXPECT_V3_EQ(const Vector3& lhs, const Vector3& rhs)
{
    jtest::check(lhs.x == rhs.x);
    jtest::check(lhs.y == rhs.y);
    jtest::check(lhs.z == rhs.z);
}

int Vector3Tests() {
    TEST("Vector3::Ctor_Default", []
    {
        EXPECT_V3_EQ(Vector3(), Vector3::Zero);
    });

    TEST("Vector3::Ctor_XYZ", []
    {
        Vector3 Input (0, 1, 0);

        EXPECT_V3_EQ(Input, Vector3::Down);
    });

    TEST("Vector3::Addition_Op", [] {
        Vector3 A (1,1,1);
        Vector3 B (2,2,2);

        Vector3 ExpectedResult (3,3,3);

        EXPECT_V3_EQ(A + B, ExpectedResult);
    });

    TEST("Vector3::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("Vector3::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("Vector3::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("Vector3::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("Vector3::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("Vector3::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("Vector3::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("Vector3::Scalar_Div_Op", [] {
        Vector3 A (4,4,4);
        float B = 2.f;

        Vector3 ExpectedResult (2,2,2);
        EXPECT_V3_EQ(A / B, ExpectedResult);
    });
    TEST("Vector3::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("Vector3::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("Vector3::Sizeof", [] {
        jtest::check(sizeof(Vector3) == 12);
    });
    TEST("Vector3::NaN", [] {
        jtest::check(Vector3(0, 0, 0) != Vector3::NaN);

    });
    TEST("Vector3::Min", [] {
        Vector3 Input (2,2,2);
        Vector3 Minimum (3,3,3);
        Vector3 ExpectedResult (2,2,2);

        EXPECT_V3_EQ(Input.Min(Minimum), ExpectedResult);
    });
    TEST("Vector3::Max", [] {
        Vector3 Input (2,2,2);
        Vector3 Maximum (3,3,3);
        Vector3 ExpectedResult (3,3,3);

        EXPECT_V3_EQ(Input.Max(Maximum), ExpectedResult);
    });
    TEST("Vector3::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("Vector3::DotProduct", [] {
        Vector3 A(6,6,6);
        Vector3 B(1,1,1);


        float ExpectedResult = 18;

        // TODO: Add check_float_eq
        jtest::check(A.Dot(B) == ExpectedResult);
    });
    TEST("Vector3::CrossProduct", [] {
        Vector3 A(1,1,1);
        Vector3 B(2,2,2);

        Vector3 ExpectedResult (0,0,0);

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

    });
    TEST("Vector3::Project", [] {
        Vector3 Base;
        Vector3 Projection;
        Vector3 ExpectedResult;
    });
    TEST("Vector3::Normalize", [] {
        Vector3 Input (2, 0, 0);
        Vector3 ExpectedResult (1, 0, 0);

        EXPECT_V3_EQ(Input.Normalized(), ExpectedResult);
    });
    TEST("Vector3::Lerp", []
    {
        Vector3 Start;
        Vector3 Finish;
        float Percent = 50;
        Vector3 ExpectedResult;
        EXPECT_V3_EQ(Start.Lerp(Finish, Percent), ExpectedResult);
    });
    TEST("Vector3::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);

        jtest::check(angle.x == ExpectedResult.x);
        jtest::check(angle.y == ExpectedResult.y);
    });
    return 0;
}