libakstdlib/tests/test_format.c

/*
 * Formatted-output wrappers: aksl_printf / aksl_fprintf / aksl_sprintf.
 *
 * TODO.md section 1.3. Each happy path asserts both halves of the contract --
 * the byte count handed back through *count and the text that actually landed
 * somewhere -- and every pointer argument is checked for its NULL guard.
 *
 * Readback goes through plain libc rather than aksl_fread so that a failure here
 * points at the formatted-output wrapper under test and not at the stream
 * wrappers, which tests/test_stream.c covers.
 *
 * Not covered: the destination-overflow case, because aksl_sprintf wraps the
 * unbounded vsprintf and there is no bounded entry point to test yet
 * (TODO.md 2.2.4).
 */

#include "aksl_capture.h"

#include <errno.h>

/* Read a whole file into buf and NUL-terminate. Returns bytes read, or -1. */
static long read_file(const char *path, char *buf, size_t n)
{
    FILE *fp = fopen(path, "r");
    size_t got = 0;

    if ( fp == NULL ) {
	return -1;
    }
    got = fread(buf, 1, n - 1, fp);
    buf[got] = '\0';
    if ( ferror(fp) ) {
	fclose(fp);
	return -1;
    }
    fclose(fp);
    return (long)got;
}

static int test_sprintf_writes_text_and_count(void)
{
    char buf[64];
    int count = -1;

    memset(buf, 0x00, sizeof(buf));
    AKSL_CHECK_OK(aksl_sprintf(&count, buf, "%s=%d", "x", 7));
    AKSL_CHECK(count == 3);
    AKSL_CHECK(strcmp(buf, "x=7") == 0);
    return 0;
}

static int test_sprintf_empty_format_writes_nothing(void)
{
    char buf[8] = { 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z' };
    int count = -1;

    AKSL_CHECK_OK(aksl_sprintf(&count, buf, "%s", ""));
    AKSL_CHECK(count == 0);
    AKSL_CHECK(buf[0] == '\0');
    return 0;
}

static int test_sprintf_rejects_null_arguments(void)
{
    char buf[8];
    int count = 0;

    memset(buf, 0x00, sizeof(buf));
    AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_sprintf(NULL, buf, "x"),
                                   AKERR_NULLPOINTER, "count=");
    AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_sprintf(&count, NULL, "x"),
                                   AKERR_NULLPOINTER, "str=");
    AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_sprintf(&count, buf, NULL),
                                   AKERR_NULLPOINTER, "format=");
    return 0;
}

static int test_fprintf_writes_to_stream(void)
{
    char path[AKSL_TMP_MAX];
    char readback[64];
    FILE *fp = NULL;
    int count = -1;

    AKSL_CHECK(aksl_temp_file(path, sizeof(path)) == 0);
    AKSL_CHECK_OK(aksl_fopen(path, "w", &fp));
    AKSL_CHECK_OK(aksl_fprintf(&count, fp, "%s %d", "value", 42));
    AKSL_CHECK_OK(aksl_fclose(fp));

    AKSL_CHECK(count == 8);
    AKSL_CHECK(read_file(path, readback, sizeof(readback)) == 8);
    AKSL_CHECK(strcmp(readback, "value 42") == 0);
    AKSL_CHECK(unlink(path) == 0);
    return 0;
}

/*
 * vfprintf on a stream opened "r" fails outright, so the wrapper reports the
 * errno it saw (EBADF on glibc). *count is left holding -1 in this case, which
 * TODO.md 1.3 flags as a contract gap -- the status is the assertion here.
 */
static int test_fprintf_to_read_only_stream_reports_errno(void)
{
    char path[AKSL_TMP_MAX];
    FILE *fp = NULL;
    int count = 0;

    AKSL_CHECK(aksl_temp_file(path, sizeof(path)) == 0);
    AKSL_CHECK_OK(aksl_fopen(path, "r", &fp));
    AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_fprintf(&count, fp, "%d", 1),
                                   EBADF, "Short write");
    AKSL_CHECK_OK(aksl_fclose(fp));
    AKSL_CHECK(unlink(path) == 0);
    return 0;
}

