Run tests before building library

.gitignore

@@ -3,6 +3,8 @@
 test
 test.*
 *.dSYM
+*.pdb
+*.obj
 compile_commands.json
 libwapp-build
 libwapp.so

build.ps1

@@ -3,11 +3,16 @@ Param(
 )
 
 $Compiler = "cl.exe"
+
 $GeneralFlags = "/Wall /WX /wd4996"
 $LibraryFlags = "/LD"
+
 $IncludeDirs = Get-ChildItem -Path src -Recurse -Directory -ErrorAction SilentlyContinue -Force | %{$("/I " + '"' + $_.FullName + '"')}
 $SrcFiles = Get-ChildItem -Path src -Recurse -Filter *.c -ErrorAction SilentlyContinue -Force | %{$('"' + $_.FullName + '"')}
 
+$TestIncludeDirs = Get-ChildItem -Path tests -Recurse -Directory -ErrorAction SilentlyContinue -Force | %{$("/I " + '"' + $_.FullName + '"')}
+$TestSrcFiles = Get-ChildItem -Path tests -Recurse -Filter *.c -ErrorAction SilentlyContinue -Force | %{$('"' + $_.FullName + '"')}
+
 If ($Release -eq $True) {
 	$GeneralFlags += " /O2 /Og"
 	$BuildType = "release"
@@ -19,15 +24,35 @@ If ($Release -eq $True) {
 $BuildDir = "./libwapp-build/windows-$BuildType"
 $ObjDir = "$BuildDir/objects"
 $OutDir = "$BuildDir/output"
+$TestsDir = "$BuildDir/tests"
+
 $OutBasename = "libwapp"
 $Objects = "/Fo:$ObjDir/"
 $Outputs = "/Fd:$OutDir/$OutBasename /Fe:$OutDir/$OutBasename"
 
+$TestOutBasename = "wapptest"
+$TestOutputs = "/Fo:$TestsDir/ /Fe:$TestsDir/$TestOutBasename"
+
 If (Test-Path $BuildDir) {
 	Remove-Item $BuildDir -Recurse -Force
 }
 
 mkdir -p $ObjDir > $null
 mkdir -p $OutDir > $null
+mkdir -p $TestsDir > $null
 
+# Build and run tests
+Invoke-Expression "$Compiler $GeneralFlags $IncludeDirs $TestIncludeDirs $SrcFiles $TestSrcFiles $TestOutputs" -ErrorAction Stop
+
+Invoke-Expression "$TestsDir/$TestOutBasename.exe"
+$Status = $LASTEXITCODE
+
+Remove-Item $TestsDir -Recurse -Force
+
+If ($Status -ne 0) {
+	Write-Error "Tests failed"
+	Exit 1
+}
+
+# Build library
 Invoke-Expression "$Compiler $GeneralFlags $LibraryFlags $IncludeDirs $SrcFiles $Objects $Outputs"

compile

@@ -64,8 +64,3 @@ fi
 
 # Compile library
 (set -x ; $CC $CFLAGS $LIBFLAGS $INCLUDE $SRC -o $OUT)
-
-# Compile test.c if it exists
-if [[ -f ./test.c ]]; then
-  (set -x ; $CC $CFLAGS $INCLUDE $SRC ./test.c -o test)
-fi

src/mem/arena/mem_arena.c

@@ -80,13 +80,14 @@ void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
 
 #ifdef WAPP_PLATFORM_WINDOWS
   if (!(arena->committed)) {
-    output = (u8 *)wapp_mem_util_alloc(output, size, WAPP_MEM_ACCESS_READ_WRITE,
-                                       WAPP_MEM_ALLOC_COMMIT,
-                                       WAPP_MEM_INIT_UNINITIALISED);
+    output = (u8 *)wapp_mem_util_alloc(
+        alloc_start, (uptr)(arena->offset) - (uptr)(alloc_start),
+        WAPP_MEM_ACCESS_READ_WRITE, WAPP_MEM_ALLOC_COMMIT,
+        WAPP_MEM_INIT_INITIALISED);
   }
-#endif // ifdef WAPP_PLATFORM_WINDOWS
-
+#else
   memset(output, 0, size);
+#endif // ifdef WAPP_PLATFORM_WINDOWS
 
   return (void *)output;
 }

src/strings/dstr/dstr.c

@@ -115,7 +115,7 @@ StringUpdate wapp_dstr_concat(String **dst, const char *src, Arena *arena) {
 #else
   char str[new_length + 1];
   memset(str, 0, new_length + 1);
-#endif
+#endif /* ifdef WAPP_PLATFORM_WINDOWS */
 
   strncpy(str, (*dst)->buf, (*dst)->size);
   strncat(str, src, new_length + 1 - (*dst)->size);

src/termcolour/termcolour.c

@@ -0,0 +1,101 @@
+#include "termcolour.h"
+#include "aliases.h"
+#include "platform.h"
+#include <stdio.h>
+
+internal void print_coloured_text(const TerminalColourist *colourist,
+                                  const char *text);
+
+#ifdef WAPP_PLATFORM_WINDOWS
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+
+internal WORD colours[COUNT_TERM_COLOUR] = {
+    [WAPP_TERM_COLOUR_FG_BLACK] = 0,
+    [WAPP_TERM_COLOUR_FG_RED] = FOREGROUND_RED,
+    [WAPP_TERM_COLOUR_FG_GREEN] = FOREGROUND_GREEN,
+    [WAPP_TERM_COLOUR_FG_BLUE] = FOREGROUND_BLUE,
+    [WAPP_TERM_COLOUR_FG_CYAN] = FOREGROUND_GREEN | FOREGROUND_BLUE,
+    [WAPP_TERM_COLOUR_FG_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE,
+    [WAPP_TERM_COLOUR_FG_YELLOW] = FOREGROUND_RED | FOREGROUND_GREEN,
+    [WAPP_TERM_COLOUR_FG_WHITE] =
+        FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
+    [WAPP_TERM_COLOUR_FG_BR_BLACK] = FOREGROUND_INTENSITY,
+    [WAPP_TERM_COLOUR_FG_BR_RED] = FOREGROUND_RED | FOREGROUND_INTENSITY,
+    [WAPP_TERM_COLOUR_FG_BR_GREEN] = FOREGROUND_GREEN | FOREGROUND_INTENSITY,
+    [WAPP_TERM_COLOUR_FG_BR_BLUE] = FOREGROUND_BLUE | FOREGROUND_INTENSITY,
+    [WAPP_TERM_COLOUR_FG_BR_CYAN] =
+        FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
+    [WAPP_TERM_COLOUR_FG_BR_MAGENTA] =
+        FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY,
+    [WAPP_TERM_COLOUR_FG_BR_YELLOW] =
+        FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY,
+    [WAPP_TERM_COLOUR_FG_BR_WHITE] = FOREGROUND_RED | FOREGROUND_GREEN |
+                                     FOREGROUND_BLUE | FOREGROUND_INTENSITY,
+};
+#else
+internal const char *colours[COUNT_TERM_COLOUR] = {
+    [WAPP_TERM_COLOUR_FG_BLACK] = "\033[30m",
+    [WAPP_TERM_COLOUR_FG_RED] = "\033[31m",
+    [WAPP_TERM_COLOUR_FG_GREEN] = "\033[32m",
+    [WAPP_TERM_COLOUR_FG_BLUE] = "\033[34m",
+    [WAPP_TERM_COLOUR_FG_CYAN] = "\033[36m",
+    [WAPP_TERM_COLOUR_FG_MAGENTA] = "\033[35m",
+    [WAPP_TERM_COLOUR_FG_YELLOW] = "\033[33m",
+    [WAPP_TERM_COLOUR_FG_WHITE] = "\033[37m",
+    [WAPP_TERM_COLOUR_FG_BR_BLACK] = "\033[90m",
+    [WAPP_TERM_COLOUR_FG_BR_RED] = "\033[91m",
+    [WAPP_TERM_COLOUR_FG_BR_GREEN] = "\033[92m",
+    [WAPP_TERM_COLOUR_FG_BR_BLUE] = "\033[94m",
+    [WAPP_TERM_COLOUR_FG_BR_CYAN] = "\033[96m",
+    [WAPP_TERM_COLOUR_FG_BR_MAGENTA] = "\033[95m",
+    [WAPP_TERM_COLOUR_FG_BR_YELLOW] = "\033[93m",
+    [WAPP_TERM_COLOUR_FG_BR_WHITE] = "\033[97m",
+};
+#endif /* ifdef WAPP_PLATFORM_WINDOWS */
+
+TerminalColourist wapp_termcolour_get_colourist(void) {
+  TerminalColourist colourist;
+
+#ifdef WAPP_PLATFORM_WINDOWS
+  // create handle
+  colourist.handle = GetStdHandle(STD_OUTPUT_HANDLE);
+
+  // get console colour information
+  CONSOLE_SCREEN_BUFFER_INFO csbi;
+  GetConsoleScreenBufferInfo(colourist.handle, &csbi);
+  colourist.default_colour = csbi.wAttributes;
+#else
+  colourist.default_colour = "\033[0m";
+#endif // ifdef WAPP_PLATFORM_WINDOWS
+
+  colourist.current_colour = colourist.default_colour;
+
+  return colourist;
+}
+
+void wapp_termcolour_print_text(TerminalColourist *colourist, const char *text,
+                                TerminalColour colour) {
+  if (colour < WAPP_TERM_COLOUR_FG_BLACK ||
+      colour > WAPP_TERM_COLOUR_FG_BR_WHITE) {
+    return;
+  }
+
+  colourist->current_colour = colours[colour];
+  print_coloured_text(colourist, text);
+}
+
+void wapp_termcolour_clear_colour(TerminalColourist *colourist) {
+  colourist->current_colour = colourist->default_colour;
+  print_coloured_text(colourist, "");
+}
+
+internal void print_coloured_text(const TerminalColourist *colourist,
+                                  const char *text) {
+#ifdef WAPP_PLATFORM_WINDOWS
+  SetConsoleTextAttribute(colourist->handle, colourist->current_colour);
+  printf("%s", text);
+#else
+  printf("%s%s", colourist->current_colour, text);
+#endif // ifdef WAPP_PLATFORM_WINDOWS
+}

src/termcolour/termcolour.h

@@ -1,48 +1,56 @@
 #ifndef TERM_COLOUR_H
 #define TERM_COLOUR_H
 
+#include "aliases.h"
+#include "misc_utils.h"
 #include "platform.h"
 
+typedef enum {
+  WAPP_TERM_COLOUR_FG_BLACK,
+  WAPP_TERM_COLOUR_FG_RED,
+  WAPP_TERM_COLOUR_FG_GREEN,
+  WAPP_TERM_COLOUR_FG_BLUE,
+  WAPP_TERM_COLOUR_FG_CYAN,
+  WAPP_TERM_COLOUR_FG_MAGENTA,
+  WAPP_TERM_COLOUR_FG_YELLOW,
+  WAPP_TERM_COLOUR_FG_WHITE,
+  WAPP_TERM_COLOUR_FG_BR_BLACK,
+  WAPP_TERM_COLOUR_FG_BR_RED,
+  WAPP_TERM_COLOUR_FG_BR_GREEN,
+  WAPP_TERM_COLOUR_FG_BR_BLUE,
+  WAPP_TERM_COLOUR_FG_BR_CYAN,
+  WAPP_TERM_COLOUR_FG_BR_MAGENTA,
+  WAPP_TERM_COLOUR_FG_BR_YELLOW,
+  WAPP_TERM_COLOUR_FG_BR_WHITE,
+
+  COUNT_TERM_COLOUR,
+} TerminalColour;
+
+typedef struct terminal_colourist TerminalColourist;
+
 // clang-format off
-#if defined(WAPP_PLATFORM_WINDOWS)
-  #define TERM_COLOUR_CLEAR ""
-  #define TERM_COLOUR_BOLD ""
-  #define TERM_COLOUR_FG_BLACK ""
-  #define TERM_COLOUR_FG_RED ""
-  #define TERM_COLOUR_FG_GREEN ""
-  #define TERM_COLOUR_FG_YELLOW ""
-  #define TERM_COLOUR_FG_BLUE ""
-  #define TERM_COLOUR_FG_MAGENTA ""
-  #define TERM_COLOUR_FG_CYAN ""
-  #define TERM_COLOUR_FG_WHITE ""
-  #define TERM_COLOUR_FG_BR_BLACK ""
-  #define TERM_COLOUR_FG_BR_RED ""
-  #define TERM_COLOUR_FG_BR_GREEN ""
-  #define TERM_COLOUR_FG_BR_YELLOW ""
-  #define TERM_COLOUR_FG_BR_BLUE ""
-  #define TERM_COLOUR_FG_BR_MAGENTA ""
-  #define TERM_COLOUR_FG_BR_CYAN ""
-  #define TERM_COLOUR_FG_BR_WHITE ""
-#elif defined(WAPP_PLATFORM_POSIX)
-  #define TERM_COLOUR_CLEAR "\033[0m"
-  #define TERM_COLOUR_BOLD "\033[1m"
-  #define TERM_COLOUR_FG_BLACK "\033[30m"
-  #define TERM_COLOUR_FG_RED "\033[31m"
-  #define TERM_COLOUR_FG_GREEN "\033[32m"
-  #define TERM_COLOUR_FG_YELLOW "\033[33m"
-  #define TERM_COLOUR_FG_BLUE "\033[34m"
-  #define TERM_COLOUR_FG_MAGENTA "\033[35m"
-  #define TERM_COLOUR_FG_CYAN "\033[36m"
-  #define TERM_COLOUR_FG_WHITE "\033[37m"
-  #define TERM_COLOUR_FG_BR_BLACK "\033[90m"
-  #define TERM_COLOUR_FG_BR_RED "\033[91m"
-  #define TERM_COLOUR_FG_BR_GREEN "\033[92m"
-  #define TERM_COLOUR_FG_BR_YELLOW "\033[93m"
-  #define TERM_COLOUR_FG_BR_BLUE "\033[94m"
-  #define TERM_COLOUR_FG_BR_MAGENTA "\033[95m"
-  #define TERM_COLOUR_FG_BR_CYAN "\033[96m"
-  #define TERM_COLOUR_FG_BR_WHITE "\033[97m"
-#endif
+#ifdef WAPP_PLATFORM_WINDOWS
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <WinCon.h>
+
+struct terminal_colourist {
+  HANDLE handle;
+  WORD default_colour;
+  WORD current_colour;
+  wapp_misc_utils_padding_size(sizeof(HANDLE) + sizeof(WORD) + sizeof(WORD));
+};
+#else
+struct terminal_colourist {
+  const char *default_colour;
+  const char *current_colour;
+};
+#endif // WAPP_PLATFORM_WINDOWS
 // clang-format on
 
+TerminalColourist wapp_termcolour_get_colourist(void);
+void wapp_termcolour_print_text(TerminalColourist *colourist, const char *text,
+                                TerminalColour colour);
+void wapp_termcolour_clear_colour(TerminalColourist *colourist);
+
 #endif // !TERM_COLOUR_H

src/tester/tester.c

@@ -1,16 +1,20 @@
 #include "tester.h"
 #include "aliases.h"
+#include "platform.h"
 #include "termcolour.h"
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-internal void print_test_result(TestFuncResult result);
+internal void handle_test_result(TerminalColourist *colourist,
+                                 TestFuncResult result);
 
 void run_tests(TestFunc *func1, ...) {
+  TerminalColourist colourist = wapp_termcolour_get_colourist();
+
   printf("\n");
 
-  print_test_result(func1());
+  handle_test_result(&colourist, func1());
 
   va_list args;
   va_start(args, func1);
@@ -19,11 +23,7 @@ void run_tests(TestFunc *func1, ...) {
 
   while (func) {
     TestFuncResult result = func();
-    print_test_result(result);
-
-    if (!result.passed) {
-      exit(EXIT_FAILURE);
-    }
+    handle_test_result(&colourist, result);
 
     func = va_arg(args, TestFunc *);
   }
@@ -33,18 +33,25 @@ void run_tests(TestFunc *func1, ...) {
   printf("\n");
 }
 
-internal void print_test_result(TestFuncResult result) {
-  const char *colour;
+internal void handle_test_result(TerminalColourist *colourist,
+                                 TestFuncResult result) {
+  TerminalColour colour;
   const char *result_text;
 
   if (result.passed) {
-    colour = TERM_COLOUR_FG_BR_GREEN;
+    colour = WAPP_TERM_COLOUR_FG_BR_GREEN;
     result_text = "PASSED";
   } else {
-    colour = TERM_COLOUR_FG_BR_RED;
+    colour = WAPP_TERM_COLOUR_FG_BR_RED;
     result_text = "FAILED";
   }
 
-  printf("[%s%s%s%s] %s\n", colour, TERM_COLOUR_BOLD, result_text,
-         TERM_COLOUR_CLEAR, result.name);
+  printf("[");
+  wapp_termcolour_print_text(colourist, result_text, colour);
+  wapp_termcolour_clear_colour(colourist);
+  printf("] %s\n", result.name);
+
+  if (!result.passed) {
+    exit(EXIT_FAILURE);
+  }
 }

tests/arena/test_arena.c

@@ -8,7 +8,7 @@
 #define ARENA_CAPACITY 1024
 
 internal Arena *arena = NULL;
-internal u64 count = 20;
+internal i32 count = 20;
 internal i32 *array = NULL;
 
 TestFuncResult test_arena_init(void) {
@@ -20,20 +20,20 @@ TestFuncResult test_arena_init(void) {
 TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) {
   Arena *large_arena = NULL;
   u64 capacity = 512ull * 1024ull * 1024ull * 1024ull;
-  bool result =
-      wapp_mem_arena_init(&large_arena, capacity, WAPP_MEM_ALLOC_RESERVE, false);
-	if (result) {
-		wapp_mem_arena_destroy(&large_arena);
-	}
+  bool result = wapp_mem_arena_init(&large_arena, capacity,
+                                    WAPP_MEM_ALLOC_RESERVE, false);
+  if (result) {
+    wapp_mem_arena_destroy(&large_arena);
+  }
 
-	return wapp_tester_result(result);
+  return wapp_tester_result(result);
 }
 
 TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) {
   array = wapp_mem_arena_alloc(arena, count * sizeof(i32));
   bool result = array != NULL;
 
-  for (u64 i = 0; i < count; ++i) {
+  for (i32 i = 0; i < count; ++i) {
     array[i] = i * 10;
   }
 
@@ -51,7 +51,7 @@ TestFuncResult test_arena_clear(void) {
   wapp_mem_arena_clear(arena);
   bool result = true;
 
-  for (u64 i = 0; i < count; ++i) {
+  for (i32 i = 0; i < count; ++i) {
     if (array[i] != 0) {
       result = false;
       break;