j3ml autodoc test

tests/CMakeLists.txt

@@ -0,0 +1,19 @@
+include(FetchContent)
+
+FetchContent_Declare(
+        googletest
+        GIT_REPOSITORY https://github.com/google/googletest.git
+        GIT_TAG        release-1.11.0
+)
+FetchContent_MakeAvailable(googletest)
+add_library(GTest::GTest INTERFACE IMPORTED)
+target_link_libraries(GTest::GTest INTERFACE gtest_main)
+
+
+file(GLOB_RECURSE TEST_SRC "tests.cpp" "*.cpp")
+add_executable(Test ${TEST_SRC})
+target_link_libraries(Test PUBLIC J3ML)
+#find_package(GTest REQUIRED)
+target_link_libraries(Test PRIVATE GTest::GTest)
+include_directories("include")
+add_test(NAME "J3MLTestSuite" COMMAND Test)

tests/LinearAlgebra/EulerAngleTests.cpp

@@ -0,0 +1,3 @@
+//
+// Created by josh on 12/26/2023.
+//

tests/LinearAlgebra/Matrix2x2Tests.cpp

@@ -0,0 +1,3 @@
+//
+// Created by josh on 12/26/2023.
+//

tests/LinearAlgebra/QuaternionTests.cpp

@@ -0,0 +1,3 @@
+//
+// Created by josh on 12/26/2023.
+//

tests/LinearAlgebra/Vector2Tests.cpp

@@ -0,0 +1,183 @@
+#include <gtest/gtest.h>
+#include <J3ML/LinearAlgebra/Vector2.h>
+
+using J3ML::LinearAlgebra::Vector2;
+
+TEST(Vector2Test, V2_Constructor_Default)
+{
+    EXPECT_EQ(Vector2(), Vector2::Zero);
+}
+
+TEST(Vector2Test, V2_Constructor_XY)
+{
+    Vector2 vec {1, 0};
+    EXPECT_EQ(vec, Vector2::Right);
+}
+
+TEST(Vector2Test, V2_Addition_Op)
+{
+    Vector2 A {1,1};
+    Vector2 B {2,2};
+
+    Vector2 C {3, 3};
+
+    EXPECT_EQ(A+B, C);
+}
+
+TEST(Vector2Test, V2_Addition_Method)
+{
+    Vector2 A {2,2};
+    Vector2 B {2,2};
+
+    Vector2 C {4, 4};
+
+    EXPECT_EQ(A.Add(B), C);
+}
+
+TEST(Vector2Test, V2_Addition_Static)
+{
+    Vector2 A {3, 3};
+    Vector2 B {2, 2};
+
+    Vector2 C {5, 5};
+
+    EXPECT_EQ(Vector2::Add(A, B), C);
+}
+
+TEST(Vector2Test, V2_Subtract_Op)
+{
+    Vector2 A {1,1};
+    Vector2 B {2,2};
+
+    Vector2 C {-1, -1};
+
+    EXPECT_EQ(A-B, C);
+}
+
+TEST(Vector2Test, V2_Subtract_Method)
+{
+    Vector2 A {1,1};
+    Vector2 B {2,2};
+
+    Vector2 C {-1, -1};
+
+    EXPECT_EQ(A.Sub(B), C);
+}
+
+TEST(Vector2Test, V2_Subtract_Static)
+{
+    Vector2 A {1,1};
+    Vector2 B {2,2};
+
+    Vector2 C {-1, -1};
+
+    EXPECT_EQ(Vector2::Sub(A, B), C);
+}
+
+TEST(Vector2Test, V2_Scalar_Multiplication)
+{
+    Vector2 A {5, 1};
+    float B = 0.5f;
+    Vector2 C = {2.5f, .5f};
+    EXPECT_EQ(A*B, C);
+}
+
+TEST(Vector2Test, V2_Size)
+{
+    EXPECT_EQ(sizeof(Vector2), 8);
+}
+
+TEST(Vector2Test, V2_NaN)
+{
+
+    EXPECT_NE(Vector2::Zero, Vector2::NaN);
+    EXPECT_NE(Vector2::Up, Vector2::NaN);
+    EXPECT_NE(Vector2::Left, Vector2::NaN);
+    EXPECT_NE(Vector2::Down, Vector2::NaN);
+    EXPECT_NE(Vector2::Right, Vector2::NaN);
+    EXPECT_NE(Vector2::NaN, Vector2::NaN);
+}
+
+TEST(Vector2Test, V2_MarginOfError)
+{
+    Vector2 A {2,2};
+    Vector2 B {1.85, 1.85};
+
+    EXPECT_TRUE(A.IsWithinMarginOfError(B, 0.5f));
+}
+
+TEST(Vector2Test, V2_Min)
+{
+    Vector2 A {2,2};
+    Vector2 B {1.85, 1.85};
+
+    EXPECT_EQ( Vector2::Min(A, B), B);
+}
+
+TEST(Vector2Test, V2_Max)
+{
+    Vector2 A {2,2};
+    Vector2 B {1.85, 1.85};
+
+    EXPECT_EQ( Vector2::Max(A, B), A);
+}
+
+TEST(Vector2Test, V2_Clamp)
+{
+    Vector2 Input{0, 20};
+
+    Vector2 Minimum { 2, 2};
+    Vector2 Maximum {16, 16};
+
+    Vector2 ExpectedResult {2, 16};
+
+    EXPECT_EQ(Input.Clamp(Minimum, Maximum), ExpectedResult);
+}
+
+TEST(Vector2Test, V2_DotProduct)
+{
+    // TODO: Equality
+    Vector2 A {2, 2};
+    Vector2 B {1, 1};
+    EXPECT_FLOAT_EQ(A.Dot(B), 1.f);
+}
+
+TEST(Vector2Test, V2_Project)
+{
+    Vector2 Base {1, 1};
+    Vector2 Projected {1, 1};
+
+    Vector2 ExpectedResult {0.5, 0.5};
+
+    EXPECT_EQ(Base.Project(Projected), ExpectedResult);
+}
+
+TEST(Vector2Test, V2_Normalize)
+{
+    Vector2 A{2, 0};
+    Vector2 B{1, 0};
+    EXPECT_EQ(A.Normalize(), B);
+}
+
+TEST(Vector2Test, V2_Lerp)
+{
+    Vector2 A {2,2};
+    Vector2 B {10, 10};
+    Vector2 C {6, 6};
+
+    EXPECT_EQ(A.Lerp(B, 0.f), A);
+    EXPECT_EQ(A.Lerp(B, 1.f), B);
+    EXPECT_EQ(A.Lerp(B, 0.5f), C);
+}
+
+TEST(Vector2Test, V2_AngleBetween)
+{
+    Vector2 A {0.5f, 0.5};
+    Vector2 B {0.5f, 0.1f};
+
+    A = A.Normalize();
+    B = B.Normalize();
+
+    // TODO: AngleBetween returns not a number
+    EXPECT_FLOAT_EQ(A.AngleBetween(B), 0.58800244);
+}

