stupidtools/tests/unit/test_gen_configure.c

/* LINK: ../../src/gen/configure.c ../../src/gen/sh_emit.c ../../src/detect/probe.c ../../src/detect/checks.c ../../src/detect/check_registry.c ../../src/detect/resolve.c ../../src/kdl/schema.c ../../src/kdl/parser.c ../../src/kdl/lexer.c ../../src/kdl/value.c ../../src/ext/abi.c ../../src/ext/lang_c.c ../../src/ext/lang_cpp.c ../../src/error.c ../../src/span.c */
#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L /* mkdtemp/unsetenv/setenv (POSIX.1-2008) */
#endif
/* tests/unit/test_gen_configure.c
 *
 * Unit + integration tests for the ./configure generator (todo 16):
 * src/gen/configure.c. THE MODEL: the generator EMITS a POSIX-sh script
 * from a schema-validated DSL document + an extension ctx; the emitted
 * script RUNS at configure time (probes + @VAR@ substitution). These tests
 * prove the emitted script is syntactically valid (sh/bash/zsh -n, no
 * banned constructs), REALLY runs (exit 0, Makefile written, CC/LIBS/
 * prefix correct), honors --prefix, errors cleanly on an unknown @VAR@, a
 * missing Makefile.in and an unrecognized option, carries values with
 * '/', spaces and '&' byte-exact, keeps $(...) / backticks inert, and
 * cross-compile-skips RUN probes.
 *
 * The magic LINK comment on line 1 is REQUIRED by tests/run.sh (extra .c
 * sources, relative to tests/unit/). configure.c pulls in the whole detect
 * chain (probe/checks/check_registry/resolve) + sh_emit + abi (the C/C++
 * modules register CC/CFLAGS) + kdl (parse/lexer/value/schema) + error/span.
 */
#include "munit.h"

#include "detect/check_registry.h"
#include "error.h"
#include "ext/abi.h"
#include "gen/configure.h"
#include "kdl/ast.h"
#include "kdl/schema.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>

/* ---- per-test temp dir ------------------------------------------------ */

static char temp_dir[128];

static void *
setup(const MunitParameter params[], void *user_data)
{
    (void)params;
    (void)user_data;
    if (snprintf(temp_dir, sizeof temp_dir, "/tmp/st_gen_XXXXXX") < 0) {
        return NULL;
    }
    if (mkdtemp(temp_dir) == NULL) {
        return NULL;
    }
    return (void *)1;
}

static void
teardown(void *fixture)
{
    char cmd[160];

    if (fixture == NULL || temp_dir[0] == '\0') {
        return;
    }
    if (snprintf(cmd, sizeof cmd, "rm -rf -- '%s'", temp_dir) < 0) {
        return;
    }
    (void)system(cmd); /* best-effort; mkdtemp names are [A-Za-z0-9_]* */
    temp_dir[0] = '\0';
}

/* ---- small file/process helpers --------------------------------------- */

/* Join temp_dir/`name` into `buf`; returns the snprintf result. */
static int
mkpath(char *buf, size_t sz, const char *name)
{
    return snprintf(buf, sz, "%s/%s", temp_dir, name);
}

/* Slurp a file into a NUL-terminated heap buffer, or NULL. Caller frees. */
static char *
slurp(const char *path)
{
    FILE *f;
    long n;
    char *buf;

    f = fopen(path, "rb");
    if (f == NULL) {
        return NULL;
    }
    if (fseek(f, 0, SEEK_END) != 0) {
        fclose(f);
        return NULL;
    }
    n = ftell(f);
    if (n < 0 || fseek(f, 0, SEEK_SET) != 0) {
        fclose(f);
        return NULL;
    }
    buf = malloc((size_t)n + 1);
    if (buf == NULL) {
        fclose(f);
        return NULL;
    }
    if (fread(buf, 1, (size_t)n, f) != (size_t)n) {
        free(buf);
        fclose(f);
        return NULL;
    }
    fclose(f);
    buf[n] = '\0';
    return buf;
}

/* Slurp temp_dir/Makefile, or NULL. Caller frees. */
static char *
makefile_text(void)
{
    char path[600];

    if (mkpath(path, sizeof path, "Makefile") < 0) {
        return NULL;
    }
    return slurp(path);
}

