ww/test/wcc/997_at_test_ww.c

/*
 * 997_at_test_ww — the wwstage twin of 910_at_test, driving the `-T`
 * @test mode through `w6c_ww` (the ww-built compiler) instead of `w6c`
 * (the C bootstrap). Task #15.
 *
 * Probes:
 *   1. RUN — `w6c_ww -T` the @test-only fixture (import-resolved by
 *      `ww_ww build` into a combined unit), assemble, link, run; the
 *      synthesized entry must exit 0.
 *   2. BYTE-ID (rule 10) — `w6c -T` and `w6c_ww -T` must emit
 *      byte-identical asm for the same source. The synthesized entry
 *      rides cgfn at the gated choke point, so the @test set + the
 *      collection-order calls are identical by construction. This is
 *      the new entry-synth byte-id gate.
 *   3. REJECT — `-T` of a user-main fixture exits nonzero.
 *   4. GUARD — `-T` of a non-`fn() void` @test exits nonzero.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

static int
runwait(const char *cmd)
{
	int rc = system(cmd);
	if (rc == -1) return -1;
	if (WIFEXITED(rc)) return WEXITSTATUS(rc);
	return 1;
}

static const char *
absbin(void)
{
	const char *b = getenv("BIN");
	if (!b) b = "out/bin";
	if (b[0] == '/') return b;
	static char buf[2048];
	char cwd[1024];
	if (getcwd(cwd, sizeof cwd) == NULL) return NULL;
	snprintf(buf, sizeof buf, "%s/%s", cwd, b);
	return buf;
}

static int
slurp(const char *path, char **outbuf, size_t *outlen)
{
	FILE *f = fopen(path, "rb");
	if (!f) return -1;
	fseek(f, 0, SEEK_END);
	long n = ftell(f);
	fseek(f, 0, SEEK_SET);
	if (n < 0) { fclose(f); return -1; }
	char *b = malloc((size_t)n + 1);
	if (!b) { fclose(f); return -1; }
	if (fread(b, 1, (size_t)n, f) != (size_t)n) { free(b); fclose(f); return -1; }
	b[n] = '\0';
	fclose(f);
	*outbuf = b;
	*outlen = (size_t)n;
	return 0;
}

static int
run_fixture(const char *bin)
{
	int pid = getpid();
	char src[256], comb[256], asmf[256], obj[256], exe[256];
	char rt[1024], cmd[4096];
	snprintf(src,  sizeof src,  "/tmp/at997_%d.ww", pid);
	snprintf(comb, sizeof comb, "/tmp/at997_%d.combined.ww", pid);
	snprintf(asmf, sizeof asmf, "/tmp/at997_%d.s", pid);
	snprintf(obj,  sizeof obj,  "/tmp/at997_%d.o", pid);
	snprintf(exe,  sizeof exe,  "/tmp/at997_%d.exe", pid);
	snprintf(rt,   sizeof rt,   "%s/../lib/libwwrt.a", bin);

	snprintf(cmd, sizeof cmd, "cp test/wcc/data/attest_pass.ww %s", src);
	if (runwait(cmd) != 0) { fprintf(stderr, "997 FAIL: cp\n"); return 1; }

	/* ww_ww build resolves `import rt` into the combined unit; it exits
	 * nonzero (no main — that is what -T synthesizes), so we gate on the
	 * combined ARTIFACT existing, not the exit code. */
	snprintf(cmd, sizeof cmd, "%s/ww_ww build %s > /dev/null 2>&1", bin, src);
	runwait(cmd);
	if (access(comb, 0) != 0) {
		fprintf(stderr, "997 FAIL: ww_ww build produced no %s\n", comb);
		return 1;
	}

	snprintf(cmd, sizeof cmd, "%s/w6c_ww -T %s -o %s 2>/dev/null", bin, comb, asmf);
	if (runwait(cmd) != 0) { fprintf(stderr, "997 FAIL: w6c_ww -T errored\n"); return 1; }
	snprintf(cmd, sizeof cmd, "%s/w6a_ww -o %s %s 2>/dev/null", bin, obj, asmf);
	if (runwait(cmd) != 0) { fprintf(stderr, "997 FAIL: w6a_ww\n"); return 1; }
	snprintf(cmd, sizeof cmd, "%s/w6l_ww -o %s %s %s 2>/dev/null", bin, exe, obj, rt);
	if (runwait(cmd) != 0) { fprintf(stderr, "997 FAIL: w6l_ww\n"); return 1; }

	int rc = runwait(exe);
	if (rc != 0) {
		fprintf(stderr, "997 FAIL: synth entry exited %d (a @test failed)\n", rc);
		return 1;
	}
	unlink(src); unlink(comb); unlink(asmf); unlink(obj); unlink(exe);
	return 0;
}

/* byteid — `w6c -T` and `w6c_ww -T` on the same source must agree. */
static int
byteid(const char *bin)
{
	int pid = getpid();
	char cs[256], ws[256], cmd[4096];
	snprintf(cs, sizeof cs, "/tmp/at997_bid_c_%d.s", pid);
	snprintf(ws, sizeof ws, "/tmp/at997_bid_w_%d.s", pid);

	snprintf(cmd, sizeof cmd, "%s/w6c -T test/wcc/data/attest_pass.ww -o %s 2>/dev/null",
	    bin, cs);
	if (runwait(cmd) != 0) { fprintf(stderr, "997 FAIL: w6c -T (byteid)\n"); return 1; }
	snprintf(cmd, sizeof cmd, "%s/w6c_ww -T test/wcc/data/attest_pass.ww -o %s 2>/dev/null",
	    bin, ws);
	if (runwait(cmd) != 0) { fprintf(stderr, "997 FAIL: w6c_ww -T (byteid)\n"); return 1; }

	char *bc = NULL, *bw = NULL;
	size_t nc = 0, nw = 0;
	int rc = 0;
	if (slurp(cs, &bc, &nc) < 0 || slurp(ws, &bw, &nw) < 0) {
		fprintf(stderr, "997 FAIL: slurp byteid asm\n");
		rc = 1;
	} else if (nc != nw || memcmp(bc, bw, nc) != 0) {
		fprintf(stderr, "997 FAIL: -T asm differs (cs %zu, ww %zu)\n", nc, nw);
		rc = 1;
	}
	free(bc); free(bw);
	unlink(cs); unlink(ws);
	return rc;
}

static int
reject(const char *bin, const char *fixture, const char *what)
{
	char cmd[4096];
	snprintf(cmd, sizeof cmd, "%s/w6c_ww -T %s -o /dev/null 2>/dev/null", bin, fixture);
	if (runwait(cmd) == 0) {
		fprintf(stderr, "997 FAIL: w6c_ww -T accepted %s (expected reject)\n", what);
		return 1;
	}
	return 0;
}

/* Each row: a fixture `w6c_ww -T` must loud-reject, and why. */
static const struct {
	const char *fixture;
	const char *what;
} rejects[] = {
	{ "test/wcc/data/attest_userman.ww", "user main" },
	{ "test/wcc/data/attest_badsig.ww",  "non-void @test" },
};

int
main(void)
{
	const char *bin = absbin();
	if (!bin) { fprintf(stderr, "997 FAIL: getcwd\n"); return 1; }

	if (run_fixture(bin) != 0) return 1;
	if (byteid(bin) != 0) return 1;
	for (size_t i = 0; i < sizeof rejects / sizeof rejects[0]; i++)
		if (reject(bin, rejects[i].fixture, rejects[i].what) != 0)
			return 1;

	printf("@test -T (ww_ww): run ok + cs/ww byte-id + rejects ok\n");
	return 0;
}