Unit tests

ChangeLog

 
  OpenRaider (0.1.2) xythobuz <xythobuz@xythobuz.de>
 
+	[ 20140131 ]
+	* All unit tests buildable again and no more warnings
+
 	[ 20140129 ]
 	* Removed unused libferit stuff
 	* Changed code to generate much less warnings

Makefile

 	@-echo "Building Matrix unit test"
 	mkdir -p $(BUILD_TEST_DIR)
 	$(CC) $(FLAGS_ALL) $(WARNINGS) -g -lm -lstdc++ -Iinclude \
-	src/Matrix.cpp src/Quaternion.cpp src/Vector3d.cpp \
+	src/Matrix.cpp src/Quaternion.cpp src/Vector3d.cpp src/MatMath.cpp \
 	test/Matrix.cpp -o $(BUILD_TEST_DIR)/Matrix.test
 
 Math.test:
 
 Network.test:
 	mkdir -p $(BUILD_TEST_DIR)
-	$(CC) $(TEST_FLAGS) $(WARNINGS) \
+	$(CC) $(TEST_FLAGS) $(WARNINGS) src/MatMath.cpp src/Vector3d.cpp \
 	src/Network.cpp test/Network.cpp -o $(BUILD_TEST_DIR)/Network.test
 
 #################################################################

include/MatMath.h

 
 #define HEL_PI           ((float)M_PI) //!< pi
 #define HEL_2_PI         (HEL_PI * 2.0f) //!< pi*2
-#define HEL_PI_OVER_4    (M_PI_4 / 4.0f) //!< pi/4
+#define HEL_PI_OVER_4    (HEL_PI / 4.0f) //!< pi/4
 #define HEL_PI_OVER_180  (HEL_PI / 180.0f) //!< pi/180
 #define HEL_180_OVER_PI  (180.0f / HEL_PI) //!< 180/pi
 

include/memory_test.h

     char filename_len;
     DWORD size;
     unsigned int alloc_zero;
-    unsigned short int alloc_zero_at_line[ZERO_ALLOC_SLOTS];
+    unsigned int alloc_zero_at_line[ZERO_ALLOC_SLOTS];
     struct meminfo_filename_s *next;
 } meminfo_filename_t;
 

src/Texture.cpp

 
     return id;
 #else
-    printf("ERROR: TGA support not enabled in this build\n");
+    printf("ERROR: TGA support not enabled in this build (%s)\n", filename);
     return -1;
 #endif
 }

src/memory_test.cpp

 #define UNIT_TEST_MEMORY
 #include <memory_test.h>
 