static int test_fprintf_rejects_null_arguments(void)
{
    int count = 0;

    AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_fprintf(NULL, stdout, "x"),
                                   AKERR_NULLPOINTER, "count=");
    AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_fprintf(&count, NULL, "x"),
                                   AKERR_NULLPOINTER, "stream=");
    AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_fprintf(&count, stdout, NULL),
                                   AKERR_NULLPOINTER, "format=");
    return 0;
}

/*
 * aksl_printf writes to stdout, so stdout is pointed at a temp file for the
 * duration of the call and then restored through a dup of the original
 * descriptor. Nothing between the freopen and the dup2 may return early: an
 * assertion there would leave stdout attached to the temp file for the rest of
 * the run, and the test report itself would vanish.
 */
static int test_printf_writes_to_stdout(void)
{
    char path[AKSL_TMP_MAX];
    char readback[64];
    akerr_ErrorContext *err = NULL;
    int count = -1;
    int saved = -1;
    int restored = -1;

    AKSL_CHECK(aksl_temp_file(path, sizeof(path)) == 0);

    fflush(stdout);
    saved = dup(fileno(stdout));
    AKSL_CHECK(saved >= 0);
    if ( freopen(path, "w", stdout) == NULL ) {
	close(saved);
	AKSL_CHECK(0);
    }

    err = aksl_printf(&count, "%s#%d", "out", 5);

    fflush(stdout);
    restored = dup2(saved, fileno(stdout));
    close(saved);
    clearerr(stdout);

    AKSL_CHECK(restored >= 0);
    AKSL_CHECK(aksl_take(err) == 0);
    AKSL_CHECK(count == 5);
    AKSL_CHECK(read_file(path, readback, sizeof(readback)) == 5);
    AKSL_CHECK(strcmp(readback, "out#5") == 0);
    AKSL_CHECK(unlink(path) == 0);
    return 0;
}

static int test_printf_rejects_null_arguments(void)
{
    int count = 0;

    AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_printf(NULL, "x"),
                                   AKERR_NULLPOINTER, "count=");
    AKSL_CHECK_STATUS_MSG_CONTAINS(aksl_printf(&count, NULL),
                                   AKERR_NULLPOINTER, "format=");
    return 0;
}

/*
 * Regression cover for the missing va_end (TODO.md 2.1.4). Nothing here can
 * assert on register-save state directly; the point is to run the variadic
 * wrappers enough times, with enough arguments, that the sanitizer build has
 * something to trip over.
 */
static int test_variadic_wrappers_survive_repeated_calls(void)
{
    char buf[128];
    int count = 0;
    int i = 0;

    for ( i = 0; i < 512; i++ ) {
	AKSL_CHECK_OK(aksl_sprintf(&count, buf, "%d %s %ld %c %f",
	                           i, "iteration", (long)i, 'x', (double)i));
	AKSL_CHECK(count > 0);
	AKSL_CHECK((size_t)count == strlen(buf));
    }
    return 0;
}

int main(void)
{
    int failures = 0;

    akerr_init();

    AKSL_RUN(failures, test_sprintf_writes_text_and_count);
    AKSL_RUN(failures, test_sprintf_empty_format_writes_nothing);
    AKSL_RUN(failures, test_sprintf_rejects_null_arguments);

    AKSL_RUN(failures, test_fprintf_writes_to_stream);
    AKSL_RUN(failures, test_fprintf_to_read_only_stream_reports_errno);
    AKSL_RUN(failures, test_fprintf_rejects_null_arguments);

    AKSL_RUN(failures, test_printf_writes_to_stdout);
    AKSL_RUN(failures, test_printf_rejects_null_arguments);

    AKSL_RUN(failures, test_variadic_wrappers_survive_repeated_calls);

    AKSL_REPORT(failures);
}