Merge pull request #3 from orange-cpp/u/orange-cpp/unit-tests

Added more unit tests

include/omath/Matrix.h

@@ -11,6 +11,7 @@ namespace omath
     class Matrix final
     {
     public:
+        Matrix();
         Matrix(size_t rows, size_t columns);
 
         Matrix(const std::initializer_list<std::initializer_list<float>>& rows);
@@ -99,8 +100,8 @@ namespace omath
         ~Matrix();
 
     private:
-        size_t m_rows = 0;
-        size_t m_columns = 0;
-        std::unique_ptr<float[]> m_data = nullptr;
+        size_t m_rows;
+        size_t m_columns;
+        std::unique_ptr<float[]> m_data;
     };
 }

include/omath/Vector4.h

@@ -13,7 +13,7 @@ namespace omath
         float w = 0.f;
 
         Vector4(const float x = 0.f, const float y = 0.f, const float z = 0.f, const float w = 0.f) : Vector3(x, y, z), w(w) {}
-        Vector4() = default;
+        Vector4();
 
         [[nodiscard]]
         bool operator==(const Vector4& src) const;

include/omath/color.h

@@ -21,11 +21,11 @@ namespace omath::color
     [[nodiscard]]
     Vector3 Blend(const Vector3& first, const Vector3& second, float ratio);
 
-    class Color : public Vector4
+    class Color final : public Vector4
     {
         public:
             Color(float r, float g, float b, float a);
-
+            explicit Color();
             [[nodiscard]]
             static Color FromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
 

source/Vector4.cpp

@@ -131,4 +131,11 @@ namespace omath
     {
         return x + y + z + w;
     }
+
+    Vector4::Vector4()
+    {
+        x = 0.f;
+        y = 0.f;
+        z = 0.f;
+    }
 }

source/color.cpp

@@ -95,4 +95,9 @@ namespace omath::color
 
         return hsvData;
     }
+
+    Color::Color() : Vector4(0.f, 0.f, 0.f, 0.f)
+    {
+
+    }
 }

source/matrix.cpp

@@ -83,6 +83,10 @@ namespace omath
         m_columns = other.m_columns;
         m_data = std::move(other.m_data);
 
+        other.m_rows = 0;
+        other.m_columns = 0;
+
+        other.m_data = nullptr;
     }
 
     size_t Matrix::ColumnsCount() const noexcept
@@ -196,6 +200,9 @@ namespace omath
         m_columns = other.m_columns;
         m_data = std::move(other.m_data);
 
+        other.m_rows = 0.f;
+        other.m_columns = 0.f;
+
         return *this;
 
     }
@@ -357,7 +364,7 @@ namespace omath
         };
     }
 
-    const float * Matrix::Raw() const
+    const float* Matrix::Raw() const
     {
         return m_data.get();
     }
@@ -367,4 +374,11 @@ namespace omath
         for (size_t i = 0; i < m_columns*m_rows; ++i)
             At(i / m_rows, i % m_columns) = pRawMatrix[i];
     }
+
+    Matrix::Matrix()
+    {
+        m_columns = 0;
+        m_rows = 0;
+        m_data = nullptr;
+    }
 }

tests/CMakeLists.txt

@@ -2,10 +2,15 @@ enable_testing()
 
 project(unit-tests)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}")
