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>
This commit is contained in:
188
tests/test_stream.c
Normal file
188
tests/test_stream.c
Normal file
@@ -0,0 +1,188 @@
|
||||
/*
|
||||
* Stream wrappers: aksl_fopen / aksl_fread / aksl_fwrite / aksl_fclose.
|
||||
*
|
||||
* TODO.md section 1.2. Covered here: the happy paths, the round trip, the NULL
|
||||
* guards that exist, and the two error statuses the wrappers can actually
|
||||
* produce today -- AKERR_EOF from a short read and AKERR_IO from a stream whose
|
||||
* error indicator is set.
|
||||
*
|
||||
* Not covered, because the behaviour is a documented gap rather than a
|
||||
* contract: aksl_fopen(NULL, ...) and aksl_fopen(path, NULL, ...) are unchecked
|
||||
* (2.2.2), aksl_fread/aksl_fwrite never check ptr and report a short transfer
|
||||
* that is neither EOF nor error as complete success (2.2.3).
|
||||
*
|
||||
* Temp files come from aksl_temp_file() and are unlinked by the test that made
|
||||
* them, so a failing test leaves nothing behind but the file it was mid-way
|
||||
* through.
|
||||
*/
|
||||
|
||||
#include "aksl_capture.h"
|
||||
|
||||
#include <errno.h>
|
||||
|
||||
static int test_fopen_writes_stream_pointer(void)
|
||||
{
|
||||
char path[AKSL_TMP_MAX];
|
||||
FILE *fp = NULL;
|
||||
|
||||
AKSL_CHECK(aksl_temp_file(path, sizeof(path)) == 0);
|
||||
AKSL_CHECK_OK(aksl_fopen(path, "w", &fp));
|
||||
AKSL_CHECK(fp != NULL);
|
||||
AKSL_CHECK_OK(aksl_fclose(fp));
|
||||
AKSL_CHECK(unlink(path) == 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_fopen_reports_missing_path(void)
|
||||
{
|
||||
FILE *fp = NULL;
|
||||
|
||||
/* The pathname belongs in the message; the status is the errno fopen saw. */
|
||||
AKSL_CHECK_STATUS_MSG_CONTAINS(
|
||||
aksl_fopen("/nonexistent/aksl/stream", "r", &fp),
|
||||
ENOENT, "/nonexistent/aksl/stream");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_fopen_rejects_null_stream_out(void)
|
||||
{
|
||||
char path[AKSL_TMP_MAX];
|
||||
|
||||
AKSL_CHECK(aksl_temp_file(path, sizeof(path)) == 0);
|
||||
AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_fopen(path, "r", NULL),
|
||||
AKERR_NULLPOINTER, "NULL");
|
||||
AKSL_CHECK(unlink(path) == 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* fopen -> fwrite -> fclose -> fopen -> fread -> compare, all through the wrappers. */
|
||||
static int test_write_read_round_trip(void)
|
||||
{
|
||||
char path[AKSL_TMP_MAX];
|
||||
char payload[] = "libakstdlib round trip";
|
||||
char readback[sizeof(payload)];
|
||||
FILE *fp = NULL;
|
||||
|
||||
AKSL_CHECK(aksl_temp_file(path, sizeof(path)) == 0);
|
||||
|
||||
AKSL_CHECK_OK(aksl_fopen(path, "w", &fp));
|
||||
AKSL_CHECK_OK(aksl_fwrite(payload, 1, sizeof(payload), fp));
|
||||
AKSL_CHECK_OK(aksl_fclose(fp));
|
||||
|
||||
fp = NULL;
|
||||
memset(readback, 0x00, sizeof(readback));
|
||||
AKSL_CHECK_OK(aksl_fopen(path, "r", &fp));
|
||||
AKSL_CHECK_OK(aksl_fread(readback, 1, sizeof(readback), fp));
|
||||
AKSL_CHECK_OK(aksl_fclose(fp));
|
||||
|
||||
AKSL_CHECK(memcmp(payload, readback, sizeof(payload)) == 0);
|
||||
AKSL_CHECK(unlink(path) == 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Asking for more members than the file holds sets feof, which is AKERR_EOF. */
|
||||
static int test_fread_short_read_is_eof(void)
|
||||
{
|
||||
char path[AKSL_TMP_MAX];
|
||||
char buf[32];
|
||||
FILE *fp = NULL;
|
||||
|
||||
AKSL_CHECK(aksl_temp_file(path, sizeof(path)) == 0);
|
||||
|
||||
AKSL_CHECK_OK(aksl_fopen(path, "w", &fp));
|
||||
AKSL_CHECK_OK(aksl_fwrite("abcd", 1, 4, fp));
|
||||
AKSL_CHECK_OK(aksl_fclose(fp));
|
||||
|
||||
fp = NULL;
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
AKSL_CHECK_OK(aksl_fopen(path, "r", &fp));
|
||||
AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_fread(buf, 1, sizeof(buf), fp),
|
||||
AKERR_EOF, "EOF");
|
||||
AKSL_CHECK_OK(aksl_fclose(fp));
|
||||
|
||||
/* The bytes that did arrive are still in the buffer. */
|
||||
AKSL_CHECK(memcmp(buf, "abcd", 4) == 0);
|
||||
AKSL_CHECK(unlink(path) == 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* A stream opened "w" has no read permission, so fread sets the error indicator
|
||||
* rather than the EOF one: AKERR_IO, not AKERR_EOF.
|
||||
*/
|
||||
static int test_fread_from_write_only_stream_is_io_error(void)
|
||||
{
|
||||
char path[AKSL_TMP_MAX];
|
||||
char buf[4];
|
||||
FILE *fp = NULL;
|
||||
|
||||
AKSL_CHECK(aksl_temp_file(path, sizeof(path)) == 0);
|
||||
AKSL_CHECK_OK(aksl_fopen(path, "w", &fp));
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_fread(buf, 1, sizeof(buf), fp),
|
||||
AKERR_IO, "Error reading file");
|
||||
AKSL_CHECK_OK(aksl_fclose(fp));
|
||||
AKSL_CHECK(unlink(path) == 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_fread_rejects_null_stream(void)
|
||||
{
|
||||
char buf[4];
|
||||
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_fread(buf, 1, sizeof(buf), NULL),
|
||||
AKERR_NULLPOINTER, "NULL");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Mirror image of the fread case: a "r" stream cannot be written to. */
|
||||
static int test_fwrite_to_read_only_stream_is_io_error(void)
|
||||
{
|
||||
char path[AKSL_TMP_MAX];
|
||||
FILE *fp = NULL;
|
||||
|
||||
AKSL_CHECK(aksl_temp_file(path, sizeof(path)) == 0);
|
||||
AKSL_CHECK_OK(aksl_fopen(path, "r", &fp));
|
||||
AKSL_CHECK_STATUS(aksl_fwrite("xy", 1, 2, fp), AKERR_IO);
|
||||
AKSL_CHECK_OK(aksl_fclose(fp));
|
||||
AKSL_CHECK(unlink(path) == 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_fwrite_rejects_null_stream(void)
|
||||
{
|
||||
AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_fwrite("xy", 1, 2, NULL),
|
||||
AKERR_NULLPOINTER, "NULL");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_fclose_rejects_null_stream(void)
|
||||
{
|
||||
AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_fclose(NULL),
|
||||
AKERR_NULLPOINTER, "NULL");
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int failures = 0;
|
||||
|
||||
akerr_init();
|
||||
|
||||
AKSL_RUN(failures, test_fopen_writes_stream_pointer);
|
||||
AKSL_RUN(failures, test_fopen_reports_missing_path);
|
||||
AKSL_RUN(failures, test_fopen_rejects_null_stream_out);
|
||||
|
||||
AKSL_RUN(failures, test_write_read_round_trip);
|
||||
AKSL_RUN(failures, test_fread_short_read_is_eof);
|
||||
AKSL_RUN(failures, test_fread_from_write_only_stream_is_io_error);
|
||||
AKSL_RUN(failures, test_fread_rejects_null_stream);
|
||||
|
||||
AKSL_RUN(failures, test_fwrite_to_read_only_stream_is_io_error);
|
||||
AKSL_RUN(failures, test_fwrite_rejects_null_stream);
|
||||
|
||||
AKSL_RUN(failures, test_fclose_rejects_null_stream);
|
||||
|
||||
AKSL_REPORT(failures);
|
||||
}
|
||||
Reference in New Issue
Block a user