Add timer library.

2 files changed, 280 insertions, 0 deletions

diff --git a/timer/test/test.h b/timer/test/test.h
new file mode 100644
index 0000000..fd8dc22
--- /dev/null
+++ b/timer/test/test.h
@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: MIT
+#pragma once
+
+#ifdef UNIT_TEST
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) ||     \
+    defined(__NetBSD__) || defined(__OpenBSD__)
+#define USE_SYSCTL_FOR_ARGS 1
+// clang-format off
+#include <sys/types.h>
+#include <sys/sysctl.h>
+// clang-format on
+#include <unistd.h>        // getpid
+#endif
+
+struct test_file_metadata;
+
+struct test_failure {
+        bool present;
+        const char *message;
+        const char *file;
+        int line;
+};
+
+struct test_case_metadata {
+        void (*fn)(struct test_case_metadata *, struct test_file_metadata *);
+        struct test_failure failure;
+        const char *name;
+        struct test_case_metadata *next;
+};
+
+struct test_file_metadata {
+        bool registered;
+        const char *name;
+        struct test_file_metadata *next;
+        struct test_case_metadata *tests;
+};
+
+struct test_file_metadata __attribute__((weak)) * test_file_head;
+
+#define SET_FAILURE(_message)                                                             \
+        metadata->failure = (struct test_failure) {                                       \
+                .message = _message, .file = __FILE__, .line = __LINE__, .present = true, \
+        }
+
+#define TEST_EQUAL(a, b)                                                                 \
+        do {                                                                             \
+                if ((a) != (b)) {                                                        \
+                        SET_FAILURE(#a " != " #b);                                       \
+                        return;                                                          \
+                }                                                                        \
+        } while (0)
+
+#define TEST_TRUE(a)                                                                     \
+        do {                                                                             \
+                if (!(a)) {                                                              \
+                        SET_FAILURE(#a " is not true");                                  \
+                        return;                                                          \
+                }                                                                        \
+        } while (0)
+
+#define TEST_STREQUAL(a, b)                                                              \
+        do {                                                                             \
+                if (strcmp(a, b) != 0) {                                                 \
+                        SET_FAILURE(#a " != " #b);                                       \
+                        return;                                                          \
+                }                                                                        \
+        } while (0)
+
+#define TEST_CASE(_name)                                                                  \
+        static void __test_h_##_name(struct test_case_metadata *,                         \
+                                     struct test_file_metadata *);                        \
+        static struct test_file_metadata __test_h_file;                                   \
+        static struct test_case_metadata __test_h_meta_##_name = {                        \
+            .name = #_name,                                                               \
+            .fn = __test_h_##_name,                                                       \
+        };                                                                                \
+        static void __attribute__((constructor(101))) __test_h_##_name##_register(void) { \
+                __test_h_meta_##_name.next = __test_h_file.tests;                         \
+                __test_h_file.tests = &__test_h_meta_##_name;                             \
+                if (!__test_h_file.registered) {                                          \
+                        __test_h_file.name = __FILE__;                                    \
+                        __test_h_file.next = test_file_head;                              \
+                        test_file_head = &__test_h_file;                                  \
+                        __test_h_file.registered = true;                                  \
+                }                                                                         \
+        }                                                                                 \
+        static void __test_h_##_name(                                                     \
+            struct test_case_metadata *metadata __attribute__((unused)),                  \
+            struct test_file_metadata *file_metadata __attribute__((unused)))
+
+extern void __attribute__((weak)) (*test_h_unittest_setup)(void);
+/// Run defined tests, return true if all tests succeeds
+/// @param[out] tests_run if not NULL, set to whether tests were run
+static inline void __attribute__((constructor(102))) run_tests(void) {
+        bool should_run = false;
+#ifdef USE_SYSCTL_FOR_ARGS
+        int mib[] = {
+                CTL_KERN,
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+                KERN_PROC_ARGS,
+                getpid(),
+                KERN_PROC_ARGV,
+#else
+                KERN_PROC,
+                KERN_PROC_ARGS,
+                getpid(),
+#endif
+        };
+        char *arg = NULL;
+        size_t arglen;
+        sysctl(mib, sizeof(mib) / sizeof(mib[0]), NULL, &arglen, NULL, 0);
+        arg = malloc(arglen);
+        sysctl(mib, sizeof(mib) / sizeof(mib[0]), arg, &arglen, NULL, 0);
+#else
+        FILE *cmdlinef = fopen("/proc/self/cmdline", "r");
+        char *arg = NULL;
+        int arglen;
+        fscanf(cmdlinef, "%ms%n", &arg, &arglen);
+        fclose(cmdlinef);
+#endif
+        for (char *pos = arg; pos < arg + arglen; pos += strlen(pos) + 1) {
+                if (strcmp(pos, "--unittest") == 0) {
+                        should_run = true;
+                        break;
+                }
+        }
+        free(arg);
+
+        if (!should_run) {
+                return;
+        }
+
+        if (&test_h_unittest_setup) {
+                test_h_unittest_setup();
+        }
+
+        struct test_file_metadata *i = test_file_head;
+        int failed = 0, success = 0;
+        while (i) {
+                fprintf(stderr, "Running tests from %s:\n", i->name);
+                struct test_case_metadata *j = i->tests;
+                while (j) {
+                        fprintf(stderr, "\t%s ... ", j->name);
+                        j->failure.present = false;
+                        j->fn(j, i);
+                        if (j->failure.present) {
+                                fprintf(stderr, "failed (%s at %s:%d)\n", j->failure.message,
+                                        j->failure.file, j->failure.line);
+                                failed++;
+                        } else {
+                                fprintf(stderr, "passed\n");
+                                success++;
+                        }
+                        j = j->next;
+                }
+                fprintf(stderr, "\n");
+                i = i->next;
+        }
+        int total = failed + success;
+        fprintf(stderr, "Test results: passed %d/%d, failed %d/%d\n", success, total,
+                failed, total);
+        exit(failed == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+}
+
+#else
+
+#include <stdbool.h>
+
+#define TEST_CASE(name) static void __attribute__((unused)) __test_h_##name(void)
+
+#define TEST_EQUAL(a, b)                                                                 \
+        (void)(a);                                                                       \
+        (void)(b)
+#define TEST_TRUE(a) (void)(a)
+#define TEST_STREQUAL(a, b)                                                              \
+        (void)(a);                                                                       \
+        (void)(b)
+
+#endif
diff --git a/timer/test/timer_test.c b/timer/test/timer_test.c
new file mode 100644
index 0000000..a220ead
--- /dev/null
+++ b/timer/test/timer_test.c
@@ -0,0 +1,95 @@
+#include "timer.h"
+
+#include <stdio.h>
+
+#include "test.h"
+
+// Sleep puts the calling thread to sleep for a time >= than the given time.
+TEST_CASE(sleep) {
+  const double sleep_time_sec = 0.1;
+
+  const time_point start = time_now();
+  time_sleep(sec_to_time_delta(sleep_time_sec));
+  const time_point end = time_now();
+
+  TEST_TRUE(time_delta_to_sec(time_diff(start, end)) >= sleep_time_sec);
+}
+
+// The timer starts as soon as it is created.
+TEST_CASE(start_on_new) {
+  const time_point test_start_time = time_now();
+  Timer timer = timer_make();
+  TEST_TRUE(time_delta_to_sec(time_diff(test_start_time, timer.start_time)) >=
+            0.0);
+}
+
+// Tick updates the timer's last tick time.
+TEST_CASE(tick_updates_last_tick_time) {
+  const double sleep_time_sec = 0.1;
+
+  Timer timer = timer_make();
+  time_sleep(sec_to_time_delta(sleep_time_sec));
+  timer_tick(&timer);
+
+  TEST_TRUE(time_delta_to_sec(time_diff(timer.start_time, timer.last_tick)) >=
+            sleep_time_sec);
+}
+
+// Tick updates the timer's delta time.
+TEST_CASE(tick_updates_delta_time) {
+  const double sleep_time_sec = 0.1;
+
+  Timer timer = timer_make();
+  time_sleep(sec_to_time_delta(sleep_time_sec));
+  timer_tick(&timer);
+
+  TEST_TRUE(time_delta_to_sec(timer.delta_time) >= sleep_time_sec);
+}
+
+// Tick leaves the timer's start time unchanged.
+TEST_CASE(tick_does_not_change_start_time) {
+  Timer timer = timer_make();
+  const time_point start_time = timer.start_time;
+  time_sleep(sec_to_time_delta(0.1));
+  timer_tick(&timer);
+  TEST_TRUE(time_delta_to_sec(time_diff(start_time, timer.start_time)) == 0.0);
+}
+
+// Start starts/restarts the timer and updates the timer's start time.
+TEST_CASE(start_restarts_start_time) {
+  const double sleep_time_seconds = 0.1;
+  Timer timer = timer_make();
+  const time_point start_time = timer.start_time;
+  time_sleep(sec_to_time_delta(sleep_time_seconds));
+  timer_start(&timer);
+  TEST_TRUE(time_delta_to_sec(time_diff(start_time, timer.start_time)) >=
+            sleep_time_seconds);
+}
+
+// Count the number of hundred-seconds in a second.
+TEST_CASE(count) {
+  Timer timer = timer_make();
+
+  int hundred_seconds = 0;
+  const time_point start = timer.start_time;
+  {
+    while (time_delta_to_sec(timer.running_time) <= 1.0) {
+      hundred_seconds++;
+      time_sleep(sec_to_time_delta(0.1));
+      timer_tick(&timer);
+      TEST_TRUE(time_delta_to_sec(timer.delta_time) >= 0.1);
+    }
+  }
+  const time_point end = time_now();
+
+  const double time_elapsed = time_delta_to_sec(time_diff(start, end));
+
+  TEST_EQUAL(hundred_seconds, 10);
+  TEST_TRUE(time_elapsed >= 1.0);
+}
+
+int main(int argc, const char** argv) {
+  (void)argc; // Unused.
+  printf("Usage: %s --unittest\n", argv[0]);
+  return 0;
+}