Andrew Kesterson
437da2960b
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>
104 lines
2.8 KiB
C
104 lines
2.8 KiB
C
/*
|
|
* 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);
|
|
}
|