lib/encoding+math tests: hand-main plumbing -> assert (@test conversion B2)

lib/encoding/hex/hextest.ww

@@ -1,8 +1,8 @@
 // hextest — exercises lib/encoding/hex's io-streaming surface. Run with
 // `out/bin/ww run lib/encoding/hex/hextest.ww`. Mirrors Hare's hex
 // @test fns (ref/hare/encoding/hex/hex.ha:82,96,194) plus a full-byte
-// round-trip. Same signalled-then-fail()-with-+10 pattern as the rest of
-// the 9xx stdlib tests; non-zero exit pinpoints the failing scenario.
+// round-trip. A failing row aborts via the assert/abort builtin (task #5
+// @test conversion).
 //
 // The streaming decoder (newdecoder) is deferred (#247), so the decode
 // side is exercised through decodestr only.
@@ -14,10 +14,7 @@ import errors;
 import hex;
 import io;
 import memio;
-import os;
 
-let signalled: i32 = 0;
-fn fail() void = { os.exit(signalled + 10); };
 
 fn streq(a: str, b: str) bool = {
 	if (a.len != b.len) { return false; };
@@ -40,24 +37,24 @@ fn cafebabe() [8]u8 = {
 
 @test fn encodestr_basic() void = {
 	let in: [8]u8 = cafebabe();
-	if (!streq(hex.encodestr(in[0:8]), "cafebabedeadf00d")) { fail(); };
+	assert(!(!streq(hex.encodestr(in[0:8]), "cafebabedeadf00d")));
 };
 
 // 0x00 → "00" guards a sign-extend / signed-shift on the high nibble.
 @test fn encodestr_zero() void = {
 	let in: [1]u8; in[0] = 0u8;
-	if (!streq(hex.encodestr(in[0:1]), "00")) { fail(); };
+	assert(!(!streq(hex.encodestr(in[0:1]), "00")));
 };
 
 // 0xFF → "ff" guards an off-by-one in the digit lookup.
 @test fn encodestr_ff() void = {
 	let in: [1]u8; in[0] = 0xFFu8;
-	if (!streq(hex.encodestr(in[0:1]), "ff")) { fail(); };
+	assert(!(!streq(hex.encodestr(in[0:1]), "ff")));
 };
 
 @test fn encodestr_empty() void = {
 	let in: [1]u8;
-	if (hex.encodestr(in[0:0]).len != 0) { fail(); };
+	assert(!(hex.encodestr(in[0:0]).len != 0));
 };
 
 // ---- encode (io.handle sink) ---- ref/hare/encoding/hex/hex.ha:96
@@ -66,10 +63,10 @@ fn cafebabe() [8]u8 = {
 	let in: [8]u8 = cafebabe();
 	let out: memio.stream = memio.dynamic();
 	match (hex.encode(&out.vt, in[0:8])) {
-	case let n: size => { if (n: i32 != 16) { fail(); }; };
-	case let e: io.error => fail();
+	case let n: size => { assert(!(n: i32 != 16)); };
+	case let e: io.error => abort();
 	};
-	if (!streq(memio.string(&out), "cafebabedeadf00d")) { fail(); };
+	assert(!(!streq(memio.string(&out), "cafebabedeadf00d")));
 };
 
 // ---- decodestr round-trip ---- ref/hare/encoding/hex/hex.ha:194
@@ -78,9 +75,9 @@ fn cafebabe() [8]u8 = {
 	match (hex.decodestr("cafebabedeadf00d")) {
 	case let b: []u8 => {
 		let want: [8]u8 = cafebabe();
-		if (!bytes.equal(b, want[0:8])) { fail(); };
+		assert(!(!bytes.equal(b, want[0:8])));
 	};
-	case let e: errors.invalid => fail();
+	case let e: errors.invalid => abort();
 	};
 };
 
@@ -90,9 +87,9 @@ fn cafebabe() [8]u8 = {
 	match (hex.decodestr("CAFEBABEDEADF00D")) {
 	case let b: []u8 => {
 		let want: [8]u8 = cafebabe();
-		if (!bytes.equal(b, want[0:8])) { fail(); };
+		assert(!(!bytes.equal(b, want[0:8])));
 	};
-	case let e: errors.invalid => fail();
+	case let e: errors.invalid => abort();
 	};
 };
 
@@ -100,16 +97,16 @@ fn cafebabe() [8]u8 = {
 	match (hex.decodestr("CaFeBaBeDeAdF00d")) {
 	case let b: []u8 => {
 		let want: [8]u8 = cafebabe();
-		if (!bytes.equal(b, want[0:8])) { fail(); };
+		assert(!(!bytes.equal(b, want[0:8])));
 	};
-	case let e: errors.invalid => fail();
+	case let e: errors.invalid => abort();
 	};
 };
 
 @test fn decodestr_empty() void = {
 	match (hex.decodestr("")) {
-	case let b: []u8 => { if (b.len != 0) { fail(); }; };
-	case let e: errors.invalid => fail();
+	case let b: []u8 => { assert(!(b.len != 0)); };
+	case let e: errors.invalid => abort();
 	};
 };
 
@@ -119,21 +116,21 @@ fn cafebabe() [8]u8 = {
 
 @test fn decodestr_odd() void = {
 	match (hex.decodestr("abc")) {
-	case let b: []u8 => fail();
+	case let b: []u8 => abort();
 	case let e: errors.invalid => void;
 	};
 };
 
 @test fn decodestr_bad() void = {
 	match (hex.decodestr("zz00")) {	// 'z' isn't hex
-	case let b: []u8 => fail();
+	case let b: []u8 => abort();
 	case let e: errors.invalid => void;
 	};
 };
 
 @test fn decodestr_bad_mid() void = {
 	match (hex.decodestr("aabbgg")) {	// 'g' isn't hex
-	case let b: []u8 => fail();
+	case let b: []u8 => abort();
 	case let e: errors.invalid => void;
 	};
 };
@@ -148,29 +145,29 @@ fn cafebabe() [8]u8 = {
 		i += 1;
 	};
 	let s: str = hex.encodestr(src[0:256]);
-	if (s.len != 512) { fail(); };
+	assert(!(s.len != 512));
 	match (hex.decodestr(s)) {
 	case let b: []u8 => {
-		if (b.len != 256) { fail(); };
-		if (!bytes.equal(b, src[0:256])) { fail(); };
+		assert(!(b.len != 256));
+		assert(!(!bytes.equal(b, src[0:256])));
 	};
-	case let e: errors.invalid => fail();
+	case let e: errors.invalid => abort();
 	};
 };
 
 export fn main() i32 = {
-	signalled = 1;  encodestr_basic();
-	signalled = 2;  encodestr_zero();
-	signalled = 3;  encodestr_ff();
-	signalled = 4;  encodestr_empty();
-	signalled = 5;  encode_stream();
-	signalled = 6;  decodestr_lower();
-	signalled = 7;  decodestr_upper();
-	signalled = 8;  decodestr_mixed();
-	signalled = 9;  decodestr_empty();
-	signalled = 10; decodestr_odd();
-	signalled = 11; decodestr_bad();
-	signalled = 12; decodestr_bad_mid();
-	signalled = 13; roundtrip_all_bytes();
+	encodestr_basic();
+	encodestr_zero();
+	encodestr_ff();
+	encodestr_empty();
+	encode_stream();
+	decodestr_lower();
+	decodestr_upper();
+	decodestr_mixed();
+	decodestr_empty();
+	decodestr_odd();
+	decodestr_bad();
+	decodestr_bad_mid();
+	roundtrip_all_bytes();
 	return 0;
 };