/* Slurp temp_dir/run.err, or NULL. Caller frees. */
static char *
stderr_text(void)
{
    char path[600];

    if (mkpath(path, sizeof path, "run.err") < 0) {
        return NULL;
    }
    return slurp(path);
}

/* Write `content` to temp_dir/Makefile.in. Returns 0 on success. */
static int
write_makefile_in(const char *content)
{
    char path[600];
    FILE *f;

    if (mkpath(path, sizeof path, "Makefile.in") < 0) {
        return -1;
    }
    f = fopen(path, "w");
    if (f == NULL) {
        return -1;
    }
    if (fputs(content, f) == EOF) {
        fclose(f);
        return -1;
    }
    fclose(f);
    return 0;
}

/* Run "sh ./configure <args>" with cwd = temp_dir, stderr to run.err.
 * Returns the configure exit status, or -1 if it could not be spawned. */
static int
run_configure(const char *args)
{
    char cmd[2400];
    int n;
    int spawned;

    n = snprintf(cmd, sizeof cmd, "cd '%s' && sh ./configure %s 2>'%s/run.err'",
                 temp_dir, args != NULL ? args : "", temp_dir);
    if (n < 0 || (size_t)n >= sizeof cmd) {
        return -1;
    }
    spawned = system(cmd);
    if (spawned == -1) {
        return -1;
    }
    return WEXITSTATUS(spawned);
}

/* "<shell> -n <path>": the shell's exit status or -1. */
static int
syntax_check(const char *shell, const char *path)
{
    char cmd[700];
    int n;
    int spawned;

    n = snprintf(cmd, sizeof cmd, "%s -n '%s'", shell, path);
    if (n < 0 || (size_t)n >= sizeof cmd) {
        return -1;
    }
    spawned = system(cmd);
    if (spawned == -1) {
        return -1;
    }
    return WEXITSTATUS(spawned);
}

/* ---- fixture loading (same as test_schema.c) -------------------------- */

static const char *
fixture_path(void)
{
    static const char *const candidates[] = {
        "tests/fixtures/stupid.kdl",
        "../fixtures/stupid.kdl",
    };
    size_t i;

    for (i = 0; i < sizeof(candidates) / sizeof(candidates[0]); i++) {
        FILE *f = fopen(candidates[i], "rb");

        if (f != NULL) {
            fclose(f);
            return candidates[i];
        }
    }
    return NULL;
}

/* Build a ctx with the builtins + C detected (env CC/CFLAGS/etc. reset).
 * Returns NULL on any failure. */
static struct st_ext_ctx *
build_ctx(void)
{
    struct st_ext_ctx *ctx = st_ext_ctx_new();
    struct st_error *err;

    if (ctx == NULL) {
        return NULL;
    }
    unsetenv("CC");
    unsetenv("CFLAGS");
    unsetenv("CXX");
    unsetenv("CXXFLAGS");
    err = st_ext_init_builtins(ctx);
    if (err != NULL) {
        st_error_free(err);
        st_ext_ctx_free(ctx);
        return NULL;
    }
    err = st_ext_detect_language(ctx, "c");
    if (err != NULL) {
        st_error_free(err);
        st_ext_ctx_free(ctx);
        return NULL;
    }
    return ctx;
}

/* Parse + validate + emit the fixture into temp_dir/configure, using
 * `ctx`. Returns 0 on success, -1 on failure. */
static int
emit_fixture_configure(struct st_ext_ctx *ctx)
{
    const char *path = fixture_path();
    char conf[600];
    char *src;
    struct st_kdl_document *doc = NULL;
    struct st_error *err = NULL;

    if (path == NULL || ctx == NULL) {
        return -1;
    }
    src = slurp(path);
    if (src == NULL) {
        return -1;
    }
    doc = st_kdl_parse(src, path, &err);
    if (err != NULL) {
        st_error_free(err);
        free(src);
        return -1;
    }
    if (doc == NULL) {
        free(src);
        return -1;
    }
    err = st_kdl_validate(doc);
    if (err != NULL) {
        st_error_free(err);
        st_kdl_document_free(doc);
        free(src);
        return -1;
    }
    if (mkpath(conf, sizeof conf, "configure") < 0) {
        st_kdl_document_free(doc);
        free(src);
        return -1;
    }
    err = st_gen_configure_emit_path(conf, doc, ctx);
    /* the document borrows `src`'s token slices, so free src only after
     * the document is released */
    st_kdl_document_free(doc);
    free(src);
    if (err != NULL) {
        st_error_free(err);
        return -1;
    }
    return 0;
}

