Test the libc wrappers: 52% -> 99% line coverage

Every wrapper outside the list and tree code was untested. Six new test files close that, following the plan already written in TODO.md 1.2-1.6: test_stream.c fopen/fread/fwrite/fclose -- happy paths, the round trip, AKERR_EOF on a short read, AKERR_IO on a stream opened in the wrong mode, ENOENT, and the NULL guards test_format.c printf/fprintf/sprintf -- text *and* count asserted (stdout is pointed at a temp file to check aksl_printf), all eight NULL guards, EBADF on a read-only stream, and 512 variadic calls in a loop as sanitizer cover for the missing va_end test_convert.c ato{i,l,ll,f} happy paths, negatives, leading whitespace, NULL guards test_path.c realpath on a file and on a symlink, both compared against realpath(3) since TMPDIR may itself be a link; ENOENT, ENOTDIR, NULL path test_strhash.c djb2 known-answer vectors, len == 0, embedded NUL, stability, NULL guards test_convert_strict.c known-failing (2.1.5): the AKERR_VALUE / ERANGE contract the ato* family cannot express today test_tree.c gains the BFS AKERR_NOT_IMPLEMENTED contract, NULL arguments, and a callback error that is not AKERR_ITERATOR_BREAK propagating out. Tests deliberately say nothing about behaviour TODO.md records as defective -- unchecked ptr/mode/resolved_path, short transfers reported as success, *count left at -1, the djb2 sign extension -- so the eventual fix does not have to come with a test rewrite. Each failure case in test_path.c passes a zeroed buffer, because the wrapper's own error path formats resolved_path with %s (2.1.6). aksl_capture.h gains aksl_temp_file() with an atexit unlink backstop. Without it every test that fails before its own unlink leaves temp files behind -- which is the normal case for a known-failing test, and happens 173 times over in a mutation run. Coverage on src/stdlib.c: 52.0% -> 99.0% of lines (200/202), 23.6% -> 51.0% of branches, 8/21 -> 21/21 functions. The two uncovered lines are both `} HANDLE(e, AKERR_ITERATOR_BREAK) {`, where the macro starts with the `break;` of PROCESS's `case 0:` arm -- reachable only via a non-NULL error context whose status is zero, the pathology 2.2.1 exists to remove. Mutation score on src/stdlib.c: 46.8% -> 89.6% (155/173 killed). CI, the pre-push hook and the docs ratchet from 40 to 80 accordingly, and the 18 survivors are grouped by cause in TODO.md and README.md. A new CI coverage job gates at 90% lines / 45% branches. Verified: ctest --test-dir build # 12/12 ctest --test-dir build-asan # 12/12 under ASan + UBSan ctest --test-dir build-coverage # 14/14, report attached ctest --test-dir build -j8 --repeat until-fail:3 gcc -Wall -Wextra -c on all nine test files # no warnings python3 scripts/mutation_test.py --target src/stdlib.c # 89.6% No temp files left in /tmp after any of the above. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-07-30 02:07:08 -04:00
parent 82c47ed773
commit 437da2960b
14 changed files with 1138 additions and 73 deletions
--- a/tests/test_strhash.c
+++ b/tests/test_strhash.c
@@ -0,0 +1,103 @@
+/*
+ * aksl_strhash_djb2 -- TODO.md section 1.6.
+ *
+ * The expected values are the canonical djb2 ones: h = 5381, then
+ * h = h * 33 + byte for each of len bytes, truncated to 32 bits. They were
+ * computed independently of this implementation.
+ *
+ * Every vector here is 7-bit ASCII, where signed and unsigned char agree. The
+ * high-bit case ("\xff\xfe") is the sign-extension defect in TODO.md 2.2.6 and
+ * is left for a test that can be registered as a known failure.
+ */
+
+#include "aksl_capture.h"
+
+static int test_empty_string_is_the_djb2_seed(void)
+{
+    uint32_t h = 0;
+
+    AKSL_CHECK_OK(aksl_strhash_djb2("", 0, &h));
+    AKSL_CHECK(h == 5381);
+    return 0;
+}
+
+/* len drives the loop, so a zero length ignores the contents entirely. */
+static int test_zero_length_ignores_the_buffer(void)
+{
+    char buf[] = "ignored";
+    uint32_t h = 0;
+
+    AKSL_CHECK_OK(aksl_strhash_djb2(buf, 0, &h));
+    AKSL_CHECK(h == 5381);
+    return 0;
+}
+
+static int test_known_answer_vectors(void)
+{
+    char hello[] = "hello";
+    char libname[] = "libakstdlib";
+    uint32_t h = 0;
+
+    AKSL_CHECK_OK(aksl_strhash_djb2(hello, 5, &h));
+    AKSL_CHECK(h == 261238937u);
+
+    AKSL_CHECK_OK(aksl_strhash_djb2(libname, 11, &h));
+    AKSL_CHECK(h == 884285482u);
+    return 0;
+}
+
+/* The function is length-driven, not NUL-driven: an embedded NUL is hashed. */
+static int test_embedded_nul_is_hashed(void)
+{
+    char buf[3] = { 'a', '\0', 'b' };
+    uint32_t whole = 0;
+    uint32_t prefix = 0;
+
+    AKSL_CHECK_OK(aksl_strhash_djb2(buf, sizeof(buf), &whole));
+    AKSL_CHECK(whole == 193482728u);
+
+    /* Stopping at the NUL would give the one-byte hash instead. */
+    AKSL_CHECK_OK(aksl_strhash_djb2(buf, 1, &prefix));
+    AKSL_CHECK(prefix != whole);
+    return 0;
+}
+
+static int test_hash_is_stable_across_calls(void)
+{
+    char buf[] = "repeatable";
+    uint32_t first = 0;
+    uint32_t second = 0;
+
+    AKSL_CHECK_OK(aksl_strhash_djb2(buf, sizeof(buf) - 1, &first));
+    AKSL_CHECK_OK(aksl_strhash_djb2(buf, sizeof(buf) - 1, &second));
+    AKSL_CHECK(first == second);
+    return 0;
+}
+
+static int test_rejects_null_arguments(void)
+{
+    char buf[] = "x";
+    uint32_t h = 0;
+
+    AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_strhash_djb2(NULL, 1, &h),
+                                   AKERR_NULLPOINTER, "str");
+    AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_strhash_djb2(buf, 1, NULL),
+                                   AKERR_NULLPOINTER, "hashval");
+    return 0;
+}
+
+int main(void)
+{
+    int failures = 0;
+
+    akerr_init();
+
+    AKSL_RUN(failures, test_empty_string_is_the_djb2_seed);
+    AKSL_RUN(failures, test_zero_length_ignores_the_buffer);
+    AKSL_RUN(failures, test_known_answer_vectors);
+    AKSL_RUN(failures, test_embedded_nul_is_hashed);
+    AKSL_RUN(failures, test_hash_is_stable_across_calls);
+    AKSL_RUN(failures, test_rejects_null_arguments);
+
+    AKSL_REPORT(failures);
+}