Added tests and code improvement

Angle.cpp

@@ -73,11 +73,11 @@ float Angle::SineRuleAngle(float a, float beta, float b) {
 */
 //----------------------
 
-template <> Angle2<float> Angle2<float>::Rad2Deg = 57.29578F;
-template <> Angle2<float> Angle2<float>::Deg2Rad = 0.0174532924F;
-
 template <> Angle2<float> Angle2<float>::pi = 3.1415927410125732421875F;
 
+template <> Angle2<float> Angle2<float>::Rad2Deg = 360.0f / (pi * 2);
+template <> Angle2<float> Angle2<float>::Deg2Rad = (pi * 2) / 360.0f;
+
 template <> Angle2<float> Angle2<float>::Normalize(Angle2<float> angle) {
   float angleValue = angle;
   if (!isfinite(angleValue))

Matrix.cpp

@@ -1,6 +1,12 @@
 #include "Matrix.h"
 
 template <> MatrixOf<float>::MatrixOf(unsigned int rows, unsigned int cols) {
+  if (rows <= 0 || cols <= 0) {
+    this->rows = 0;
+    this->cols = 0;
+    this->data = nullptr;
+    return;
+  }
   this->rows = rows;
   this->cols = cols;
 
@@ -15,8 +21,8 @@ template <> MatrixOf<float>::MatrixOf(Vector3 v) : MatrixOf(3, 1) {
 }
 
 template <>
-void MatrixOf<float>::Multiply(const MatrixOf<float> *m1, MatrixOf<float> *m2,
+void MatrixOf<float>::Multiply(const MatrixOf<float> *m1,
-                               MatrixOf<float> *r) {
+                               const MatrixOf<float> *m2, MatrixOf<float> *r) {
   for (unsigned int rowIx1 = 0; rowIx1 < m1->rows; rowIx1++) {
     for (unsigned int colIx2 = 0; colIx2 < m2->cols; colIx2++) {
       unsigned int rDataIx = colIx2 * m2->cols + rowIx1;

Matrix.h

@@ -43,8 +43,11 @@ public:
     }
   }
 
-  static void Multiply(const MatrixOf<T> *m1, MatrixOf<T> *m2, MatrixOf<T> *r);
+  static void Multiply(const MatrixOf<T> *m1, const MatrixOf<T> *m2,
-  void Multiply(MatrixOf<T> *m, MatrixOf<T> *r) { Multiply(this, m, r); }
+                       MatrixOf<T> *r);
+  void Multiply(const MatrixOf<T> *m, MatrixOf<T> *r) const {
+    Multiply(this, m, r);
+  }
 
   static Vector3 Multiply(const MatrixOf<T> *m, Vector3 v);
   Vector3 operator*(const Vector3 v) const;

Vector2.cpp

@@ -120,12 +120,13 @@ float Vector2::SignedAngle(Vector2 from, Vector2 to) {
 }
 
 Vector2 Vector2::Rotate(Vector2 v, float angle) {
+  float angleRad = angle * Angle::Deg2Rad;
 #if defined(AVR)
-  float sinValue = sin(angle * Angle::Deg2Rad);
+  float sinValue = sin(angleRad);
-  float cosValue = cos(angle * Angle::Deg2Rad);
+  float cosValue = cos(angleRad); // * Angle::Deg2Rad);
 #else
-  float sinValue = (float)sinf(angle * Angle::Deg2Rad);
+  float sinValue = (float)sinf(angleRad);
-  float cosValue = (float)cosf(angle * Angle::Deg2Rad);
+  float cosValue = (float)cosf(angleRad);
 #endif
 
   float tx = v.x;

test/Matrix_test.cc

@@ -1,14 +1,13 @@
 #if GTEST
 #include <gtest/gtest.h>
-#include <math.h>
 #include <limits>
+#include <math.h>
 
 #include "Matrix.h"
 
 TEST(MatrixSingle, Init) {
   // zero
-  float data0[] = {};
+  MatrixOf<float> m0 = MatrixOf<float>(0, 0);
-  MatrixOf<float> m0 = MatrixOf<float>(0, 0, data0);
 
   // one
   float data1[] = {1.0F};
@@ -19,15 +18,14 @@ TEST(MatrixSingle, Init) {
   MatrixOf<float> m2 = MatrixOf<float>(2, 2, data2);
 
   // negative
-  MatrixOf<float> m_1 = MatrixOf<float>(-1, -1, data0);
+  MatrixOf<float> m_1 = MatrixOf<float>(-1, -1);
 }
 
 TEST(MatrixSingle, Transpose) {
   float data1[] = {1.0F};
   MatrixOf<float> m = MatrixOf<float>(1, 1, data1);
 
-  float data2[] = {1.0F};
+  MatrixOf<float> r = MatrixOf<float>(1, 1);
-  MatrixOf<float> r = MatrixOf<float>(1, 1, data2);
   m.Transpose(&r);
 
   // 2 x 2

test/Vector2_test.cc

@@ -1,7 +1,7 @@
 #if GTEST
 #include <gtest/gtest.h>
-#include <math.h>
 #include <limits>
+#include <math.h>
 
 #include "Vector2.h"
 
@@ -65,7 +65,6 @@ TEST(Vector2, SqrMagnitude) {
   }
 }
 
-
 TEST(Vector2, Normalize) {
   bool r = false;
 
@@ -96,7 +95,6 @@ TEST(Vector2, Normalize) {
     v = v1.normalized();
     r = isnan(v.x) && isnan(v.y);
     EXPECT_TRUE(r) << "v.normalized -INFINITY -INFINITY";
-
   }
 }
 
@@ -120,11 +118,13 @@ TEST(Vector2, Negate) {
   if (std::numeric_limits<float>::is_iec559) {
     v1 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
     v = -v1;
-		EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY)) << "- INFINITY INFINITY";
+    EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
+        << "- INFINITY INFINITY";
 
     v1 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
     v = -v1;
-		EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY)) << "- -INFINITY -INFINITY";
+    EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
+        << "- -INFINITY -INFINITY";
   }
 }
 
@@ -153,11 +153,13 @@ TEST(Vector2, Subtract) {
   if (std::numeric_limits<float>::is_iec559) {
     v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
     v = v1 - v2;
-		EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY)) << "4 5 - INFINITY INFINITY";
+    EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
+        << "4 5 - INFINITY INFINITY";
 
     v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
     v = v1 - v2;
-		EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY)) << "4 5 - -INFINITY -INFINITY";
+    EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
+        << "4 5 - -INFINITY -INFINITY";
   }
 }
 