/* The standard Makefile.in every end-to-end case uses. */
#define STD_MAKEFILE_IN \
    "CC = @CC@\n" \
    "LIBS = @LIBS@\n" \
    "prefix = @prefix@\n" \
    "FLAGS = @CFLAGS@\n"

/* ---- (a) the emitted configure passes the three-shell syntax oracle --- */

static MunitResult
test_syntax(const MunitParameter params[], void *data)
{
    (void)params;
    (void)data;
    static const char *const banned[] = {
        "[[ ", "]]", "local ", "==", "<<<", "&>", "set -e",
    };
    struct st_ext_ctx *ctx;
    char conf[600];
    char *bytes;
    size_t i;

    ctx = build_ctx();
    munit_assert_not_null(ctx);
    munit_assert_int(emit_fixture_configure(ctx), ==, 0);
    st_ext_ctx_free(ctx);

    munit_assert_int(mkpath(conf, sizeof conf, "configure"), >, 0);
    munit_assert_int(syntax_check("sh", conf), ==, 0);
    munit_assert_int(syntax_check("bash", conf), ==, 0);
    munit_assert_int(syntax_check("zsh", conf), ==, 0);

    bytes = slurp(conf);
    munit_assert_not_null(bytes);
    for (i = 0; i < sizeof(banned) / sizeof(banned[0]); i++) {
        munit_assert_null(strstr(bytes, banned[i]));
    }
    /* the preamble is structurally marked for todo 18 */
    munit_assert_not_null(strstr(bytes, "# --- PREAMBLE ---"));
    free(bytes);
    return MUNIT_OK;
}

/* ---- (b) real end-to-end run ------------------------------------------ */

static MunitResult
test_end_to_end(const MunitParameter params[], void *data)
{
    (void)params;
    (void)data;
    struct st_ext_ctx *ctx;
    const char *cc;
    char cc_buf[64];
    char want[128];
    char *mk;
    int cc_len;

    ctx = build_ctx();
    munit_assert_not_null(ctx);
    cc = st_registry_get_var(st_ext_var_registry(ctx), "CC");
    munit_assert_not_null(cc);
    /* copy before st_ext_ctx_free() — the registry value is borrowed */
    cc_len = snprintf(cc_buf, sizeof cc_buf, "%s", cc);
    munit_assert_int(cc_len, >, 0);
    munit_assert_int(emit_fixture_configure(ctx), ==, 0);
    st_ext_ctx_free(ctx);

    munit_assert_int(write_makefile_in(STD_MAKEFILE_IN), ==, 0);
    munit_assert_int(run_configure(NULL), ==, 0);

    mk = makefile_text();
    munit_assert_not_null(mk);
    /* CC substituted from the registry value */
    {
        int n = snprintf(want, sizeof want, "CC = %s", cc_buf);

        munit_assert_int(n, >, 0);
        munit_assert_not_null(strstr(mk, want));
    }
    /* LIBS accumulated from library checks (pthread + m) */
    munit_assert_not_null(strstr(mk, "-lpthread"));
    munit_assert_not_null(strstr(mk, "-lm"));
    /* prefix defaults to /usr/local */
    munit_assert_not_null(strstr(mk, "prefix = /usr/local"));
    free(mk);
    return MUNIT_OK;
}

/* ---- (c) --prefix is honored ------------------------------------------ */

static MunitResult
test_prefix(const MunitParameter params[], void *data)
{
    (void)params;
    (void)data;
    struct st_ext_ctx *ctx;
    char *mk;

    ctx = build_ctx();
    munit_assert_not_null(ctx);
    munit_assert_int(emit_fixture_configure(ctx), ==, 0);
    st_ext_ctx_free(ctx);

    munit_assert_int(write_makefile_in(STD_MAKEFILE_IN), ==, 0);
    munit_assert_int(run_configure("--prefix=/opt/x"), ==, 0);

    mk = makefile_text();
    munit_assert_not_null(mk);
    munit_assert_not_null(strstr(mk, "prefix = /opt/x"));
    free(mk);
    return MUNIT_OK;
}

