Improve test class

modules/Test.cppm

@@ -17,11 +17,9 @@ export namespace Core {
         if(addTestResult(file, static_cast<const B&>(wanted) == actual)) {
             return true;
         }
-        char buffer[512];
-        formatBuffer(
-            buffer, sizeof(buffer), "{}{}:{} - expected '{}' got '{}'{}",
-            Terminal::FG_RED, file, l.line(), wanted, actual, Terminal::RESET);
-        puts(buffer);
+        print(
+            "{}{}:{} - expected '{}' got '{}'{}\n", Terminal::FG_RED, file,
+            l.line(), wanted, actual, Terminal::RESET);
         return false;
     }
 

src/Test.cpp

@@ -1,64 +1,45 @@
 module Core.Test;
 
 import Core.Logger;
-import Core.Utility;
 import Core.Std;
 import Core.ToString;
+import Core.HashedString;
+import Core.HashMap;
 
-typedef struct {
-    char* file;
-    int tests;
-    int successTests;
-} Result;
+using Source = std::source_location;
 
-static Result* results = nullptr;
-static size_t resultsIndex = 0;
-static size_t resultsCapacity = 0;
+struct Result {
+    int tests = 0;
+    int successTests = 0;
+};
 
-static Result* getResult(const char* file) {
-    for(size_t i = 0; i < resultsIndex; i++) {
-        Result* r = results + i;
-        if(strcmp(r->file, file) == 0) {
-            return r;
-        }
-    }
-    while(resultsIndex >= resultsCapacity) {
-        size_t newCapacity = resultsCapacity == 0 ? 8 : resultsCapacity * 2;
-        results = static_cast<Result*>(
-            Core::reallocateRaw(results, newCapacity * sizeof(Result)));
-        resultsCapacity = newCapacity;
+static Core::HashMap<Core::HashedString<256>, Result> results;
+
+static Result& getResult(const char* file) {
+    Result* r = results.search(file);
+    if(r != nullptr) {
+        return *r;
     }
-    Result* r = results + (resultsIndex++);
-    r->file = strdup(file);
-    r->successTests = 0;
-    r->tests = 0;
-    return r;
+    return results.put(file, Result());
 }
 
 void Core::finalizeTests(void) {
-    for(size_t i = 0; i < resultsIndex; i++) {
-        Result* r = results + i;
-        bool c = r->successTests == r->tests;
-        fputs(c ? Terminal::FG_GREEN : Terminal::FG_RED, stdout);
+    for(const auto& r : results) {
+        const char* color = r.value.successTests == r.value.tests
+                                ? Terminal::FG_GREEN
+                                : Terminal::FG_RED;
         print(
-            "{} - {} / {} tests succeeded", r->file, r->successTests, r->tests);
-        puts(Terminal::RESET);
-        free(r->file);
+            "{}{} - {} / {} tests succeeded{}\n", color, r.getKey(),
+            r.value.successTests, r.value.tests, Terminal::RESET);
     }
-    Core::deallocateRaw(results);
-    results = nullptr;
-    resultsIndex = 0;
-    resultsCapacity = 0;
+    results.clear();
 }
 
 bool Core::addTestResult(const char* file, bool comparison) {
-    Result* r = getResult(file);
-    r->tests++;
-    if(comparison) {
-        r->successTests++;
-        return true;
-    }
-    return false;
+    Result& r = getResult(file);
+    r.tests++;
+    r.successTests += comparison;
+    return comparison;
 }
 
 #define TEST_SUCCESS(result)                            \
@@ -67,40 +48,33 @@ bool Core::addTestResult(const char* file, bool comparison) {
         return true;                                    \
     }
 
-bool Core::testString(
-    const char* wanted, const char* actual, const std::source_location& l) {
+#define PRINT(format, ...)                                    \
+    print(                                                    \
+        "{}{}:{} - " format "{}\n", Terminal::FG_RED, file,   \
+        l.line() __VA_OPT__(, ) __VA_ARGS__, Terminal::RESET)
+
+bool Core::testString(const char* wanted, const char* actual, const Source& l) {
     TEST_SUCCESS(strcmp(wanted, actual) == 0)
-    fputs(Terminal::FG_RED, stdout);
-    print("{}:{} - expected '{}' got '{}'", file, l.line(), wanted, actual);
-    puts(Terminal::RESET);
+    PRINT("expected '{}' got '{}'", wanted, actual);
     return false;
 }
 
-bool Core::testFloat(
-    float wanted, float actual, float error, const std::source_location& l) {
+bool Core::testFloat(float wanted, float actual, float error, const Source& l) {
     float diff = wanted - actual;
     diff = diff < 0.0f ? -diff : diff;
     TEST_SUCCESS(diff <= error)
-    fputs(Terminal::FG_RED, stdout);
-    print(
-        "{}:{} - expected '{.3}' got '{.3}'", file, l.line(),
-        static_cast<double>(wanted), static_cast<double>(actual));
-    puts(Terminal::RESET);
+    PRINT("expected '{.3}' got '{.3}'", wanted, actual);
     return false;
 }
 
-bool Core::testNull(const void* actual, const std::source_location& l) {
+bool Core::testNull(const void* actual, const Source& l) {
     TEST_SUCCESS(actual == nullptr)
-    fputs(Terminal::FG_RED, stdout);
-    print("{}:{} - expected null", file, l.line());
-    puts(Terminal::RESET);
+    PRINT("expected null");
     return false;
 }
 
-bool Core::testNotNull(const void* actual, const std::source_location& l) {
+bool Core::testNotNull(const void* actual, const Source& l) {
     TEST_SUCCESS(actual != nullptr)
-    fputs(Terminal::FG_RED, stdout);
-    print("{}:{} - expected valid pointer", file, l.line());
-    puts(Terminal::RESET);
+    PRINT("expected valid pointer");
     return false;
 }