@@ -182,13 +184,14 @@ TEST(Vector2, Addition) {
   if (std::numeric_limits<float>::is_iec559) {
     v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
     v = v1 + v2;
-		EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY)) << "4 5 + INFINITY INFINITY";
+    EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
+        << "4 5 + INFINITY INFINITY";
 
     v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
     v = v1 + v2;
-		EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY)) << "4 5 + -INFINITY -INFINITY";
+    EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
+        << "4 5 + -INFINITY -INFINITY";
   }
-
 }
 
 TEST(Vector2, Scale) {
@@ -212,11 +215,13 @@ TEST(Vector2, Scale) {
   if (std::numeric_limits<float>::is_iec559) {
     v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
     v = Vector2::Scale(v1, v2);
-		EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY)) << "4 5 + INFINITY INFINITY";
+    EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
+        << "4 5 + INFINITY INFINITY";
 
     v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
     v = Vector2::Scale(v1, v2);
-		EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY)) << "4 5 + -INFINITY -INFINITY";
+    EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
+        << "4 5 + -INFINITY -INFINITY";
   }
 }
 
@@ -241,11 +246,13 @@ TEST(Vector2, Multiply) {
   if (std::numeric_limits<float>::is_iec559) {
     f = FLOAT_INFINITY;
     v = v1 * f;
-		EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY)) << "4 5 * INFINITY";
+    EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
+        << "4 5 * INFINITY";
 
     f = -FLOAT_INFINITY;
     v = v1 * f;