/* ---- (d) an unknown @VAR@ errors naming the variable ------------------ */

static MunitResult
test_unknown_var(const MunitParameter params[], void *data)
{
    (void)params;
    (void)data;
    struct st_ext_ctx *ctx;
    char *err;

    ctx = build_ctx();
    munit_assert_not_null(ctx);
    munit_assert_int(emit_fixture_configure(ctx), ==, 0);
    st_ext_ctx_free(ctx);

    munit_assert_int(write_makefile_in("CC = @NOPE@\n"), ==, 0);
    munit_assert_int(run_configure(NULL), !=, 0);

    err = stderr_text();
    munit_assert_not_null(err);
    munit_assert_not_null(strstr(err, "NOPE"));
    free(err);
    return MUNIT_OK;
}

/* ---- (e) a missing Makefile.in is a clean error ----------------------- */

static MunitResult
test_missing_makefile(const MunitParameter params[], void *data)
{
    (void)params;
    (void)data;
    struct st_ext_ctx *ctx;
    char *err;

    ctx = build_ctx();
    munit_assert_not_null(ctx);
    munit_assert_int(emit_fixture_configure(ctx), ==, 0);
    st_ext_ctx_free(ctx);

    /* no Makefile.in written at all */
    munit_assert_int(run_configure(NULL), !=, 0);

    err = stderr_text();
    munit_assert_not_null(err);
    munit_assert_not_null(strstr(err, "Makefile.in"));
    free(err);
    return MUNIT_OK;
}

/* ---- (f) '/', spaces and '&' survive byte-exact ----------------------- */

static MunitResult
test_bytes_exact(const MunitParameter params[], void *data)
{
    (void)params;
    (void)data;
    struct st_ext_ctx *ctx;
    char *mk;

    ctx = build_ctx();
    munit_assert_not_null(ctx);
    munit_assert_int(emit_fixture_configure(ctx), ==, 0);
    st_ext_ctx_free(ctx);

    /* spaces via CFLAGS; '&' and '/' via --prefix */
    munit_assert_int(write_makefile_in(STD_MAKEFILE_IN), ==, 0);
    munit_assert_int(setenv("CFLAGS", "a b c", 1), ==, 0);
    munit_assert_int(run_configure("--prefix='/opt/x & y/z'"), ==, 0);
    unsetenv("CFLAGS");

    mk = makefile_text();
    munit_assert_not_null(mk);
    munit_assert_not_null(strstr(mk, "FLAGS = a b c"));
    munit_assert_not_null(strstr(mk, "prefix = /opt/x & y/z"));
    free(mk);
    return MUNIT_OK;
}

/* ---- unrecognized --flag is a clean error ----------------------------- */

static MunitResult
test_unrecognized_option(const MunitParameter params[], void *data)
{
    (void)params;
    (void)data;
    struct st_ext_ctx *ctx;
    char *err;

    ctx = build_ctx();
    munit_assert_not_null(ctx);
    munit_assert_int(emit_fixture_configure(ctx), ==, 0);
    st_ext_ctx_free(ctx);

    munit_assert_int(run_configure("--bogus"), !=, 0);

    err = stderr_text();
    munit_assert_not_null(err);
    munit_assert_not_null(strstr(err, "unrecognized option"));
    free(err);
    return MUNIT_OK;
}

/* ---- injection: a $(...) VALUE stays inert (not executed) ------------- */

static MunitResult
test_injection_value(const MunitParameter params[], void *data)
{
    (void)params;
    (void)data;
    struct st_ext_ctx *ctx;
    char marker[600];
    char *mk;

    ctx = build_ctx();
    munit_assert_not_null(ctx);
    munit_assert_int(emit_fixture_configure(ctx), ==, 0);
    st_ext_ctx_free(ctx);

    munit_assert_int(mkpath(marker, sizeof marker, "pwned1"), >, 0);

    /* prefix gets a command-substitution payload; it must be a literal. */
    munit_assert_int(write_makefile_in("prefix = @prefix@\n"), ==, 0);
    munit_assert_int(run_configure("--prefix='$(touch pwned1)'"), ==, 0);

    munit_assert_int(access(marker, F_OK), ==, -1);
    mk = makefile_text();
    munit_assert_not_null(mk);
    munit_assert_not_null(strstr(mk, "prefix = $(touch pwned1)"));
    free(mk);
    return MUNIT_OK;
}