-#define USE_ITERATIVE_TREE_INSERT
-
-
 bool tree_check(rbtree_t *tree, const char *file, int line)
 {
     bool ret = true;
 {
     DWORD address;
     DWORD size;
-    unsigned short int line;
+    unsigned int line;
     meminfo_filename_t *filename;
 
 } meminfo_t;
 
 long memory_used(memory_query_t query)
 {
-    switch (query)
-    {
+    switch (query) {
         case MEMORY_USED_BY_PROGRAM:
             return MEMORY_USED;
-            break;
         case MAX_MEMORY_USED_BY_PROGRAM:
             return MAX_MEMORY_USED;
-            break;
         case MAX_MEMORY_USED_BY_OVERHEAD:
             return MAX_MEMORYA_USED + MAX_MEMORYC_USED;
-            break;
         case MEMORY_USED_BY_OVERHEAD:
             return MEMORYA_USED + MEMORYC_USED;
-            break;
         case MEMORY_USED_TOTAL:
             return MEMORY_USED + MEMORYA_USED + MEMORYC_USED;
-            break;
-        default:
-            ;
     }
-
-    return 0;
 }
 
 
         if (!memfile)
         {
             memfile = (meminfo_filename_t *)malloc(sizeof(meminfo_filename_t));
-            memfile->filename_len = len;
+            memfile->filename_len = (char)len;
             memfile->filename = (char *)malloc(len+1);
             strncpy(memfile->filename, filename, len);
             memfile->filename[len+1] = 0;

test/GLString.cpp

     // gluPerspective is deprecated!
     // gluPerspective(40.0, aspect, 1, 2000);
     // fix: http://stackoverflow.com/a/2417756
-    GLfloat fH = tan(float(40.0 / 360.0f * 3.14159f));
+    GLfloat fH = tanf(40.0f / 360.0f * 3.14159f);
     GLfloat fW = fH * aspect;
     glFrustum(-fW, fW, -fH, fH, 1, 2000);
 
 }
 
 void event_display(int width, int height) {
-    static float x = 0.0, y = 0.0, z = -150.0, r = 0.0;
+    static float x = 0.0f, y = 0.0f, z = -150.0f, r = 0.0f;
 
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glLoadIdentity();
 
-    glTranslatef(0.0, 0.0, -20.0);
-    glRotatef((float)cos(r)*180.0, 0.0, 0.0, 1.0);
-    r += 0.01;
+    glTranslatef(0.0f, 0.0f, -20.0f);
+    glRotatef((float)cosf(r)*180.0f, 0.0f, 0.0f, 1.0f);
+    r += 0.01f;
 
     // Mongoose 2002.01.01, Render color quad
     glDisable(GL_TEXTURE_2D);
     if (i) {
         printf(errorText, i);
     }
-    TEXT->Scale(1.2);
+    TEXT->Scale(1.2f);
     i = TEXT->glPrintf((width/2)-100, height/2+32, "Unit Test by Mongoose");
     if (i) {
         printf(errorText, i);
     TEXT->setActive(3, true);
 }
 
-int main_gl(int argc, char *argv[]) {
+[[noreturn]] void main_gl() {
     SDL_Event event;
     unsigned int mkeys, mod, key;
     int flags;
     // Setup clean up on exit
     atexit(shutdown_gl);
 
-    // Get user settings
-    //event_init(&width, &height, &fullscreen, &driver, argc, argv);
-
     // Create GL context
     SDL_Init(SDL_INIT_VIDEO);
 
             switch (event.type) {
                 case SDL_QUIT:
                     exit(0);
-                    break;
                 case SDL_MOUSEMOTION:
                     break;
                 case SDL_MOUSEBUTTONDOWN:
                     {
                         case 0x1B: // 27d, ESC
                             exit(0);
-                            break;
 #ifdef __APPLE__
                         case 113: // q
                             if ((mod & KMOD_RMETA) || (mod & KMOD_LMETA))
             }
         }
     }
-
-    return 0;
 }
 
 int main(int argc, char *argv[]) {
-    TEXT = new GLString();
-    main_gl(argc, argv);
-    return 0;
+    if (argc == 1) {
+        TEXT = new GLString();
+        main_gl();
+    } else {
+        printf("Usage:\n\t%s\n", argv[0]);
+        return 1;
+    }
 }
 

test/MatMath.cpp

 #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 testDegrees[] = { 0.0f, 30.0f, 45.0f, 60.0f, 90.0f, 360.0f, -100.0f };
+vec_t testRads[] = { 0.0f, 0.5236f, 0.7854f, 1.0472f, 1.5708f, 6.2832f, -1.7453f };
 vec_t testBounds[][2] = {
-    { 0.0, 1.0 },
-    { -5.0, 5.0 },
-    { 1.0, 1.0 },
+    { 0.0f, 1.0f },
+    { -5.0f, 5.0f },
+    { 1.0f, 1.0f },
 };
 
 TEST constants() {
-    ASSERT_EQm("Pi not correct!", HEL_PI, M_PI);
-    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));
+    ASSERTm("Pi not correct!", equalEpsilon(HEL_PI, (vec_t)M_PI));
+    ASSERTm("2Pi not correct!", equalEpsilon(HEL_2_PI, ((vec_t)M_PI * 2.0f)));
+    ASSERTm("Pi/4 not correct!", equalEpsilon(HEL_PI_OVER_4, ((vec_t)M_PI / 4.0f)));
+    ASSERTm("Pi/180 not correct!", equalEpsilon(HEL_PI_OVER_180, ((vec_t)M_PI / 180.0f)));
+    ASSERTm("180/Pi not correct!", equalEpsilon(HEL_180_OVER_PI, (180.0f / (vec_t)M_PI)));
     PASS();
 }
 
 
 TEST conversionToRad(vec_t deg) {
     vec_t conv = HEL_DEG_TO_RAD(deg);
-    vec_t hand = (deg * M_PI / 180.0);
-    if (conv != hand) {
+    vec_t hand = (deg * (vec_t)M_PI / 180.0f);
+    if (!equalEpsilon(conv, hand)) {
         printf("Degree to Radian conversion failed: %f != %f\n", conv, hand);
         FAIL();
     } else {
 
 TEST conversionToDeg(vec_t rad) {
     vec_t conv = HEL_RAD_TO_DEG(rad);
-    vec_t hand = (rad * 180.0 / M_PI);
-    if (conv != hand) {
+    vec_t hand = (rad * 180.0f / (vec_t)M_PI);
+    if (!equalEpsilon(conv, hand)) {
         printf("Radian to Degree conversion failed: %f != %f\n", conv, hand);
         FAIL();
     } else {

test/Matrix.cpp

     Matrix a;
     a.setIdentity();
     a.translate(10, 20, 30);
-    ASSERT(a.mMatrix[i12] == 10);
-    ASSERT(a.mMatrix[i13] == 20);
-    ASSERT(a.mMatrix[i14] == 30);
+    ASSERT(equalEpsilon(a.mMatrix[i12], 10));
+    ASSERT(equalEpsilon(a.mMatrix[i13], 20));
+    ASSERT(equalEpsilon(a.mMatrix[i14], 30));
     PASS();
 }
 
     vec_t rot = 90 * 0.01745329251994329f;
     a.rotate((axis == 0) ? rot : 0, (axis == 1) ? rot : 0, (axis == 2) ? rot : 0);
     if (axis == 0) {
-        ASSERT(a.mMatrix[i0] == 1);
-        ASSERT(a.mMatrix[i15] == 1);
-        ASSERT(a.mMatrix[i9] == -1);
-        ASSERT(a.mMatrix[i6] == 1);
+        ASSERT(equalEpsilon(a.mMatrix[i0], 1));
+        ASSERT(equalEpsilon(a.mMatrix[i15], 1));
+        ASSERT(equalEpsilon(a.mMatrix[i9], -1));
+        ASSERT(equalEpsilon(a.mMatrix[i6], 1));
     } else if (axis == 1) {
-        ASSERT(a.mMatrix[i8] == 1);
-        ASSERT(a.mMatrix[i2] == -1);
-        ASSERT(a.mMatrix[i15] == 1);
+        ASSERT(equalEpsilon(a.mMatrix[i8], 1));
+        ASSERT(equalEpsilon(a.mMatrix[i2], -1));
+        ASSERT(equalEpsilon(a.mMatrix[i15], 1));
     } else if (axis == 2) {
-        ASSERT(a.mMatrix[i4] == -1);
-        ASSERT(a.mMatrix[i15] == 1);
-        ASSERT(a.mMatrix[i1] == 1);
-        ASSERT(a.mMatrix[i10] == 1);
+        ASSERT(equalEpsilon(a.mMatrix[i4], -1));
+        ASSERT(equalEpsilon(a.mMatrix[i15], 1));
+        ASSERT(equalEpsilon(a.mMatrix[i1], 1));
+        ASSERT(equalEpsilon(a.mMatrix[i10], 1));
     } else {
         FAIL();
     }
     a.scale(10, 10, 10);
     a.print();
     printf("\n -> scale (0.1, 0.1, 0.1)\n");
-    a.scale(0.1, 0.1, 0.1);
+    a.scale(0.1f, 0.1f, 0.1f);
     printf(" -> Translate (-10, -20, -30)\n");
     a.translate(-10, -20, -30);
     printf(" -> Rotate (0, 0, -90 degrees)\n");

test/TombRaider.cpp

 
             if (f)
             {
-                if (!mtk_image__tga_save(f, image, 256, 256, 4))
+                if (!tga_save(f, image, 256, 256, 4))
                     printf("\tWrote texture %s\n", buffer);
 
                 fclose(f);
 
             if (f)
             {
-                if (!mtk_image__tga_save(f, bumpmap, 256, 256, 4))
+                if (!tga_save(f, bumpmap, 256, 256, 4))
                     printf("\tWrote texture %s\n", buffer);
 
                 fclose(f);
 
         if (f)
         {
-            if (!mtk_image__tga_save(f, image, 256, 256, 4))
+            if (!tga_save(f, image, 256, 256, 4))
                 printf("\tWrote texture %s\n", buffer);
 
             fclose(f);
                         & 0xff, rgba);
                 break;
             default:
+            case TR_VERSION_UNKNOWN:
+            case TR_VERSION_2:
+            case TR_VERSION_3:
+            case TR_VERSION_4:
+            case TR_VERSION_5:
                 tr->getColor((meshes[index].coloured_triangles[i].texture>>8)
                         & 0xff, rgba);
         }
                         & 0xff, rgba);
                 break;
             default:
+            case TR_VERSION_UNKNOWN:
+            case TR_VERSION_2:
+            case TR_VERSION_3:
+            case TR_VERSION_4:
+            case TR_VERSION_5:
                 tr->getColor((meshes[index].coloured_rectangles[i].texture>>8)
                         & 0xff, rgba);
         }

test/memory_test.cpp

 
 #define PRINT_TEST_BREAK_LINE   printf("\n############################################################\n\n");
 
-int memory_test_unit_test(int argc, char *argv[])
-{
+int memory_test_unit_test() {
     int *i, *j, *k, *l, *m, *n, *o;
 
-
     PRINT_TEST_BREAK_LINE
         printf("Memory test\n");
     PRINT_TEST_BREAK_LINE
 
-        i = new int;
+    i = new int;
     printf(">\ti = new int; (%p)  %s:%i\n", i, __FILE__, __LINE__);
     dump_memory_report();
     tree_valid_report(MEMORY_INFO);
 
     PRINT_TEST_BREAK_LINE
 
-        i = new int[3];
+    i = new int[3];
     printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
     dump_memory_report();
     tree_valid_report(MEMORY_INFO);
 
     PRINT_TEST_BREAK_LINE
 
-        i = new int[3];
+    i = new int[3];
     printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
     j = new int;
     printf(">\tj = new int; (%p)  %s:%i\n", j, __FILE__, __LINE__);
 
     PRINT_TEST_BREAK_LINE
 
-        i = new int[3];
+    i = new int[3];
     printf(">\ti = new int[3]; (%p)  %s:%i\n", i, __FILE__, __LINE__);
     j = new int;
     printf(">\tj = new int; (%p)  %s:%i\n", j, __FILE__, __LINE__);
 
     PRINT_TEST_BREAK_LINE
 
-        return 0;
+    return 0;
 }
 
-
-int main(int argc, char *argv[])
-{
-    printf("[memory_test test]\n");
-
-    return memory_test_unit_test(argc, argv);
+int main(int argc, char *argv[]) {
+    if (argc != 1) {
+        printf("Usage:\n\t%s\n", argv[0]);
+        return 1;
+    } else {
+        printf("[memory_test test]\n");
+        return memory_test_unit_test();
+    }
 }