lib/strings-core tests: hand-main plumbing -> assert (@test conversion B4)

bytes EXCLUDED: its green masked a real signalled corruption (filed;
conversion rides the fix). stringstest documents the per-row signalled
pinpoint loss.

lib/shlex/shlextest.ww

@@ -15,10 +15,8 @@
 //     shape against a memio.dynamic sink, mirroring Hare's escape.ha
 //     testquote table.
 //
-// Failure path: each @test fn bumps `signalled` to its slot index,
-// the helpers do `exit(signalled + 10)` on miscompare so the harness
-// reports `WEXITSTATUS = 11..N` pointing at the failing scenario.
-// Same convention as fnmatchtest / logtest.
+// Failure path: a miscompare aborts via the assert/abort builtin
+// (task #5 @test conversion).
 
 package shlex_test;
 
@@ -26,19 +24,6 @@ import shlex;
 import io;
 import memio;
 
-// Direct rt_syscall binding rather than `use os;` — os exports
-// read/write/close, which collide with io.read/write/close under the
-// driver's flat-scope concat. Mirrors fnmatchtest / logtest / fmttest
-// / bufiotest.
-@symbol("rt_syscall") fn syscall1ww(num: i64, a: i64) i64;
-fn doexit(code: i32) void = {
-	syscall1ww(60i64, code: i64);
-};
-
-let signalled: i32 = 0;
-
-fn fail() void = { doexit(signalled + 10); };
-
 fn streq(a: str, b: str) bool = {
 	if (a.len != b.len) { return false; };
 	let i: i32 = 0;
@@ -56,10 +41,10 @@ fn streq(a: str, b: str) bool = {
 fn check1(in: str, e0: str) void = {
 	let r = shlex.split(in);
 	match (r) {
-	case shlex.syntaxerr => { fail(); };
+	case shlex.syntaxerr => { abort(); };
 	case let s: []str => {
-		if (s.len != 1) { fail(); };
-		if (!streq(s[0], e0)) { fail(); };
+		assert(!(s.len != 1));
+		assert(!(!streq(s[0], e0)));
 	};
 	};
 };
@@ -67,11 +52,11 @@ fn check1(in: str, e0: str) void = {
 fn check2(in: str, e0: str, e1: str) void = {
 	let r = shlex.split(in);
 	match (r) {
-	case shlex.syntaxerr => { fail(); };
+	case shlex.syntaxerr => { abort(); };
 	case let s: []str => {
-		if (s.len != 2) { fail(); };
-		if (!streq(s[0], e0)) { fail(); };
-		if (!streq(s[1], e1)) { fail(); };
+		assert(!(s.len != 2));
+		assert(!(!streq(s[0], e0)));
+		assert(!(!streq(s[1], e1)));
 	};
 	};
 };
@@ -79,12 +64,12 @@ fn check2(in: str, e0: str, e1: str) void = {
 fn check3(in: str, e0: str, e1: str, e2: str) void = {
 	let r = shlex.split(in);
 	match (r) {
-	case shlex.syntaxerr => { fail(); };
+	case shlex.syntaxerr => { abort(); };
 	case let s: []str => {
-		if (s.len != 3) { fail(); };
-		if (!streq(s[0], e0)) { fail(); };
-		if (!streq(s[1], e1)) { fail(); };
-		if (!streq(s[2], e2)) { fail(); };
+		assert(!(s.len != 3));
+		assert(!(!streq(s[0], e0)));
+		assert(!(!streq(s[1], e1)));
+		assert(!(!streq(s[2], e2)));
 	};
 	};
 };
@@ -93,16 +78,16 @@ fn checkerr(in: str) void = {
 	let r = shlex.split(in);
 	match (r) {
 	case shlex.syntaxerr => {};
-	case let s: []str => { fail(); };
+	case let s: []str => { abort(); };
 	};
 };
 
 fn checkempty(in: str) void = {
 	let r = shlex.split(in);
 	match (r) {
-	case shlex.syntaxerr => { fail(); };
+	case shlex.syntaxerr => { abort(); };
 	case let s: []str => {
-		if (s.len != 0) { fail(); };
+		assert(!(s.len != 0));
 	};
 	};
 };
@@ -115,12 +100,12 @@ fn checkquote(in: str, expected: str) void = {
 	let n: size = 0;
 	match (r) {
 	case let v: size => { n = v; };
-	case let _e: io.error => { fail(); };
+	case let _e: io.error => { abort(); };
 	};
-	if (n != expected.len: size) { fail(); };
+	assert(!(n != expected.len: size));
 
 	let view: str = memio.string(&st);
-	if (!streq(view, expected)) { fail(); };
+	assert(!(!streq(view, expected)));
 
 	let _c: (void | io.error) = io.close(snk);
 };
@@ -182,7 +167,7 @@ fn checkquote(in: str, expected: str) void = {
 
 @test fn test_quotestr() void = {
 	let r: str = shlex.quotestr("hello world");
-	if (!streq(r, "'hello world'")) { fail(); };
+	assert(!(!streq(r, "'hello world'")));
 	// leak r — short-lived test process, same precedent as fnmatchtest.
 };
 
@@ -191,13 +176,13 @@ fn checkquote(in: str, expected: str) void = {
 @test fn test_strerror() void = {
 	let e: shlex.syntaxerr;
 	let s: str = shlex.strerror(e);
-	if (!streq(s, "Invalid shell syntax")) { fail(); };
+	assert(!(!streq(s, "Invalid shell syntax")));
 };
 
 export fn main() i32 = {
-	signalled = 1; test_split();
-	signalled = 2; test_quote();
-	signalled = 3; test_quotestr();
-	signalled = 4; test_strerror();
+	test_split();
+	test_quote();
+	test_quotestr();
+	test_strerror();
 	return 0;
 };