j3ml/tests/LinearAlgebra/Vector2Tests.hpp

#include <J3ML/LinearAlgebra/Vector2.h>

using J3ML::LinearAlgebra::Vector2;

int Vector2Tests()
{
    TEST("Vector2::Ctor_Default", []
    {
        // TODO: implement check_eq
        jtest::check(Vector2() == Vector2::Zero);
    });

    TEST("Vector2::Ctor_XY", []
    {
        Vector2 vec (1, 0);
        // TODO: implement check_eq
        jtest::check(vec == Vector2::Right);
    });

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

        Vector2 C (3, 3);
        // TODO: implement check_eq
        jtest::check(A+B == C);
    });

    TEST("Vector2::Addition_Method", []
    {
        Vector2 A (2,2);
        Vector2 B (2,2);

        Vector2 C (4, 4);
        // TODO: implement check_eq
        jtest::check(A.Add(B) == C);
    });

    TEST("Vector2::Addition_Static", []
    {
        Vector2 A (3, 3);
        Vector2 B (2, 2);

        Vector2 C (5, 5);
        // TODO: implement check_eq
        jtest::check(Vector2::Add(A, B) == C);
    });

    TEST("Vector2::Subtract_Op", []
    {
        Vector2 A (1,1);
        Vector2 B (2,2);

        Vector2 C (-1, -1);

        jtest::check(A-B == C);
    });

    TEST("Vector2::Subtract_Method", []
    {
        Vector2 A (1,1);
        Vector2 B (2,2);

        Vector2 C (-1, -1);

        jtest::check(A.Sub(B) == C);
    });

    TEST("Vector2::Subtract_Static", []
    {
        Vector2 A (1,1);
        Vector2 B (2,2);

        Vector2 C (-1, -1);

        jtest::check(Vector2::Sub(A, B) == C);
    });

    TEST("Vector2::Scalar_Multiplication", []
    {
        Vector2 A (5, 1);
        float B = 0.5f;
        Vector2 C (2.5f, .5f);
        jtest::check(A*B == C);
    });

    TEST("Vector2::Size", []
    {
        jtest::check(sizeof(Vector2) == 8);
    });

    TEST("Vector2::NaN", []
    {

        jtest::check(Vector2::Zero != Vector2::NaN);
        jtest::check(Vector2::Up != Vector2::NaN);
        jtest::check(Vector2::Left != Vector2::NaN);
        jtest::check(Vector2::Down != Vector2::NaN);
        jtest::check(Vector2::Right != Vector2::NaN);
        jtest::check(Vector2::NaN != Vector2::NaN);
    });

    TEST("Vector2::MarginOfError", []
    {
        Vector2 A (2,2);
        Vector2 B (1.85, 1.85);

        jtest::check(A.IsWithinMarginOfError(B, 0.5f));
    });

    TEST("Vector2::Min", []
    {
        Vector2 A (2,2);
        Vector2 B (1.85, 1.85);

        jtest::check( Vector2::Min(A, B) == B);
    });

    TEST("Vector2::Max", []
    {
        Vector2 A (2,2);
        Vector2 B (1.85, 1.85);

        jtest::check( Vector2::Max(A, B) == A);
    });

    TEST("Vector2::Clamp", []
    {
        Vector2 Input (0, 20);

        Vector2 Minimum ( 2, 2);
        Vector2 Maximum (16, 16);

        Vector2 ExpectedResult (2, 16);

        jtest::check(Input.Clamp(Minimum, Maximum) == ExpectedResult);
    });

    TEST("Vector2::DotProduct", []
    {

        Vector2 A (2, 2);
        Vector2 B (1, 1);
        jtest::check(A.Dot(B) == 4.f);
    });

    TEST("Vector2::Project", []
    {
        Vector2 Base (4, 4);
        Vector2 Projected (1, 0);

        Vector2 ExpectedResult (4, 0);

        jtest::check(Base.Project(Projected) == ExpectedResult);
    });

    TEST("Vector2::Normalize", []
    {
        Vector2 A(2, 0);
        Vector2 B(1, 0);
        jtest::check(A.Normalized() == B);
    });

    TEST("Vector2::Lerp", []
    {
        Vector2 A (2,2);
        Vector2 B (10, 10);
        Vector2 C (6, 6);

        jtest::check(A.Lerp(B, 0.f) == A);
        jtest::check(A.Lerp(B, 1.f) == B);
        jtest::check(A.Lerp(B, 0.5f) == C);
    });

    TEST("Vector2::AngleBetween", []
    {
        Vector2 A (0.5f, 0.5);
        Vector2 B (0.5f, 0.1f);

        A = A.Normalized();
        B = B.Normalized();

        // TODO: AngleBetween returns not a number
        // TODO: implement jtest::check_float_eq
        jtest::check(A.AngleBetween(B) == 0.58800244);
    });

    return 0;
}