-		EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY)) << "4 5 * -INFINITY";
+    EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
+        << "4 5 * -INFINITY";
   }
 }
 
@@ -382,7 +389,6 @@ TEST(Vector2, Angle) {
     f = Vector2::Angle(v1, v2);
     r = isnan(f);
     EXPECT_TRUE(r) << "Angle(4 5, -INFINITY -INFINITY)";
-
   }
 }
 
@@ -413,17 +419,47 @@ TEST(Vector2, SignedAngle) {
     f = Vector2::SignedAngle(v1, v2);
     r = isnan(f);
     EXPECT_TRUE(r) << "SignedAngle(4 5, -INFINITY -INFINITY)";
-
   }
 }
 
-TEST(Vector2, DISABLED_Lerp) {
+TEST(Vector2, Rotate) {
+  Vector2 v1 = Vector2(1, 2);
+  Vector2 r = Vector2(0, 0);
+
+  r = Vector2::Rotate(v1, 0);
+  EXPECT_FLOAT_EQ(Vector2::Distance(r, v1), 0);
+
+  r = Vector2::Rotate(v1, 180);
+  EXPECT_NEAR(Vector2::Distance(r, Vector2(-1, -2)), 0, 1.0e-06);
+
+  r = Vector2::Rotate(v1, -90);
+  EXPECT_NEAR(Vector2::Distance(r, Vector2(2, -1)), 0, 1.0e-06);
+
+  r = Vector2::Rotate(v1, 270);
+  EXPECT_NEAR(Vector2::Distance(r, Vector2(2, -1)), 0, 1.0e-06);
 }
 
-TEST(Vector2, DISABLED_ToFactor) {
+TEST(Vector2, Lerp) {
+  Vector2 v1 = Vector2(4, 5);
+  Vector2 v2 = Vector2(1, 2);
+  Vector2 r = Vector2(0, 0);
+
+  r = Vector2::Lerp(v1, v2, 0);
+  EXPECT_FLOAT_EQ(Vector2::Distance(r, v1), 0);
+
+  r = Vector2::Lerp(v1, v2, 1);
+  EXPECT_FLOAT_EQ(Vector2::Distance(r, v2), 0);
+
+  r = Vector2::Lerp(v1, v2, 0.5f);
+  EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2(2.5f, 3.5f)), 0);
+
+  r = Vector2::Lerp(v1, v2, -1);
+  EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2(7.0f, 8.0f)), 0);
+
+  r = Vector2::Lerp(v1, v2, 2);
+  EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2(-2.0, -1.0f)), 0);
 }
 
-TEST(Vector2, DISABLED_Rotate) {
+TEST(Vector2, DISABLED_ToFactor) {}
-}
 
 #endif

test/Vector3_test.cc

@@ -1,7 +1,7 @@
 #if GTEST
 #include <gtest/gtest.h>
-#include <math.h>
 #include <limits>
+#include <math.h>
 
 #include "Vector3.h"
 
@@ -28,11 +28,13 @@ TEST(Vector3, Magnitude) {
   if (std::numeric_limits<float>::is_iec559) {
     v = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
     m = v.magnitude();
-		EXPECT_FLOAT_EQ(m, FLOAT_INFINITY) << "v.magnitude INFINITY INFINITY INFINITY ";
+    EXPECT_FLOAT_EQ(m, FLOAT_INFINITY)
+        << "v.magnitude INFINITY INFINITY INFINITY ";
 
     v = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
     m = v.magnitude();
-		EXPECT_FLOAT_EQ(m, FLOAT_INFINITY) << "v.magnitude -INFINITY -INFINITY -INFINITY ";
+    EXPECT_FLOAT_EQ(m, FLOAT_INFINITY)
+        << "v.magnitude -INFINITY -INFINITY -INFINITY ";
   }
 }
 