-file(GLOB TEST_SRC_FILES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
 
 include(GoogleTest)
-add_executable(unit-tests UnitTestPrediction.cpp UnitTestMatrix.cpp UnitTestAstar.cpp UnitTestProjection.cpp)
+add_executable(unit-tests
+        UnitTestPrediction.cpp
+        UnitTestMatrix.cpp
+        UnitTestAstar.cpp
+        UnitTestProjection.cpp
+        UnitTestVector3.cpp
+        UnitTestColor.cpp)
 
 target_link_libraries(unit-tests PRIVATE gtest gtest_main omath)
 

tests/UnitTestColor.cpp

@@ -0,0 +1,113 @@
+//
+// Created by Vlad on 01.09.2024.
+//
+#include <gtest/gtest.h>
+#include <omath/Color.h>
+
+
+using namespace omath::color;
+
+class UnitTestColor : public ::testing::Test
+{
+protected:
+    Color color1;
+    Color color2;
+
+    void SetUp() override
+    {
+        color1 = Color::Red();
+        color2 = Color::Green();
+    }
+};
+
+// Test constructors
+TEST_F(UnitTestColor, Constructor_Float)
+{
+    Color color(0.5f, 0.5f, 0.5f, 1.0f);
+    EXPECT_FLOAT_EQ(color.x, 0.5f);
+    EXPECT_FLOAT_EQ(color.y, 0.5f);
+    EXPECT_FLOAT_EQ(color.z, 0.5f);
+    EXPECT_FLOAT_EQ(color.w, 1.0f);
+}
+
+TEST_F(UnitTestColor, Constructor_Vector4)
+{
+    omath::Vector4 vec(0.2f, 0.4f, 0.6f, 0.8f);
+    Color color(vec);
+    EXPECT_FLOAT_EQ(color.x, 0.2f);
+    EXPECT_FLOAT_EQ(color.y, 0.4f);
+    EXPECT_FLOAT_EQ(color.z, 0.6f);
+    EXPECT_FLOAT_EQ(color.w, 0.8f);
+}
+
+// Test static methods for color creation
+TEST_F(UnitTestColor, FromRGBA)
+{
+    Color color = Color::FromRGBA(128, 64, 32, 255);
+    EXPECT_FLOAT_EQ(color.x, 128.0f / 255.0f);
+    EXPECT_FLOAT_EQ(color.y, 64.0f / 255.0f);
+    EXPECT_FLOAT_EQ(color.z, 32.0f / 255.0f);
+    EXPECT_FLOAT_EQ(color.w, 1.0f);
+}
+
+TEST_F(UnitTestColor, FromHSV)
+{
+    Color color = Color::FromHSV(0.0f, 1.0f, 1.0f); // Red in HSV
+    EXPECT_FLOAT_EQ(color.x, 1.0f);
+    EXPECT_FLOAT_EQ(color.y, 0.0f);
+    EXPECT_FLOAT_EQ(color.z, 0.0f);
+    EXPECT_FLOAT_EQ(color.w, 1.0f);
+}
+
+// Test HSV conversion
+TEST_F(UnitTestColor, ToHSV)
+{
+    HSV hsv = color1.ToHSV(); // Red color
+    EXPECT_FLOAT_EQ(hsv.m_hue, 0.0f);
+    EXPECT_FLOAT_EQ(hsv.m_saturation, 1.0f);
+    EXPECT_FLOAT_EQ(hsv.m_value, 1.0f);
+}
+
+// Test color blending
+TEST_F(UnitTestColor, Blend)
+{
+    Color blended = color1.Blend(color2, 0.5f);
+    EXPECT_FLOAT_EQ(blended.x, 0.5f);
+    EXPECT_FLOAT_EQ(blended.y, 0.5f);
+    EXPECT_FLOAT_EQ(blended.z, 0.0f);
+    EXPECT_FLOAT_EQ(blended.w, 1.0f);
+}
+
+// Test predefined colors
+TEST_F(UnitTestColor, PredefinedColors)
+{
+    Color red = Color::Red();
+    Color green = Color::Green();
+    Color blue = Color::Blue();
+
+    EXPECT_FLOAT_EQ(red.x, 1.0f);
+    EXPECT_FLOAT_EQ(red.y, 0.0f);
+    EXPECT_FLOAT_EQ(red.z, 0.0f);
+    EXPECT_FLOAT_EQ(red.w, 1.0f);
+
+    EXPECT_FLOAT_EQ(green.x, 0.0f);
+    EXPECT_FLOAT_EQ(green.y, 1.0f);
+    EXPECT_FLOAT_EQ(green.z, 0.0f);
+    EXPECT_FLOAT_EQ(green.w, 1.0f);
+
+    EXPECT_FLOAT_EQ(blue.x, 0.0f);
+    EXPECT_FLOAT_EQ(blue.y, 0.0f);
+    EXPECT_FLOAT_EQ(blue.z, 1.0f);
+    EXPECT_FLOAT_EQ(blue.w, 1.0f);
+}
+
+// Test non-member function: Blend for Vector3
+TEST_F(UnitTestColor, BlendVector3)
+{
+    omath::Vector3 v1(1.0f, 0.0f, 0.0f); // Red
+    omath::Vector3 v2(0.0f, 1.0f, 0.0f); // Green
+    omath::Vector3 blended = Blend(v1, v2, 0.5f);
+    EXPECT_FLOAT_EQ(blended.x, 0.5f);
+    EXPECT_FLOAT_EQ(blended.y, 0.5f);
+    EXPECT_FLOAT_EQ(blended.z, 0.0f);
+}

tests/UnitTestMatrix.cpp

@@ -3,15 +3,179 @@
 //
 #include <gtest/gtest.h>
 #include <omath/Matrix.h>
-#include <print>
+#include "omath/Vector3.h"
+
+using namespace omath;
 
 
-TEST(UnitTestMatrix, ToString)
+class UnitTestMatrix : public ::testing::Test
 {
-    omath::Matrix matrix(2, 2);
-    matrix.Set(1.1);
-    const auto str = matrix.ToSrtring();
+protected:
+    Matrix m1;
+    Matrix m2;
 
-    std::cout << str;
+    void SetUp() override {
+        m1 = Matrix(2, 2);
+        m2 = Matrix{{1.0f, 2.0f}, {3.0f, 4.0f}};
+    }
+};
 
+// Test constructors
+TEST_F(UnitTestMatrix, Constructor_Size)
+{
+    Matrix m(3, 3);
+    EXPECT_EQ(m.RowCount(), 3);
+    EXPECT_EQ(m.ColumnsCount(), 3);
+}
+
+TEST_F(UnitTestMatrix, Constructor_InitializerList)
+{
+    Matrix m{{1.0f, 2.0f}, {3.0f, 4.0f}};
+    EXPECT_EQ(m.RowCount(), 2);
+    EXPECT_EQ(m.ColumnsCount(), 2);
+    EXPECT_FLOAT_EQ(m.At(0, 0), 1.0f);
+    EXPECT_FLOAT_EQ(m.At(1, 1), 4.0f);
+}
+
+TEST_F(UnitTestMatrix, Constructor_Copy)
+{
+    Matrix m3 = m2;
+    EXPECT_EQ(m3.RowCount(), m2.RowCount());
+    EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
+    EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
+}
+
+TEST_F(UnitTestMatrix, Constructor_Move)
+{
+    Matrix m3 = std::move(m2);
+    EXPECT_EQ(m3.RowCount(), 2);
+    EXPECT_EQ(m3.ColumnsCount(), 2);
+    EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
+    EXPECT_EQ(m2.RowCount(), 0);  // m2 should be empty after the move
+    EXPECT_EQ(m2.ColumnsCount(), 0);
+}
+
+// Test matrix operations
+TEST_F(UnitTestMatrix, Operator_Multiplication_Matrix)
+{
+    Matrix m3 = m2 * m2;
+    EXPECT_EQ(m3.RowCount(), 2);
+    EXPECT_EQ(m3.ColumnsCount(), 2);
+    EXPECT_FLOAT_EQ(m3.At(0, 0), 7.0f);
+    EXPECT_FLOAT_EQ(m3.At(1, 1), 22.0f);
+}
+
+TEST_F(UnitTestMatrix, Operator_Multiplication_Vector3)
+{
+    Vector3 v(1.0f, 2.0f, 3.0f);
+    Matrix m3(3, 3, new float[9]{1, 0, 0, 0, 1, 0, 0, 0, 1});
+    Matrix result = m3 * v;
+
+    EXPECT_FLOAT_EQ(result.At(0, 0), 1.0f);
+    EXPECT_FLOAT_EQ(result.At(1, 0), 2.0f);
+    EXPECT_FLOAT_EQ(result.At(2, 0), 3.0f);
+}
+
+TEST_F(UnitTestMatrix, Operator_Multiplication_Scalar)
+{
+    Matrix m3 = m2 * 2.0f;
+    EXPECT_FLOAT_EQ(m3.At(0, 0), 2.0f);
+    EXPECT_FLOAT_EQ(m3.At(1, 1), 8.0f);
+}
+
+TEST_F(UnitTestMatrix, Operator_Division_Scalar)
+{
+    Matrix m3 = m2 / 2.0f;
+    EXPECT_FLOAT_EQ(m3.At(0, 0), 0.5f);
+    EXPECT_FLOAT_EQ(m3.At(1, 1), 2.0f);
+}
+
+// Test matrix functions
+TEST_F(UnitTestMatrix, Transpose)
+{
+    Matrix m3 = m2.Transpose();
+    EXPECT_FLOAT_EQ(m3.At(0, 1), 3.0f);
+    EXPECT_FLOAT_EQ(m3.At(1, 0), 2.0f);
+}
+
+TEST_F(UnitTestMatrix, Determinant)
+{
+    float det = m2.Determinant();
+    EXPECT_FLOAT_EQ(det, -2.0f);
+}
+
+TEST_F(UnitTestMatrix, Minor)
+{
+    float minor = m2.Minor(0, 0);
+    EXPECT_FLOAT_EQ(minor, 4.0f);
+}
+
+TEST_F(UnitTestMatrix, AlgComplement)
+{
+    float algComp = m2.AlgComplement(0, 0);
+    EXPECT_FLOAT_EQ(algComp, 4.0f);
+}
+
+TEST_F(UnitTestMatrix, Strip)
+{
+    Matrix m3 = m2.Strip(0, 0);
+    EXPECT_EQ(m3.RowCount(), 1);
+    EXPECT_EQ(m3.ColumnsCount(), 1);
+    EXPECT_FLOAT_EQ(m3.At(0, 0), 4.0f);
+}
+
+TEST_F(UnitTestMatrix, ProjectionMatrix)
+{
+    Matrix proj = Matrix::ProjectionMatrix(45.0f, 1.33f, 0.1f, 100.0f);
+    EXPECT_EQ(proj.RowCount(), 4);
+    EXPECT_EQ(proj.ColumnsCount(), 4);
+    // Further checks on projection matrix elements could be added
+}
+
+// Test other member functions
+TEST_F(UnitTestMatrix, Set)
+{
+    m1.Set(3.0f);
+    EXPECT_FLOAT_EQ(m1.At(0, 0), 3.0f);
+    EXPECT_FLOAT_EQ(m1.At(1, 1), 3.0f);
+}
+
+TEST_F(UnitTestMatrix, Sum)
+{
+    float sum = m2.Sum();
+    EXPECT_FLOAT_EQ(sum, 10.0f);
+}
+
+TEST_F(UnitTestMatrix, Clear)
+{
+    m2.Clear();
+    EXPECT_FLOAT_EQ(m2.At(0, 0), 0.0f);
+    EXPECT_FLOAT_EQ(m2.At(1, 1), 0.0f);
+}
+
+TEST_F(UnitTestMatrix, ToString)
+{
+    std::string str = m2.ToSrtring();
+    EXPECT_FALSE(str.empty());
+}
+
+// Test assignment operators
+TEST_F(UnitTestMatrix, AssignmentOperator_Copy)
+{
+    Matrix m3(2, 2);
+    m3 = m2;
+    EXPECT_EQ(m3.RowCount(), m2.RowCount());
+    EXPECT_EQ(m3.ColumnsCount(), m2.ColumnsCount());
+    EXPECT_FLOAT_EQ(m3.At(0, 0), m2.At(0, 0));
+}
+
+TEST_F(UnitTestMatrix, AssignmentOperator_Move)
+{
+    Matrix m3(2, 2);
+    m3 = std::move(m2);
+    EXPECT_EQ(m3.RowCount(), 2);
+    EXPECT_EQ(m3.ColumnsCount(), 2);
+    EXPECT_FLOAT_EQ(m3.At(0, 0), 1.0f);
+    EXPECT_EQ(m2.RowCount(), 0);  // m2 should be empty after the move
+    EXPECT_EQ(m2.ColumnsCount(), 0);
 }

tests/UnitTestProjection.cpp

@@ -12,7 +12,5 @@ TEST(UnitTestProjection, IsPointOnScreen)
     const omath::projection::Camera camera({0.f, 0.f, 0.f}, {0, 0.f, 0.f} , {1920.f, 1080.f}, 110.f, 0.1f, 500.f);
 
     const auto proj = camera.WorldToScreen({100, 0, 15});
-    if (proj)
-        std::print("{} {}", proj->x, proj->y);
     EXPECT_TRUE(proj.has_value());
 }

