Unit Tests are back!

CMakeLists.txt

 
 #################################################################
 
+enable_testing ()
+
+#################################################################
+
 # Add subdirectories
 add_subdirectory (src)
 
     set (CHECK_NORMAL "--enable=information,warning,performance,portability")
     set (CHECK_FULL "--enable=all")
     set (CHECK_CONFIG "--check-config")
-    add_custom_target (check echo "Running cppcheck..."
+    add_custom_target (cppcheck echo "Running cppcheck..."
         COMMAND cppcheck ${CHECK_FLAGS} "-I${PROJECT_SOURCE_DIR}/include" ${CHECK_STD} ${CHECK_NORMAL} ${PROJECT_SOURCE_DIR}
     )
-    add_custom_target (checkFull echo "Running full cppcheck..."
+    add_custom_target (cppcheckFull echo "Running full cppcheck..."
         COMMAND cppcheck ${CHECK_FLAGS} "-I${PROJECT_SOURCE_DIR}/include" ${CHECK_STD} ${CHECK_FULL} ${PROJECT_SOURCE_DIR}
     )
-    add_custom_target (checkConfig echo "Checking cppcheck config..."
+    add_custom_target (cppcheckConfig echo "Checking cppcheck config..."
         COMMAND cppcheck ${CHECK_FLAGS} "-I${PROJECT_SOURCE_DIR}/include" ${CHECK_CONFIG} ${PROJECT_SOURCE_DIR}
     )
 

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140729 ]
+    * Unit Tests are back, currently only for the binary reader
+    * Some cmake build system improvements:
+      - deps/math/utils libs are now so-called object libraries
+      - added ctest unit testing
+
     [ 20140728 ]
     * Implemented binary file reading utility in preparation of
       TombRaider.cpp/h rewrite

README.md

 
 On Mac OS X, running `make install` will produce a (more or less) distributable OpenRaider.app bundle.
 
-You can run a static analysis with cppcheck using `make check`, `make checkFull` or `make checkConfig`.
+Run `make check` to build and run the unit tests.
+
+You can run a static analysis with cppcheck using `make cppcheck`, `make cppcheckFull` or `make cppcheckConfig`.
 
 A Doxygen API documentation can be created with `make doc`.
 

TODO.md

 
 * Support SSE with other compilers than Clang (src/CMakeLists.txt)
 * Visual C++ compiler flags? (CMakeLists.txt)
+* Better test integration
 
 ## Future Features
 

include/utils/binary.h

     int64_t read64();
     uint64_t readU64();
 
+    float readFloat();
+
 private:
     std::ifstream file;
 };

src/CMakeLists.txt

     # Copy Icon
     set (MAC_ICON "../cmake/AppIcon.icns")
     set_source_files_properties (${MAC_ICON} PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
-    set (SRCS ${SRCS} ${MAC_ICON})
+    set (RESRCS ${RESRCS} ${MAC_ICON})
 
     # Copy Data
     set (MAC_DATA "../data/font.pc" "../data/OpenRaider.ini" "../data/test.ttf" "../data/splash.tga")
     set_source_files_properties (${MAC_DATA} PROPERTIES MACOSX_PACKAGE_LOCATION Resources/defaults)
-    set (SRCS ${SRCS} ${MAC_DATA})
+    set (RESRCS ${RESRCS} ${MAC_DATA})
 endif (APPLE)
 
 #################################################################
 # Add subdirectories
 add_subdirectory ("deps")
 add_subdirectory ("math")
+add_subdirectory ("test")
 add_subdirectory ("utils")
 
 # Add Executable
-add_executable (OpenRaider MACOSX_BUNDLE ${SRCS})
+add_library (OpenRaider_all OBJECT ${SRCS})
+add_executable (OpenRaider MACOSX_BUNDLE ${RESRCS}
+    $<TARGET_OBJECTS:OpenRaider_all> $<TARGET_OBJECTS:OpenRaider_deps>
+    $<TARGET_OBJECTS:OpenRaider_math> $<TARGET_OBJECTS:OpenRaider_utils>
+)
 
 #################################################################
 
     set (LIBS ${LIBS} m)
 endif (UNIX)
 
-# Add utils Library
-set (LIBS ${LIBS} OpenRaider_deps)
-set (LIBS ${LIBS} OpenRaider_math)
-set (LIBS ${LIBS} OpenRaider_utils)
-
 # Link to all found libs
 target_link_libraries (OpenRaider ${LIBS})
 

src/deps/CMakeLists.txt

 set (DEPS_SRCS ${DEPS_SRCS} "commander/commander.c")
 
 # Add library
-add_library (OpenRaider_deps ${DEPS_SRCS})
+add_library (OpenRaider_deps OBJECT ${DEPS_SRCS})
 

src/math/CMakeLists.txt

 set (MATH_SRCS ${MATH_SRCS} "Vector3d.cpp")
 
 # Add library
-add_library (OpenRaider_math ${MATH_SRCS})
+add_library (OpenRaider_math OBJECT ${MATH_SRCS})
 

src/test/CMakeLists.txt

+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenRaider_CXX_FLAGS}")
+set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${OpenRaider_CXX_FLAGS} ${OpenRaider_CXX_FLAGS_DEBUG}")
+set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${OpenRaider_CXX_FLAGS} ${OpenRaider_CXX_FLAGS_RELEASE}")
+
+add_custom_target (check COMMAND ${CMAKE_CTEST_COMMAND} -V)
+
+#################################################################
+
+add_executable (tester_binary EXCLUDE_FROM_ALL
+    "binary.cpp" "../utils/binary.cpp"
+)
+add_dependencies (check tester_binary)
+add_test (NAME test_binary COMMAND tester_binary)
+
+#################################################################
+

src/test/binary.cpp

+/*!
+ * \file test/binary.cpp
+ * \brief Binary Unit Test
+ *
+ * \author xythobuz
+ */
+
+#include <cstdio>
+#include <iostream>
+#include <fstream>
+
+#include "utils/binary.h"
+
+
+namespace {
+    const char testData[] = {
+        // Unsigned Integers
+        -1,                     // u 8 -> 255
+        -1, -1,                 // u16 -> 65535
+        42, 0, 0, 0,            // u32 -> 42
+        1, 0, 0, 0, 0, 0, 0, 0, // u64 -> 1
+
+        // Signed Integers
+        -1,                     //  8 -> -1
+        92, -2,                 // 16 -> -420
+        102, -3, -1, -1,        // 32 -> -666
+        -5, -1, -1, -1,
+        -1, -1, -1, -1          // 64 -> -5
+    };
+
+    float f1 = 3.1415926f;
+    float f2 = 42.23f;
+
+    void fillFile(const char *name) {
+        std::ofstream file(name, std::ios_base::out | std::ios_base::binary);
+        file.write(testData, sizeof(testData) / sizeof(testData[0]));
+        file.write(reinterpret_cast<char *>(&f1), sizeof(f1));
+        file.write(reinterpret_cast<char *>(&f2), sizeof(f2));
+    }
+
+    int assertImplementation(const char *exp, const char *file, int line) {
+        std::cout << "Failed: \"" << exp << "\" in " << file << " at " << line << std::endl;
+        return 1;
+    }
+
+#define assert(x) if (!(x)) { return assertImplementation(#x, __FILE__, __LINE__); }
+
+    int test(const char *name) {
+        BinaryFile file(name);
+
+        uint8_t a = file.readU8();
+        uint16_t b = file.readU16();
+        uint32_t c = file.readU32();
+        uint64_t d = file.readU64();
+
+        int8_t e = file.read8();
+        int16_t f = file.read16();
+        int32_t g = file.read32();
+        int64_t h = file.read64();
+
+        float i = file.readFloat();
+        float j = file.readFloat();
+
+        assert(a == 255);
+        assert(b == 65535);
+        assert(c == 42);
+        assert(d == 1);
+
+        assert(e == -1);
+        assert(f == -420);
+        assert(g == -666);
+        assert(h == -5);
+
+        assert(i == f1);
+        assert(j == f2);
+
+        return 0;
+    }
+}
+
+int main(int argc, char *argv[]) {
+    char *tmpFile = tmpnam(NULL);
+    std::cout << "Temporary test-file: " << tmpFile << std::endl;
+
+    fillFile(tmpFile);
+    int error = test(tmpFile);
+    remove(tmpFile);
+
+    return error;
+}
+

src/utils/CMakeLists.txt

 endif (USING_PNG)
 
 # Add library
-add_library (OpenRaider_utils ${UTIL_SRCS})
+add_library (OpenRaider_utils OBJECT ${UTIL_SRCS})
 

src/utils/binary.cpp

  * \author xythobuz
  */
 
-#include "global.h"
 #include "utils/binary.h"
 
-/*! \fixme Left-Shift with signed integer is undefined!
- *  Is there a portable way to read multi-byte signed integers?
- *  Without having to detect the endianness at run-time?
- */
-const int bigendiandetection = 1;
-#define ISBIGENDIAN() ((*(char *)&bigendiandetection) == 0)
-
 BinaryFile::BinaryFile(const char *f) {
     file.open(f, std::ios_base::in | std::ios_base:: binary);
 }
 }
 
 void BinaryFile::seek(long long pos) {
-    assert(pos >= 0);
     file.seekg(pos);
 }
 
