Wrote MatMath Unit Test using greatest

Makefile

@@ -314,6 +314,15 @@ GLString.test:
 #################################################################
 
 Hel.test: Quaternion.test Matrix.test Math.test
+	@-echo "================================================="
+	@-echo "Running Matrix unit test"
+	$(BUILD_TEST_DIR)/Matrix.test
+	@-echo "================================================="
+	$(BUILD_TEST_DIR)/Math.test
+	@-echo "Running hel Math unit test"
+	@-echo "================================================="
+	@-echo "Running Quaternion unit test"
+	$(BUILD_TEST_DIR)/Quaternion.test
 
 Matrix.test:
 	@-echo "Building Matrix unit test"
@@ -321,27 +330,18 @@ Matrix.test:
 	$(CC) -Wall -g -lm -lstdc++ -Iinclude \
 	src/Matrix.cpp src/Quaternion.cpp src/Vector3d.cpp \
 	test/Matrix.cpp -o $(BUILD_TEST_DIR)/Matrix.test
-	@-echo "================================================="
-	@-echo "Running Matrix unit test"
-	$(BUILD_TEST_DIR)/Matrix.test
 
 Quaternion.test:
 	@-echo "Building Quaternion unit test"
 	mkdir -p $(BUILD_TEST_DIR)
 	$(CC) -Wall -g -lm -lstdc++ -Iinclude \
 	src/Quaternion.cpp test/Quaternion.cpp -o $(BUILD_TEST_DIR)/Quaternion.test
-	@-echo "================================================="
-	@-echo "Running Quaternion unit test"
-	$(BUILD_TEST_DIR)/Quaternion.test
 
 Math.test:
 	@-echo "Building Math unit test"
 	mkdir -p $(BUILD_TEST_DIR)
 	$(CC) -Wall -g -lm -lstdc++ -Iinclude \
 	src/MatMath.cpp src/Vector3d.cpp test/MatMath.cpp -o $(BUILD_TEST_DIR)/Math.test
-	@-echo "================================================="
-	@-echo "Running hel unit test"
-	$(BUILD_TEST_DIR)/Math.test
 
 #################################################################
 

test/MatMath.cpp

@@ -1,21 +1,93 @@
+/*!
+ * \file test/MatMath.cpp
+ * \brief Mat Math Unit Test
+ *
+ * \todo Also test the geometric methods (intersection, distance, midpoint)
+ *
+ * \author xythobuz
+ */
 #include <stdio.h>
 #include <math.h>
-
 #include <MatMath.h>
+#include "greatest.h"
+
+vec_t testDegrees[] = { 0.0, 30.0, 45.0, 60.0, 90.0, 360.0, -100.0 };
+vec_t testRads[] = { 0.0, 0.5236, 0.7854, 1.0472, 1.5708, 6.2832, -1.7453 };
+vec_t testBounds[][2] = {
+    { 0.0, 1.0 },
+    { -5.0, 5.0 },
+    { 1.0, 1.0 },
+};
+
+TEST constants() {
+    ASSERT_EQm("Pi not correct!", HEL_PI, M_PI);
+    ASSERT_EQm("Pi/2 not correct!", HEL_PI_OVER_2, (M_PI / 2.0));
+    ASSERT_EQm("2Pi not correct!", HEL_2_PI, (M_PI * 2.0));
+    ASSERT_EQm("Pi/4 not correct!", HEL_PI_OVER_4, (M_PI / 4.0));
+    ASSERT_EQm("Pi/180 not correct!", HEL_PI_OVER_180, (M_PI / 180.0));
+    ASSERT_EQm("180/Pi not correct!", HEL_180_OVER_PI, (180.0 / M_PI));
+    PASS();
+}
+
+TEST types() {
+    ASSERT_EQ(sizeof(vec2_t), (2 * sizeof(vec_t)));
+    ASSERT_EQ(sizeof(vec3_t), (3 * sizeof(vec_t)));
+    ASSERT_EQ(sizeof(vec4_t), (4 * sizeof(vec_t)));
+    ASSERT_EQ(sizeof(matrix_t), (16 * sizeof(vec_t)));
+    PASS();
+}
 
-void helMathTest()
-{
-	printf("180/PI: %f, %f, %f\n",
-			 HEL_180_OVER_PI,
-			 180.0f / HEL_PI,
-			 180.0 / M_PI);
+TEST conversionToRad(vec_t deg) {
+    vec_t conv = HEL_DEG_TO_RAD(deg);
+    vec_t hand = (deg * M_PI / 180.0);
+    if (conv != hand) {
+        printf("Degree to Radian conversion failed: %f != %f\n", conv, hand);
+        FAIL();
+    } else {
+        PASS();
+    }
 }
 
+TEST conversionToDeg(vec_t rad) {
+    vec_t conv = HEL_RAD_TO_DEG(rad);
+    vec_t hand = (rad * 180.0 / M_PI);
+    if (conv != hand) {
+        printf("Radian to Degree conversion failed: %f != %f\n", conv, hand);
+        FAIL();
+    } else {
+        PASS();
+    }
+}
+
+#define TESTNUMS 100
+TEST random(vec_t bound[2]) {
+    for (int i = 0; i < TESTNUMS; i++) {
+        vec_t number = helRandomNum(bound[0], bound[1]);
+        ASSERT(number >= bound[0]);
+        ASSERT(number <= bound[1]);
+    }
+    PASS();
+}
+
+SUITE(mathSuite) {
+    RUN_TEST(constants);
+    RUN_TEST(types);
+    for (int i = 0; i < (sizeof(testDegrees) / sizeof(testDegrees[0])); i++) {
+        RUN_TESTp(conversionToRad, testDegrees[i]);
+    }
+    for (int i = 0; i < (sizeof(testRads) / sizeof(testRads[0])); i++) {
+        RUN_TESTp(conversionToDeg, testRads[i]);
+    }
+    for (int i = 0; i < sizeof(testBounds) / sizeof(testBounds[0]); i++) {
+        RUN_TESTp(random, testBounds[i]);
+    }
+}
 
-int main(int argc, char *argv[])
-{
-	helMathTest();
+GREATEST_MAIN_DEFS();
 
-	return 0;
+int main(int argc, char *argv[]) {
+    GREATEST_MAIN_BEGIN();
+    RUN_SUITE(mathSuite);
+    GREATEST_MAIN_END();
 }