kit

kit_unit.h (8188B)

---

 /* test/lib/kit_unit.h — shared scaffolding for kit C unit tests.
  *
  * The unit suite copy-pasted the same prologue into ~18 files: a
  * malloc/realloc/free shim wrapping the host allocator into a KitHeap, a
  * diagnostic sink that prints to stderr, an EXPECT/CHECK macro, a
  * KitTargetSpec + KitTarget + KitContext + kit_compiler_new dance, and a
  * pass/fail counter checked in main(). This header folds all of that into one
  * stack-resident KitUnit context.
  *
  * Design constraints honored:
  *   - No global mutable state: every test threads a KitUnit it owns
  *     (matches the project's "everything hangs off a context struct" rule).
  *   - Public headers only (<kit/core.h>), so the header compiles
  *     unchanged in BOTH linkage regimes: linking the public archive
  *     (LIB_AR, where ld -r has hidden internal symbols) and linking the raw
  *     objects (LIB_OBJS + -Isrc, internal symbols visible). It never names
  *     an internal symbol, so a test that additionally pulls internal
  *     headers (its own #include "abi/abi.h" etc.) is unaffected.
  *   - Every helper is `static inline` so a TU that uses only part of the
  *     API does not trip -Werror,-Wunused-function (verified: unused
  *     `static inline` is warning-clean; unused bare `static` is not).
  *
  * The build rule adds -Itest, so include as:
  *   #include "lib/kit_unit.h"
  */
 
 #ifndef KIT_TEST_LIB_KIT_UNIT_H
 #define KIT_TEST_LIB_KIT_UNIT_H
 
 #include <kit/core.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 /* One context per test. Zero-initialize with kit_unit_init. The diag sink
  * captures the most recent message body into last_diag (before any
  * suppression), which expected-panic tests strstr() against. */
 typedef struct KitUnitTargetNode {
   KitTarget* target;
   struct KitUnitTargetNode* next;
 } KitUnitTargetNode;
 
 typedef struct KitUnit {
   KitHeap heap;
   KitDiagSink diag;
   KitContext ctx;
   KitUnitTargetNode* targets;
   char last_diag[256];
   int suppress_fatal; /* when set, FATAL diagnostics are captured but not
                        * printed — used by tests that drive a deliberate
                        * panic and assert on last_diag. */
   int checks;         /* total CU_CHECK/CU_EXPECT evaluations */
   int fails;          /* subset that failed */
 } KitUnit;
 
 static inline void* kit_unit_alloc(KitHeap* h, size_t n, size_t a) {
   (void)h;
   (void)a;
   return n ? malloc(n) : NULL;
 }
 
 static inline void* kit_unit_realloc(KitHeap* h, void* p, size_t old_n,
                                      size_t n, size_t a) {
   (void)h;
   (void)old_n;
   (void)a;
   return realloc(p, n);
 }
 
 static inline void kit_unit_free(KitHeap* h, void* p, size_t n) {
   (void)h;
   (void)n;
   free(p);
 }
 
 static inline void kit_unit_diag_emit(KitDiagSink* s, KitDiagKind k,
                                       KitSrcLoc loc, const char* fmt,
                                       va_list ap) {
   static const char* const names[] = {"note", "warning", "error", "fatal"};
   KitUnit* u = (KitUnit*)s->user;
   va_list copy;
   (void)loc;
   /* Capture the message body first so it is available even when suppressed. */
   if (u) {
     va_copy(copy, ap);
     vsnprintf(u->last_diag, sizeof u->last_diag, fmt, copy);
     va_end(copy);
     if (u->suppress_fatal && k == KIT_DIAG_FATAL) return;
   }
   fprintf(stderr, "%s: ", (unsigned)k < 4u ? names[k] : "diag");
   vfprintf(stderr, fmt, ap);
   fputc('\n', stderr);
 }
 
 /* Wire heap + diag + ctx onto u and zero the counters. ctx.now is set to 0
  * (the value the memset-to-zero majority of the suite already used); a test
  * that needs a specific clock may overwrite u->ctx.now afterward. */
 static inline void kit_unit_init(KitUnit* u) {
   memset(u, 0, sizeof *u);
   u->heap.alloc = kit_unit_alloc;
   u->heap.realloc = kit_unit_realloc;
   u->heap.free = kit_unit_free;
   u->diag.emit = kit_unit_diag_emit;
   u->diag.user = u;
   u->ctx.heap = &u->heap;
   u->ctx.diag = &u->diag;
   u->ctx.now = 0;
 }
 
 static inline KitTargetSpec kit_unit_target(KitArchKind arch, KitOSKind os,
                                             KitObjFmt obj) {
   KitTargetSpec t;
   memset(&t, 0, sizeof t);
   t.arch = arch;
   t.os = os;
   t.obj = obj;
   t.ptr_size = 8;
   t.ptr_align = 8;
   return t;
 }
 
 static inline KitStatus kit_unit_compiler_new(KitUnit* u, KitTargetSpec t,
                                               KitCompiler** out) {
   KitTargetOptions opts;
   KitTarget* target = NULL;
   KitUnitTargetNode* node = NULL;
   KitStatus st;
   if (out) *out = NULL;
   memset(&opts, 0, sizeof opts);
   opts.spec = t;
   st = kit_target_new(&u->ctx, &opts, &target);
   if (st != KIT_OK) return st;
   node = (KitUnitTargetNode*)kit_unit_alloc(&u->heap, sizeof(*node),
                                             _Alignof(KitUnitTargetNode));
   if (!node) {
     kit_target_free(target);
     return KIT_NOMEM;
   }
   st = kit_compiler_new(target, &u->ctx, out);
   if (st != KIT_OK) {
     kit_unit_free(&u->heap, node, sizeof(*node));
     kit_target_free(target);
     return st;
   }
   node->target = target;
   node->next = u->targets;
   u->targets = node;
   return KIT_OK;
 }
 
 static inline void kit_unit_fini(KitUnit* u) {
   KitUnitTargetNode* n = u ? u->targets : NULL;
   while (n) {
     KitUnitTargetNode* next = n->next;
     kit_target_free(n->target);
     kit_unit_free(&u->heap, n, sizeof(*n));
     n = next;
   }
   if (u) u->targets = NULL;
 }
 
 /* Byte-substring search, for tests asserting emitted machine code contains a
  * given encoding. Returns 1 if pat occurs in data (empty pat matches). */
 static inline int kit_unit_contains(const uint8_t* data, size_t len,
                                     const uint8_t* pat, size_t pat_len) {
   size_t i;
   if (pat_len == 0) return 1;
   if (len < pat_len) return 0;
   for (i = 0; i <= len - pat_len; ++i) {
     if (memcmp(data + i, pat, pat_len) == 0) return 1;
   }
   return 0;
 }
 
 static inline void kit_unit_summary(KitUnit* u, const char* name) {
   if (u->fails) {
     fprintf(stderr, "%s: %d/%d checks failed\n", name, u->fails, u->checks);
   } else {
     printf("%s: %d checks, 0 failures\n", name, u->checks);
   }
 }
 
 static inline int kit_unit_status(KitUnit* u) {
   int rc = u->fails ? 1 : 0;
   kit_unit_fini(u);
   return rc;
 }
 
 /* Record one check. `cond` is evaluated EXACTLY ONCE — it may have side
  * effects (e.g. EXPECT(kit_ar_iter_next(it, &m), ...) advances an
  * iterator). Always bumps u->checks; on a miss bumps u->fails and prints a
  * located FAIL line. Threads the context explicitly (no hidden global). */
 #define CU_CHECK(u, cond, ...)                             \
   do {                                                     \
     int cu_ok_ = (cond) ? 1 : 0;                           \
     ++(u)->checks;                                         \
     if (!cu_ok_) {                                         \
       ++(u)->fails;                                        \
       fprintf(stderr, "FAIL %s:%d: ", __FILE__, __LINE__); \
       fprintf(stderr, __VA_ARGS__);                        \
       fputc('\n', stderr);                                 \
     }                                                      \
   } while (0)
 
 /* Spelling preferred by most existing call sites. */
 #define CU_EXPECT(u, cond, ...) CU_CHECK(u, cond, __VA_ARGS__)
 
 /* CU_CHECK then `return 0;` on a miss — also evaluates `cond` exactly once.
  * Preserves the per-test-function early-return shape used by table-of-tests
  * harnesses (e.g. ar_test). */
 #define CU_CHECK_RET(u, cond, ...)                         \
   do {                                                     \
     int cu_ok_ = (cond) ? 1 : 0;                           \
     ++(u)->checks;                                         \
     if (!cu_ok_) {                                         \
       ++(u)->fails;                                        \
       fprintf(stderr, "FAIL %s:%d: ", __FILE__, __LINE__); \
       fprintf(stderr, __VA_ARGS__);                        \
       fputc('\n', stderr);                                 \
       return 0;                                            \
     }                                                      \
   } while (0)
 
 #endif /* KIT_TEST_LIB_KIT_UNIT_H */