andrew/libakstdlib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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>
This commit is contained in:
Andrew Kesterson
2026-07-30 02:07:08 -04:00
parent 82c47ed773
commit 437da2960b
14 changed files with 1138 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
tests/aksl_capture.h
View File

@@ -28,6 +28,8 @@
* unhandled-error output.
* aksl_slots_in_use() how many slots are currently checked out of
* AKERR_ARRAY_ERROR, for pool-leak assertions.
* aksl_temp_file() create an empty temp file for the stream, formatted
* output and path tests to work on.
* AKSL_RUN() run one test function and tally the result.
*
* Tests are written as a set of `static int test_xxx(void)` functions that
@@ -37,7 +39,9 @@
#include <akstdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
/* ---------------------------------------------------------------------- */
/* Log capture */
@@ -95,6 +99,68 @@ static int __attribute__((unused)) aksl_slots_in_use(void)
return n;
}
/* ---------------------------------------------------------------------- */
/* Temp files */
/* ---------------------------------------------------------------------- */
#define AKSL_TMP_MAX 256
#define AKSL_TMP_TRACKED 32
static char aksl_tmp_paths[AKSL_TMP_TRACKED][AKSL_TMP_MAX];
static int aksl_tmp_count = 0;
/*
* Unlink every path aksl_temp_file() handed out. Registered with atexit, so the
* files go away even when a test returns early on a failed assertion -- which is
* the normal case for a known-failing test and for every mutant the mutation
* harness builds. Paths a test already unlinked simply fail here, harmlessly.
*/
static void aksl_temp_cleanup(void)
{
int i = 0;
for ( i = 0; i < aksl_tmp_count; i++ ) {
unlink(aksl_tmp_paths[i]);
}
aksl_tmp_count = 0;
}
/*
* Create an empty temp file under $TMPDIR (or /tmp) and write its path into buf.
* Returns 0 on success, non-zero on failure.
*
* mkstemp both names and creates the file, so a test that opens the path for
* reading is never racing another process for the name. Tests should still
* unlink what they create -- asserting on it catches a wrapper that removed or
* renamed the file -- but aksl_temp_cleanup() is the backstop.
*/
static int __attribute__((unused)) aksl_temp_file(char *buf, size_t n)
{
const char *dir = getenv("TMPDIR");
int fd = -1;
if ( dir == NULL || dir[0] == '\0' ) {
dir = "/tmp";
}
if ( (size_t)snprintf(buf, n, "%s/aksl_test_XXXXXX", dir) >= n ) {
return 1;
}
fd = mkstemp(buf);
if ( fd < 0 ) {
return 1;
}
close(fd);
if ( aksl_tmp_count < AKSL_TMP_TRACKED ) {
if ( aksl_tmp_count == 0 && atexit(&aksl_temp_cleanup) != 0 ) {
return 0; /* tracking is best-effort; the file itself is fine */
}
snprintf(aksl_tmp_paths[aksl_tmp_count], AKSL_TMP_MAX, "%s", buf);
aksl_tmp_count++;
}
return 0;
}
/* ---------------------------------------------------------------------- */
/* Taking ownership of a returned error context */
/* ---------------------------------------------------------------------- */