kit

ar_test.c (28381B)

---

 /* Round-trip tests for the kit ar reader/writer.
  *
  * Builds against just include/kit.h + libkit.a and a few libc calls
  * (malloc/realloc/free, printf for diagnostics). kit_ar_write itself
  * makes no heap allocations, so the test does not need a KitHeap.
  *
  * Set KIT_AR_TEST_HOST=1 to also dump the produced symbol-index
  * archive to /tmp/kit_ar_test.a and run the host's `ar t` and
  * `nm --print-armap` on it as a cross-check. */
 #include <kit/archive.h>
 #include <kit/core.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "lib/kit_unit.h"
 
 /* ===== minimal KitWriter over a growing buffer ===== */
 
 typedef struct BufW {
   KitWriter base;
   uint8_t* data;
   size_t len;
   size_t cap;
   KitStatus st;
 } BufW;
 
 static KitStatus bufw_write(KitWriter* w, const void* data, size_t n) {
   BufW* b = (BufW*)w;
   if (b->st != KIT_OK) return b->st;
   if (b->len + n > b->cap) {
     size_t nc = b->cap ? b->cap * 2 : 256;
     while (nc < b->len + n) nc *= 2;
     uint8_t* p = (uint8_t*)realloc(b->data, nc);
     if (!p) {
       b->st = KIT_NOMEM;
       return KIT_NOMEM;
     }
     b->data = p;
     b->cap = nc;
   }
   memcpy(b->data + b->len, data, n);
   b->len += n;
   return KIT_OK;
 }
 
 static KitStatus bufw_seek(KitWriter* w, uint64_t off) {
   (void)w;
   (void)off;
   return KIT_OK;
 }
 static uint64_t bufw_tell(KitWriter* w) { return ((BufW*)w)->len; }
 static KitStatus bufw_status(KitWriter* w) { return ((BufW*)w)->st; }
 static void bufw_close(KitWriter* w) { (void)w; }
 
 static void bufw_init(BufW* b) {
   b->base.write = bufw_write;
   b->base.seek = bufw_seek;
   b->base.tell = bufw_tell;
   b->base.status = bufw_status;
   b->base.close = bufw_close;
   b->data = NULL;
   b->len = 0;
   b->cap = 0;
   b->st = KIT_OK;
 }
 
 static void bufw_fini(BufW* b) { free(b->data); }
 
 /* ===== libc heap + context (needed by kit_ar_iter_new) ===== */
 
 static KitUnit g_u;
 
 /* ar_test keeps its own context: now=-1 and no diag sink, since its archive
  * assertions depend on exact header bytes (the clock) and never expect a
  * diagnostic. The heap comes from g_u, filled by kit_unit_init in main. */
 static KitContext g_ctx = {.heap = &g_u.heap, .now = -1};
 
 /* ===== assertion helpers ===== */
 
 /* EXPECT keeps its per-test early-return-on-fail shape via CU_CHECK_RET. */
 #define EXPECT(cond, ...) CU_CHECK_RET(&g_u, cond, __VA_ARGS__)
 
 static uint32_t be32(const uint8_t* p) {
   return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
          ((uint32_t)p[2] << 8) | (uint32_t)p[3];
 }
 
 /* Decode the ar_size field (10-byte ASCII decimal, space-padded). */
 static uint64_t ar_size_field(const uint8_t* hdr) {
   uint64_t v = 0;
   int j;
   for (j = 48; j < 58; ++j) {
     char c = (char)hdr[j];
     if (c < '0' || c > '9') break;
     v = v * 10 + (uint64_t)(c - '0');
   }
   return v;
 }
 
 /* Decode the ar_date field (12-byte ASCII decimal, space-padded). */
 static uint64_t ar_date_field(const uint8_t* hdr) {
   uint64_t v = 0;
   int j;
   for (j = 16; j < 28; ++j) {
     char c = (char)hdr[j];
     if (c < '0' || c > '9') break;
     v = v * 10 + (uint64_t)(c - '0');
   }
   return v;
 }
 
 /* ===== tests ===== */
 
 static int test_basic_roundtrip(void) {
   KitArInput ms[2];
   BufW bw;
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
   int rc;
 
   ms[0].name = KIT_SLICE_LIT("a.o");
   ms[0].bytes.data = (const uint8_t*)"AAAA";
   ms[0].bytes.len = 4;
   ms[1].name = KIT_SLICE_LIT("b.o");
   ms[1].bytes.data = (const uint8_t*)"BBBBB";
   ms[1].bytes.len = 5;
 
   bufw_init(&bw);
   rc = kit_ar_write(&bw.base, ms, 2, NULL);
   EXPECT(rc == 0, "kit_ar_write returned %d", rc);
   EXPECT(bw.st == KIT_OK, "writer error");
   EXPECT(bw.len >= 8, "archive too short");
   EXPECT(memcmp(bw.data, "!<arch>\n", 8) == 0, "magic");
 
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
 
   EXPECT(kit_ar_iter_next(it, &m), "first member");
   EXPECT(kit_slice_eq_cstr(m.name, "a.o"), "name 0 = %.*s",
          KIT_SLICE_ARG(m.name));
   EXPECT(m.size == 4 && memcmp(m.data, "AAAA", 4) == 0, "data 0");
 
   EXPECT(kit_ar_iter_next(it, &m), "second member");
   EXPECT(kit_slice_eq_cstr(m.name, "b.o"), "name 1 = %.*s",
          KIT_SLICE_ARG(m.name));
   EXPECT(m.size == 5 && memcmp(m.data, "BBBBB", 5) == 0, "data 1");
 
   EXPECT(!kit_ar_iter_next(it, &m), "iter end");
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_long_name_table(void) {
   /* >15 chars triggers the // long-name table. */
   KitArInput ms[2];
   BufW bw;
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
   KitArWriteOptions opts = {0};
   int rc;
 
   opts.long_names = 1;
   ms[0].name = KIT_SLICE_LIT("short.o");
   ms[0].bytes.data = (const uint8_t*)"x";
   ms[0].bytes.len = 1;
   ms[1].name = KIT_SLICE_LIT("this_name_is_long_enough.o");
   ms[1].bytes.data = (const uint8_t*)"yy";
   ms[1].bytes.len = 2;
 
   bufw_init(&bw);
   rc = kit_ar_write(&bw.base, ms, 2, &opts);
   EXPECT(rc == 0, "write rc=%d", rc);
 
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
   EXPECT(kit_ar_iter_next(it, &m), "first member");
   EXPECT(kit_slice_eq_cstr(m.name, "short.o"), "name 0 = %.*s",
          KIT_SLICE_ARG(m.name));
   EXPECT(kit_ar_iter_next(it, &m), "second member");
   EXPECT(kit_slice_eq_cstr(m.name, "this_name_is_long_enough.o"),
          "long name = %.*s", KIT_SLICE_ARG(m.name));
   EXPECT(!kit_ar_iter_next(it, &m), "iter end");
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_symbol_index_empty(void) {
   KitArInput ms[1];
   BufW bw;
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
   KitArWriteOptions opts = {0};
   int rc;
   uint32_t nsyms;
 
   opts.symbol_index = 1;
   ms[0].name = KIT_SLICE_LIT("lonely.o");
   ms[0].bytes.data = (const uint8_t*)"P";
   ms[0].bytes.len = 1;
 
   bufw_init(&bw);
   rc = kit_ar_write(&bw.base, ms, 1, &opts);
   EXPECT(rc == 0, "write rc=%d", rc);
 
   /* First member after magic must be `/` index with count=0. */
   EXPECT(bw.len >= 8 + 60 + 4, "archive too short");
   EXPECT(bw.data[8] == '/' && bw.data[9] == ' ', "index name field");
   EXPECT(ar_size_field(bw.data + 8) == 4, "index payload size = 4");
   nsyms = be32(bw.data + 8 + 60);
   EXPECT(nsyms == 0, "nsyms = %u", nsyms);
 
   /* Iterator should skip the `/` and yield only the user member. */
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
   EXPECT(kit_ar_iter_next(it, &m), "first user member");
   EXPECT(kit_slice_eq_cstr(m.name, "lonely.o"), "name = %.*s",
          KIT_SLICE_ARG(m.name));
   EXPECT(!kit_ar_iter_next(it, &m), "iter end");
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_symbol_index_basic(void) {
   /* 2 members with symbol lists; verify count, offsets, and names. */
   KitSlice a_syms[] = {KIT_SLICE_LIT("foo"), KIT_SLICE_LIT("bar")};
   KitSlice b_syms[] = {KIT_SLICE_LIT("baz")};
   KitArMemberSymbols msyms[2];
   KitArInput ms[2];
   BufW bw;
   KitArWriteOptions opts = {0};
   int rc;
   uint32_t nsyms;
   const uint8_t* p;
   uint64_t index_payload;
   uint32_t off0, off1, off2;
   uint64_t a_hdr_off, b_hdr_off;
   const char* name;
 
   opts.symbol_index = 1;
   opts.long_names = 1;
 
   msyms[0].names = a_syms;
   msyms[0].count = 2;
   msyms[1].names = b_syms;
   msyms[1].count = 1;
   opts.member_symbols = msyms;
 
   ms[0].name = KIT_SLICE_LIT("a.o");
   ms[0].bytes.data = (const uint8_t*)"AAAA";
   ms[0].bytes.len = 4;
   ms[1].name = KIT_SLICE_LIT("b.o");
   ms[1].bytes.data = (const uint8_t*)"BBBBB";
   ms[1].bytes.len = 5;
 
   bufw_init(&bw);
   rc = kit_ar_write(&bw.base, ms, 2, &opts);
   EXPECT(rc == 0, "write rc=%d", rc);
 
   EXPECT(memcmp(bw.data, "!<arch>\n", 8) == 0, "magic");
   EXPECT(bw.data[8] == '/' && bw.data[9] == ' ', "index ar_name field");
 
   index_payload = ar_size_field(bw.data + 8);
   /* 4 (count) + 4*3 (offsets) + 3+1 + 3+1 + 3+1 (names "foo\0bar\0baz\0") = 28
    */
   EXPECT(index_payload == 28, "index payload = %llu",
          (unsigned long long)index_payload);
 
   p = bw.data + 8 + 60;
   nsyms = be32(p);
   p += 4;
   EXPECT(nsyms == 3, "nsyms = %u", nsyms);
 
   off0 = be32(p);     /* foo → a.o */
   off1 = be32(p + 4); /* bar → a.o */
   off2 = be32(p + 8); /* baz → b.o */
   p += 12;
 
   /* Compute expected header offsets: index_total = 60+28 (no pad, even).
    * No long-name table is emitted (basenames ≤ 15 chars). So:
    *   a.o header at offset 8 + 88 = 96
    *   b.o header at offset 96 + 60 + 4 (+0 pad) = 160 */
   a_hdr_off = 8 + 60 + 28;
   b_hdr_off = a_hdr_off + 60 + 4;
   EXPECT(off0 == a_hdr_off, "off0 = %u, expected %llu", off0,
          (unsigned long long)a_hdr_off);
   EXPECT(off1 == a_hdr_off, "off1 = %u, expected %llu", off1,
          (unsigned long long)a_hdr_off);
   EXPECT(off2 == b_hdr_off, "off2 = %u, expected %llu", off2,
          (unsigned long long)b_hdr_off);
 
   /* Sanity: the member headers must actually live at those offsets. */
   EXPECT(memcmp(bw.data + a_hdr_off, "a.o/", 4) == 0, "a.o at offset");
   EXPECT(memcmp(bw.data + b_hdr_off, "b.o/", 4) == 0, "b.o at offset");
 
   /* Names: "foo\0bar\0baz\0" */
   name = (const char*)p;
   EXPECT(strcmp(name, "foo") == 0, "name 0 = %s", name);
   name += strlen(name) + 1;
   EXPECT(strcmp(name, "bar") == 0, "name 1 = %s", name);
   name += strlen(name) + 1;
   EXPECT(strcmp(name, "baz") == 0, "name 2 = %s", name);
 
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_symbol_index_with_long_names(void) {
   /* `/` member must come BEFORE `//` long-name table, and offsets must
    * still point at correct member-header positions. */
   KitSlice syms0[] = {KIT_SLICE_LIT("alpha")};
   KitSlice syms1[] = {KIT_SLICE_LIT("beta")};
   KitArMemberSymbols msyms[2];
   KitArInput ms[2];
   BufW bw;
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
   KitArWriteOptions opts = {0};
   int rc;
   uint64_t index_payload, longtab_payload;
   uint64_t index_total, longtab_total;
   uint64_t m0_hdr, m1_hdr;
   uint32_t off0, off1;
   const uint8_t* p;
 
   opts.symbol_index = 1;
   opts.long_names = 1;
   msyms[0].names = syms0;
   msyms[0].count = 1;
   msyms[1].names = syms1;
   msyms[1].count = 1;
   opts.member_symbols = msyms;
 
   ms[0].name = KIT_SLICE_LIT("this_name_is_long_enough.o"); /* 26 chars → // */
   ms[0].bytes.data = (const uint8_t*)"X";
   ms[0].bytes.len = 1;
   ms[1].name = KIT_SLICE_LIT("short.o");
   ms[1].bytes.data = (const uint8_t*)"YY";
   ms[1].bytes.len = 2;
 
   bufw_init(&bw);
   rc = kit_ar_write(&bw.base, ms, 2, &opts);
   EXPECT(rc == 0, "write rc=%d", rc);
 
   /* Layout: magic(8) | / index member | // long-name member | members. */
   EXPECT(bw.data[8] == '/' && bw.data[9] == ' ', "/ first");
   index_payload = ar_size_field(bw.data + 8);
   /* 4 (count) + 4*2 (offsets) + 6 ("alpha\0") + 5 ("beta\0") = 23 → odd → pad 1
    */
   EXPECT(index_payload == 23, "index_payload = %llu",
          (unsigned long long)index_payload);
   index_total = 60 + index_payload + (index_payload & 1);
 
   /* Verify // header sits at 8 + index_total. */
   EXPECT(bw.data[8 + index_total] == '/', "// pos byte 0");
   EXPECT(bw.data[8 + index_total + 1] == '/', "// pos byte 1");
   longtab_payload = ar_size_field(bw.data + 8 + index_total);
   /* "this_name_is_long_enough.o/\n" = 28 bytes → even → no pad */
   EXPECT(longtab_payload == 28, "longtab payload = %llu",
          (unsigned long long)longtab_payload);
   longtab_total = 60 + longtab_payload + (longtab_payload & 1);
 
   m0_hdr = 8 + index_total + longtab_total;
   m1_hdr = m0_hdr + 60 + 1 + 1 /* parity pad for odd len 1 */;
 
   p = bw.data + 8 + 60;
   EXPECT(be32(p) == 2, "nsyms = %u", be32(p));
   p += 4;
   off0 = be32(p);
   off1 = be32(p + 4);
   EXPECT(off0 == m0_hdr, "off0 = %u, expected %llu", off0,
          (unsigned long long)m0_hdr);
   EXPECT(off1 == m1_hdr, "off1 = %u, expected %llu", off1,
          (unsigned long long)m1_hdr);
   /* Spot-check m1 starts with "short.o/" for sanity. */
   EXPECT(memcmp(bw.data + m1_hdr, "short.o/", 8) == 0, "m1 hdr");
 
   /* Iterator should walk past both /, // and yield 2 members. */
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
   EXPECT(kit_ar_iter_next(it, &m), "m0");
   EXPECT(kit_slice_eq_cstr(m.name, "this_name_is_long_enough.o"),
          "m0 name = %.*s", KIT_SLICE_ARG(m.name));
   EXPECT(kit_ar_iter_next(it, &m), "m1");
   EXPECT(kit_slice_eq_cstr(m.name, "short.o"), "m1 name = %.*s",
          KIT_SLICE_ARG(m.name));
   EXPECT(!kit_ar_iter_next(it, &m), "iter end");
 
   /* Optional host cross-check. */
   if (getenv("KIT_AR_TEST_HOST")) {
     FILE* f = fopen("/tmp/kit_ar_test.a", "wb");
     if (f) {
       fwrite(bw.data, 1, bw.len, f);
       fclose(f);
       fprintf(stderr, "host cross-check: ar t /tmp/kit_ar_test.a\n");
       (void)!system("ar t /tmp/kit_ar_test.a");
       fprintf(stderr,
               "host cross-check: nm --print-armap /tmp/kit_ar_test.a\n");
       (void)!system("nm --print-armap /tmp/kit_ar_test.a 2>&1 || true");
     }
   }
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_iter_skips_index(void) {
   /* Make sure the iterator never surfaces the `/` member as a user member. */
   KitSlice s[] = {KIT_SLICE_LIT("only_sym")};
   KitArMemberSymbols msyms[1];
   KitArInput ms[1];
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
   BufW bw;
   KitArWriteOptions opts = {0};
   int seen = 0;
 
   opts.symbol_index = 1;
   msyms[0].names = s;
   msyms[0].count = 1;
   opts.member_symbols = msyms;
   ms[0].name = KIT_SLICE_LIT("only.o");
   ms[0].bytes.data = (const uint8_t*)"Z";
   ms[0].bytes.len = 1;
 
   bufw_init(&bw);
   EXPECT(kit_ar_write(&bw.base, ms, 1, &opts) == 0, "write");
 
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
   while (kit_ar_iter_next(it, &m)) {
     EXPECT(!kit_slice_eq_cstr(m.name, "/"), "iter surfaced raw `/` member");
     seen++;
   }
   EXPECT(seen == 1, "saw %d members", seen);
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_empty_archive(void) {
   /* nmembers == 0 with NULL members should produce a magic-only archive. */
   BufW bw;
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
   int rc;
 
   bufw_init(&bw);
   rc = kit_ar_write(&bw.base, NULL, 0, NULL);
   EXPECT(rc == 0, "write rc=%d", rc);
   EXPECT(bw.len == 8, "size = %zu", bw.len);
   EXPECT(memcmp(bw.data, "!<arch>\n", 8) == 0, "magic only");
 
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
   EXPECT(!kit_ar_iter_next(it, &m), "no members");
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_epoch_field(void) {
   /* opts.epoch is written into ar_date for every member. */
   KitArInput ms[1];
   BufW bw;
   KitArWriteOptions opts = {0};
   int rc;
 
   ms[0].name = KIT_SLICE_LIT("x.o");
   ms[0].bytes.data = (const uint8_t*)"q";
   ms[0].bytes.len = 1;
 
   opts.epoch = 1234567890u;
   bufw_init(&bw);
   rc = kit_ar_write(&bw.base, ms, 1, &opts);
   EXPECT(rc == 0, "write rc=%d", rc);
   EXPECT(ar_date_field(bw.data + 8) == 1234567890u, "ar_date = %llu",
          (unsigned long long)ar_date_field(bw.data + 8));
   bufw_fini(&bw);
 
   /* Default (epoch=0): single '0' followed by spaces. */
   opts.epoch = 0;
   bufw_init(&bw);
   rc = kit_ar_write(&bw.base, ms, 1, &opts);
   EXPECT(rc == 0, "write rc=%d", rc);
   EXPECT(bw.data[8 + 16] == '0', "epoch default first byte");
   EXPECT(bw.data[8 + 17] == ' ', "epoch default second byte = 0x%02x",
          bw.data[8 + 17]);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_path_basename(void) {
   /* Member name with path components is stored as basename only. */
   KitArInput ms[1];
   BufW bw;
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
 
   ms[0].name = KIT_SLICE_LIT("src/sub/foo.o");
   ms[0].bytes.data = (const uint8_t*)"D";
   ms[0].bytes.len = 1;
 
   bufw_init(&bw);
   EXPECT(kit_ar_write(&bw.base, ms, 1, NULL) == 0, "write");
 
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
   EXPECT(kit_ar_iter_next(it, &m), "first");
   EXPECT(kit_slice_eq_cstr(m.name, "foo.o"), "basename = %.*s",
          KIT_SLICE_ARG(m.name));
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_truncate_when_long_names_off(void) {
   /* >15 chars without long_names: name is truncated to 15. */
   KitArInput ms[1];
   BufW bw;
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
 
   ms[0].name = KIT_SLICE_LIT("abcdefghijklmnopqrst.o"); /* 22 chars */
   ms[0].bytes.data = (const uint8_t*)"D";
   ms[0].bytes.len = 1;
 
   bufw_init(&bw);
   EXPECT(kit_ar_write(&bw.base, ms, 1, NULL) == 0, "write");
 
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
   EXPECT(kit_ar_iter_next(it, &m), "first");
   EXPECT(kit_slice_eq_cstr(m.name, "abcdefghijklmno"), "truncated = %.*s",
          KIT_SLICE_ARG(m.name));
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_name_15_char_boundary(void) {
   /* Exactly 15 chars: fits in-header even with long_names enabled. */
   KitArInput ms[1];
   BufW bw;
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
   KitArWriteOptions opts = {0};
 
   opts.long_names = 1;
   ms[0].name = KIT_SLICE_LIT("abcdefghijklmno"); /* 15 chars */
   ms[0].bytes.data = (const uint8_t*)"X";
   ms[0].bytes.len = 1;
 
   bufw_init(&bw);
   EXPECT(kit_ar_write(&bw.base, ms, 1, &opts) == 0, "write");
 
   /* No `//` long-name table: first member sits right after magic. */
   EXPECT(memcmp(bw.data + 8, "abcdefghijklmno/", 16) == 0, "name field = %.16s",
          (const char*)(bw.data + 8));
 
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
   EXPECT(kit_ar_iter_next(it, &m), "first");
   EXPECT(kit_slice_eq_cstr(m.name, "abcdefghijklmno"), "name = %.*s",
          KIT_SLICE_ARG(m.name));
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_name_16_char_boundary(void) {
   /* Exactly 16 chars: triggers // long-name table. */
   KitArInput ms[1];
   BufW bw;
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
   KitArWriteOptions opts = {0};
 
   opts.long_names = 1;
   ms[0].name = KIT_SLICE_LIT("abcdefghijklmnop"); /* 16 chars */
   ms[0].bytes.data = (const uint8_t*)"Y";
   ms[0].bytes.len = 1;
 
   bufw_init(&bw);
   EXPECT(kit_ar_write(&bw.base, ms, 1, &opts) == 0, "write");
   EXPECT(bw.data[8] == '/' && bw.data[9] == '/', "// header");
 
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
   EXPECT(kit_ar_iter_next(it, &m), "first");
   EXPECT(kit_slice_eq_cstr(m.name, "abcdefghijklmnop"), "name = %.*s",
          KIT_SLICE_ARG(m.name));
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_empty_member_payload(void) {
   /* len=0 (data=NULL): header only, no pad; followed by the next member. */
   KitArInput ms[2];
   BufW bw;
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
 
   ms[0].name = KIT_SLICE_LIT("empty.o");
   ms[0].bytes.data = NULL;
   ms[0].bytes.len = 0;
   ms[1].name = KIT_SLICE_LIT("next.o");
   ms[1].bytes.data = (const uint8_t*)"N";
   ms[1].bytes.len = 1;
 
   bufw_init(&bw);
   EXPECT(kit_ar_write(&bw.base, ms, 2, NULL) == 0, "write");
   /* magic(8) + hdr(60) + 0 + hdr(60) + 1 + pad(1) = 130 */
   EXPECT(bw.len == 130, "size = %zu", bw.len);
 
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
   EXPECT(kit_ar_iter_next(it, &m), "first");
   EXPECT(kit_slice_eq_cstr(m.name, "empty.o") && m.size == 0,
          "empty.o size=%zu", m.size);
   EXPECT(kit_ar_iter_next(it, &m), "second");
   EXPECT(kit_slice_eq_cstr(m.name, "next.o") && m.size == 1 && m.data[0] == 'N',
          "next.o");
   EXPECT(!kit_ar_iter_next(it, &m), "iter end");
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_odd_payload_pad(void) {
   /* Odd-length payloads add a '\n' parity pad; even lengths do not. */
   KitArInput ms[3];
   BufW bw;
 
   ms[0].name = KIT_SLICE_LIT("a.o");
   ms[0].bytes.data = (const uint8_t*)"x";
   ms[0].bytes.len = 1;
   ms[1].name = KIT_SLICE_LIT("b.o");
   ms[1].bytes.data = (const uint8_t*)"yy";
   ms[1].bytes.len = 2;
   ms[2].name = KIT_SLICE_LIT("c.o");
   ms[2].bytes.data = (const uint8_t*)"z";
   ms[2].bytes.len = 1;
 
   bufw_init(&bw);
   EXPECT(kit_ar_write(&bw.base, ms, 3, NULL) == 0, "write");
   /* 8 + (60+1+1) + (60+2) + (60+1+1) = 194 */
   EXPECT(bw.len == 194, "size = %zu", bw.len);
   EXPECT(bw.data[8 + 60 + 1] == '\n', "pad after a.o = 0x%02x",
          bw.data[8 + 60 + 1]);
   /* No pad after b.o (even): next header begins immediately. */
   EXPECT(bw.data[8 + 62 + 60 + 2] == 'c', "c.o name follows b.o without pad");
 
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_ar_list_output(void) {
   /* kit_ar_list emits one user member per line, skipping / and //. */
   KitArInput ms[3];
   BufW bw, lw;
   KitSlice in;
   KitArWriteOptions opts = {0};
   const char* expected = "a.o\nlong_name_member.o\nb.o\n";
 
   opts.symbol_index = 1;
   opts.long_names = 1;
   ms[0].name = KIT_SLICE_LIT("a.o");
   ms[0].bytes.data = (const uint8_t*)"A";
   ms[0].bytes.len = 1;
   ms[1].name = KIT_SLICE_LIT("long_name_member.o");
   ms[1].bytes.data = (const uint8_t*)"B";
   ms[1].bytes.len = 1;
   ms[2].name = KIT_SLICE_LIT("b.o");
   ms[2].bytes.data = (const uint8_t*)"C";
   ms[2].bytes.len = 1;
 
   bufw_init(&bw);
   EXPECT(kit_ar_write(&bw.base, ms, 3, &opts) == 0, "write");
 
   in.data = bw.data;
   in.len = bw.len;
   bufw_init(&lw);
   EXPECT(kit_ar_list(&in, &lw.base) == 0, "list");
   EXPECT(lw.len == strlen(expected), "list len = %zu, want %zu", lw.len,
          strlen(expected));
   EXPECT(memcmp(lw.data, expected, lw.len) == 0, "list = %.*s", (int)lw.len,
          (const char*)lw.data);
 
   bufw_fini(&lw);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_iter_bad_magic(void) {
   /* iter_init must reject non-ar inputs. */
   static const uint8_t bad[] = "NOT-AN-AR";
   KitSlice in;
   KitArIter* it = NULL;
 
   in.data = bad;
   in.len = sizeof(bad) - 1;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) != KIT_OK, "rejects bad magic");
 
   in.data = NULL;
   in.len = 0;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) != KIT_OK, "rejects empty");
 
   in.data = bad;
   in.len = 4; /* too short */
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) != KIT_OK, "rejects short");
 
   return 1;
 }
 
 static int test_write_invalid_args(void) {
   /* Bad argument combinations must return 1 from kit_ar_write. */
   KitArInput ms[1];
   BufW bw;
   KitArWriteOptions opts = {0};
   KitSlice bad_syms[1];
   KitArMemberSymbols msyms[1];
 
   bufw_init(&bw);
 
   EXPECT(kit_ar_write(NULL, NULL, 0, NULL) != KIT_OK, "NULL writer rejected");
   EXPECT(kit_ar_write(&bw.base, NULL, 1, NULL) != KIT_OK,
          "NULL members with nmembers>0 rejected");
 
   ms[0].name = KIT_SLICE_NULL;
   ms[0].bytes.data = (const uint8_t*)"X";
   ms[0].bytes.len = 1;
   EXPECT(kit_ar_write(&bw.base, ms, 1, NULL) != KIT_OK, "NULL name rejected");
 
   /* NULL symbol-name with nonzero count. */
   bad_syms[0] = KIT_SLICE_NULL;
   msyms[0].names = bad_syms;
   msyms[0].count = 1;
   opts.symbol_index = 1;
   opts.member_symbols = msyms;
   ms[0].name = KIT_SLICE_LIT("ok.o");
   EXPECT(kit_ar_write(&bw.base, ms, 1, &opts) != KIT_OK,
          "NULL symbol name rejected");
 
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_iter_skips_bsd_symdef(void) {
   /* Hand-craft an archive containing a BSD __.SYMDEF SORTED member; the
    * iterator must not surface it. (kit_ar_write never emits BSD indexes,
    * but the iterator is documented to handle them on read.) */
   BufW bw;
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
   char hdr[60];
   size_t j;
   int seen = 0;
 
   bufw_init(&bw);
   bw.base.write(&bw.base, "!<arch>\n", 8);
 
   /* __.SYMDEF SORTED with a 4-byte payload. */
   for (j = 0; j < 60; ++j) hdr[j] = ' ';
   {
     const char* nm = "__.SYMDEF SORTED";
     for (j = 0; j < 16 && nm[j]; ++j) hdr[j] = nm[j];
   }
   hdr[16] = '0';
   hdr[28] = '0';
   hdr[34] = '0';
   hdr[40] = '6';
   hdr[41] = '4';
   hdr[42] = '4';
   hdr[48] = '4'; /* size = 4 */
   hdr[58] = '`';
   hdr[59] = '\n';
   bw.base.write(&bw.base, hdr, 60);
   bw.base.write(&bw.base, "ZZZZ", 4);
 
   /* User member u.o size=1 + parity pad. */
   for (j = 0; j < 60; ++j) hdr[j] = ' ';
   hdr[0] = 'u';
   hdr[1] = '.';
   hdr[2] = 'o';
   hdr[3] = '/';
   hdr[16] = '0';
   hdr[28] = '0';
   hdr[34] = '0';
   hdr[40] = '6';
   hdr[41] = '4';
   hdr[42] = '4';
   hdr[48] = '1';
   hdr[58] = '`';
   hdr[59] = '\n';
   bw.base.write(&bw.base, hdr, 60);
   bw.base.write(&bw.base, "U\n", 2);
 
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
   while (kit_ar_iter_next(it, &m)) {
     EXPECT(kit_slice_eq_cstr(m.name, "u.o"), "unexpected name = %.*s",
            KIT_SLICE_ARG(m.name));
     seen++;
   }
   EXPECT(seen == 1, "saw %d members", seen);
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_iter_data_aliases_archive(void) {
   /* KitArMember.data must point into the archive's own bytes. */
   KitArInput ms[1];
   BufW bw;
   KitSlice in;
   KitArIter* it = NULL;
   KitArMember m;
 
   ms[0].name = KIT_SLICE_LIT("a.o");
   ms[0].bytes.data = (const uint8_t*)"PAYLOAD";
   ms[0].bytes.len = 7;
 
   bufw_init(&bw);
   EXPECT(kit_ar_write(&bw.base, ms, 1, NULL) == 0, "write");
 
   in.data = bw.data;
   in.len = bw.len;
   EXPECT(kit_ar_iter_new(&g_ctx, &in, &it) == KIT_OK, "iter_init");
   EXPECT(kit_ar_iter_next(it, &m), "first");
   EXPECT(m.data >= bw.data && m.data + m.size <= bw.data + bw.len,
          "data aliases archive bytes");
   EXPECT(memcmp(m.data, "PAYLOAD", 7) == 0, "payload");
 
   kit_ar_iter_free(it);
   bufw_fini(&bw);
   return 1;
 }
 
 static int test_symbol_index_partial_members(void) {
   /* Members with 0 symbols mid-list: cur_offset must still advance for
    * every member so later offsets land on the right header. */
   KitSlice mid_syms[] = {KIT_SLICE_LIT("midsym")};
   KitArMemberSymbols msyms[3];
   KitArInput ms[3];
   BufW bw;
   KitArWriteOptions opts = {0};
   uint32_t nsyms, off;
   uint64_t expected_b_hdr;
 
   opts.symbol_index = 1;
   msyms[0].names = NULL;
   msyms[0].count = 0;
   msyms[1].names = mid_syms;
   msyms[1].count = 1;
   msyms[2].names = NULL;
   msyms[2].count = 0;
   opts.member_symbols = msyms;
 
   ms[0].name = KIT_SLICE_LIT("a.o");
   ms[0].bytes.data = (const uint8_t*)"AA";
   ms[0].bytes.len = 2;
   ms[1].name = KIT_SLICE_LIT("b.o");
   ms[1].bytes.data = (const uint8_t*)"BB";
   ms[1].bytes.len = 2;
   ms[2].name = KIT_SLICE_LIT("c.o");
   ms[2].bytes.data = (const uint8_t*)"CC";
   ms[2].bytes.len = 2;
 
   bufw_init(&bw);
   EXPECT(kit_ar_write(&bw.base, ms, 3, &opts) == 0, "write");
 
   /* Index payload: 4(count) + 4(offset) + 7("midsym\0") = 15 → odd → +1 pad. */
   EXPECT(ar_size_field(bw.data + 8) == 15, "index payload = %llu",
          (unsigned long long)ar_size_field(bw.data + 8));
 
   nsyms = be32(bw.data + 8 + 60);
   EXPECT(nsyms == 1, "nsyms = %u", nsyms);
 
   off = be32(bw.data + 8 + 60 + 4);
   /* magic(8) + index(60+15+1) + a.o(60+2) = 146 */
   expected_b_hdr = 8 + 60 + 15 + 1 + 60 + 2;
   EXPECT(off == expected_b_hdr, "off = %u, expected %llu", off,
          (unsigned long long)expected_b_hdr);
   EXPECT(memcmp(bw.data + off, "b.o/", 4) == 0, "b.o at offset");
 
   bufw_fini(&bw);
   return 1;
 }
 
 int main(void) {
   int passes = 0;
   int total = 0;
 #define RUN(t)       \
   do {               \
     total++;         \
     passes += (t)(); \
   } while (0)
 
   kit_unit_init(&g_u);
   RUN(test_basic_roundtrip);
   RUN(test_long_name_table);
   RUN(test_symbol_index_empty);
   RUN(test_symbol_index_basic);
   RUN(test_symbol_index_with_long_names);
   RUN(test_iter_skips_index);
   RUN(test_empty_archive);
   RUN(test_epoch_field);
   RUN(test_path_basename);
   RUN(test_truncate_when_long_names_off);
   RUN(test_name_15_char_boundary);
   RUN(test_name_16_char_boundary);
   RUN(test_empty_member_payload);
   RUN(test_odd_payload_pad);
   RUN(test_ar_list_output);
   RUN(test_iter_bad_magic);
   RUN(test_write_invalid_args);
   RUN(test_iter_skips_bsd_symdef);
   RUN(test_iter_data_aliases_archive);
   RUN(test_symbol_index_partial_members);
 
   if (g_u.fails) {
     fprintf(stderr, "ar_test: %d failure(s) (%d/%d passed)\n", g_u.fails,
             passes, total);
     return 1;
   }
   printf("ar_test: OK (%d/%d)\n", passes, total);
   return 0;
 }