ww/test/wcc/949_driver_flagargs.c

/*
 * 949_driver_flagargs — task #15 B2: the ww driver's flag-argument error
 * branches, pinned across BOTH driver twins (cstage `ww` and wwstage
 * `ww_ww`). The branches under test:
 *   build/run  — a lone -I/-L/-l/-o (flag with no following argument) is a
 *                hard error "ww <cmd>: -X needs an argument" (rc 2), not a
 *                silently-swallowed positional.
 *   test       — -I/-c/-o carry meaning; -l/-L and any unknown flag are
 *                rejected with "ww test: unknown flag" (rc 2); a lone -I/-o
 *                is "ww test: -X needs an argument" (rc 2); -o without a
 *                single test file is "ww test: -c/-S/-o need a single test
 *                file" (rc 2, #17); a missing -run argument is rc 2; a 2nd positional
 *                in directory mode is "ww test: pattern needs a single test
 *                file" (rc 2, #17).
 * Each row asserts the expected rc + stderr substring AND that the two
 * drivers are byte-identical (rule 10): the cstage parse_build_flags /
 * do_test must match the wwstage main.ww dobuild/dorun/dotest verbatim.
 * This carrier also owns the `-V` output and C/WW-driver version parity.
 *
 * All flag rows error during parsing, before any compile, so there are no
 * build intermediates to redirect (rule 14: light driver test, any NNN).
 * Sibling of 949_missingpkg (driver enforcement) and 993_ww_ww (twin parity).
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include "ww.h"

struct row {
	const char *args;	/* argv tail after the driver path */
	int         rc;		/* expected exit code */
	const char *sub;	/* expected stderr substring */
};

static const struct row rows[] = {
	{ "build -o",   2, "ww build: -o needs an argument" },
	{ "build -I",   2, "ww build: -I needs an argument" },
	{ "build -L",   2, "ww build: -L needs an argument" },
	{ "build -l",   2, "ww build: -l needs an argument" },
	{ "build -zz",  2, "ww build: unknown flag" },
	{ "run -o",     2, "ww run: -o needs an argument" },
	{ "run -l",     2, "ww run: -l needs an argument" },
	{ "run -zz",    2, "ww run: unknown flag" },
	{ "test -l",    2, "ww test: unknown flag" },
	{ "test -zz",   2, "ww test: unknown flag" },
	{ "test -I",    2, "ww test: -I needs an argument" },
	/* Package `test -c` is now valid and covered by native package tests. A
	 * lone -o needs an argument, while -o still has no directory contract. */
	{ "test -o",    2, "ww test: -o needs an argument" },
	{ "test -o x",  2, "ww test: -c/-S/-o need a single test file" },
	{ "test -run",  2, "ww test: -run needs an argument" },
	/* #17: a 2nd positional is a fnmatch name-filter pattern, valid only
	 * for a single test file/module; in directory mode (target ".") it
	 * has no single binary to route to and is rejected (rc 2). */
	{ "test . zzz", 2, "ww test: pattern needs a single test file" },
};

static void
read_text(const char *path, char *buf, size_t bufsz)
{
	buf[0] = '\0';
	FILE *f = fopen(path, "r");
	if (f == NULL)
		return;
	size_t n = fread(buf, 1, bufsz - 1, f);
	buf[n] = '\0';
	fclose(f);
}

/* Run "<bin>/<drv> <args>" and capture both output streams. */
static int
run_drv(const char *bin, const char *drv, const char *args,
	char *out, size_t outsz, char *err, size_t errsz)
{
	int pid = getpid();
	char outf[64], errf[64], cmd[2048];
	snprintf(outf, sizeof outf, "/tmp/dfa949_%d.out", pid);
	snprintf(errf, sizeof errf, "/tmp/dfa949_%d.err", pid);
	snprintf(cmd, sizeof cmd, "%s/%s %s >%s 2>%s",
	    bin, drv, args, outf, errf);
	int rc = system(cmd);
	if (rc == -1) {
		unlink(outf);
		unlink(errf);
		return -1;
	}
	rc = WIFEXITED(rc) ? WEXITSTATUS(rc) : 1;
	read_text(outf, out, outsz);
	read_text(errf, err, errsz);
	unlink(outf);
	unlink(errf);
	return rc;
}

static int
test_version(const char *bin)
{
	char cout[128], cerr[128], wout[128], werr[128], want[128];
	int crc = run_drv(bin, "ww", "-V", cout, sizeof cout,
	    cerr, sizeof cerr);
	int wrc = run_drv(bin, "ww_ww", "-V", wout, sizeof wout,
	    werr, sizeof werr);
	int fail = 0;
	snprintf(want, sizeof want, "ww %s\n", WW_VERSION);
	if (crc != 0 || strcmp(cout, want) != 0 || cerr[0] != '\0') {
		fprintf(stderr, "949 FAIL: ww -V rc=%d stdout='%s' stderr='%s'\n",
		    crc, cout, cerr);
		fail = 1;
	}
	if (wrc != crc || strcmp(wout, cout) != 0 || strcmp(werr, cerr) != 0) {
		fprintf(stderr, "949 FAIL: ww_ww -V rc=%d stdout='%s' stderr='%s' "
		    "!= ww rc=%d stdout='%s' stderr='%s'\n",
		    wrc, wout, werr, crc, cout, cerr);
		fail = 1;
	}
	return fail;
}

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;
	}

	int fail = test_version(bin);
	size_t n = sizeof rows / sizeof rows[0];
	for (size_t i = 0; i < n; i++) {
		char cout[256], cerr[4096], wout[256], werr[4096];
		int crc = run_drv(bin, "ww", rows[i].args,
		    cout, sizeof cout, cerr, sizeof cerr);
		int wrc = run_drv(bin, "ww_ww", rows[i].args,
		    wout, sizeof wout, werr, sizeof werr);

		if (crc != rows[i].rc) {
			fprintf(stderr, "949 FAIL: ww %s rc=%d want=%d\n",
			    rows[i].args, crc, rows[i].rc);
			fail = 1;
		}
		if (!strstr(cerr, rows[i].sub)) {
			fprintf(stderr, "949 FAIL: ww %s stderr missing '%s' (got '%s')\n",
			    rows[i].args, rows[i].sub, cerr);
			fail = 1;
		}
		/* twin parity: ww_ww must match ww exactly (rc + stderr). */
		if (wrc != crc) {
			fprintf(stderr, "949 FAIL: %s ww_ww rc=%d != ww rc=%d\n",
			    rows[i].args, wrc, crc);
			fail = 1;
		}
		if (strcmp(werr, cerr) != 0) {
			fprintf(stderr, "949 FAIL: %s ww_ww stderr '%s' != ww '%s'\n",
			    rows[i].args, werr, cerr);
			fail = 1;
		}
		if (strcmp(wout, cout) != 0) {
			fprintf(stderr, "949 FAIL: %s ww_ww stdout '%s' != ww '%s'\n",
			    rows[i].args, wout, cout);
			fail = 1;
		}
	}

	if (fail) return 1;
	printf("driver version + flag-argument errors: %zu rows, ww==ww_ww pinned\n",
	    n);
	return 0;
}