-int8_t BinaryFile::read8() {
-    int8_t ret;
-    file.read(reinterpret_cast<char *>(&ret), sizeof(ret));
+uint8_t BinaryFile::readU8() {
+    uint8_t ret;
+    char *c = reinterpret_cast<char *>(&ret);
+    file.read(c, 1);
     return ret;
 }
 
-uint8_t BinaryFile::readU8() {
-    uint8_t ret;
-    file.read(reinterpret_cast<char *>(&ret), sizeof(ret));
+uint16_t BinaryFile::readU16() {
+    uint8_t a = readU8();
+    uint8_t b = readU8();
+    return ((uint16_t)a | (uint16_t)(b << 8));
+}
+
+uint32_t BinaryFile::readU32() {
+    uint16_t a = readU16();
+    uint16_t b = readU16();
+    return ((uint32_t)a | (uint32_t)(b << 16));
+}
+
+uint64_t BinaryFile::readU64() {
+    uint32_t a = readU32();
+    uint32_t b = readU32();
+    return ((uint64_t)a | ((uint64_t)b << 32));
+}
+
+float BinaryFile::readFloat() {
+    uint32_t val = readU32();
+    char *a = reinterpret_cast<char *>(&val);
+
+    float ret;
+    char *b = reinterpret_cast<char *>(&ret);
+
+    for (int i = 0; i < 4; i++)
+        b[i] = a[i];
+
     return ret;
 }
 
-int16_t BinaryFile::read16() {
-    int16_t ret;
-    file.read(reinterpret_cast<char *>(&ret), sizeof(ret));
-    if (ISBIGENDIAN()) {
-        char *p = reinterpret_cast<char *>(&ret);
-        char tmp = p[0];
-        p[0] = p[1];
-        p[1] = tmp;
+namespace {
+    /*! \fixme Left-Shift with signed integer is undefined!
+     *  So we can't use the same method as for unsigned integers.
+     *  Is there a portable way to read multi-byte signed integers,
+     *  without having to detect the endianness at run-time?
+     */
+    const int bigendiandetection = 1;
+#define ISBIGENDIAN() ((*(char *)&bigendiandetection) == 0)
+
+    void swapByteOrder(char *d, unsigned int n) {
+        if (ISBIGENDIAN()) {
+            for (unsigned int i = 0; i < (n / 2); i++) {
+                char tmp = d[i];
+                d[i] = d[n - i - 1];
+                d[n - i - 1] = tmp;
+            }
+        }
     }
+}
+
+int8_t BinaryFile::read8() {
+    int8_t ret;
+    char *p = reinterpret_cast<char *>(&ret);
+    file.read(p, sizeof(ret));
     return ret;
 }
 
-uint16_t BinaryFile::readU16() {
-    uint16_t a = readU8();
-    uint16_t b = readU8();
-    return (uint16_t)(a | (b << 8));
+int16_t BinaryFile::read16() {
+    int16_t ret;
+    char *p = reinterpret_cast<char *>(&ret);
+    file.read(p, sizeof(ret));
+    swapByteOrder(p, 2);
+    return ret;
 }
 
 int32_t BinaryFile::read32() {
     int32_t ret;
-    file.read(reinterpret_cast<char *>(&ret), sizeof(ret));
-    if (ISBIGENDIAN()) {
-        char *p = reinterpret_cast<char *>(&ret);
-        char tmp = p[0];
-        p[0] = p[3];
-        p[3] = tmp;
-        tmp = p[1];
-        p[1] = p[2];
-        p[2] = tmp;
-    }
+    char *p = reinterpret_cast<char *>(&ret);
+    file.read(p, sizeof(ret));
+    swapByteOrder(p, 4);
     return ret;
 }
 
-uint32_t BinaryFile::readU32() {
-    uint32_t a = readU8();
-    uint32_t b = readU8();
-    uint32_t c = readU8();
-    uint32_t d = readU8();
-    return (uint32_t)(a | (b << 8) | (c << 16) | (d << 24));
-}
-
 int64_t BinaryFile::read64() {
     int64_t ret;
-    file.read(reinterpret_cast<char *>(&ret), sizeof(ret));
-    if (ISBIGENDIAN()) {
-        char *p = reinterpret_cast<char *>(&ret);
-        char tmp = p[0];
-        p[0] = p[7];
-        p[7] = tmp;
-        tmp = p[1];
-        p[1] = p[6];
-        p[6] = tmp;
-        tmp = p[2];
-        p[2] = p[5];
-        p[5] = tmp;
-        tmp = p[3];
-        p[3] = p[4];
-        p[4] = tmp;
-    }
+    char *p = reinterpret_cast<char *>(&ret);
+    file.read(p, sizeof(ret));
+    swapByteOrder(p, 8);
     return ret;
 }
 
-uint64_t BinaryFile::readU64() {
-    uint64_t a = readU8();
-    uint64_t b = readU8();
-    uint64_t c = readU8();
-    uint64_t d = readU8();
-    uint64_t e = readU8();
-    uint64_t f = readU8();
-    uint64_t g = readU8();
-    uint64_t h = readU8();
-    return (uint64_t)(a | (b << 8) | (c << 16) | (d << 24)
-            | (e << 32) | (f << 40) | (g << 48) | (h << 56));
-}
-