Add some tests

src/assert/assert.c

@@ -9,23 +9,39 @@
 #include "debug/debug.h"
 
 #ifndef ASSERTIONS_FAKED
-  void assertTrueImpl(
-    const char *file,
-    const int32_t line,
-    const bool x,
-    const char *message
-  ) {
-    if(x != true) {
-      debugPrint(
-        "Assertion Failed in %s:%i\n\n%s\n",
+  #ifdef DUSK_TEST_ASSERT
+    void assertTrueImpl(
+      const char *file,
+      const int32_t line,
+      const bool x,
+      const char *message
+    ) {
+      mock_assert(
+        x == true,
+        message,
         file,
-        line,
-        message
+        line
       );
-
-      abort();
     }
-  }
+  #else
+    void assertTrueImpl(
+      const char *file,
+      const int32_t line,
+      const bool x,
+      const char *message
+    ) {
+      if(x != true) {
+        debugPrint(
+          "Assertion Failed in %s:%i\n\n%s\n",
+          file,
+          line,
+          message
+        );
+
+        abort();
+      }
+    }
+  #endif
 
   void assertFalseImpl(
     const char *file,

src/assert/assert.h

@@ -8,6 +8,14 @@
 #pragma once
 #include "dusk.h"
 
+#ifdef DUSK_TEST_ASSERT
+  #include <cmocka.h>
+  
+  #ifdef ASSERTIONS_FAKED
+    #error "Cannot fake assertions when DUSK_TEST_ASSERT is set."
+  #endif
+#endif
+
 #ifndef ASSERTIONS_FAKED
   /**
    * Assert a given value to be true.
@@ -105,27 +113,77 @@
     const char *message
   );
 
+  /**
+   * Asserts a given value to be true.
+   * 
+   * @param x Value to assert as true.
+   * @param message Message to throw against assertion failure.
+   */
   #define assertTrue(x, message) \
     assertTrueImpl(__FILE__, __LINE__, x, message)
 
+  /**
+   * Asserts a given statement to be false.
+   * 
+   * @param x Value to assert as false.
+   * @param message Message to throw against assertion failure.
+   */
   #define assertFalse(x, message) \
     assertFalseImpl(__FILE__, __LINE__, x, message)
 
+  /**
+   * Asserts that a given line of code is unreachable. Essentially a forced
+   * assertion failure, good for "edge cases"
+   * 
+   * @param message Message to throw against assertion failure.
+   */
   #define assertUnreachable(message) \
     assertUnreachableImpl(__FILE__, __LINE__, message)
 
+
+  /**
+   * Asserts a pointer is not null.
+   *
+   * @param pointer Pointer to check.
+   * @param message Message to throw against assertion failure.
+   */
   #define assertNotNull(pointer, message) \
     assertNotNullImpl(__FILE__, __LINE__, pointer, message)
 
+  /**
+   * Asserts a pointer is null.
+   *
+   * @param pointer Pointer to check.
+   * @param message Message to throw against assertion failure.
+   */
   #define assertNull(pointer, message) \
     assertNullImpl(__FILE__, __LINE__, pointer, message)
 
+  /**
+   * Asserts a function or code path is deprecated.
+   *
+   * @param message Message to throw against assertion failure.
+   */
   #define assertDeprecated(message) \
     assertDeprecatedImpl(__FILE__, __LINE__, message)
 
+  /**
+   * Asserts a string's length is less than a maximum.
+   *
+   * @param str String to check.
+   * @param len Maximum length.
+   * @param message Message to throw against assertion failure.
+   */
   #define assertStrLenMax(str, len, message) \
     assertTrue(strlen(str) < len, message)
 
+  /**
+   * Asserts a string's length is at least a minimum.
+   *
+   * @param str String to check.
+   * @param len Minimum length.
+   * @param message Message to throw against assertion failure.
+   */
   #define assertStrLenMin(str, len, message) \
     assertTrue(strlen(str) >= len, message)
 

src/util/math.c

@@ -9,6 +9,8 @@
 
 uint32_t mathNextPowTwo(uint32_t value) {
   if(value == 0) return 1; // Handle zero case
+  if(value >= 0x80000000) return 1; // Handle overflow case
+
   value--;
   value |= value >> 1;
   value |= value >> 2;

src/util/memory.c

@@ -7,6 +7,7 @@
 
 #include "memory.h"
 #include "assert/assert.h"
+#include "util/math.h"
 
 void * memoryAllocate(const size_t size) {
   assertTrue(size > 0, "Cannot allocate 0 bytes of memory.");
@@ -83,14 +84,13 @@ void memoryReallocate(void **ptr, const size_t size) {
 
 void memoryResize(void **ptr, const size_t oldSize, const size_t newSize) {
   assertNotNull(ptr, "Cannot resize NULL pointer.");
+  assertTrue(newSize > 0, "Cannot resize to 0 bytes of memory.");
+  assertTrue(oldSize > 0, "Old size cannot be 0 bytes.");
   if(newSize == oldSize) return;
-  if(oldSize == 0) return memoryReallocate(ptr, newSize);
-
-  assertTrue(newSize > oldSize, "New size must be greater than old size.");
 
   void *newPointer = memoryAllocate(newSize);
   assertNotNull(newPointer, "Memory resizing failed.");
-  memoryCopy(newPointer, *ptr, oldSize);
+  memoryCopy(newPointer, *ptr, mathMin(oldSize, newSize));
   memoryFree(*ptr);
   *ptr = newPointer;
 }