ww/test/wcc/737_direnum.c

/*
 * 737_direnum — driver-level sentinel for task #22 directory-as-
 * module enumeration. Two row families pinning the contract:
 *
 *   ok    — multi-file dir is concatenated by both stages; the entry
 *           reads cross-pkg bare-leaf fns from sibling files. Build
 *           must succeed for both C-built `ww` and ww-built `ww_ww`.
 *   bad   — multi-file dir with mismatched `package <name>;` decls
 *           triggers the strict-same-package error (task #25 subset
 *           bundled with #22 because the failure mode is dir-enum's
 *           own; cross-stage symmetric).
 *
 * Asm-presence isn't checked separately — 968_utf8_run, 966_strings_
 * run, 995_self_rebuild already exercise dir-enum end-to-end at
 * binary level. This file pins the cstage/wwstage symmetric error
 * path so a regression on either driver fails loud.
 */
#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 int
runbuild(const char *driver, const char *src, const char *outbin)
{
	char cmd[2048];
	snprintf(cmd, sizeof cmd, "%s build %s -o /dev/null >/dev/null 2>%s",
	    driver, src, outbin);
	return runwait(cmd);
}

static int
stderr_contains(const char *path, const char *needle)
{
	FILE *f = fopen(path, "rb");
	if (!f) return 0;
	char buf[4096];
	size_t n = fread(buf, 1, sizeof buf - 1, f);
	fclose(f);
	buf[n] = '\0';
	return strstr(buf, needle) != NULL;
}

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

	char ww[1280], ww_ww[1280];
	snprintf(ww,    sizeof ww,    "%s/ww",    bin);
	snprintf(ww_ww, sizeof ww_ww, "%s/ww_ww", bin);

	int total = 0, fail = 0;
	char errp[64];

	/* ok: cross-pkg bare-leaf via dir-enum, both stages. */
	{
		const char *src = "test/wcc/data/direnum/entry.ww";
		char tmp[64];
		snprintf(tmp, sizeof tmp, "/tmp/direnum_%d_ok", getpid());
		char cmd[2048];

		snprintf(cmd, sizeof cmd, "%s run %s >/dev/null 2>&1", ww, src);
		total++;
		if (runwait(cmd) != 0) {
			fprintf(stderr, "737[ok-cstage]: ww run %s failed\n", src);
			fail++;
		}

		if (access(ww_ww, X_OK) == 0) {
			snprintf(cmd, sizeof cmd, "%s run %s >/dev/null 2>&1",
			    ww_ww, src);
			total++;
			if (runwait(cmd) != 0) {
				fprintf(stderr, "737[ok-wwstage]: ww_ww run %s failed\n", src);
				fail++;
			}
		}
		(void)tmp;
	}

	/* bad: mismatched package decls in same dir → strict-same-package
	 * error. Both stages must surface "differs from" in stderr. */
	{
		const char *src = "test/wcc/data/direnum/bad_entry.ww";
		snprintf(errp, sizeof errp, "/tmp/direnum_%d_bad.err", getpid());

		char cmd[2048];
		snprintf(cmd, sizeof cmd, "%s build %s 2>%s >/dev/null",
		    ww, src, errp);
		int rc = runwait(cmd);
		total++;
		if (rc == 0) {
			fprintf(stderr, "737[bad-cstage]: expected build failure, succeeded\n");
			fail++;
		} else if (!stderr_contains(errp, "differs from")) {
			fprintf(stderr, "737[bad-cstage]: stderr missing 'differs from'\n");
			fail++;
		}
		unlink(errp);

		if (access(ww_ww, X_OK) == 0) {
			snprintf(cmd, sizeof cmd, "%s build %s 2>%s >/dev/null",
			    ww_ww, src, errp);
			rc = runwait(cmd);
			total++;
			if (rc == 0) {
				fprintf(stderr, "737[bad-wwstage]: expected build failure, succeeded\n");
				fail++;
			} else if (!stderr_contains(errp, "differs from")) {
				fprintf(stderr, "737[bad-wwstage]: stderr missing 'differs from'\n");
				fail++;
			}
			unlink(errp);
		}
	}

	/* bad-deep: same mismatch, but one file's `package` decl sits behind
	 * a >2048-byte comment header. Pins the PREP-peek whole-file read
	 * (#16): the old 2048-capped peek missed that decl, so the strict-
	 * same-package check skipped the file and the mismatch went
	 * undetected (build wrongly succeeded); the whole-file peek finds it
	 * → "differs from". Both stages. (reviewer-batcha pin.) */
	{
		const char *src = "test/wcc/data/direnum/bad_deep_entry.ww";
		snprintf(errp, sizeof errp, "/tmp/direnum_%d_baddeep.err", getpid());

		char cmd[2048];
		snprintf(cmd, sizeof cmd, "%s build %s 2>%s >/dev/null",
		    ww, src, errp);
		int rc = runwait(cmd);
		total++;
		if (rc == 0) {
			fprintf(stderr, "737[bad-deep-cstage]: expected build failure, succeeded\n");
			fail++;
		} else if (!stderr_contains(errp, "differs from")) {
			fprintf(stderr, "737[bad-deep-cstage]: stderr missing 'differs from'\n");
			fail++;
		}
		unlink(errp);

		if (access(ww_ww, X_OK) == 0) {
			snprintf(cmd, sizeof cmd, "%s build %s 2>%s >/dev/null",
			    ww_ww, src, errp);
			rc = runwait(cmd);
			total++;
			if (rc == 0) {
				fprintf(stderr, "737[bad-deep-wwstage]: expected build failure, succeeded\n");
				fail++;
			} else if (!stderr_contains(errp, "differs from")) {
				fprintf(stderr, "737[bad-deep-wwstage]: stderr missing 'differs from'\n");
				fail++;
			}
			unlink(errp);
		}
	}

	if (fail) {
		fprintf(stderr, "737_direnum: %d/%d fixtures failed\n", fail, total);
		return 1;
	}
	printf("737_direnum: %d/%d ok\n", total, total);
	return 0;
}