Implementing Vector3 Unit Tests

tests/LinearAlgebra/Vector2Tests.cpp

@@ -24,7 +24,27 @@ TEST(Vector2Test, V2_Addition_Op)
     EXPECT_EQ(A+B, C);
 }
 
-TEST(Vector2Test, V2_Subtraction_Op)
+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};
@@ -34,6 +54,26 @@ TEST(Vector2Test, V2_Subtraction_Op)
     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};
@@ -84,20 +124,60 @@ TEST(Vector2Test, V2_Max)
 
 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

@@ -5,5 +5,123 @@ using Vector3 = LinearAlgebra::Vector3;
 
 TEST(Vector3Test, V3_Constructor_Default)
 {
+    EXPECT_EQ(Vector3(), Vector3::Zero);
+}
 
-}
+TEST(Vector3Test, V3_Constructor_XYZ)
+{
+    Vector3 Input {0, 1, 0};
+
+    EXPECT_EQ(Input, Vector3::Down);
+}
+
+TEST(Vector3Test, V3_Addition_Op) {
+    Vector3 A {};
+    Vector3 B {};
+
+    Vector3 ExpectedResult {};
+
+    EXPECT_EQ(A + B, ExpectedResult);
+}
+TEST(Vector3Test, V3_Addition_Method) {
+    Vector3 A {};
+    Vector3 B {};
+
+    Vector3 ExpectedResult {};
+
+    EXPECT_EQ(A.Add(B), ExpectedResult);
+}
+TEST(Vector3Test, V3_Addition_Static) {
+    Vector3 A {};
+    Vector3 B {};
+
+    Vector3 ExpectedResult {};
+
+    EXPECT_EQ(Vector3::Add(A, B), ExpectedResult);
+}
+TEST(Vector3Test, V3_Subtract_Op) {
+    Vector3 A {};
+    Vector3 B {};
+
+    Vector3 ExpectedResult {};
+
+    EXPECT_EQ(A - B, ExpectedResult);
+}
+TEST(Vector3Test, V3_Subtract_Method) {
+    Vector3 A {};
+    Vector3 B {};
+
+    Vector3 ExpectedResult {};
+
+    EXPECT_EQ(A.Sub(B), ExpectedResult);
+}
+TEST(Vector3Test, V3_Subtract_Static) {
+    Vector3 A {};
+    Vector3 B {};
+
+    Vector3 ExpectedResult {};
+
+    EXPECT_EQ(Vector3::Sub(A, B), ExpectedResult);
+}
+TEST(Vector3Test, V3_Scalar_Mult_Op) {
+    Vector3 A { };
+    float B = 1.5f;
+
+    Vector3 ExpectedResult {};
+
+    EXPECT_EQ(A * B, ExpectedResult);
+}
+TEST(Vector3Test, V3_Scalar_Mult_Method) {
+    Vector3 A { };
+    float B = 1.5f;
+
+    Vector3 ExpectedResult {};
+
+    EXPECT_EQ(A.Mul(B), ExpectedResult);
+}
+TEST(Vector3Test, V3_Scalar_Mult_Static) {
+    Vector3 A { };
+    float B = 1.5f;
+
+    Vector3 ExpectedResult {};
+
+    EXPECT_EQ(Vector3::Mul(A, B), ExpectedResult);
+}
+TEST(Vector3Test, V3_Scalar_Div_Op) {
+    Vector3 A {};
+    float B = 1.5f;
+
+    Vector3 ExpectedResult { };
+    EXPECT_EQ(A / B, ExpectedResult);
+}
+TEST(Vector3Test, V3_Scalar_Div_Method) {
+    Vector3 A { };
+    float B = 1.5f;
+    Vector3 ExpectedResult { };
+
+    EXPECT_EQ(A.Div(B), ExpectedResult);
+}
+TEST(Vector3Test, V3_Scalar_Div_Static) {
+    Vector3 A { };
+    float B = 1.5f;
+
+    Vector3 ExpectedResult { };
+
+    EXPECT_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) {}
+TEST(Vector3Test, V3_Max) {}
+TEST(Vector3Test, V3_Clamp) {}
+TEST(Vector3Test, V3_DotProduct) {}
+TEST(Vector3Test, V3_CrossProduct) {}
+TEST(Vector3Test, V3_Project) {}
+TEST(Vector3Test, V3_Normalize) {}
+TEST(Vector3Test, V3_Lerp) {}
+TEST(Vector3Test, V3_AngleBetween) {}