@@ -57,11 +59,13 @@ TEST(Vector3, SqrMagnitude) {
   if (std::numeric_limits<float>::is_iec559) {
     v = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
     m = v.sqrMagnitude();
-		EXPECT_FLOAT_EQ(m, FLOAT_INFINITY) << "v.sqrMagnitude INFINITY INFINITY INFINITY ";
+    EXPECT_FLOAT_EQ(m, FLOAT_INFINITY)
+        << "v.sqrMagnitude INFINITY INFINITY INFINITY ";
 
     v = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
     m = v.sqrMagnitude();
-		EXPECT_FLOAT_EQ(m, FLOAT_INFINITY) << "v.sqrMagnitude -INFINITY -INFINITY -INFINITY ";
+    EXPECT_FLOAT_EQ(m, FLOAT_INFINITY)
+        << "v.sqrMagnitude -INFINITY -INFINITY -INFINITY ";
   }
 }
 
@@ -95,7 +99,6 @@ TEST(Vector3, Normalize) {
     v = v1.normalized();
     r = isnan(v.x) && isnan(v.y) && isnan(v.z);
     EXPECT_TRUE(r) << "v.normalized -INFINITY -INFINITY -INFINITY";
-
   }
 }
 
@@ -119,11 +122,13 @@ TEST(Vector3, Negate) {
   if (std::numeric_limits<float>::is_iec559) {
     v1 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
     v = -v1;
-		EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY)) << "- INFINITY INFINITY INFINITY";
+    EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY))
+        << "- INFINITY INFINITY INFINITY";
 
     v1 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
     v = -v1;
-		EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY)) << "- -INFINITY -INFINITY -INFINITY";
+    EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY))
+        << "- -INFINITY -INFINITY -INFINITY";
   }
 }
 
@@ -152,11 +157,13 @@ TEST(Vector3, Subtract) {
   if (std::numeric_limits<float>::is_iec559) {
     v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
     v = v1 - v2;
-		EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY)) << "4 5 6 - INFINITY INFINITY INFINITY";
+    EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY))
+        << "4 5 6 - INFINITY INFINITY INFINITY";
 
     v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
     v = v1 - v2;
-		EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY)) << "4 5 6 - -INFINITY -INFINITY -INFINITY";
+    EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY))
+        << "4 5 6 - -INFINITY -INFINITY -INFINITY";
   }
 }
 
@@ -181,13 +188,14 @@ TEST(Vector3, Addition) {
   if (std::numeric_limits<float>::is_iec559) {
     v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
     v = v1 + v2;
-		EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY)) << "4 5 6 + INFINITY INFINITY INFINITY";
+    EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY))
+        << "4 5 6 + INFINITY INFINITY INFINITY";
 
     v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
     v = v1 + v2;
-		EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY)) << "4 5 6 + -INFINITY -INFINITY -INFINITY";
+    EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY))
+        << "4 5 6 + -INFINITY -INFINITY -INFINITY";
   }
-
 }
 
 TEST(Vector3, Scale) {
@@ -211,11 +219,13 @@ TEST(Vector3, Scale) {
   if (std::numeric_limits<float>::is_iec559) {
     v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
     v = Vector3::Scale(v1, v2);
-		EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY)) << "4 5 6 + INFINITY INFINITY INFINITY";
+    EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY))
+        << "4 5 6 + INFINITY INFINITY INFINITY";
 
     v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
     v = Vector3::Scale(v1, v2);
-		EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY)) << "4 5 6 + -INFINITY -INFINITY -INFINITY";
+    EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY))
+        << "4 5 6 + -INFINITY -INFINITY -INFINITY";
   }
 }
 
@@ -240,11 +250,13 @@ TEST(Vector3, Multiply) {
   if (std::numeric_limits<float>::is_iec559) {
     f = FLOAT_INFINITY;
     v = v1 * f;
-		EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY)) << "4 5 6 * INFINITY";
+    EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY))
+        << "4 5 6 * INFINITY";
 
     f = -FLOAT_INFINITY;
     v = v1 * f;
-		EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY)) << "4 5 6 * -INFINITY";
+    EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY))
+        << "4 5 6 * -INFINITY";
   }
 }
 
@@ -265,7 +277,8 @@ TEST(Vector3, Divide) {
   if (std::numeric_limits<float>::is_iec559) {
     f = 0;
     v = v1 / f;
-		EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY)) << "4 5 6 / 0";
+    EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY))
+        << "4 5 6 / 0";
 
     f = FLOAT_INFINITY;
     v = v1 / f;