tests/LinearAlgebra/Vector3Tests.cpp

@@ -0,0 +1,198 @@
+#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 = 1;
+
+    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.Normalize(), 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.Normalize();
+    B = B.Normalize();
+    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);
+}

tests/LinearAlgebra/Vector4Tests.cpp

@@ -0,0 +1,106 @@
+#include <gtest/gtest.h>
+#include <J3ML/LinearAlgebra/Vector4.h>
+
+using Vector4 = J3ML::LinearAlgebra::Vector4;
+
+
+void EXPECT_V4_EQ(const Vector4& lhs, const Vector4& rhs)
+{
+
+}
+
+TEST(Vector4Test, V4_Constructor_Default)
+{
+    EXPECT_V4_EQ(Vector4(), Vector4::Zero);
+}
+
+TEST(Vector4Test, V4_Constructor_XYZW)
+{
+    Vector4 Input {0, 1, 0, 1};
+    EXPECT_FLOAT_EQ(Input.x, 0);
+    EXPECT_FLOAT_EQ(Input.y, 1);
+    EXPECT_FLOAT_EQ(Input.z, 0);
+    EXPECT_FLOAT_EQ(Input.w, 1);
+}
+
+TEST(Vector4Test, V4_Addition_Op) {
+    Vector4 A {1, 1, 1, 1};
+    Vector4 B {2, 2, 2, 2};
+
+    Vector4 ExpectedResult {3, 3, 3, 3};
+
+    EXPECT_V4_EQ(A + B, ExpectedResult);
+}
+
+TEST(Vector4Test, V4_Addition_Method)
+{
+
+}
+
+TEST(Vector4Test, V4_Addition_Static)
+{
+
+}
+
+TEST(Vector4Test, V4_Subtract_Op)
+{
+
+}
+
+TEST(Vector4Test, V4_Subtract_Method)
+{
+
+}
+
+TEST(Vector4Test, V4_Subtract_Static)
+{
+
+}
+
+TEST(Vector4Test, V4_Scalar_Mult_Op)
+{
+
+}
+
+TEST(Vector4Test, V4_Scalar_Mult_Method)
+{
+
+}
+
+TEST(Vector4Test, V4_Scalar_Mult_Static)
+{
+
+}
+
+TEST(Vector4Test, V4_Scalar_Div_Op)
+{
+
+}
+
+TEST(Vector4Test, V4_Scalar_Div_Method)
+{
+
+}
+
+TEST(Vector4Test, V4_Scalar_Div_Static)
+{
+
+}
+
+TEST(Vector4Test, V4_Sizeof)
+{
+
+}
+
+TEST(Vector4Test, V4_NaN)
+{
+
+}
+
+TEST(Vector4Tests, V4_Min) {}
+TEST(Vector4Tests, V4_Max) {}
+TEST(Vector4Tests, V4_Clamp) {}
+TEST(Vector4Tests, V4_DotProduct) {}
+TEST(Vector4Tests, V4_CrossProduct) {}
+TEST(Vector4Tests, V4_Project) {}
+TEST(Vector4Test, V4_Normalize) {}

tests/tests.cpp

@@ -0,0 +1,16 @@
+#include <gtest/gtest.h>
+
+
+GTEST_API_ int main(int argc, char** argv) {
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
+
+#ifdef __WIN32
+extern "C" {
+ int wmain(int argc, wchar_t* argv[])
+    {
+        return main(argc, reinterpret_cast<char **>(argv));
+    }
+};
+#endif