tests/UnitTestVector3.cpp

@@ -0,0 +1,263 @@
+//
+// Created by Vlad on 01.09.2024.
+//
+#include <gtest/gtest.h>
+#include <omath/Vector3.h>
+
+using namespace omath;
+
+class UnitTestVector3 : public ::testing::Test
+{
+protected:
+    Vector3 v1;
+    Vector3 v2;
+
+    void SetUp() override
+    {
+        v1 = Vector3(1.0f, 2.0f, 3.0f);
+        v2 = Vector3(4.0f, 5.0f, 6.0f);
+    }
+};
+
+// Test constructor and default values
+TEST_F(UnitTestVector3, Constructor_Default)
+{
+    Vector3 v;
+    EXPECT_FLOAT_EQ(v.x, 0.0f);
+    EXPECT_FLOAT_EQ(v.y, 0.0f);
+    EXPECT_FLOAT_EQ(v.z, 0.0f);
+}
+
+TEST_F(UnitTestVector3, Constructor_Values)
+{
+    Vector3 v(1.0f, 2.0f, 3.0f);
+    EXPECT_FLOAT_EQ(v.x, 1.0f);
+    EXPECT_FLOAT_EQ(v.y, 2.0f);
+    EXPECT_FLOAT_EQ(v.z, 3.0f);
+}
+
+// Test equality operators
+TEST_F(UnitTestVector3, EqualityOperator)
+{
+    Vector3 v3(1.0f, 2.0f, 3.0f);
+    EXPECT_TRUE(v1 == v3);
+    EXPECT_FALSE(v1 == v2);
+}
+
+TEST_F(UnitTestVector3, InequalityOperator)
+{
+    Vector3 v3(1.0f, 2.0f, 3.0f);
+    EXPECT_FALSE(v1 != v3);
+    EXPECT_TRUE(v1 != v2);
+}
+
+// Test arithmetic operators
+TEST_F(UnitTestVector3, AdditionOperator)
+{
+    Vector3 v3 = v1 + v2;
+    EXPECT_FLOAT_EQ(v3.x, 5.0f);
+    EXPECT_FLOAT_EQ(v3.y, 7.0f);
+    EXPECT_FLOAT_EQ(v3.z, 9.0f);
+}
+
+TEST_F(UnitTestVector3, SubtractionOperator)
+{
+    Vector3 v3 = v2 - v1;
+    EXPECT_FLOAT_EQ(v3.x, 3.0f);
+    EXPECT_FLOAT_EQ(v3.y, 3.0f);
+    EXPECT_FLOAT_EQ(v3.z, 3.0f);
+}
+
+TEST_F(UnitTestVector3, MultiplicationOperator)
+{
+    Vector3 v3 = v1 * 2.0f;
+    EXPECT_FLOAT_EQ(v3.x, 2.0f);
+    EXPECT_FLOAT_EQ(v3.y, 4.0f);
+    EXPECT_FLOAT_EQ(v3.z, 6.0f);
+}
+
+TEST_F(UnitTestVector3, MultiplicationWithVectorOperator)
+{
+    Vector3 v3 = v1 * v2;
+    EXPECT_FLOAT_EQ(v3.x, 4.0f);
+    EXPECT_FLOAT_EQ(v3.y, 10.0f);
+    EXPECT_FLOAT_EQ(v3.z, 18.0f);
+}
+
+TEST_F(UnitTestVector3, DivisionOperator)
+{
+    Vector3 v3 = v2 / 2.0f;
+    EXPECT_FLOAT_EQ(v3.x, 2.0f);
+    EXPECT_FLOAT_EQ(v3.y, 2.5f);
+    EXPECT_FLOAT_EQ(v3.z, 3.0f);
+}
+
+TEST_F(UnitTestVector3, DivisionWithVectorOperator)
+{
+    Vector3 v3 = v2 / v1;
+    EXPECT_FLOAT_EQ(v3.x, 4.0f);
+    EXPECT_FLOAT_EQ(v3.y, 2.5f);
+    EXPECT_FLOAT_EQ(v3.z, 2.0f);
+}
+
+// Test compound assignment operators
+TEST_F(UnitTestVector3, AdditionAssignmentOperator)
+{
+    v1 += v2;
+    EXPECT_FLOAT_EQ(v1.x, 5.0f);
+    EXPECT_FLOAT_EQ(v1.y, 7.0f);
+    EXPECT_FLOAT_EQ(v1.z, 9.0f);
+}
+
+TEST_F(UnitTestVector3, SubtractionAssignmentOperator)
+{
+    v1 -= v2;
+    EXPECT_FLOAT_EQ(v1.x, -3.0f);
+    EXPECT_FLOAT_EQ(v1.y, -3.0f);
+    EXPECT_FLOAT_EQ(v1.z, -3.0f);
+}
+
+TEST_F(UnitTestVector3, MultiplicationAssignmentOperator)
+{
+    v1 *= 2.0f;
+    EXPECT_FLOAT_EQ(v1.x, 2.0f);
+    EXPECT_FLOAT_EQ(v1.y, 4.0f);
+    EXPECT_FLOAT_EQ(v1.z, 6.0f);
+}
+
+TEST_F(UnitTestVector3, MultiplicationWithVectorAssignmentOperator)
+{
+    v1 *= v2;
+    EXPECT_FLOAT_EQ(v1.x, 4.0f);
+    EXPECT_FLOAT_EQ(v1.y, 10.0f);
+    EXPECT_FLOAT_EQ(v1.z, 18.0f);
+}
+
+TEST_F(UnitTestVector3, DivisionAssignmentOperator)
+{
+    v1 /= 2.0f;
+    EXPECT_FLOAT_EQ(v1.x, 0.5f);
+    EXPECT_FLOAT_EQ(v1.y, 1.0f);
+    EXPECT_FLOAT_EQ(v1.z, 1.5f);
+}
+
+TEST_F(UnitTestVector3, DivisionWithVectorAssignmentOperator)
+{
+    v1 /= v2;
+    EXPECT_FLOAT_EQ(v1.x, 0.25f);
+    EXPECT_FLOAT_EQ(v1.y, 0.4f);
+    EXPECT_FLOAT_EQ(v1.z, 0.5f);
+}
+
+TEST_F(UnitTestVector3, NegationOperator)
+{
+    Vector3 v3 = -v1;
+    EXPECT_FLOAT_EQ(v3.x, -1.0f);
+    EXPECT_FLOAT_EQ(v3.y, -2.0f);
+    EXPECT_FLOAT_EQ(v3.z, -3.0f);
+}
+
+// Test other member functions
+TEST_F(UnitTestVector3, DistTo)
+{
+    float dist = v1.DistTo(v2);
+    EXPECT_FLOAT_EQ(dist, sqrt(27.0f));
+}
+
+TEST_F(UnitTestVector3, DistToSqr)
+{
+    float distSqr = v1.DistToSqr(v2);
+    EXPECT_FLOAT_EQ(distSqr, 27.0f);
+}
+
+TEST_F(UnitTestVector3, DotProduct)
+{
+    float dot = v1.Dot(v2);
+    EXPECT_FLOAT_EQ(dot, 32.0f);
+}
+
+TEST_F(UnitTestVector3, CrossProduct)
+{
+    Vector3 v3 = v1.Cross(v2);
+    EXPECT_FLOAT_EQ(v3.x, -3.0f);
+    EXPECT_FLOAT_EQ(v3.y, 6.0f);
+    EXPECT_FLOAT_EQ(v3.z, -3.0f);
+}
+
+TEST_F(UnitTestVector3, Length)
+{
+    float length = v1.Length();
+    EXPECT_FLOAT_EQ(length, sqrt(14.0f));
+}
+
+TEST_F(UnitTestVector3, LengthSqr)
+{
+    float lengthSqr = v1.LengthSqr();
+    EXPECT_FLOAT_EQ(lengthSqr, 14.0f);
+}
+
+TEST_F(UnitTestVector3, Length2D)
+{
+    float length2D = v1.Length2D();
+    EXPECT_FLOAT_EQ(length2D, sqrt(5.0f));
+}
+
+TEST_F(UnitTestVector3, Abs)
+{
+    Vector3 v3(-1.0f, -2.0f, -3.0f);
+    v3.Abs();
+    EXPECT_FLOAT_EQ(v3.x, 1.0f);
+    EXPECT_FLOAT_EQ(v3.y, 2.0f);
+    EXPECT_FLOAT_EQ(v3.z, 3.0f);
+}
+
+TEST_F(UnitTestVector3, Sum)
+{
+    float sum = v1.Sum();
+    EXPECT_FLOAT_EQ(sum, 6.0f);
+}
+
+TEST_F(UnitTestVector3, Sum2D)
+{
+    float sum2D = v1.Sum2D();
+    EXPECT_FLOAT_EQ(sum2D, 3.0f);
+}
+
+TEST_F(UnitTestVector3, ViewAngleTo)
+{
+    Vector3 angle = v1.ViewAngleTo(v1 + Vector3(0.f, 0.f, 5.f));
+    EXPECT_NEAR(angle.x, 90.f, 0.01f);  // Approximate values, you can fine-tune the expected values
+    EXPECT_NEAR(angle.y, 0.f, 0.01f);
+}
+
+TEST_F(UnitTestVector3, ForwardVector)
+{
+    Vector3 forward = Vector3::ForwardVector(0.0f, 0.0f);
+    EXPECT_FLOAT_EQ(forward.x, 1.0f);
+    EXPECT_FLOAT_EQ(forward.y, 0.0f);
+    EXPECT_FLOAT_EQ(forward.z, 0.0f);
+}
+
+TEST_F(UnitTestVector3, RightVector)
+{
+    Vector3 right = Vector3::RightVector(0.0f, 0.0f, 0.0f);
+    EXPECT_FLOAT_EQ(right.x, 0.0f);
+    EXPECT_FLOAT_EQ(right.y, -1.0f);
+    EXPECT_FLOAT_EQ(right.z, 0.0f);
+}
+
+TEST_F(UnitTestVector3, UpVector)
+{
+    Vector3 up = Vector3::UpVector(0.f, 0.0f, 0.0f);
+    EXPECT_FLOAT_EQ(up.x, 0.0f);
+    EXPECT_FLOAT_EQ(up.y, 0.0f);
+    EXPECT_FLOAT_EQ(up.z, 1.0f);
+}
+
+TEST_F(UnitTestVector3, Normalized)
+{
+    Vector3 v3 = v1.Normalized();
+    EXPECT_NEAR(v3.x, 0.26726f, 0.0001f);
+    EXPECT_NEAR(v3.y, 0.53452f, 0.0001f);
+    EXPECT_NEAR(v3.z, 0.80178f, 0.0001f);
+}