@@ -296,11 +309,13 @@ TEST(Vector3, Dot) {
   if (std::numeric_limits<float>::is_iec559) {
     v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
     f = Vector3::Dot(v1, v2);
-		EXPECT_FLOAT_EQ(f, FLOAT_INFINITY) << "Dot(4 5 6, INFINITY INFINITY INFINITY)";
+    EXPECT_FLOAT_EQ(f, FLOAT_INFINITY)
+        << "Dot(4 5 6, INFINITY INFINITY INFINITY)";
 
     v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
     f = Vector3::Dot(v1, v2);
-		EXPECT_FLOAT_EQ(f, -FLOAT_INFINITY) << "Dot(4 5 6, -INFINITY -INFINITY -INFINITY)";
+    EXPECT_FLOAT_EQ(f, -FLOAT_INFINITY)
+        << "Dot(4 5 6, -INFINITY -INFINITY -INFINITY)";
   }
 }
 
@@ -323,7 +338,8 @@ TEST(Vector3, Equality) {
 
     v1 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
     r = v1 == v2;
-		EXPECT_FALSE(r) << "-INFINITY -INFINITY -INFINITY == INFINITY INFINITY INFINITY";
+    EXPECT_FALSE(r)
+        << "-INFINITY -INFINITY -INFINITY == INFINITY INFINITY INFINITY";
   }
 }
 
@@ -346,11 +362,13 @@ TEST(Vector3, Distance) {
   if (std::numeric_limits<float>::is_iec559) {
     v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
     f = Vector3::Distance(v1, v2);
-		EXPECT_FLOAT_EQ(f, FLOAT_INFINITY) << "Distance(4 5 6, INFINITY INFINITY INFINITY)";
+    EXPECT_FLOAT_EQ(f, FLOAT_INFINITY)
+        << "Distance(4 5 6, INFINITY INFINITY INFINITY)";
 
     v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
     f = Vector3::Distance(v1, v2);
-		EXPECT_FLOAT_EQ(f, FLOAT_INFINITY) << "Distance(4 5 6, -INFINITY -INFINITY -INFINITY)";
+    EXPECT_FLOAT_EQ(f, FLOAT_INFINITY)
+        << "Distance(4 5 6, -INFINITY -INFINITY -INFINITY)";
   }
 }
 
@@ -480,7 +498,6 @@ TEST(Vector3, Angle) {
     f = Vector3::Angle(v1, v2);
     r = isnan(f);
     EXPECT_TRUE(r) << "Angle(4 5 6, -INFINITY -INFINITY -INFINITY)";
-
   }
 }
 
@@ -522,11 +539,27 @@ TEST(Vector3, SignedAngle) {
     f = Vector3::SignedAngle(v1, v2, v3);
     r = isnan(f);
     EXPECT_TRUE(r) << "SignedAngle(4 5 6, -INFINITY -INFINITY -INFINITY)";
-
   }
 }
 
-TEST(Vector3, DISABLED_Lerp) {
+TEST(Vector3, Lerp) {
+  Vector3 v1 = Vector3(4, 5, 6);
+  Vector3 v2 = Vector3(1, 2, 3);
+  Vector3 r = Vector3(0, 0, 0);
 
+  r = Vector3::Lerp(v1, v2, 0);
+  EXPECT_FLOAT_EQ(Vector3::Distance(r, v1), 0);
+
+  r = Vector3::Lerp(v1, v2, 1);
+  EXPECT_FLOAT_EQ(Vector3::Distance(r, v2), 0);
+
+  r = Vector3::Lerp(v1, v2, 0.5f);
+  EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3(2.5f, 3.5f, 4.5f)), 0);
+
+  r = Vector3::Lerp(v1, v2, -1);
+  EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3(7.0f, 8.0f, 9.0f)), 0);
+
+  r = Vector3::Lerp(v1, v2, 2);
+  EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3(-2.0, -1.0f, 0.0f)), 0);
 }
 #endif