/* ---- injection: an unknown @$(...)@ name stays inert (not executed) --- */

static MunitResult
test_injection_unknown_name(const MunitParameter params[], void *data)
{
    (void)params;
    (void)data;
    struct st_ext_ctx *ctx;
    char marker[600];
    char *err;

    ctx = build_ctx();
    munit_assert_not_null(ctx);
    munit_assert_int(emit_fixture_configure(ctx), ==, 0);
    st_ext_ctx_free(ctx);

    munit_assert_int(mkpath(marker, sizeof marker, "pwned2"), >, 0);

    munit_assert_int(write_makefile_in("X = @$(touch pwned2)@\n"), ==, 0);
    munit_assert_int(run_configure(NULL), !=, 0);

    munit_assert_int(access(marker, F_OK), ==, -1);
    err = stderr_text();
    munit_assert_not_null(err);
    munit_assert_not_null(strstr(err, "unknown variable"));
    free(err);
    return MUNIT_OK;
}

/* ---- cross-compile: RUN probes skip with a warning -------------------- */

static MunitResult
test_cross_compile(const MunitParameter params[], void *data)
{
    (void)params;
    (void)data;
    static const char *const docsrc =
        "project \"x\" version \"1.0\"\n"
        "feature \"sz\" { sizeof \"long\" }\n";
    struct st_ext_ctx *ctx;
    struct st_kdl_document *doc = NULL;
    struct st_error *err = NULL;
    char conf[600];
    char *e;

    ctx = build_ctx();
    munit_assert_not_null(ctx);

    doc = st_kdl_parse(docsrc, "inline.kdl", &err);
    munit_assert_null(err);
    munit_assert_not_null(doc);
    munit_assert_null(st_kdl_validate(doc));
    munit_assert_int(mkpath(conf, sizeof conf, "configure"), >, 0);
    munit_assert_null(st_gen_configure_emit_path(conf, doc, ctx));
    st_kdl_document_free(doc);
    st_ext_ctx_free(ctx);

    munit_assert_int(write_makefile_in("CC = @CC@\n"), ==, 0);
    munit_assert_int(run_configure("--host=aarch64-linux --build=x86_64-linux"),
                     ==, 0);

    e = stderr_text();
    munit_assert_not_null(e);
    munit_assert_not_null(strstr(e, "cross-compiling"));
    free(e);
    return MUNIT_OK;
}

static MunitTest tests[] = {
    { "/gen/syntax", test_syntax, setup, teardown, MUNIT_TEST_OPTION_NONE,
      NULL },
    { "/gen/end-to-end", test_end_to_end, setup, teardown,
      MUNIT_TEST_OPTION_NONE, NULL },
    { "/gen/prefix", test_prefix, setup, teardown, MUNIT_TEST_OPTION_NONE,
      NULL },
    { "/gen/unknown-var", test_unknown_var, setup, teardown,
      MUNIT_TEST_OPTION_NONE, NULL },
    { "/gen/missing-makefile", test_missing_makefile, setup, teardown,
      MUNIT_TEST_OPTION_NONE, NULL },
    { "/gen/bytes-exact", test_bytes_exact, setup, teardown,
      MUNIT_TEST_OPTION_NONE, NULL },
    { "/gen/unrecognized-option", test_unrecognized_option, setup, teardown,
      MUNIT_TEST_OPTION_NONE, NULL },
    { "/gen/injection-value", test_injection_value, setup, teardown,
      MUNIT_TEST_OPTION_NONE, NULL },
    { "/gen/injection-unknown-name", test_injection_unknown_name, setup,
      teardown, MUNIT_TEST_OPTION_NONE, NULL },
    { "/gen/cross-compile", test_cross_compile, setup, teardown,
      MUNIT_TEST_OPTION_NONE, NULL },
    { NULL, NULL, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL },
};

static const MunitSuite suite = {
    "/gen", tests, NULL, 1, MUNIT_SUITE_OPTION_NONE,
};

int
main(int argc, char *argv[MUNIT_ARRAY_PARAM(argc + 1)])
{
    return munit_suite_main(&suite, NULL, argc, argv);
}