radiance · commit

lib/std/arch/rv64/tests/abi.sizes.rad +18 -54

}

/// Test 1-byte record.
fn testByte() -> i32 {
    let b = makeByte(42);
    if b.x != 42 {
        return 1;
    }
    assert b.x == 42;
    return 0;
}

/// Test 2-byte record.
fn testShort() -> i32 {
    let s = makeShort(1234);
    if s.x != 1234 {
        return 1;
    }
    assert s.x == 1234;
    return 0;
}

/// Test 4-byte record.
fn testWord() -> i32 {
    let w = makeWord(0xDEAD);
    if w.x != 0xDEAD {
        return 1;
    }
    assert w.x == 0xDEAD;
    return 0;
}

/// Test 8-byte record (boundary case, should be by value).
fn testPair() -> i32 {
    let p = makePair(10, 20);
    if p.a != 10 {
        return 1;
    }
    if p.b != 20 {
        return 2;
    }
    assert p.a == 10;
    assert p.b == 20;
    return 0;
}

/// Test 12-byte record (should be by reference).
fn testTriple() -> i32 {
    let t = makeTriple(100, 200, 300);
    if t.x != 100 {
        return 1;
    }
    if t.y != 200 {
        return 2;
    }
    if t.z != 300 {
        return 3;
    }
    assert t.x == 100;
    assert t.y == 200;
    assert t.z == 300;
    return 0;
}

/// Test passing small aggregate as parameter and returning it.
fn testIdentity() -> i32 {
    let p = makePair(5, 6);
    let q = identity(p);
    if q.a != 5 {
        return 1;
    }
    if q.b != 6 {
        return 2;
    }
    assert q.a == 5;
    assert q.b == 6;
    return 0;
}

/// Test multiple small aggregate args.
fn testAddPairs() -> i32 {
    let a = makePair(1, 2);
    let b = makePair(3, 4);
    let c = addPairs(a, b);
    if c.a != 4 {
        return 1;
    }
    if c.b != 6 {
        return 2;
    }
    assert c.a == 4;
    assert c.b == 6;
    return 0;
}

/// Test chained calls.
fn testDoublePair() -> i32 {
    let p = makePair(10, 20);
    let d = doublePair(p);
    if d.a != 20 {
        return 1;
    }
    if d.b != 40 {
        return 2;
    }
    assert d.a == 20;
    assert d.b == 40;
    return 0;
}

/// Test multiple returns don't interfere.
fn testMultipleReturns() -> i32 {
    let p1 = makePair(1, 2);
    let p2 = makePair(3, 4);
    if p1.a != 1 {
        return 1;
    }
    if p1.b != 2 {
        return 2;
    }
    if p2.a != 3 {
        return 3;
    }
    if p2.b != 4 {
        return 4;
    }
    assert p1.a == 1;
    assert p1.b == 2;
    assert p2.a == 3;
    assert p2.b == 4;
    return 0;
}

@default fn main() -> i32 {
    let r1 = testByte();

lib/std/arch/rv64/tests/aggregate.return.rad +27 -81

fn testReturnDoesNotCorruptLocals() -> i32 {
    let sentinel: u32 = 0xDEAD;
    let p: Pair = makePair(10, 20);
    let sentinel2: u32 = 0xBEEF;

    if p.a != 10 {
        return 1;
    }
    if p.b != 20 {
        return 2;
    }
    if sentinel != 0xDEAD {
        return 3;
    }
    if sentinel2 != 0xBEEF {
        return 4;
    }
    assert p.a == 10;
    assert p.b == 20;
    assert sentinel == 0xDEAD;
    assert sentinel2 == 0xBEEF;
    return 0;
}

/// Two consecutive aggregate returns must not interfere.
fn testMultipleReturns() -> i32 {
    let p1: Pair = makePair(1, 2);
    let p2: Pair = makePair(3, 4);

    if p1.a != 1 {
        return 1;
    }
    if p1.b != 2 {
        return 2;
    }
    if p2.a != 3 {
        return 3;
    }
    if p2.b != 4 {
        return 4;
    }
    assert p1.a == 1;
    assert p1.b == 2;
    assert p2.a == 3;
    assert p2.b == 4;
    return 0;
}

/// Mutating a returned aggregate must not corrupt the stack.
fn testMutateReturnedAggregate() -> i32 {

    let after: u32 = 99;

    p.a = 100;
    p.b = 200;

    if before != 42 {
        return 1;
    }
    if after != 99 {
        return 2;
    }
    if p.a != 100 {
        return 3;
    }
    if p.b != 200 {
        return 4;
    }
    assert before == 42;
    assert after == 99;
    assert p.a == 100;
    assert p.b == 200;
    return 0;
}

/// Aggregate return inside a loop must not corrupt accumulator state.
fn testAggregateReturnInLoop() -> i32 {

        let p: Pair = makePair(idx, idx + 10);
        total += p.a + p.b;
        idx += 1;
    }
    // total = sum(i + i+10 for i in 0..5) = sum(2i+10) = 2*(0+1+2+3+4) + 50 = 20 + 50 = 70
    if total != 70 {
        return 1;
    }
    assert total == 70;
    return 0;
}

/// Throwing function returning aggregate (result buffer) must not corrupt stack.
fn testThrowingAggregateReturn() -> i32 {
    let sentinel: u32 = 0xCAFE;
    let p: Pair = try! makePairOrFail(10, 20, false);
    let sentinel2: u32 = 0xFACE;

    if p.a != 10 {
        return 1;
    }
    if p.b != 20 {
        return 2;
    }
    if sentinel != 0xCAFE {
        return 3;
    }
    if sentinel2 != 0xFACE {
        return 4;
    }
    assert p.a == 10;
    assert p.b == 20;
    assert sentinel == 0xCAFE;
    assert sentinel2 == 0xFACE;
    return 0;
}

/// Catching a thrown error from aggregate-returning function.
fn testThrowingAggregateCatch() -> i32 {
    let sentinel: u32 = 0xBEEF;
    try makePairOrFail(10, 20, true) catch {};
    if sentinel != 0xBEEF {
        return 1;
    }
    assert sentinel == 0xBEEF;
    return 0;
}

/// Triple (12 bytes) aggregate return.
fn testTripleReturn() -> i32 {
    let t: Triple = makeTriple(100, 200, 300);
    if t.x != 100 {
        return 1;
    }
    if t.y != 200 {
        return 2;
    }
    if t.z != 300 {
        return 3;
    }
    assert t.x == 100;
    assert t.y == 200;
    assert t.z == 300;
    return 0;
}

/// Multiple aggregate calls interleaved with scalar work.
fn testInterleavedCalls() -> i32 {
    let p1: Pair = makePair(5, 6);
    let scalar: u32 = p1.a + p1.b;
    let t: Triple = makeTriple(scalar, scalar + 1, scalar + 2);
    let p2: Pair = makePair(t.x, t.z);

    if scalar != 11 {
        return 1;
    }
    if t.x != 11 {
        return 2;
    }
    if t.y != 12 {
        return 3;
    }
    if t.z != 13 {
        return 4;
    }
    if p2.a != 11 {
        return 5;
    }
    if p2.b != 13 {
        return 6;
    }
    assert scalar == 11;
    assert t.x == 11;
    assert t.y == 12;
    assert t.z == 13;
    assert p2.a == 11;
    assert p2.b == 13;
    return 0;
}

@default fn main() -> i32 {
    let r1: i32 = testReturnDoesNotCorruptLocals();

lib/std/arch/rv64/tests/arith.subword.rad +15 -45

    }
    return true;
}

@default fn main() -> i32 {
    if not testI8Overflow() {
        return 1;
    }
    if not testU8Overflow() {
        return 2;
    }
    if not testI8Subtraction() {
        return 3;
    }
    if not testU8Subtraction() {
        return 4;
    }
    if not testI16Overflow() {
        return 5;
    }
    if not testU16Overflow() {
        return 6;
    }
    if not testI8Multiply() {
        return 7;
    }
    if not testU8Multiply() {
        return 8;
    }
    if not testI8Comparison() {
        return 9;
    }
    if not testU8Comparison() {
        return 10;
    }
    if not testNarrowingCast() {
        return 11;
    }
    if not testW32ShiftRight() {
        return 12;
    }
    if not testI8NegOverflow() {
        return 13;
    }
    if not testU8BitNot() {
        return 14;
    }
    if not testW32ShiftLargeImmediate() {
        return 15;
    }
    assert testI8Overflow();
    assert testU8Overflow();
    assert testI8Subtraction();
    assert testU8Subtraction();
    assert testI16Overflow();
    assert testU16Overflow();
    assert testI8Multiply();
    assert testU8Multiply();
    assert testI8Comparison();
    assert testU8Comparison();
    assert testNarrowingCast();
    assert testW32ShiftRight();
    assert testI8NegOverflow();
    assert testU8BitNot();
    assert testW32ShiftLargeImmediate();
    return 0;
}

lib/std/arch/rv64/tests/arith.w64.rad +18 -54

    }
    return true;
}

@default fn main() -> i32 {
    if not testI64Add() {
        return 1;
    }
    if not testU64Add() {
        return 2;
    }
    if not testI64Sub() {
        return 3;
    }
    if not testI64Mul() {
        return 4;
    }
    if not testI64Div() {
        return 5;
    }
    if not testU64Div() {
        return 6;
    }
    if not testI64Neg() {
        return 7;
    }
    if not testI64Shift() {
        return 8;
    }
    if not testU64Shift() {
        return 9;
    }
    if not testI64Bitwise() {
        return 10;
    }
    if not testWidenI32ToI64() {
        return 11;
    }
    if not testWidenU32ToU64() {
        return 12;
    }
    if not testNarrowI64ToI32() {
        return 13;
    }
    if not testNarrowU64ToU32() {
        return 14;
    }
    if not testI64Compare() {
        return 15;
    }
    if not testU64Compare() {
        return 16;
    }
    if not testI64Modulo() {
        return 17;
    }
    if not testU64Modulo() {
        return 18;
    }
    assert testI64Add();
    assert testU64Add();
    assert testI64Sub();
    assert testI64Mul();
    assert testI64Div();
    assert testU64Div();
    assert testI64Neg();
    assert testI64Shift();
    assert testU64Shift();
    assert testI64Bitwise();
    assert testWidenI32ToI64();
    assert testWidenU32ToU64();
    assert testNarrowI64ToI32();
    assert testNarrowU64ToU32();
    assert testI64Compare();
    assert testU64Compare();
    assert testI64Modulo();
    assert testU64Modulo();
    return 0;
}

lib/std/arch/rv64/tests/array.index.assign.rad +1 -3

    sum += arr[1];
    sum += arr[2];
    sum += arr[3];
    sum -= arr[4];

    if sum != 50 {
        return 1;
    }
    assert sum == 50;
    return 0;
}

lib/std/arch/rv64/tests/array.slice.rad +7 -21

    let slice1: *[i32] = &arr[..];
    let slice2: *[i32] = &arr[1..4];
    let slice3: *[i32] = &arr[..3];
    let slice4: *[i32] = &arr[2..];

    if slice1.len != 5 {
        return 1;
    }
    if slice2.len != 3 {
        return 2;
    }
    if slice3.len != 3 {
        return 3;
    }
    if slice4.len != 3 {
        return 4;
    }
    assert slice1.len == 5;
    assert slice2.len == 3;
    assert slice3.len == 3;
    assert slice4.len == 3;

    let slice5: *[i32] = slice3;

    if slice5.len != 3 {
        return 5;
    }
    if slice5.ptr != slice3.ptr {
        return 6;
    }
    assert slice5.len == 3;
    assert slice5.ptr == slice3.ptr;

    let sum1: i32 = slice1[0] + slice1[4];  // 6
    let sum2: i32 = slice2[0] + slice2[1];  // 5
    let sum3: i32 = slice3[0] + slice3[2];  // 4
    let sum4: i32 = slice4[0] + slice4[2];  // 8

    let total: i32 = sum1 + sum2 + sum3 + sum4;
    if total != 23 {
        return 7;
    }
    assert total == 23;

    return 0;
}

lib/std/arch/rv64/tests/binop.bitwise.rad +10 -30

1	1		@default fn main() -> i32 {
2	2		// Test `&` (bitwise AND).
3	3		// `12 = 0b1100`, `10 = 0b1010`, result = `0b1000 = 8`.
4	4		let a: i32 = 12 & 10;
5		-	if a != 8 {
6		-	return 1;
7		-	}
	5	+	assert a == 8;
8	6
9	7		// Test `\|` (bitwise OR).
10	8		// `12 = 0b1100`, `10 = 0b1010`, result = `0b1110 = 14`.
11	9		let b: i32 = 12 \| 10;
12		-	if b != 14 {
13		-	return 2;
14		-	}
	10	+	assert b == 14;
15	11
16	12		// Test `^` (bitwise XOR).
17	13		// `12 = 0b1100`, `10 = 0b1010`, result = `0b0110 = 6`.
18	14		let c: i32 = 12 ^ 10;
19		-	if c != 6 {
20		-	return 3;
21		-	}
	15	+	assert c == 6;
22	16
23	17		// Test `<<` (shift left).
24	18		// `3 << 4 = 48`.
25	19		let d: i32 = 3 << 4;
26		-	if d != 48 {
27		-	return 4;
28		-	}
	20	+	assert d == 48;
29	21
30	22		// Test `>>` (shift right, arithmetic for signed).
31	23		// `48 >> 2 = 12`.
32	24		let e: i32 = 48 >> 2;
33		-	if e != 12 {
34		-	return 5;
35		-	}
	25	+	assert e == 12;
36	26
37	27		// Test `>>` with negative (arithmetic shift preserves sign).
38	28		// `-16 >> 2 = -4` (sign bit extended).
39	29		let f: i32 = -16 >> 2;
40		-	if f != -4 {
41		-	return 6;
42		-	}
	30	+	assert f == -4;
43	31
44	32		// Test `~` (bitwise NOT).
45	33		// `~0 = -1` (all bits set).
46	34		let g: i32 = ~0;
47		-	if g != -1 {
48		-	return 7;
49		-	}
	35	+	assert g == -1;
50	36
51	37		// Test `~` with positive value.
52	38		// `~1 = -2` (in two's complement).
53	39		let h: i32 = ~1;
54		-	if h != -2 {
55		-	return 8;
56		-	}
	40	+	assert h == -2;
57	41
58	42		// Combined operations.
59	43		// `(5 \| 3) & 6 = 7 & 6 = 6`.
60	44		let i: i32 = (5 \| 3) & 6;
61		-	if i != 6 {
62		-	return 9;
63		-	}
	45	+	assert i == 6;
64	46
65	47		// XOR self is `0`.
66	48		let j: i32 = 42;
67		-	if (j ^ j) != 0 {
68		-	return 10;
69		-	}
	49	+	assert (j ^ j) == 0;
70	50		return 0;
71	51		}

lib/std/arch/rv64/tests/binop.cmp.rad +16 -48

1	1		@default fn main() -> i32 {
2	2		let a: i32 = 5;
3	3		let b: i32 = 5;
4	4		let c: i32 = 6;
5	5
6		-	if not (a == b) {
7		-	return 1;
8		-	}
9		-	if a == c {
10		-	return 2;
11		-	}
	6	+	assert (a == b);
	7	+	assert a != c;
12	8
13		-	if a != b {
14		-	return 3;
15		-	}
16		-	if not (a != c) {
17		-	return 4;
18		-	}
	9	+	assert a == b;
	10	+	assert (a != c);
19	11
20		-	if not (a < c) {
21		-	return 5;
22		-	}
23		-	if a < b {
24		-	return 6;
25		-	}
26		-	if c < a {
27		-	return 7;
28		-	}
	12	+	assert (a < c);
	13	+	assert a >= b;
	14	+	assert c >= a;
29	15
30		-	if not (c > a) {
31		-	return 8;
32		-	}
33		-	if a > b {
34		-	return 9;
35		-	}
36		-	if a > c {
37		-	return 10;
38		-	}
	16	+	assert (c > a);
	17	+	assert a <= b;
	18	+	assert a <= c;
39	19
40		-	if not (a <= b) {
41		-	return 11;
42		-	}
43		-	if not (a <= c) {
44		-	return 12;
45		-	}
46		-	if c <= a {
47		-	return 13;
48		-	}
	20	+	assert (a <= b);
	21	+	assert (a <= c);
	22	+	assert c > a;
49	23
50		-	if not (a >= b) {
51		-	return 14;
52		-	}
53		-	if not (c >= a) {
54		-	return 15;
55		-	}
56		-	if a >= c {
57		-	return 16;
58		-	}
	24	+	assert (a >= b);
	25	+	assert (c >= a);
	26	+	assert a < c;
59	27		return 0;
60	28		}

lib/std/arch/rv64/tests/bool.comparison.nested.gen.rad +3 -9

    };
    return c1 != c2;
}

@default fn main() -> i32 {
    if not testNestedEqual() {
        return 1;
    }
    if not testNestedNotEqualCenter() {
        return 2;
    }
    if not testNestedNotEqualRadius() {
        return 3;
    }
    assert testNestedEqual();
    assert testNestedNotEqualCenter();
    assert testNestedNotEqualRadius();
    return 0;
}

lib/std/arch/rv64/tests/bool.comparison.record.gen.rad +5 -15


    return r1 != r2;
}

@default fn main() -> i32 {
    if not testPointEqual() {
        return 1;
    }
    if not testPointNotEqualX() {
        return 2;
    }
    if not testPointNotEqualY() {
        return 3;
    }
    if not testRectEqual() {
        return 4;
    }
    if not testRectNotEqual() {
        return 5;
    }
    assert testPointEqual();
    assert testPointNotEqualX();
    assert testPointNotEqualY();
    assert testRectEqual();
    assert testRectNotEqual();
    return 0;
}

lib/std/arch/rv64/tests/bool.comparison.slice.record.gen.rad +5 -15


    return not lineEqual(line1, line2);
}

@default fn main() -> i32 {
    if not testSliceStructEqual() {
        return 1;
    }
    if not testSliceStructNotEqualContent() {
        return 2;
    }
    if not testSliceStructNotEqualLength() {
        return 3;
    }
    if not testStructWithSliceFieldEqual() {
        return 4;
    }
    if not testStructWithSliceFieldNotEqual() {
        return 5;
    }
    assert testSliceStructEqual();
    assert testSliceStructNotEqualContent();
    assert testSliceStructNotEqualLength();
    assert testStructWithSliceFieldEqual();
    assert testStructWithSliceFieldNotEqual();
    return 0;
}

lib/std/arch/rv64/tests/bool.comparison.slice.union.gen.rad +4 -12


    return not shapeEqual(s1, s2);
}

@default fn main() -> i32 {
    if not testEnumSliceEqual() {
        return 1;
    }
    if not testEnumSliceNotEqual() {
        return 2;
    }
    if not testEnumSizesSliceEqual() {
        return 3;
    }
    if not testEnumDifferentVariants() {
        return 4;
    }
    assert testEnumSliceEqual();
    assert testEnumSliceNotEqual();
    assert testEnumSizesSliceEqual();
    assert testEnumDifferentVariants();
    return 0;
}

lib/std/arch/rv64/tests/bool.comparison.union.ctor.rad +3 -9

    let a: Op = Op::Add;
    let s: Op = Op::Sub;
    let m: Op = Op::Mul;

    // isAdd tests
    if not isAdd(a) {
        return 1;
    }
    assert isAdd(a);
    if isAdd(s) {
        return 2;
    }
    if isAdd(m) {
        return 3;
    }
    // isSub tests
    if not isSub(s) {
        return 4;
    }
    assert isSub(s);
    if isSub(a) {
        return 5;
    }
    // isMul tests
    if not isMul(m) {
        return 6;
    }
    assert isMul(m);
    if isMul(a) {
        return 7;
    }
    return 0;
}

lib/std/arch/rv64/tests/bool.comparison.union.gen.rad +6 -18


    return a != b;
}

@default fn main() -> i32 {
    if not testSameVariantNoPayload() {
        return 1;
    }
    if not testDifferentVariants() {
        return 2;
    }
    if not testSameVariantSamePayload() {
        return 3;
    }
    if not testSameVariantDifferentPayload() {
        return 4;
    }
    if not testBoolPayloadSame() {
        return 5;
    }
    if not testBoolPayloadDifferent() {
        return 6;
    }
    assert testSameVariantNoPayload();
    assert testDifferentVariants();
    assert testSameVariantSamePayload();
    assert testSameVariantDifferentPayload();
    assert testBoolPayloadSame();
    assert testBoolPayloadDifferent();
    return 0;
}

lib/std/arch/rv64/tests/bool.comparison.union.record.gen.rad +12 -24

    circle(u32),
    point(Point),
    rect(Size),
}

fn test_same_variant_primitive() -> bool {
fn testSameVariantPrimitive() -> bool {
    let s1: Shape = Shape::circle(10);
    let s2: Shape = Shape::circle(10);
    return s1 == s2;
}

fn test_different_variant() -> bool {
fn testDifferentVariant() -> bool {
    let s1: Shape = Shape::circle(10);
    let s2: Shape = Shape::point(Point { x: 5, y: 5 });
    return s1 != s2;
}

fn test_same_variant_struct_equal() -> bool {
fn testSameVariantStructEqual() -> bool {
    let s1: Shape = Shape::point(Point { x: 10, y: 20 });
    let s2: Shape = Shape::point(Point { x: 10, y: 20 });
    return s1 == s2;
}

fn test_same_variant_struct_not_equal() -> bool {
fn testSameVariantStructNotEqual() -> bool {
    let s1: Shape = Shape::point(Point { x: 10, y: 20 });
    let s2: Shape = Shape::point(Point { x: 10, y: 25 });
    return s1 != s2;
}

fn test_rect_variant_equal() -> bool {
fn testRectVariantEqual() -> bool {
    let s1: Shape = Shape::rect(Size { width: 100, height: 50 });
    let s2: Shape = Shape::rect(Size { width: 100, height: 50 });
    return s1 == s2;
}

fn test_rect_variant_not_equal() -> bool {
fn testRectVariantNotEqual() -> bool {
    let s1: Shape = Shape::rect(Size { width: 100, height: 50 });
    let s2: Shape = Shape::rect(Size { width: 100, height: 60 });
    return s1 != s2;
}

@default fn main() -> i32 {
    if not test_same_variant_primitive() {
        return 1;
    }
    if not test_different_variant() {
        return 2;
    }
    if not test_same_variant_struct_equal() {
        return 3;
    }
    if not test_same_variant_struct_not_equal() {
        return 4;
    }
    if not test_rect_variant_equal() {
        return 5;
    }
    if not test_rect_variant_not_equal() {
        return 6;
    }
    assert testSameVariantPrimitive();
    assert testDifferentVariant();
    assert testSameVariantStructEqual();
    assert testSameVariantStructNotEqual();
    assert testRectVariantEqual();
    assert testRectVariantNotEqual();
    return 0;
}

lib/std/arch/rv64/tests/bool.comparison.union.simple.gen.rad +2 -6

@default fn main() -> i32 {
    let r1: Color = Color::red;
    let r2: Color = Color::red;
    let g: Color = Color::green;

    if r1 != r2 {
        return 1;
    }
    if r1 == g {
        return 2;
    }
    assert r1 == r2;
    assert r1 != g;
    return 0;
}

lib/std/arch/rv64/tests/bool.short.circuit.rad +22 -66


@default fn main() -> i32 {
    // Test 'and' short-circuits when first operand is false.
    let mut x1: i32 = 0;
    let r1: bool = modify(&mut x1, false) and modify(&mut x1, true);
    if r1 {
        return 1;
    }
    if x1 != 1 {
        return 2;
    }
    assert not r1;
    assert x1 == 1;

    // Test 'and' does not short-circuit when first operand is true.
    let mut x2: i32 = 0;
    let r2: bool = modify(&mut x2, true) and modify(&mut x2, true);
    if not r2 {
        return 3;
    }
    if x2 != 2 {
        return 4;
    }
    assert r2;
    assert x2 == 2;

    // Test 'and' evaluates both when first is true, second is false.
    let mut x3: i32 = 0;
    let r3: bool = modify(&mut x3, true) and modify(&mut x3, false);
    if r3 {
        return 5;
    }
    if x3 != 2 {
        return 6;
    }
    assert not r3;
    assert x3 == 2;

    // Test 'or' short-circuits when first operand is true.
    let mut x4: i32 = 0;
    let r4: bool = modify(&mut x4, true) or modify(&mut x4, true);
    if x4 != 1 {
        return 7;
    }
    if not r4 {
        return 8;
    }
    assert x4 == 1;
    assert r4;

    // Test 'or' does not short-circuit when first operand is false.
    let mut x5: i32 = 0;
    let r5: bool = modify(&mut x5, false) or modify(&mut x5, true);
    if x5 != 2 {
        return 9;
    }
    if not r5 {
        return 10;
    }
    assert x5 == 2;
    assert r5;

    let mut y5: i32 = 0;
    let t5: bool = modify(&mut y5, false) or modify(&mut y5, false);
    if y5 != 2 {
        return 11;
    }
    if t5 {
        return 12;
    }
    assert y5 == 2;
    assert not t5;

    // Test complex short-circuiting with nested expressions.
    let mut a6: i32 = 0;
    let r6: bool =
        modify(&mut a6, false) and
        (modify(&mut a6, true) or modify(&mut a6, false));
    if r6 {
        return 13;
    }
    if a6 != 1 {
        return 14;
    }
    assert not r6;
    assert a6 == 1;

    let mut b6: i32 = 0;
    let t6: bool = modify(&mut b6, true) and
        (modify(&mut b6, false) or modify(&mut b6, false));
    if t6 {
        return 15;
    }
    if b6 != 3 {
        return 16;
    }
    assert not t6;
    assert b6 == 3;

    // Test nested or short-circuit.
    let mut a7: i32 = 0;
    let r7: bool = modify(&mut a7, false) or
        (modify(&mut a7, true) and modify(&mut a7, true));
    if not r7 {
        return 17;
    }
    if a7 != 3 {
        return 18;
    }
    assert r7;
    assert a7 == 3;

    // Test chained 'and' short-circuit.
    let mut a8: i32 = 0;
    let mut r8: bool =
        modify(&mut a8, true) and
        modify(&mut a8, false) and
        modify(&mut a8, false);
    if r8 {
        return 19;
    }
    if a8 != 2 {
        return 20;
    }
    assert not r8;
    assert a8 == 2;

    // Test chained 'or' short-circuit.
    let mut a9: i32 = 0;
    let mut r9: bool =
        modify(&mut a9, false) or
        modify(&mut a9, true) or
        modify(&mut a9, false);
    if not r9 {
        return 21;
    }
    if a9 != 2 {
        return 22;
    }
    assert r9;
    assert a9 == 2;

    return 0;
}

lib/std/arch/rv64/tests/bool.values.rad +11 -33

    let t: bool = true;
    let f: bool = false;

    // Assign `and` results to variables.
    let a: bool = t and t;
    if not a {
        return 1;
    }
    assert a;

    let b: bool = t and f;
    if b {
        return 2;
    }
    assert not b;

    let c: bool = f and t;
    if c {
        return 3;
    }
    assert not c;

    let d: bool = f and f;
    if d {
        return 4;
    }
    assert not d;

    // Assign `or` results to variables.
    let e: bool = t or f;
    if not e {
        return 5;
    }
    assert e;

    let g: bool = f or t;
    if not g {
        return 6;
    }
    assert g;

    let h: bool = t or t;
    if not h {
        return 7;
    }
    assert h;

    let i: bool = f or f;
    if i {
        return 8;
    }
    assert not i;

    // Nested expressions.
    let j: bool = (t and t) or f;
    if not j {
        return 9;
    }
    assert j;

    let k: bool = f or (t and t);
    if not k {
        return 10;
    }
    assert k;

    let l: bool = (t or f) and (f or t);
    if not l {
        return 11;
    }
    assert l;
    return 0;
}

lib/std/arch/rv64/tests/call.arg.clobber.rad +1 -3

20	20		}
21	21
22	22		@default fn main() -> i32 {
23	23		let r: i32 = test(10);
24	24		// Expected: 11+12+13+14+15+16 = 81
25		-	if r != 81 {
26		-	return 1;
27		-	}
	25	+	assert r == 81;
28	26		return 0;
29	27		}

lib/std/arch/rv64/tests/call.clobber.rad +4 -12

}

@default fn main() -> i32 {
    let mut x: i32 = 0;
    let r: bool = modify(&mut x, false);
    if x != 1 {
        return 1;
    }
    if r {
        return 2;
    }
    assert x == 1;
    assert not r;

    // Pointer live across call.
    let mut y: i32 = 42;
    let p: *mut i32 = &mut y;
    let r2: bool = modify(p, true);
    if *p != 43 {
        return 3;
    }
    if not r2 {
        return 4;
    }
    assert *p == 43;
    assert r2;
    return 0;
}

lib/std/arch/rv64/tests/cast.same.size.rad +10 -30

@default fn main() -> i32 {
    // Test i8 -> u8 cast: -1 should become 255.
    let x: i8 = -1;
    let a: u8 = x as u8;
    if a != 255 {
        return 1;
    }
    assert a == 255;

    // Test u8 -> i8 cast: 255 should become -1.
    let y: u8 = 255;
    let b: i8 = y as i8;
    if b != -1 {
        return 2;
    }
    assert b == -1;

    // Test i8 -> u8 with boundary value: -128 should become 128.
    let z: i8 = -128;
    let c: u8 = z as u8;
    if c != 128 {
        return 3;
    }
    assert c == 128;

    // Test u8 -> i8 with boundary value: 128 should become -128.
    let w: u8 = 128;
    let d: i8 = w as i8;
    if d != -128 {
        return 4;
    }
    assert d == -128;

    // Test i16 -> u16 cast: -1 should become 65535.
    let p: i16 = -1;
    let q: u16 = p as u16;
    if q != 65535 {
        return 5;
    }
    assert q == 65535;

    // Test u16 -> i16 cast: 65535 should become -1.
    let r: u16 = 65535;
    let s: i16 = r as i16;
    if s != -1 {
        return 6;
    }
    assert s == -1;

    // Eq/Ne used as values must compare at the declared width.
    let eqU8: bool = a == 255;
    if not eqU8 {
        return 7;
    }
    assert eqU8;
    let eqI8: bool = b == -1;
    if not eqI8 {
        return 8;
    }
    assert eqI8;
    let neU8: bool = a != 255;
    if neU8 {
        return 9;
    }
    assert not neU8;
    let neI8: bool = b != -1;
    if neI8 {
        return 10;
    }
    assert not neI8;
    return 0;
}

lib/std/arch/rv64/tests/casting.numbers.rad +8 -24


    return y == -2147483648 and z == 2147483648;
}

@default fn main() -> i32 {
    if not casting() {
        return 1;
    }
    if not zeroExtension() {
        return 2;
    }
    if not signedCasting() {
        return 3;
    }
    if not unsignedToSigned() {
        return 4;
    }
    if not signed16bitCasting() {
        return 5;
    }
    if not maxU8Casting() {
        return 6;
    }
    if not truncationTest() {
        return 7;
    }
    if not sameSizeCasting() {
        return 8;
    }
    assert casting();
    assert zeroExtension();
    assert signedCasting();
    assert unsignedToSigned();
    assert signed16bitCasting();
    assert maxU8Casting();
    assert truncationTest();
    assert sameSizeCasting();
    return 0;
}

lib/std/arch/rv64/tests/char.literal.rad +3 -9

//! Test character literals including escaped chars.
@default fn main() -> i32 {
    if 'a' != 97 {
        return 1;
    }
    if '\'' != 39 {
        return 2;
    }
    if '\\' != 92 {
        return 3;
    }
    assert 'a' == 97;
    assert '\'' == 39;
    assert '\\' == 92;
    return 0;
}

lib/std/arch/rv64/tests/compound.assign.field.rad +3 -9

6	6
7	7		@default fn main() -> i32 {
8	8		let mut p = Point { x: 10, y: 20 };
9	9
10	10		p.x += 5;
11		-	if p.x != 15 {
12		-	return 1;
13		-	}
	11	+	assert p.x == 15;
14	12
15	13		p.y -= 3;
16		-	if p.y != 17 {
17		-	return 2;
18		-	}
	14	+	assert p.y == 17;
19	15
20	16		p.x *= 2;
21		-	if p.x != 30 {
22		-	return 3;
23		-	}
	17	+	assert p.x == 30;
24	18
25	19		return 0;
26	20		}

lib/std/arch/rv64/tests/compound.assign.rad +13 -39

@default fn main() -> i32 {
    let mut a: i32 = 10;

    // Test +=
    a += 5;
    if a != 15 {
        return 1;
    }
    assert a == 15;

    // Test -=
    a -= 3;
    if a != 12 {
        return 2;
    }
    assert a == 12;

    // Test *=
    a *= 2;
    if a != 24 {
        return 3;
    }
    assert a == 24;

    // Test /=
    a /= 4;
    if a != 6 {
        return 4;
    }
    assert a == 6;

    // Test %=
    a %= 4;
    if a != 2 {
        return 5;
    }
    assert a == 2;

    // Test &=
    let mut b: i32 = 0xFF;
    b &= 0x0F;
    if b != 0x0F {
        return 6;
    }
    assert b == 0x0F;

    // Test |=
    b |= 0xF0;
    if b != 0xFF {
        return 7;
    }
    assert b == 0xFF;

    // Test ^=
    b ^= 0x0F;
    if b != 0xF0 {
        return 8;
    }
    assert b == 0xF0;

    // Test <<=
    let mut c: i32 = 1;
    c <<= 4;
    if c != 16 {
        return 9;
    }
    assert c == 16;

    // Test >>=
    c >>= 2;
    if c != 4 {
        return 10;
    }
    assert c == 4;

    // Test compound assignment with array subscript.
    let mut arr: [i32; 3] = [10, 20, 30];
    arr[1] += 5;
    if arr[1] != 25 {
        return 11;
    }
    assert arr[1] == 25;

    // Test compound assignment with pointer dereference.
    let mut val: i32 = 100;
    let p: *mut i32 = &mut val;
    *p += 50;
    if val != 150 {
        return 12;
    }
    assert val == 150;

    // Test chained compound assignments.
    let mut x: i32 = 1;
    x += 2;
    x *= 3;
    x -= 1;
    if x != 8 {
        return 13;
    }
    assert x == 8;

    return 0;
}

lib/std/arch/rv64/tests/cond.assign.rad +3 -9

9	9		if t {
10	10		x = 1;
11	11		} else {
12	12		x = 2;
13	13		}
14		-	if x != 1 {
15		-	return 1;
16		-	}
	14	+	assert x == 1;
17	15
18	16		// `if-else` with `false` condition.
19	17		let f: bool = false;
20	18		if f {
21	19		x = 10;
22	20		} else {
23	21		x = 20;
24	22		}
25		-	if x != 20 {
26		-	return 2;
27		-	}
	23	+	assert x == 20;
28	24
29	25		// `if-else` chain.
30	26		let a: i32 = 5;
31	27		if a == 3 {
32	28		x = 100;
33	29		} else if a == 5 {
34	30		x = 200;
35	31		} else {
36	32		x = 300;
37	33		}
38		-	if x != 200 {
39		-	return 3;
40		-	}
	34	+	assert x == 200;
41	35		return 0;
42	36		}

lib/std/arch/rv64/tests/cond.expr.aggregate.rad +4 -12


/// Test tagged union conditional expression.
fn testUnion() -> i32 {
    let v1 = pickVal(true, 7);
    if let case Val::Reg(r) = v1 {
        if r != 7 {
            return 1;
        }
        assert r == 7;
    } else {
        return 2;
    }

    let v2 = pickVal(false, 7);
    if let case Val::Imm(i) = v2 {
        if i != 99 {
            return 3;
        }
        assert i == 99;
    } else {
        return 4;
    }
    return 0;
}

43	39
44	40		let r1 = pickOpt(a, b);
45	41		let v1 = r1 else {
46	42		return 10;
47	43		};
48		-	if v1 != 42 {
49		-	return 11;
50		-	}
	44	+	assert v1 == 42;
51	45
52	46		let r2 = pickOpt(n, b);
53	47		let v2 = r2 else {
54	48		return 12;
55	49		};
56		-	if v2 != 99 {
57		-	return 13;
58		-	}
	50	+	assert v2 == 99;
59	51
60	52		return 0;
61	53		}
62	54
63	55		@default fn main() -> i32 {

lib/std/arch/rv64/tests/cond.expr.rad +11 -33

}

/// Test basic scalar conditional expression.
fn testScalar() -> i32 {
    let x: i32 = 10 if true else 20;
    if x != 10 {
        return 1;
    }
    assert x == 10;
    let y: i32 = 10 if false else 20;
    if y != 20 {
        return 2;
    }
    assert y == 20;
    return 0;
}

/// Test min-value pattern.
fn testMin() -> i32 {
    if min(5, 3) != 3 {
        return 10;
    }
    if min(3, 5) != 3 {
        return 11;
    }
    if min(4, 4) != 4 {
        return 12;
    }
    assert min(5, 3) == 3;
    assert min(3, 5) == 3;
    assert min(4, 4) == 4;
    return 0;
}

/// Test with function argument as condition.
fn testFnArg() -> i32 {
    if pick(true, 42, 99) != 42 {
        return 20;
    }
    if pick(false, 42, 99) != 99 {
        return 21;
    }
    assert pick(true, 42, 99) == 42;
    assert pick(false, 42, 99) == 99;
    return 0;
}

/// Test with enum values.
fn testEnum() -> i32 {
    let c1 = colorPick(true);
    if c1 != Color::Red {
        return 30;
    }
    assert c1 == Color::Red;
    let c2 = colorPick(false);
    if c2 != Color::Blue {
        return 31;
    }
    assert c2 == Color::Blue;
    return 0;
}

/// Test nested conditional expression (right-associative).
fn testNested() -> i32 {

    let b: i32 = 1;
    let c: i32 = 2;

    // a if false else b if false else c => a if false else (b if false else c) => c
    let result: i32 = a if false else b if false else c;
    if result != 2 {
        return 40;
    }
    assert result == 2;

    // a if true else b if false else c => a
    let result2: i32 = a if true else b if false else c;
    if result2 != 0 {
        return 41;
    }
    assert result2 == 0;
    return 0;
}

@default fn main() -> i32 {
    let r1 = testScalar();

lib/std/arch/rv64/tests/cond.for.unsigned.range.rad +3 -9

    let mut count: i32 = 0;

    for i in start..end {
        count += 1;
    }
    if count != 1 {
        return 1;
    }
    assert count == 1;

    // Unsigned range above signed boundary.
    let start2: u32 = 2147483648;
    let end2: u32 = 2147483651;
    let mut count2: i32 = 0;

    for i in start2..end2 {
        count2 += 1;
    }
    if count2 != 3 {
        return 2;
    }
    assert count2 == 3;

    // Signed range still uses signed ordering.
    let mut sum: i32 = 0;
    for i in -2..2 {
        sum += i;
    }
    if sum != -2 {
        return 3;
    }
    assert sum == -2;

    return 0;
}

lib/std/arch/rv64/tests/cond.if.rad +4 -12

        return 1;
    }

    // Basic `if` with `false`.
    let f: bool = false;
    if f {
        return 2;
    }
    assert not f;

    // Boolean `not`.
    if not f {
    } else {
        return 3;
    }
    if not t {
        return 4;
    }
    assert t;

    // Comparison in condition.
    let a: i32 = 5;
    let b: i32 = 10;
    if a < b {
        // Ignore.
    } else {
        return 5;
    }
    if a > b {
        return 6;
    }
    assert a <= b;
    if a == a {
        // Ignore.
    } else {
        return 7;
    }

        return 8;
    }

    // Nested if.
    if t {
        if f {
            return 9;
        }
        assert not f;
    }

    // `if` in `else` branch.
    if f {
        return 10;

lib/std/arch/rv64/tests/cond.match.guard.rad +10 -30

        }
    }
}

@default fn main() -> i32 {
    if checkStmt(OptionNum::Some(5)) != 5 {
        return 1;
    }
    if checkStmt(OptionNum::Some(2)) != -2 {
        return 2;
    }
    if checkStmt(OptionNum::Other(7)) != 14 {
        return 3;
    }
    if checkStmt(OptionNum::Other(3)) != 0 {
        return 4;
    }
    if checkStmt(OptionNum::None) != 0 {
        return 5;
    }
    if checkExpr(OptionNum::Some(5)) != 6 {
        return 6;
    }
    if checkExpr(OptionNum::Some(9)) != 11 {
        return 7;
    }
    if checkExpr(OptionNum::Other(7)) != 10 {
        return 8;
    }
    if checkExpr(OptionNum::Other(3)) != 0 {
        return 9;
    }
    if checkExpr(OptionNum::None) != 0 {
        return 10;
    }
    assert checkStmt(OptionNum::Some(5)) == 5;
    assert checkStmt(OptionNum::Some(2)) == -2;
    assert checkStmt(OptionNum::Other(7)) == 14;
    assert checkStmt(OptionNum::Other(3)) == 0;
    assert checkStmt(OptionNum::None) == 0;
    assert checkExpr(OptionNum::Some(5)) == 6;
    assert checkExpr(OptionNum::Some(9)) == 11;
    assert checkExpr(OptionNum::Other(7)) == 10;
    assert checkExpr(OptionNum::Other(3)) == 0;
    assert checkExpr(OptionNum::None) == 0;
    return 0;
}

lib/std/arch/rv64/tests/cond.match.guard.regalloc.rad +4 -12

    };
    let mut buffer: [*[u8]; 4] = undefined;
    let path = getPath(&n, &mut buffer[..]);

    let pathLen = path.len as i32;
    if pathLen > 1 {
        return 1;
    }
    if pathLen <= 0 {
        return 2;
    }
    assert pathLen <= 1;
    assert pathLen > 0;

    let elemLen = path[0].len as i32;
    if elemLen > 5 {
        return 3;
    }
    if elemLen <= 4 {
        return 4;
    }
    assert elemLen <= 5;
    assert elemLen > 4;
    return 0;
}

lib/std/arch/rv64/tests/const.fn.array.rad +3 -9

18	18		const OPS: [fn(i32, i32) -> i32; 3] = [add, sub, mul];
19	19
20	20		@default fn main() -> i32 {
21	21		// add(10, 3) == 13
22	22		let r0 = OPS[0](10, 3);
23		-	if r0 != 13 {
24		-	return 1;
25		-	}
	23	+	assert r0 == 13;
26	24		// sub(10, 3) == 7
27	25		let r1 = OPS[1](10, 3);
28		-	if r1 != 7 {
29		-	return 2;
30		-	}
	26	+	assert r1 == 7;
31	27		// mul(10, 3) == 30
32	28		let r2 = OPS[2](10, 3);
33		-	if r2 != 30 {
34		-	return 3;
35		-	}
	29	+	assert r2 == 30;
36	30		return 0;
37	31		}

lib/std/arch/rv64/tests/const.record.ctor.rad +1 -3

record Pair(i32, i32);

const P: Pair = Pair(40, 2);

@default fn main() -> i32 {
    if P != Pair(40, 2) {
        return 1;
    }
    assert P == Pair(40, 2);
    return 0;
}

lib/std/arch/rv64/tests/const.union.payload.ctor.rad +1 -3

const V: Value = Value::Int(42);

@default fn main() -> i32 {
    match V {
        case Value::Int(x) => {
            if x != 42 {
                return 1;
            }
            assert x == 42;
        }
        case Value::Bool(_) => return 2,
        case Value::None => return 3,
    }
    return 0;

lib/std/arch/rv64/tests/const.union.record.literal.rad +1 -3


@default fn main() -> i32 {
    match E {
        case Expr::Nil => return 1,
        case Expr::Pair { first, second } => {
            if first + second != 42 {
                return 2;
            }
            assert first + second == 42;
        }
    }
    return 0;
}

lib/std/arch/rv64/tests/data.array.rad +14 -14

6	6		const I16S: [i16; 2] = [-1000, 1000];
7	7		const I32S: [i32; 2] = [-100000, 100000];
8	8		const BOOLS: [bool; 2] = [true, false];
9	9
10	10		@default fn main() -> i32 {
11		-	if U8S[0] != 10 { return 1; }
12		-	if U8S[1] != 20 { return 2; }
	11	+	assert U8S[0] == 10;
	12	+	assert U8S[1] == 20;
13	13
14		-	if U16S[0] != 1000 { return 3; }
15		-	if U16S[1] != 2000 { return 4; }
	14	+	assert U16S[0] == 1000;
	15	+	assert U16S[1] == 2000;
16	16
17		-	if U32S[0] != 100000 { return 5; }
18		-	if U32S[1] != 200000 { return 6; }
	17	+	assert U32S[0] == 100000;
	18	+	assert U32S[1] == 200000;
19	19
20		-	if I8S[0] != -10 { return 7; }
21		-	if I8S[1] != 10 { return 8; }
	20	+	assert I8S[0] == -10;
	21	+	assert I8S[1] == 10;
22	22
23		-	if I16S[0] != -1000 { return 9; }
24		-	if I16S[1] != 1000 { return 10; }
	23	+	assert I16S[0] == -1000;
	24	+	assert I16S[1] == 1000;
25	25
26		-	if I32S[0] != -100000 { return 11; }
27		-	if I32S[1] != 100000 { return 12; }
	26	+	assert I32S[0] == -100000;
	27	+	assert I32S[1] == 100000;
28	28
29		-	if BOOLS[0] != true { return 13; }
30		-	if BOOLS[1] != false { return 14; }
	29	+	assert BOOLS[0] == true;
	30	+	assert BOOLS[1] == false;
31	31
32	32		return 0;
33	33		}

lib/std/arch/rv64/tests/data.bool.rad +4 -4

//! Test read-only data access for `bool` type.
const T: bool = true;
const F: bool = false;

@default fn main() -> i32 {
    if T != true { return 1; }
    if F != false { return 2; }
    if not T { return 3; }
    if F { return 4; }
    assert T == true;
    assert F == false;
    assert T;
    assert not F;

    return 0;
}

lib/std/arch/rv64/tests/data.i16.rad +4 -4

3	3		const B: i16 = 32767;
4	4		const C: i16 = -32768;
5	5		const D: i16 = -1;
6	6
7	7		@default fn main() -> i32 {
8		-	if A != 0 { return 1; }
9		-	if B != 32767 { return 2; }
10		-	if C != -32768 { return 3; }
11		-	if D != -1 { return 4; }
	8	+	assert A == 0;
	9	+	assert B == 32767;
	10	+	assert C == -32768;
	11	+	assert D == -1;
12	12
13	13		return 0;
14	14		}

lib/std/arch/rv64/tests/data.i32.rad +4 -4

3	3		const B: i32 = 2147483647;
4	4		const C: i32 = -2147483648;
5	5		const D: i32 = -1;
6	6
7	7		@default fn main() -> i32 {
8		-	if A != 0 { return 1; }
9		-	if B != 2147483647 { return 2; }
10		-	if C != -2147483648 { return 3; }
11		-	if D != -1 { return 4; }
	8	+	assert A == 0;
	9	+	assert B == 2147483647;
	10	+	assert C == -2147483648;
	11	+	assert D == -1;
12	12
13	13		return 0;
14	14		}

lib/std/arch/rv64/tests/data.i8.rad +4 -4

3	3		const B: i8 = 127;
4	4		const C: i8 = -128;
5	5		const D: i8 = -1;
6	6
7	7		@default fn main() -> i32 {
8		-	if A != 0 { return 1; }
9		-	if B != 127 { return 2; }
10		-	if C != -128 { return 3; }
11		-	if D != -1 { return 4; }
	8	+	assert A == 0;
	9	+	assert B == 127;
	10	+	assert C == -128;
	11	+	assert D == -1;
12	12
13	13		return 0;
14	14		}

lib/std/arch/rv64/tests/data.record.rad +8 -8

14	14		const ORIGIN: Point = Point { x: 0, y: 0 };
15	15		const P1: Point = Point { x: 100, y: -50 };
16	16		const M1: Mixed = Mixed { a: 255, b: 1000, c: 100000, d: true };
17	17
18	18		@default fn main() -> i32 {
19		-	if ORIGIN.x != 0 { return 1; }
20		-	if ORIGIN.y != 0 { return 2; }
	19	+	assert ORIGIN.x == 0;
	20	+	assert ORIGIN.y == 0;
21	21
22		-	if P1.x != 100 { return 3; }
23		-	if P1.y != -50 { return 4; }
	22	+	assert P1.x == 100;
	23	+	assert P1.y == -50;
24	24
25		-	if M1.a != 255 { return 5; }
26		-	if M1.b != 1000 { return 6; }
27		-	if M1.c != 100000 { return 7; }
28		-	if M1.d != true { return 8; }
	25	+	assert M1.a == 255;
	26	+	assert M1.b == 1000;
	27	+	assert M1.c == 100000;
	28	+	assert M1.d == true;
29	29
30	30		return 0;
31	31		}

lib/std/arch/rv64/tests/data.u16.rad +3 -3

2	2		const A: u16 = 0;
3	3		const B: u16 = 32767;
4	4		const C: u16 = 65535;
5	5
6	6		@default fn main() -> i32 {
7		-	if A != 0 { return 1; }
8		-	if B != 32767 { return 2; }
9		-	if C != 65535 { return 3; }
	7	+	assert A == 0;
	8	+	assert B == 32767;
	9	+	assert C == 65535;
10	10
11	11		return 0;
12	12		}

lib/std/arch/rv64/tests/data.u32.rad +3 -3

2	2		const A: u32 = 0;
3	3		const B: u32 = 2147483647;
4	4		const C: u32 = 4294967295;
5	5
6	6		@default fn main() -> i32 {
7		-	if A != 0 { return 1; }
8		-	if B != 2147483647 { return 2; }
9		-	if C != 4294967295 { return 3; }
	7	+	assert A == 0;
	8	+	assert B == 2147483647;
	9	+	assert C == 4294967295;
10	10
11	11		return 0;
12	12		}

lib/std/arch/rv64/tests/data.u8.rad +3 -3

2	2		const A: u8 = 0;
3	3		const B: u8 = 127;
4	4		const C: u8 = 255;
5	5
6	6		@default fn main() -> i32 {
7		-	if A != 0 { return 1; }
8		-	if B != 127 { return 2; }
9		-	if C != 255 { return 3; }
	7	+	assert A == 0;
	8	+	assert B == 127;
	9	+	assert C == 255;
10	10
11	11		return 0;
12	12		}

lib/std/arch/rv64/tests/debug.tag.rad +1 -3

    },
}

@default fn main() -> u32 {
    let padding: [u32; 600] = [0; 600];
    if padding[0] != 0 {
        return 99;
    }
    assert padding[0] == 0;

    let big: Huge = Huge::Large {
        payload: [0; 32],
        flag: 7,
    };

lib/std/arch/rv64/tests/edge.cases.4.rad +4 -6

        sign: Signedness::Signed,
    };
    let case TypeSig::Integer { width: w1, .. } = direct
        else return 50;

    if w1 != 4 {
        return 51;
    }
    assert w1 == 4;
    let mut nodes: [Node; 2] = undefined;
    let nodes_ptr: *mut Node = &mut nodes[0];
    let nodesPtr: *mut Node = &mut nodes[0];
    let mut count: u32 = 0;
    let type_node = nodeTypeInt(nodes_ptr, &mut count, 4, Signedness::Signed);
    let case NodeValue::TypeSig(sig) = type_node.value
    let typeNode = nodeTypeInt(nodesPtr, &mut count, 4, Signedness::Signed);
    let case NodeValue::TypeSig(sig) = typeNode.value
        else return 40;

    let case TypeSig::Integer { width: w2, .. } = sig
        else return 41;


lib/std/arch/rv64/tests/edge.cases.6.rad +1 -3

    }
    if ANALYZER.len != 1 {
        // Bookkeeping field was overwritten by the bad store.
        return 2;
    }
    if ANALYZER.pad0 != 0xDEADAAA0 or ANALYZER.pad1 != 0xDEADAAA1 {
        return 4;
    }
    assert ANALYZER.pad0 == 0xDEADAAA0 and ANALYZER.pad1 == 0xDEADAAA1;

    let stored = STORAGE[0];
    if stored.a != 0xAAAA1111 or stored.b != 0xBBBB2222 or stored.c != 0xCCCC3333 or stored.d != 0xDDDD4444 or stored.e != 0xEEEE5555 or stored.f != 0x12345601 or stored.j != 0x12345605 or stored.t != 0x1234560F {
        // The write never hit the backing buffer.
        return 3;

lib/std/arch/rv64/tests/edge.cases.8.bug.rad +1 -3

}

@default fn main() -> i32 {
    global = Outer { padding: 0, inner: Inner { value: 42 } };

    if readInner(global.inner) != 42 {
        return 1;
    }
    assert readInner(global.inner) == 42;
    return 0;
}

lib/std/arch/rv64/tests/edge.cases.rad +1 -3

pub record Scanner {
    source: *[u8],
}

fn peek(s: *Scanner)  -> i32 {
    if 0 + 0 > s.source.len {
        return 1;
    }
    assert 0 + 0 <= s.source.len;
    return 0;
}

@default fn main() -> i32 {
    let s: Scanner = Scanner { source: "1" };

lib/std/arch/rv64/tests/error.catch.rad +9 -9

    // Catch block with return in function
    let val3: u32 = returnsEarly();
    assert val3 == 42;

    // try? converts to optional on error
    let ptr_ok: ?*i32 = try? returnsPtrOk();
    if let p = ptr_ok {
    let ptrOk: ?*i32 = try? returnsPtrOk();
    if let p = ptrOk {
        assert *p == 7;
    } else {
        assert false;
    }

    // try? converts to nil on error
    let ptr_err: ?*i32 = try? returnsPtrErr();
    assert ptr_err == nil;
    let ptrErr: ?*i32 = try? returnsPtrErr();
    assert ptrErr == nil;

    // try? on success
    let opt_ok: ?u32 = try? returnsOk();
    assert opt_ok != nil;
    if let v = opt_ok {
    let optOk: ?u32 = try? returnsOk();
    assert optOk != nil;
    if let v = optOk {
        assert v == 21;
    }

    // try? on error
    let opt_err: ?u32 = try? returnsErr();
    assert opt_err == nil;
    let optErr: ?u32 = try? returnsErr();
    assert optErr == nil;

    return 0;
}

fn catchWithReturn(fail: bool) -> u32 {

lib/std/arch/rv64/tests/error.multi.basic.rad +3 -9

    // Test throwing ErrA.
    let mut caught: i32 = 0;
    try failA() catch {
        caught = 1;
    };
    if caught != 1 {
        return 1;
    }
    assert caught == 1;

    // Test throwing ErrB.
    caught = 0;
    try failB() catch {
        caught = 2;
    };
    if caught != 2 {
        return 2;
    }
    assert caught == 2;

    // Test success path.
    let val = try succeed() catch {
        return 3;
    };
    if val != 42 {
        return 4;
    }
    assert val == 42;
    return 0;
}

lib/std/arch/rv64/tests/error.multi.catch.rad +4 -12

    // Catch ErrA without binding.
    let mut handled: i32 = 0;
    try failA() catch {
        handled = 1;
    };
    if handled != 1 {
        return 1;
    }
    assert handled == 1;

    // Catch ErrB without binding.
    handled = 0;
    try failB() catch {
        handled = 2;
    };
    if handled != 2 {
        return 2;
    }
    assert handled == 2;

    // Success path should not trigger catch.
    handled = 0;
    let val = try succeed() catch {
        handled = 99;
    };
    if handled != 0 {
        return 3;
    }
    if val != 99 {
        return 4;
    }
    assert handled == 0;
    assert val == 99;
    return 0;
}

lib/std/arch/rv64/tests/error.multi.catch.typed.binding.rad +2 -6

        };
        got = v;
    } catch e as ErrB {
        return 2;
    };
    if got != 100 {
        return 3;
    }
    assert got == 100;

    // Extract ErrB payload.
    got = 0;
    try failB(200) catch e as ErrA {
        return 4;

        let case ErrB::B(v) = e else {
            return 5;
        };
        got = v;
    };
    if got != 200 {
        return 6;
    }
    assert got == 200;
    return 0;
}

lib/std/arch/rv64/tests/error.multi.catch.typed.catchall.rad +7 -13

        };
        result = v;
    } catch {
        return 1;
    };
    if result != 10 {
        return 2;
    }
    assert result == 10;

    // ErrB should fall into catch-all.
    let mut caught_all: i32 = 0;
    let mut caughtAll: i32 = 0;
    try failB() catch e as ErrA {
        return 3;
    } catch {
        caught_all = 1;
        caughtAll = 1;
    };
    if caught_all != 1 {
        return 4;
    }
    assert caughtAll == 1;

    // ErrC should also fall into catch-all.
    caught_all = 0;
    caughtAll = 0;
    try failC() catch e as ErrA {
        return 5;
    } catch {
        caught_all = 1;
        caughtAll = 1;
    };
    if caught_all != 1 {
        return 6;
    }
    assert caughtAll == 1;
    return 0;
}

lib/std/arch/rv64/tests/error.multi.catch.typed.rad +3 -9

        result = v;
        0
    } catch e as ErrB {
        return 1;
    };
    if result != 10 {
        return 2;
    }
    assert result == 10;

    // Catch ErrB specifically with typed binding.
    result = 0;
    let val2 = try failB() catch e as ErrA {
        return 3;

            return 11;
        };
        result = v;
        0
    };
    if result != 20 {
        return 4;
    }
    assert result == 20;

    // Success path should skip all catches.
    let val3 = try succeed() catch e as ErrA {
        return 5;
    } catch e as ErrB {
        return 6;
    };
    if val3 != 42 {
        return 7;
    }
    assert val3 == 42;
    return 0;
}

lib/std/arch/rv64/tests/error.multi.propagate.multi.rad +3 -9

    try outer(1) catch e as ErrA {
        result = 10;
    } catch e as ErrB {
        result = 20;
    };
    if result != 10 {
        return 1;
    }
    assert result == 10;

    // Propagate ErrB through outer.
    result = 0;
    try outer(2) catch e as ErrA {
        result = 10;
    } catch e as ErrB {
        result = 20;
    };
    if result != 20 {
        return 2;
    }
    assert result == 20;

    // Success path.
    let val = try outer(0) catch e as ErrA {
        return 3;
    } catch e as ErrB {
        return 4;
    };
    if val != 101 {
        return 5;
    }
    assert val == 101;
    return 0;
}

lib/std/arch/rv64/tests/error.multi.propagate.rad +3 -9

    // Propagate ErrA through middle.
    let mut caught: i32 = 0;
    try middle(1) catch {
        caught = 1;
    };
    if caught != 1 {
        return 1;
    }
    assert caught == 1;

    // Propagate ErrB through middle.
    caught = 0;
    try middle(2) catch {
        caught = 2;
    };
    if caught != 2 {
        return 2;
    }
    assert caught == 2;

    // Success path.
    let val = try middle(0) catch {
        return 3;
    };
    if val != 100 {
        return 4;
    }
    assert val == 100;
    return 0;
}

lib/std/arch/rv64/tests/error.multi.try.optional.rad +3 -9

}

@default fn main() -> i32 {
    // try? on failure should produce nil.
    let r1 = try? failA();
    if r1 != nil {
        return 1;
    }
    assert r1 == nil;

    // try? on success should produce the value.
    let r2 = try? succeed();
    if r2 == nil {
        return 2;
    }
    assert r2 != nil;
    let val = r2 else {
        return 3;
    };
    if val != 77 {
        return 4;
    }
    assert val == 77;
    return 0;
}

lib/std/arch/rv64/tests/error.try.optional.rad +11 -33

}

@default fn main() -> i32 {
    // Test 1: try? on success returns Some(value)
    let result1: ?u32 = try? returnsOk();
    if result1 == nil {
        return 1;
    }
    assert result1 != nil;
    if let x = result1 {
        if x != 42 {
            return 2;
        }
        assert x == 42;
    }

    // Test 2: try? on error returns nil
    let result2: ?u32 = try? returnsErr();
    if result2 != nil {
        return 3;
    }
    assert result2 == nil;

    // Test 3: try? with if-let pattern matching
    if let value = try? returnsOk() {
        if value != 42 {
            return 4;
        }
        assert value == 42;
    } else {
        return 5;
    }

    // Test 4: try? with if-let on error path

        return 6;
    }

    // Test 5: try? in non-throwing function
    let result5: ?u32 = nonThrowingCaller();
    if result5 == nil {
        return 7;
    }
    assert result5 != nil;
    if let x = result5 {
        if x != 42 {
            return 8;
        }
        assert x == 42;
    }

    // Test 6: try? with record return type
    let result8: ?Point = try? returnsOkPoint();
    if result8 == nil {
        return 9;
    }
    assert result8 != nil;
    if let p = result8 {
        if p.x != 10 {
            return 10;
        }
        if p.y != 20 {
            return 11;
        }
        assert p.x == 10;
        assert p.y == 20;
    }

    let result9: ?Point = try? returnsErrPoint();
    if result9 != nil {
        return 12;
    }
    assert result9 == nil;

    // Test 7: try? in while-let loop
    let mut count: u32 = 0;
    let mut iter: u32 = 0;
    while let value = try? maybeValue(iter) {
        count += value;
        iter += 1;
    }
    if count != 6 {
        return 13;
    }
    assert count == 6;

    return 0;
}

lib/std/arch/rv64/tests/error.try.rad +18 -54

}

@default fn main() -> i32 {
    let mut sumFlag: u32 = 0;
    let total: u32 = try! sumThree();
    if total != 39 {
        return 1;
    }
    assert total == 39;
    sumFlag = total;

    let mut scOkFlag: u32 = 0;
    let scVal: u32 = try! shortCircuit(true);
    if scVal != 10 {
        return 2;
    }
    assert scVal == 10;
    scOkFlag = scVal;

    let mut scErrFlag: u32 = 0;
    try shortCircuit(false) catch {};
    if scErrFlag != 0 {
        return 3;
    }
    assert scErrFlag == 0;

    let mut aggFlag: u32 = 0;
    let aggVal: u32 = try! aggregateTwo();
    if aggVal != 30 {
        return 4;
    }
    assert aggVal == 30;

    let mut casOkFlag: u32 = 0;
    let casVal: u32 = try! cascade(false);
    if casVal != 22 {
        return 5;
    }
    assert casVal == 22;

    let mut casErrFlag: u32 = 0;
    try cascade(true) catch {};
    if casErrFlag != 0 {
        return 6;
    }
    assert casErrFlag == 0;

    let mut loopOkFlag: u32 = 0;
    let loopVal: u32 = try! accumulateSteps(false);
    if loopVal != 27 {
        return 7;
    }
    assert loopVal == 27;

    let mut loopErrFlag: u32 = 0;
    try accumulateSteps(true) catch {};
    if loopErrFlag != 0 {
        return 8;
    }
    assert loopErrFlag == 0;

    let mut sink: ResultSink = ResultSink { last: 0, count: 0 };
    let sVal: u32 = try! structSuccess(&mut sink);
    if sink.last != 21 {
        return 9;
    }
    if sink.count != 1 {
        return 10;
    }
    assert sink.last == 21;
    assert sink.count == 1;

    try structFailure(&mut sink) catch {};
    try! structSuccess(&mut sink);
    try structFailure(&mut sink) catch {};
    if sink.count != 2 {
        return 11;
    }
    assert sink.count == 2;

    let mut voidOkFlag: u32 = 0;
    try! returnsOkVoid();
    voidOkFlag = 77;
    if voidOkFlag != 77 {
        return 12;
    }
    assert voidOkFlag == 77;

    let mut voidErrFlag: u32 = 0;
    try returnsErrVoid() catch {};
    if voidErrFlag != 0 {
        return 13;
    }
    assert voidErrFlag == 0;

    let result: ?u32 = try? directThrow();
    if result != nil {
        return 14;
    }
    assert result == nil;

    let mut catchReturnFlag: u32 = 0;
    let catchReturnFail: bool = catchReturn(&mut catchReturnFlag, true);
    if not catchReturnFail {
        return 15;
    }
    if catchReturnFlag != 0 {
        return 16;
    }
    assert catchReturnFail;
    assert catchReturnFlag == 0;

    let catchReturnOk: bool = catchReturn(&mut catchReturnFlag, false);
    if catchReturnOk {
        return 17;
    }
    if catchReturnFlag != 77 {
        return 18;
    }
    assert not catchReturnOk;
    assert catchReturnFlag == 77;

    return 0;
}

lib/std/arch/rv64/tests/fn.callback.nested.rad +1 -3


    // maxReg should be 6 (max register 5 + 1)
    if maxReg == 6 {
        return 0;
    }
    if maxReg > 255 {
        return 255;
    }
    assert maxReg <= 255;
    return maxReg as i32;
}

lib/std/arch/rv64/tests/for.else.continue.rad +2 -6

    fields[3] = Field { name: "bar", value: 40 };

    let v1 = findField(&fields[..], "foo") else {
        return 1;
    };
    if v1 != 20 {
        return 2;
    }
    assert v1 == 20;

    let v2 = findField(&fields[..], "bar") else {
        return 3;
    };
    if v2 != 40 {
        return 4;
    }
    assert v2 == 40;

    if let _ = findField(&fields[..], "baz") {
        return 5;
    }


lib/std/arch/rv64/tests/frame.large.rad +3 -9


    return ary[4091] as i32;
}

@default fn main() -> i32 {
    if bigFrame1() != 491824 {
        return 1;
    }
    if bigFrame2() != 7 {
        return 2;
    }
    if bigFrame3() != 192 {
        return 3;
    }
    assert bigFrame1() == 491824;
    assert bigFrame2() == 7;
    assert bigFrame3() == 192;
    return 0;
}

lib/std/arch/rv64/tests/iflet.shadow.leak.rad +1 -3

    let mut x: i32 = 7;
    let opt: ?i32 = 41;

    if let x = opt {
        // Inner pattern binding shadows outer `x`.
        if x != 41 {
            return 100;
        }
        assert x == 41;
    }

    // Must refer to outer x (7), not if-let binding (41).
    return x;
}

lib/std/arch/rv64/tests/integer.bitwise.basic.rad +12 -12

@default fn main() -> i32 {
    let a: i32 = 12;    // 0b1100
    let b: i32 = 5;     // 0b0101

    let and_result:    i32 = a & b;  // 0b00100
    let or_result:     i32 = a | b;  // 0b01101
    let xor_result:    i32 = a ^ b;  // 0b01001
    let not_result:    i32 = ~a;     // 0b00011
    let lshift_result: i32 = a << 1; // 0b11000
    let rshift_result: i32 = a >> 2; // 0b00011
    let andResult:    i32 = a & b;  // 0b00100
    let orResult:     i32 = a | b;  // 0b01101
    let xorResult:    i32 = a ^ b;  // 0b01001
    let notResult:    i32 = ~a;     // 0b00011
    let lshiftResult: i32 = a << 1; // 0b11000
    let rshiftResult: i32 = a >> 2; // 0b00011

    if and_result    != 4   { return (1) - 42; }
    if or_result     != 13  { return (1) - 42; }
    if xor_result    != 9   { return (1) - 42; }
    if not_result    != -13 { return (1) - 42; }
    if lshift_result != 24  { return (1) - 42; }
    if rshift_result != 3   { return (1) - 42; }
    if andResult    != 4   { return (1) - 42; }
    if orResult     != 13  { return (1) - 42; }
    if xorResult    != 9   { return (1) - 42; }
    if notResult    != -13 { return (1) - 42; }
    if lshiftResult != 24  { return (1) - 42; }
    if rshiftResult != 3   { return (1) - 42; }

    return (42) - 42;
}

lib/std/arch/rv64/tests/integer.overflow.rad +10 -30

    let overflowResult: i16 = minI16 / -1 as i16;
    return overflowResult == -32768;
}

@default fn main() -> i32 {
    if not testI32Overflow() {
        return 1;
    }
    if not testI32Underflow() {
        return 2;
    }
    if not testU32Overflow() {
        return 3;
    }
    if not testU32Underflow() {
        return 4;
    }
    if not testI8Overflow() {
        return 5;
    }
    if not testI8Underflow() {
        return 6;
    }
    if not testU8Overflow() {
        return 7;
    }
    if not testU8Underflow() {
        return 8;
    }
    if not testI8DivOverflow() {
        return 9;
    }
    if not testI16DivOverflow() {
        return 10;
    }
    assert testI32Overflow();
    assert testI32Underflow();
    assert testU32Overflow();
    assert testU32Underflow();
    assert testI8Overflow();
    assert testI8Underflow();
    assert testU8Overflow();
    assert testU8Underflow();
    assert testI8DivOverflow();
    assert testI16DivOverflow();
    return 0;
}

lib/std/arch/rv64/tests/large.blit.store.rad +11 -33

/// Generates `store w32 <imm> %0 2200` in IL, which triggers the
/// SCRATCH1 aliasing bug when adjustOffset clobbers the value.
fn storeLargeOffset() -> i32 {
    let mut b: Big = undefined;
    b.tag = 42;
    if b.tag != 42 {
        return 1;
    }
    assert b.tag == 42;
    b.tag = 99;
    if b.tag != 99 {
        return 2;
    }
    assert b.tag == 99;
    return 0;
}

/// Copy a >2047 byte struct (triggers blit offset overflow).
fn copyBig() -> i32 {

    src.a[2199] = 30;
    src.tag = 77;

    let mut dst: Big = src;

    if dst.a[0] != 10 {
        return 1;
    }
    if dst.a[1000] != 20 {
        return 2;
    }
    if dst.a[2199] != 30 {
        return 3;
    }
    if dst.tag != 77 {
        return 4;
    }
    assert dst.a[0] == 10;
    assert dst.a[1000] == 20;
    assert dst.a[2199] == 30;
    assert dst.tag == 77;
    return 0;
}

/// Mutate a copy to ensure the blit produced an independent copy.
fn copyIndependence() -> i32 {

67	55
68	56		let mut b: Big = a;
69	57		b.a[0] = 99;
70	58		b.tag = 200;
71	59
72		-	if a.a[0] != 1 {
73		-	return 1;
74		-	}
75		-	if a.tag != 100 {
76		-	return 2;
77		-	}
78		-	if b.a[0] != 99 {
79		-	return 3;
80		-	}
81		-	if b.a[2199] != 2 {
82		-	return 4;
83		-	}
84		-	if b.tag != 200 {
85		-	return 5;
86		-	}
	60	+	assert a.a[0] == 1;
	61	+	assert a.tag == 100;
	62	+	assert b.a[0] == 99;
	63	+	assert b.a[2199] == 2;
	64	+	assert b.tag == 200;
87	65		return 0;
88	66		}
89	67
90	68		@default fn main() -> i32 {
91	69		let r1 = storeLargeOffset();

lib/std/arch/rv64/tests/literal.w64.rad +6 -18

    }
    return true;
}

@default fn main() -> i32 {
    if not testU64MaxLiteral() {
        return 1;
    }
    if not testI64MaxLiteral() {
        return 2;
    }
    if not testI64MinLiteral() {
        return 3;
    }
    if not testHexW64Literal() {
        return 4;
    }
    if not testLargeI64Arith() {
        return 5;
    }
    if not testU64Overflow32() {
        return 6;
    }
    assert testU64MaxLiteral();
    assert testI64MaxLiteral();
    assert testI64MinLiteral();
    assert testHexW64Literal();
    assert testLargeI64Arith();
    assert testU64Overflow32();
    return 0;
}

lib/std/arch/rv64/tests/loc.addr.offset.bug.rad +1 -3

@default fn main() -> i32 {
    outer.inner.value = 42;

    let ptr: *Inner = &outer.inner;

    if (*ptr).value != 42 {
        return 1;
    }
    assert (*ptr).value == 42;
    return 0;
}

lib/std/arch/rv64/tests/loc.addr.opt.to.opt.rad +3 -5

}

static container: Container = undefined;

@default fn main() -> i32 {
    let source_opt: ?i32 = 42;
    let sourceOpt: ?i32 = 42;

    container.opt = source_opt;
    container.opt = sourceOpt;

    if let val = container.opt {
        if val != 42 {
            return 2;
        }
        assert val == 42;
        return 0;
    } else {
        return 1;
    }
}

lib/std/arch/rv64/tests/loc.addr.optional.assign.rad +1 -3


@default fn main() -> i32 {
    container.opt = 42;

    if let val = container.opt {
        if val != 42 {
            return 2;
        }
        assert val == 42;
        return 0;
    } else {
        return 1;
    }
}

lib/std/arch/rv64/tests/loc.addr.record.assign.rad +1 -3

@default fn main() -> i32 {
    source.value = 42;

    outer.inner = source;

    if outer.inner.value != 42 {
        return 1;
    }
    assert outer.inner.value == 42;
    return 0;
}

lib/std/arch/rv64/tests/loop.complex.flow.rad +2 -6

    }

    // val sequence: -2, -1, 0, 1, 2, 3
    // Err for val <= 0: errCount = 3 (for -2, -1, 0)
    // Ok for val > 0: sum = 0 + 1 + 2 + 3 = 6
    if sum != 6 {
        return 1;
    }
    if errCount != 3 {
        return 2;
    }
    assert sum == 6;
    assert errCount == 3;

    return 0;
}

lib/std/arch/rv64/tests/loop.sealblock.rad +3 -9

    while i < 5 {
        sum += i;
        i += 1;
    }
    // sum = 0 + 1 + 2 + 3 + 4 = 10
    if sum != 10 {
        return 1;
    }
    assert sum == 10;

    // For loop with mutable variable.
    let mut count: i32 = 0;
    for j in 0..4 {
        count += 1;
    }
    if count != 4 {
        return 2;
    }
    assert count == 4;

    // Nested pattern: mutable var with function call in loop.
    let mut total: i32 = 0;
    for k in 0..3 {
        total += addOne(k);
    }
    // total = 1 + 2 + 3 = 6
    if total != 6 {
        return 3;
    }
    assert total == 6;

    return 0;
}

fn addOne(x: i32) -> i32 {

lib/std/arch/rv64/tests/match.multi.seal.rad +4 -12

    }
}

@default fn main() -> i32 {
    // Multi-pattern first variant
    if classify(Kind::A, 5) != 15 {
        return 1;
    }
    assert classify(Kind::A, 5) == 15;
    // Multi-pattern last variant
    if classify(Kind::C, 5) != 15 {
        return 2;
    }
    assert classify(Kind::C, 5) == 15;
    // Single-pattern variant
    if classify(Kind::D, 5) != 25 {
        return 3;
    }
    assert classify(Kind::D, 5) == 25;
    // Else branch - the critical path
    if classify(Kind::E, 5) != 35 {
        return 4;
    }
    assert classify(Kind::E, 5) == 35;
    return 0;
}

lib/std/arch/rv64/tests/match.multi.survive.rad +4 -12

}

@default fn main() -> i32 {
    // Test multi-pattern match (Alpha)
    let s1 = State { value: 5, kind: Kind::Alpha };
    if classify(s1) != 15 {
        return 1;
    }
    assert classify(s1) == 15;
    // Test multi-pattern match (Gamma)
    let s2 = State { value: 5, kind: Kind::Gamma };
    if classify(s2) != 15 {
        return 2;
    }
    assert classify(s2) == 15;
    // Test single-pattern match (Delta)
    let s3 = State { value: 5, kind: Kind::Delta };
    if classify(s3) != 25 {
        return 3;
    }
    assert classify(s3) == 25;
    // Test else branch (Epsilon) - the critical case
    let s4 = State { value: 5, kind: Kind::Epsilon };
    if classify(s4) != 35 {
        return 4;
    }
    assert classify(s4) == 35;
    return 0;
}

lib/std/arch/rv64/tests/match.mutref.push.rad +5 -15

@default fn main() -> i32 {
    let mut buf: [u32; 8] = undefined;
    buf[0] = 0;
    let mut state = Sealed::No { items: U32List { data: &mut buf[0..8], len: 0 } };

    if not addToUnsealedBlock(&mut state, 42) {
        return 1;
    }
    if not addToUnsealedBlock(&mut state, 99) {
        return 2;
    }
    assert addToUnsealedBlock(&mut state, 42);
    assert addToUnsealedBlock(&mut state, 99);

    // Check that the state is still No with len=2.
    let case Sealed::No { items } = state else {
        return 3;
    };
    if items.len != 2 {
        return 4;
    }
    if items.data[0] != 42 {
        return 5;
    }
    if items.data[1] != 99 {
        return 6;
    }
    assert items.len == 2;
    assert items.data[0] == 42;
    assert items.data[1] == 99;
    return 0;
}

lib/std/arch/rv64/tests/match.mutref.union.rad +2 -6

}

@default fn main() -> i32 {
    let mut d = Data { state: State::A { count: 10 }, value: 42 };
    let r1 = process(&mut d);
    if r1 != 10 {
        return 1;
    }
    assert r1 == 10;
    let r2 = process(&mut d);
    if r2 != 11 {
        return 2;
    }
    assert r2 == 11;
    return 0;
}

lib/std/arch/rv64/tests/match.value.copy.rad +6 -18

        return 1;
    };
    // Overwrite the source - binding should be unaffected.
    b.data = Data::None;

    if pair.a != 10 {
        return 2;
    }
    if pair.b != 20 {
        return 3;
    }
    assert pair.a == 10;
    assert pair.b == 20;
    return 0;
}

/// Test if-let-case with aggregate payload.
fn testIfLetCase() -> i32 {

        data: Data::Some { pair: Pair { a: 30, b: 40 } },
    };

    if let case Data::Some { pair } = b.data {
        b.data = Data::None;
        if pair.a != 30 {
            return 5;
        }
        if pair.b != 40 {
            return 6;
        }
        assert pair.a == 30;
        assert pair.b == 40;
    } else {
        return 4;
    }
    return 0;
}

    };

    match b.data {
        case Data::Some { pair } => {
            b.data = Data::None;
            if pair.a != 50 {
                return 8;
            }
            if pair.b != 60 {
                return 9;
            }
            assert pair.a == 50;
            assert pair.b == 60;
        }
        case Data::None => {
            return 7;
        }
    }

lib/std/arch/rv64/tests/match.void.then.or.rad +7 -21

}

@default fn main() -> i32 {
    // Test Add (in or-branch)
    let e1 = Expr { op: Op::Add, left: 3, right: 4 };
    if eval(e1) != 7 {
        return 1;
    }
    assert eval(e1) == 7;
    // Test Sub (in or-branch)
    let e2 = Expr { op: Op::Sub, left: 10, right: 3 };
    if eval(e2) != 13 {
        return 2;
    }
    assert eval(e2) == 13;
    // Test Mul (else of or-branch)
    let e3 = Expr { op: Op::Mul, left: 3, right: 4 };
    if eval(e3) != 12 {
        return 3;
    }
    assert eval(e3) == 12;
    // Test And (first multi-pattern case)
    let e4 = Expr { op: Op::And, left: 0, right: 0 };
    if eval(e4) != -1 {
        return 4;
    }
    assert eval(e4) == -1;
    // Test Xor (last in multi-pattern case)
    let e5 = Expr { op: Op::Xor, left: 0, right: 0 };
    if eval(e5) != -1 {
        return 5;
    }
    assert eval(e5) == -1;
    // Test Eq (second multi-pattern case)
    let e6 = Expr { op: Op::Eq, left: 0, right: 0 };
    if eval(e6) != -2 {
        return 6;
    }
    assert eval(e6) == -2;
    // Test Div (else of or, uses multiply path)
    let e7 = Expr { op: Op::Div, left: 5, right: 6 };
    if eval(e7) != 30 {
        return 7;
    }
    assert eval(e7) == 30;
    return 0;
}

lib/std/arch/rv64/tests/mutref.loop.bug.rad +4 -12

    return a + b;
}

@default fn main() -> i32 {
    // Zero iterations: the critical regression case.
    if testZeroIter(0) != 42 {
        return 1;
    }
    assert testZeroIter(0) == 42;
    // Non-zero iterations still work.
    if testZeroIter(3) != 45 {
        return 2;
    }
    assert testZeroIter(3) == 45;
    // Accumulation: 0+0+1+2+3+4 = 10
    if testMultiIter() != 10 {
        return 3;
    }
    assert testMultiIter() == 10;
    // Multiple vars: 3 + 97 = 100
    if testMultipleVars() != 100 {
        return 4;
    }
    assert testMultipleVars() == 100;
    return 0;
}

lib/std/arch/rv64/tests/opt.if.let.complex.rad +13 -39

    }
    return false;
}

@default fn main() -> i32 {
    if not testOptionalTypes() {
        return 1;
    }
    if not testComplexCoercion() {
        return 2;
    }
    if not testVariableShadowing() {
        return 3;
    }
    if not testBoundaryValues() {
        return 4;
    }
    if not testZeroGuardCondition() {
        return 5;
    }
    if not testMultipleNilAssignments() {
        return 6;
    }
    if not testNestedSameVariableGuards() {
        return 7;
    }
    if not testComplexGuardExpressions() {
        return 8;
    }
    if not testArithmeticInGuards() {
        return 9;
    }
    if not testEarlyReturnGuardFailure() {
        return 10;
    }
    if not testSequentialNilChecks() {
        return 11;
    }
    if not testMixedIfTypes() {
        return 12;
    }
    if not testOptionalAssignmentChains() {
        return 13;
    }
    assert testOptionalTypes();
    assert testComplexCoercion();
    assert testVariableShadowing();
    assert testBoundaryValues();
    assert testZeroGuardCondition();
    assert testMultipleNilAssignments();
    assert testNestedSameVariableGuards();
    assert testComplexGuardExpressions();
    assert testArithmeticInGuards();
    assert testEarlyReturnGuardFailure();
    assert testSequentialNilChecks();
    assert testMixedIfTypes();
    assert testOptionalAssignmentChains();
    return 0;
}

lib/std/arch/rv64/tests/opt.nil.check.rad +2 -6

    let p = makeAlignedPtr();
    let opt: ?*u8 = p;

    // The pointer is not nil, but its low byte is 0x00.
    // A W8 comparison would wrongly say it's nil.
    if opt == nil {
        return 1;
    }
    assert opt != nil;
    if let v = opt {
        // Good: correctly identified as non-nil.
        return 0;
    }
    return 2;

    let offset: u64 = 256 - (base % 256);
    // Create a slice starting at an address whose low byte is 0.
    let s: *[u8] = &arr[offset as u32 ..];

    let opt: ?*[u8] = s;
    if opt == nil {
        return 1;
    }
    assert opt != nil;
    if let v = opt {
        return 0;
    }
    return 2;
}

lib/std/arch/rv64/tests/opt.record.eq.rad +15 -15

record Outer {
    item: ?Inner,
}

@default fn main() -> bool {
    let outer_a = Outer { item: Inner { start: 3, end: 9 } };
    let outer_b = Outer { item: Inner { start: 3, end: 9 } };
    let outerA = Outer { item: Inner { start: 3, end: 9 } };
    let outerB = Outer { item: Inner { start: 3, end: 9 } };

    if outer_a != outer_b {
    if outerA != outerB {
        return false;
    }

    let outer_c = Outer { item: Inner { start: 4, end: 6 } };
    if outer_a == outer_c {
    let outerC = Outer { item: Inner { start: 4, end: 6 } };
    if outerA == outerC {
        return false;
    }

    let mut opt_a: ?Outer = nil;
    let mut opt_b: ?Outer = nil;
    let mut opt_diff: ?Outer = nil;
    let mut opt_nil: ?Outer = nil;
    let mut optA: ?Outer = nil;
    let mut optB: ?Outer = nil;
    let mut optDiff: ?Outer = nil;
    let mut optNil: ?Outer = nil;

    opt_a = outer_a;
    opt_b = outer_b;
    opt_diff = outer_c;
    optA = outerA;
    optB = outerB;
    optDiff = outerC;

    if opt_a != opt_b {
    if optA != optB {
        return false;
    }
    if opt_a == opt_diff {
    if optA == optDiff {
        return false;
    }
    if opt_a == opt_nil {
    if optA == optNil {
        return false;
    }
    return true;
}

lib/std/arch/rv64/tests/opt.record.rad +2 -2


record Wrapper {
    opt: ?i32,
}

fn take_optional(x: ?i32) -> i32 {
fn takeOptional(x: ?i32) -> i32 {
    if let value = x {
        return value;
    }
    return 0;
}

        total += value;
    } else {
        return 0;
    }

    let call = take_optional(9);
    let call = takeOptional(9);
    return total + call;
}

lib/std/arch/rv64/tests/opt.return.nested.rad +2 -2

}

@default fn main() -> u32 {
    if let outer = nest(true, true) {
        if let pair = outer; pair.x == 10 and pair.y == 89 {
            if let outer_some_nil = nest(true, false) {
                if let inner_nil = outer_some_nil {
            if let outerSomeNil = nest(true, false) {
                if let innerNil = outerSomeNil {
                    return 11;
                }
            } else {
                return 12;
            }

lib/std/arch/rv64/tests/opt.slice.npo.rad +16 -48

//! Optional slices should have the same size as slices (16 bytes),
//! using a null data pointer to represent `nil`.

fn checkSizes() -> u8 {
    // ?*[T] should be the same size as *[T] (16 bytes, not 24).
    if @sizeOf(?*[u8]) != 16 {
        return 1;
    }
    if @alignOf(?*[u8]) != 8 {
        return 2;
    }
    if @sizeOf(?*[u16]) != 16 {
        return 3;
    }
    if @sizeOf(?*mut [u8]) != 16 {
        return 4;
    }
    assert @sizeOf(?*[u8]) == 16;
    assert @alignOf(?*[u8]) == 8;
    assert @sizeOf(?*[u16]) == 16;
    assert @sizeOf(?*mut [u8]) == 16;
    return 0;
}

fn checkNil() -> u8 {
    let x: ?*[u8] = nil;
    if x != nil {
        return 10;
    }
    assert x == nil;
    return 0;
}

fn checkWrap() -> u8 {
    let arr: [u8; 3] = [1, 2, 3];
    let s = &arr[..];
    let opt: ?*[u8] = s;

    if opt == nil {
        return 20;
    }
    assert opt != nil;
    return 0;
}

fn checkIfLet() -> u8 {
    let arr: [u8; 3] = [10, 20, 30];
    let s = &arr[..];
    let opt: ?*[u8] = s;

    if let val = opt {
        if val.len != 3 {
            return 31;
        }
        if val[0] != 10 {
            return 32;
        }
        if val[1] != 20 {
            return 33;
        }
        assert val.len == 3;
        assert val[0] == 10;
        assert val[1] == 20;
    } else {
        return 34;
    }

    let none: ?*[u8] = nil;

    let opt: ?*[u8] = s;

    let val = opt else {
        return 40;
    };
    if val.len != 3 {
        return 41;
    }
    assert val.len == 3;
    return 0;
}

fn returnNil() -> ?*[u8] {
    return nil;

    return &arr[..];
}

fn checkReturn() -> u8 {
    let a = returnNil();
    if a != nil {
        return 50;
    }
    assert a == nil;
    let b = returnSome();
    if b == nil {
        return 51;
    }
    assert b != nil;
    if let val = b {
        if val[0] != 42 {
            return 52;
        }
        assert val[0] == 42;
    } else {
        return 53;
    }
    return 0;
}

131	105		fn checkEq() -> u8 {
132	106		let a: ?*[u8] = nil;
133	107		let b: ?*[u8] = nil;
134	108
135	109		// nil == nil
136		-	if a != b {
137		-	return 70;
138		-	}
	110	+	assert a == b;
139	111
140	112		let arr: [u8; 2] = [1, 2];
141	113		let s = &arr[..];
142	114		let c: ?*[u8] = s;
143	115
144	116		// some != nil
145		-	if c == a {
146		-	return 71;
147		-	}
	117	+	assert c != a;
148	118
149	119		// some == some (same pointer)
150	120		let d: ?*[u8] = s;
151		-	if c != d {
152		-	return 72;
153		-	}
	121	+	assert c == d;
154	122
155	123		return 0;
156	124		}
157	125
158	126		@default fn main() -> u8 {

lib/std/arch/rv64/tests/opt.while.let.complex.rad +1 -3

17	17		sum += x;
18	18		cur = x;
19	19		}
20	20
21	21		// sum should be 6 + 5 + 4 + 3 + 2 = 20
22		-	if sum != 20 {
23		-	return 1;
24		-	}
	22	+	assert sum == 20;
25	23		return 0;
26	24		}

lib/std/arch/rv64/tests/placeholder.comprehensive.rad +1 -3

    let arr: [i32; 3] = [1, 2, 3];
    let mut count: i32 = 0;
    for _ in &arr[..] {
        count += 1;
    }
    if count != 3 {
        return 3;
    }
    assert count == 3;
    return 0;
}

lib/std/arch/rv64/tests/pointer.copy.edge.case.rad +1 -3

    let node: *mut Node = makeNode(&mut parser, NodeKind::Bool(true));
    setLen(node, 4);

    match parser.nodes[0].kind {
        case NodeKind::Bool(value) => {
            if not value {
                return 1;
            }
            assert value;
        }
        case NodeKind::Placeholder => {
            return 2;
        }
    }

lib/std/arch/rv64/tests/pointer.slice.store.rad +4 -12


    HOLDER.ptr = &mut TABLE.entries;

    HOLDER.ptr[0] = Entry { a: 1, b: 2, c: 3, d: 4, e: 5 };

    if TABLE.entries.len != 2 or TABLE.entries.ptr != &STORAGE[0] {
        return 1;
    }
    if STORAGE[0].a != 1 or STORAGE[0].e != 5 {
        return 2;
    }
    assert TABLE.entries.len == 2 and TABLE.entries.ptr == &STORAGE[0];
    assert STORAGE[0].a == 1 and STORAGE[0].e == 5;

    HOLDER.ptr[1] = Entry { a: 10, b: 20, c: 30, d: 40, e: 50 };

    if TABLE.entries.len != 2 or TABLE.entries.ptr != &STORAGE[0] {
        return 3;
    }
    if STORAGE[1].c != 30 or STORAGE[1].d != 40 {
        return 4;
    }
    assert TABLE.entries.len == 2 and TABLE.entries.ptr == &STORAGE[0];
    assert STORAGE[1].c == 30 and STORAGE[1].d == 40;
    return 0;
}

lib/std/arch/rv64/tests/prog.ackermann.rad +25 -75

65	65		}
66	66
67	67		/// Test known small values using the recursive implementation.
68	68		fn testSmallRecursive() -> i32 {
69	69		// A(0, 0) = 1
70		-	if ack(0, 0) != 1 {
71		-	return 1;
72		-	}
	70	+	assert ack(0, 0) == 1;
73	71		// A(0, 5) = 6
74		-	if ack(0, 5) != 6 {
75		-	return 2;
76		-	}
	72	+	assert ack(0, 5) == 6;
77	73		// A(1, 0) = 2
78		-	if ack(1, 0) != 2 {
79		-	return 3;
80		-	}
	74	+	assert ack(1, 0) == 2;
81	75		// A(1, 5) = 7
82		-	if ack(1, 5) != 7 {
83		-	return 4;
84		-	}
	76	+	assert ack(1, 5) == 7;
85	77		// A(2, 0) = 3
86		-	if ack(2, 0) != 3 {
87		-	return 5;
88		-	}
	78	+	assert ack(2, 0) == 3;
89	79		// A(2, 3) = 9
90		-	if ack(2, 3) != 9 {
91		-	return 6;
92		-	}
	80	+	assert ack(2, 3) == 9;
93	81		// A(2, 4) = 11
94		-	if ack(2, 4) != 11 {
95		-	return 7;
96		-	}
	82	+	assert ack(2, 4) == 11;
97	83		// A(3, 0) = 5
98		-	if ack(3, 0) != 5 {
99		-	return 8;
100		-	}
	84	+	assert ack(3, 0) == 5;
101	85		// A(3, 1) = 13
102		-	if ack(3, 1) != 13 {
103		-	return 9;
104		-	}
	86	+	assert ack(3, 1) == 13;
105	87		// A(3, 2) = 29
106		-	if ack(3, 2) != 29 {
107		-	return 10;
108		-	}
	88	+	assert ack(3, 2) == 29;
109	89		// A(3, 3) = 61
110		-	if ack(3, 3) != 61 {
111		-	return 11;
112		-	}
	90	+	assert ack(3, 3) == 61;
113	91		// A(3, 4) = 125
114		-	if ack(3, 4) != 125 {
115		-	return 12;
116		-	}
	92	+	assert ack(3, 4) == 125;
117	93		return 0;
118	94		}
119	95
120	96		/// Test the memoized version against known values.
121	97		fn testMemoized() -> i32 {
122	98		// Verify m=0 row.
123	99		let mut n: u32 = 0;
124	100		while n < 50 {
125	101		let expected: i32 = n as i32 + 1;
126		-	if ackMemo(0, n) != expected {
127		-	return 1;
128		-	}
	102	+	assert ackMemo(0, n) == expected;
129	103		n += 1;
130	104		}
131	105
132	106		// Verify m=1 row.
133	107		n = 0;
134	108		while n < 50 {
135	109		let expected: i32 = n as i32 + 2;
136		-	if ackMemo(1, n) != expected {
137		-	return 2;
138		-	}
	110	+	assert ackMemo(1, n) == expected;
139	111		n += 1;
140	112		}
141	113
142	114		// Verify m=2 row.
143	115		n = 0;
144	116		while n < 50 {
145	117		let expected: i32 = (2 * n + 3) as i32;
146		-	if ackMemo(2, n) != expected {
147		-	return 3;
148		-	}
	118	+	assert ackMemo(2, n) == expected;
149	119		n += 1;
150	120		}
151	121
152	122		// Verify m=3 row for small n.
153	123		// A(3,0)=5, A(3,1)=13, A(3,2)=29, A(3,3)=61, A(3,4)=125
154		-	if ackMemo(3, 0) != 5 {
155		-	return 4;
156		-	}
157		-	if ackMemo(3, 1) != 13 {
158		-	return 5;
159		-	}
160		-	if ackMemo(3, 2) != 29 {
161		-	return 6;
162		-	}
163		-	if ackMemo(3, 3) != 61 {
164		-	return 7;
165		-	}
166		-	if ackMemo(3, 4) != 125 {
167		-	return 8;
168		-	}
	124	+	assert ackMemo(3, 0) == 5;
	125	+	assert ackMemo(3, 1) == 13;
	126	+	assert ackMemo(3, 2) == 29;
	127	+	assert ackMemo(3, 3) == 61;
	128	+	assert ackMemo(3, 4) == 125;
169	129		// A(3, 5) = 2^8 - 3 = 253
170		-	if ackMemo(3, 5) != 253 {
171		-	return 9;
172		-	}
	130	+	assert ackMemo(3, 5) == 253;
173	131		// A(3, 10) = 2^13 - 3 = 8189
174		-	if ackMemo(3, 10) != 8189 {
175		-	return 10;
176		-	}
	132	+	assert ackMemo(3, 10) == 8189;
177	133
178	134		return 0;
179	135		}
180	136
181	137		/// Cross-check recursive and memoized for small values.

    let mut m: u32 = 0;
    while m <= 3 {
        let mut n: u32 = 0;
        while n < 20 {
            let val: i32 = ackMemo(m, n);
            if val <= n as i32 {
                return 1;
            }
            assert val > n as i32;
            // A(m, n) < A(m, n+1) (strictly increasing in n).
            let valNext: i32 = ackMemo(m, n + 1);
            if valNext <= val {
                return 2;
            }
            assert valNext > val;
            n += 1;
        }
        m += 1;
    }


    while m2 < 3 {
        let mut n2: u32 = 0;
        while n2 < 10 {
            let lower: i32 = ackMemo(m2, n2);
            let upper: i32 = ackMemo(m2 + 1, n2);
            if upper <= lower {
                return 3;
            }
            assert upper > lower;
            n2 += 1;
        }
        m2 += 1;
    }


lib/std/arch/rv64/tests/prog.bignum.rad +34 -102


    bnFromU32(&mut a[..], 0xFFFFFFFF);
    bnFromU32(&mut b[..], 1);
    let carry: u32 = bnAdd(&mut c[..], &a[..], &b[..]);

    if carry != 0 {
        return 1;
    }
    if c[0] != 0 {
        return 2;
    }
    if c[1] != 1 {
        return 3;
    }
    assert carry == 0;
    assert c[0] == 0;
    assert c[1] == 1;

    bnFromU32(&mut b[..], 0xFFFFFFFF);
    let carry2: u32 = bnAdd(&mut d[..], &c[..], &b[..]);
    if carry2 != 0 {
        return 4;
    }
    if d[0] != 0xFFFFFFFF {
        return 5;
    }
    if d[1] != 1 {
        return 6;
    }
    assert carry2 == 0;
    assert d[0] == 0xFFFFFFFF;
    assert d[1] == 1;

    return 0;
}

/// Test subtraction.

    bnZero(&mut a[..]);
    a[1] = 1;
    bnFromU32(&mut b[..], 1);
    let borrow: u32 = bnSub(&mut c[..], &a[..], &b[..]);

    if borrow != 0 {
        return 1;
    }
    if c[0] != 0xFFFFFFFF {
        return 2;
    }
    if c[1] != 0 {
        return 3;
    }
    assert borrow == 0;
    assert c[0] == 0xFFFFFFFF;
    assert c[1] == 0;

    return 0;
}

/// Test multiplication.


    bnFromU32(&mut a[..], 12345);
    bnFromU32(&mut b[..], 67890);
    bnMul(&mut wide[..], &a[..], &b[..]);

    if wide[0] != 838102050 {
        return 1;
    }
    if wide[1] != 0 {
        return 2;
    }
    assert wide[0] == 838102050;
    assert wide[1] == 0;

    bnFromU32(&mut a[..], 0xFFFFFFFF);
    bnFromU32(&mut b[..], 0xFFFFFFFF);
    bnMul(&mut wide[..], &a[..], &b[..]);

    if wide[0] != 0x00000001 {
        return 3;
    }
    if wide[1] != 0xFFFFFFFE {
        return 4;
    }
    assert wide[0] == 0x00000001;
    assert wide[1] == 0xFFFFFFFE;

    return 0;
}

/// Test the identity a + b - b = a.

285	259		b[3] = 0x00AABB00;
286	260
287	261		bnAdd(&mut c[..], &a[..], &b[..]);
288	262		bnSub(&mut d[..], &c[..], &b[..]);
289	263
290		-	if bnCmp(&d[..], &a[..]) != 0 {
291		-	return 1;
292		-	}
	264	+	assert bnCmp(&d[..], &a[..]) == 0;
293	265
294	266		bnSub(&mut d[..], &c[..], &a[..]);
295		-	if bnCmp(&d[..], &b[..]) != 0 {
296		-	return 2;
297		-	}
	267	+	assert bnCmp(&d[..], &b[..]) == 0;
298	268
299	269		return 0;
300	270		}
301	271
302	272		/// Test shift operations.

305	275		let mut b: [u32; 4] = [0; 4];
306	276		let mut c: [u32; 4] = [0; 4];
307	277
308	278		bnFromU32(&mut a[..], 1);
309	279		bnShl1(&mut b[..], &a[..]);
310		-	if b[0] != 2 {
311		-	return 1;
312		-	}
	280	+	assert b[0] == 2;
313	281
314	282		bnFromU32(&mut a[..], 0x80000000);
315	283		bnShl1(&mut b[..], &a[..]);
316		-	if b[0] != 0 {
317		-	return 2;
318		-	}
319		-	if b[1] != 1 {
320		-	return 3;
321		-	}
	284	+	assert b[0] == 0;
	285	+	assert b[1] == 1;
322	286
323	287		bnShr1(&mut c[..], &b[..]);
324		-	if c[0] != 0x80000000 {
325		-	return 4;
326		-	}
327		-	if c[1] != 0 {
328		-	return 5;
329		-	}
	288	+	assert c[0] == 0x80000000;
	289	+	assert c[1] == 0;
330	290
331	291		return 0;
332	292		}
333	293
334	294		/// Test large multiply.

    a[2] = 0;
    a[3] = 0;

    bnFromU32(&mut b[..], 1);
    bnMul(&mut wide[..], &a[..], &b[..]);
    if wide[0] != 0xFFFFFFFF {
        return 1;
    }
    if wide[1] != 0xFFFFFFFF {
        return 2;
    }
    if wide[2] != 0 {
        return 3;
    }
    assert wide[0] == 0xFFFFFFFF;
    assert wide[1] == 0xFFFFFFFF;
    assert wide[2] == 0;

    bnZero(&mut a[..]);
    a[1] = 1;
    bnZero(&mut b[..]);
    b[1] = 1;
    bnMul(&mut wide[..], &a[..], &b[..]);
    if wide[0] != 0 {
        return 4;
    }
    if wide[1] != 0 {
        return 5;
    }
    if wide[2] != 1 {
        return 6;
    }
    if wide[3] != 0 {
        return 7;
    }
    assert wide[0] == 0;
    assert wide[1] == 0;
    assert wide[2] == 1;
    assert wide[3] == 0;

    return 0;
}

/// Test Fibonacci sequence with big numbers.

        bnCopy(&mut fibA[..], &fibB[..]);
        bnCopy(&mut fibB[..], &fibC[..]);
        i += 1;
    }

    if fibB[0] != 0x1E8D0A40 {
        return 1;
    }
    if fibB[1] != 0x01 {
        return 2;
    }
    assert fibB[0] == 0x1E8D0A40;
    assert fibB[1] == 0x01;

    let mut fa: [u32; 4] = [0; 4];
    let mut fb: [u32; 4] = [0; 4];
    let mut fc: [u32; 4] = [0; 4];
    fa[0] = 0;

410	352		bnCopy(&mut fa[..], &fb[..]);
411	353		bnCopy(&mut fb[..], &fc[..]);
412	354		i += 1;
413	355		}
414	356		bnAdd(&mut fc[..], &fa[..], &fb[..]);
415		-	if bnCmp(&fc[..], &fibB[..]) != 0 {
416		-	return 3;
417		-	}
	357	+	assert bnCmp(&fc[..], &fibB[..]) == 0;
418	358
419	359		return 0;
420	360		}
421	361
422	362		/// Test compare function.

425	365		let mut b: [u32; 4] = [0; 4];
426	366
427	367		bnFromU32(&mut a[..], 100);
428	368		bnFromU32(&mut b[..], 200);
429	369
430		-	if bnCmp(&a[..], &b[..]) != -1 {
431		-	return 1;
432		-	}
433		-	if bnCmp(&b[..], &a[..]) != 1 {
434		-	return 2;
435		-	}
436		-	if bnCmp(&a[..], &a[..]) != 0 {
437		-	return 3;
438		-	}
	370	+	assert bnCmp(&a[..], &b[..]) == -1;
	371	+	assert bnCmp(&b[..], &a[..]) == 1;
	372	+	assert bnCmp(&a[..], &a[..]) == 0;
439	373
440	374		bnZero(&mut a[..]);
441	375		bnZero(&mut b[..]);
442	376		a[3] = 1;
443	377		b[0] = 0xFFFFFFFF;
444	378		b[1] = 0xFFFFFFFF;
445	379		b[2] = 0xFFFFFFFF;
446		-	if bnCmp(&a[..], &b[..]) != 1 {
447		-	return 4;
448		-	}
	380	+	assert bnCmp(&a[..], &b[..]) == 1;
449	381
450	382		return 0;
451	383		}
452	384
453	385		@default fn main() -> i32 {

lib/std/arch/rv64/tests/prog.binsearch.rad +10 -30

fn testPresent(data: *[i32]) -> i32 {
    // First element.
    let idx0 = binarySearch(data, 3) else {
        return 1;
    };
    if idx0 != 0 {
        return 1;
    }
    assert idx0 == 0;

    // Last element.
    let idx19 = binarySearch(data, 120) else {
        return 2;
    };
    if idx19 != 19 {
        return 2;
    }
    assert idx19 == 19;

    // Middle element.
    let idx9 = binarySearch(data, 58) else {
        return 3;
    };
    if idx9 != 9 {
        return 3;
    }
    assert idx9 == 9;

    // Another element.
    if let idx = binarySearch(data, 22) {
        if idx != 4 {
            return 4;
        }
        assert idx == 4;
    } else {
        return 4;
    }

    // Element near end.
    let idx16 = binarySearch(data, 100) else {
        return 5;
    };
    if idx16 != 16 {
        return 5;
    }
    assert idx16 == 16;
    return 0;
}

/// Test searching for elements that do not exist.
fn testAbsent(data: *[i32]) -> i32 {
    // Below range.
    if binarySearch(data, 1) != nil {
        return 1;
    }
    assert binarySearch(data, 1) == nil;
    // Above range.
    if binarySearch(data, 200) != nil {
        return 2;
    }
    assert binarySearch(data, 200) == nil;
    // Between existing elements.
    if binarySearch(data, 40) != nil {
        return 3;
    }
    assert binarySearch(data, 40) == nil;
    // Just above an existing element.
    if binarySearch(data, 8) != nil {
        return 4;
    }
    assert binarySearch(data, 8) == nil;
    // Just below an existing element.
    if binarySearch(data, 99) != nil {
        return 5;
    }
    assert binarySearch(data, 99) == nil;
    return 0;
}

/// Test searching for every element in the array.
fn testAllPresent(data: *[i32]) -> i32 {

lib/std/arch/rv64/tests/prog.bubblesort.rad +8 -24

}

/// Verify specific positions in the sorted output.
fn verifyPositions(data: *[i32]) -> i32 {
    // Sorted: 3 5 7 12 17 19 28 31 42 50 55 66 71 80 88 93
    if data[0] != 3 {
        return 1;
    }
    if data[1] != 5 {
        return 2;
    }
    if data[2] != 7 {
        return 3;
    }
    if data[7] != 31 {
        return 4;
    }
    if data[14] != 88 {
        return 5;
    }
    if data[15] != 93 {
        return 6;
    }
    assert data[0] == 3;
    assert data[1] == 5;
    assert data[2] == 7;
    assert data[7] == 31;
    assert data[14] == 88;
    assert data[15] == 93;
    return 0;
}

@default fn main() -> i32 {
    let mut data: [i32; 16] = [

    let sumBefore = sum(&data[..]);

    bubbleSort(&mut data[..]);

    // Check the array is sorted.
    if not isSorted(&data[..]) {
        return 1;
    }
    assert isSorted(&data[..]);

    // Check sum is preserved (no data corruption).
    let sumAfter = sum(&data[..]);
    if sumBefore != sumAfter {
        return 2;
    }
    assert sumBefore == sumAfter;

    // Check specific element positions.
    let r = verifyPositions(&data[..]);
    if r != 0 {
        return 10 + r;

lib/std/arch/rv64/tests/prog.cordic.rad +11 -33

    // cos(0) should be close to 65536 (1.0 in Q16.16).
    let cosErr: i32 = abs(r.cos - SCALE);
    let sinErr: i32 = abs(r.sin);

    // Allow error of ~1% = 655.
    if cosErr > 655 {
        return 1;
    }
    if sinErr > 655 {
        return 2;
    }
    assert cosErr <= 655;
    assert sinErr <= 655;
    return 0;
}

/// Test cos(pi/2) = 0, sin(pi/2) = 1.
fn testHalfPi(atanTable: *[i32]) -> i32 {
    let r: CosSin = cosSin(HALF_PI, atanTable);
    let cosErr: i32 = abs(r.cos);
    let sinErr: i32 = abs(r.sin - SCALE);

    if cosErr > 655 {
        return 1;
    }
    if sinErr > 655 {
        return 2;
    }
    assert cosErr <= 655;
    assert sinErr <= 655;
    return 0;
}

/// Test cos(pi) = -1, sin(pi) = 0.
fn testPi(atanTable: *[i32]) -> i32 {
    let r: CosSin = cosSin(PI, atanTable);
    let cosErr: i32 = abs(r.cos + SCALE);
    let sinErr: i32 = abs(r.sin);

    if cosErr > 655 {
        return 1;
    }
    if sinErr > 655 {
        return 2;
    }
    assert cosErr <= 655;
    assert sinErr <= 655;
    return 0;
}

/// Test Pythagorean identity: sin^2 + cos^2 = 1 for several angles.
fn testPythagorean(atanTable: *[i32]) -> i32 {

        let cos2: i32 = fpmul(r.cos, r.cos);
        let sum: i32 = sin2 + cos2;
        let err: i32 = abs(sum - SCALE);

        // Allow ~2% error due to fixed-point precision.
        if err > 1311 {
            return 1;
        }
        assert err <= 1311;
        i += step;
    }
    return 0;
}



        let rPos: CosSin = cosSin(a, atanTable);
        let rNeg: CosSin = cosSin(0 - a, atanTable);

        // cos(-x) should equal cos(x).
        if abs(rPos.cos - rNeg.cos) > 655 {
            return 1;
        }
        assert abs(rPos.cos - rNeg.cos) <= 655;
        // sin(-x) should equal -sin(x).
        if abs(rPos.sin + rNeg.sin) > 655 {
            return 2;
        }
        assert abs(rPos.sin + rNeg.sin) <= 655;
        i += 1;
    }
    return 0;
}


    let cosErr: i32 = abs(r.cos - 32768);
    // sin(pi/3) = 0.866 = 56756 in Q16.16.
    let sinErr: i32 = abs(r.sin - 56756);

    // Allow ~2% error.
    if cosErr > 1311 {
        return 1;
    }
    if sinErr > 1311 {
        return 2;
    }
    assert cosErr <= 1311;
    assert sinErr <= 1311;
    return 0;
}

@default fn main() -> i32 {
    /// CORDIC arctangent table in Q16.16 fixed-point.

lib/std/arch/rv64/tests/prog.crc32.rad +9 -27

}

/// Test the lookup table has been built correctly.
fn testTable(table: *[u32]) -> i32 {
    // TABLE[0] should be 0 (zero input, all shifts produce zero).
    if table[0] != 0 {
        return 1;
    }
    assert table[0] == 0;
    // Known value: TABLE[1] = 0x77073096
    if table[1] != 0x77073096 {
        return 2;
    }
    assert table[1] == 0x77073096;
    // TABLE[255] is a known value: 0x2D02EF8D
    if table[255] != 0x2D02EF8D {
        return 3;
    }
    assert table[255] == 0x2D02EF8D;
    return 0;
}

/// Test CRC-32 of known strings.
fn testKnownCRC(table: *[u32]) -> i32 {
    // CRC-32 of empty data should be 0x00000000.
    if crc32(table, &[]) != 0x00000000 {
        return 1;
    }
    assert crc32(table, &[]) == 0x00000000;

    // CRC-32 of "123456789" = 0xCBF43926 (the standard check value).
    let check: [u8; 9] = [0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39];
    if crc32(table, &check[..]) != 0xCBF43926 {
        return 2;
    }
    assert crc32(table, &check[..]) == 0xCBF43926;

    // CRC-32 of a single byte 'A' (0x41) = 0xD3D99E8B.
    let single: [u8; 1] = [0x41];
    if crc32(table, &single[..]) != 0xD3D99E8B {
        return 3;
    }
    assert crc32(table, &single[..]) == 0xD3D99E8B;
    return 0;
}

/// Test CRC-32 of incrementally built data.
fn testIncremental(table: *[u32]) -> i32 {

        i += 1;
    }
    let crcFull = crc32(table, &buf[..]);

    // CRC should be non-zero and deterministic.
    if crcFull == 0 {
        return 1;
    }
    assert crcFull != 0;

    // Recompute and verify it's the same.
    if crc32(table, &buf[..]) != crcFull {
        return 2;
    }
    assert crc32(table, &buf[..]) == crcFull;

    // Known value for bytes 0..31: 0x91267E8A
    if crcFull != 0x91267E8A {
        return 3;
    }
    assert crcFull == 0x91267E8A;
    return 0;
}

@default fn main() -> i32 {
    let mut table: [u32; 256] = [0; 256];

lib/std/arch/rv64/tests/prog.dijkstra.rad +15 -45

        }
    }

    let mut path: [u32; 16] = [0; 16];
    let len: u32 = reconstructPath(g, 4, &mut path[..]);
    if len != 5 {
        return 6;
    }
    if path[0] != 0 {
        return 7;
    }
    if path[4] != 4 {
        return 8;
    }
    assert len == 5;
    assert path[0] == 0;
    assert path[4] == 4;

    return 0;
}

fn testShortcut(g: *mut Graph) -> i32 {

    addEdge(g, 0, 3, 5);
    addEdge(g, 3, 2, 3);

    dijkstra(g, 0);

    if g.dist[2] != 8 {
        return 1;
    }
    assert g.dist[2] == 8;

    let prev2 = getPrev(g, 2) else {
        return 2;
    };
    if prev2 != 3 {
        return 2;
    }
    assert prev2 == 3;

    return 0;
}

fn testBidirectional(g: *mut Graph) -> i32 {

    addEdge(g, 3, 4, 2);
    addEdge(g, 4, 5, 1);

    dijkstra(g, 0);

    if g.dist[0] != 0 {
        return 1;
    }
    if g.dist[1] != 5 {
        return 2;
    }
    if g.dist[2] != 8 {
        return 3;
    }
    assert g.dist[0] == 0;
    assert g.dist[1] == 5;
    assert g.dist[2] == 8;
    // Unreachable nodes stay at INF.
    if g.dist[3] != INF {
        return 4;
    }
    if g.dist[4] != INF {
        return 5;
    }
    if g.dist[5] != INF {
        return 6;
    }
    assert g.dist[3] == INF;
    assert g.dist[4] == INF;
    assert g.dist[5] == INF;

    // Predecessors of unreachable nodes should be nil.
    if getPrev(g, 3) != nil {
        return 7;
    }
    assert getPrev(g, 3) == nil;

    return 0;
}

fn testDiamond(g: *mut Graph) -> i32 {

    addEdge(g, 2, 3, 5);
    addEdge(g, 3, 4, 2);

    dijkstra(g, 0);

    if g.dist[3] != 10 {
        return 1;
    }
    if g.dist[4] != 12 {
        return 2;
    }
    assert g.dist[3] == 10;
    assert g.dist[4] == 12;
    // Predecessor should be 1 or 2.
    let prev3 = getPrev(g, 3) else {
        return 3;
    };
    if prev3 != 1 and prev3 != 2 {
        return 3;
    }
    assert prev3 == 1 or prev3 == 2;

    return 0;
}

@default fn main() -> i32 {

lib/std/arch/rv64/tests/prog.eval.rad +10 -30


/// Test 1: Simple addition: 3 + 4 = 7
fn testSimpleAdd(pool: *mut Pool) -> i32 {
    reset(pool);
    let root = add(pool, num(pool, 3), num(pool, 4));
    if try! eval(&pool.nodes[..], root) != 7 {
        return 1;
    }
    assert try! eval(&pool.nodes[..], root) == 7;
    return 0;
}

/// Test 2: Nested expression: (2 + 3) * (4 - 1) = 5 * 3 = 15
fn testNested(pool: *mut Pool) -> i32 {
    reset(pool);
    let left = add(pool, num(pool, 2), num(pool, 3));
    let right = sub(pool, num(pool, 4), num(pool, 1));
    let root = mul(pool, left, right);
    if try! eval(&pool.nodes[..], root) != 15 {
        return 1;
    }
    if countNodes(&pool.nodes[..], root) != 7 {
        return 2;
    }
    assert try! eval(&pool.nodes[..], root) == 15;
    assert countNodes(&pool.nodes[..], root) == 7;
    return 0;
}

/// Test 3: Complex expression: ((10 + 5) * 2 - 6) / 4 = (30 - 6) / 4 = 24 / 4 = 6
fn testComplex(pool: *mut Pool) -> i32 {
    reset(pool);
    let a = add(pool, num(pool, 10), num(pool, 5));
    let b = mul(pool, a, num(pool, 2));
    let c = sub(pool, b, num(pool, 6));
    let root = div(pool, c, num(pool, 4));
    if try! eval(&pool.nodes[..], root) != 6 {
        return 1;
    }
    assert try! eval(&pool.nodes[..], root) == 6;
    return 0;
}

/// Test 4: Negation: -(3 + 4) = -7
fn testNeg(pool: *mut Pool) -> i32 {
    reset(pool);
    let root = neg(pool, add(pool, num(pool, 3), num(pool, 4)));
    if try! eval(&pool.nodes[..], root) != -7 {
        return 1;
    }
    assert try! eval(&pool.nodes[..], root) == -7;
    return 0;
}

/// Test 5: Deep tree: 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 = 36
fn testDeep(pool: *mut Pool) -> i32 {

    let mut root = num(pool, 1);
    let values: [i32; 7] = [2, 3, 4, 5, 6, 7, 8];
    for v in values {
        root = add(pool, root, num(pool, v));
    }
    if try! eval(&pool.nodes[..], root) != 36 {
        return 1;
    }
    if countNodes(&pool.nodes[..], root) != 15 {
        return 2;
    }
    assert try! eval(&pool.nodes[..], root) == 36;
    assert countNodes(&pool.nodes[..], root) == 15;
    return 0;
}

/// Test 6: Mixed operations: (100 - 3 * (2 + 8)) / 7 = (100 - 30) / 7 = 70 / 7 = 10
fn testMixed(pool: *mut Pool) -> i32 {
    reset(pool);
    let inner = add(pool, num(pool, 2), num(pool, 8));
    let product = mul(pool, num(pool, 3), inner);
    let diff = sub(pool, num(pool, 100), product);
    let root = div(pool, diff, num(pool, 7));
    if try! eval(&pool.nodes[..], root) != 10 {
        return 1;
    }
    assert try! eval(&pool.nodes[..], root) == 10;
    return 0;
}

/// Test 7: Single number.
fn testSingleNum(pool: *mut Pool) -> i32 {
    reset(pool);
    let root = num(pool, 42);
    if try! eval(&pool.nodes[..], root) != 42 {
        return 1;
    }
    if countNodes(&pool.nodes[..], root) != 1 {
        return 2;
    }
    assert try! eval(&pool.nodes[..], root) == 42;
    assert countNodes(&pool.nodes[..], root) == 1;
    return 0;
}

@default fn main() -> i32 {
    let mut pool: Pool = Pool { nodes: [Expr::Num(0); 64], count: 0 };

lib/std/arch/rv64/tests/prog.hanoi.rad +16 -48

}

/// Verify total move count.
fn testMoveCount(ml: *MoveLog) -> i32 {
    // For N disks, there are 2^N - 1 moves.
    if ml.count != MAX_MOVES {
        return 1;
    }
    assert ml.count == MAX_MOVES;
    return 0;
}

/// Verify specific moves.
fn testSpecificMoves(ml: *MoveLog) -> i32 {
    // First move: smallest disk (1) from peg 0 to peg 2.
    if ml.moves[0].disk != 1 {
        return 1;
    }
    if ml.moves[0].from != 0 {
        return 2;
    }
    if ml.moves[0].to != 2 {
        return 3;
    }
    assert ml.moves[0].disk == 1;
    assert ml.moves[0].from == 0;
    assert ml.moves[0].to == 2;

    // Middle move (index 31): disk 6 from peg 0 to peg 1.
    if ml.moves[31].disk != 6 {
        return 4;
    }
    if ml.moves[31].from != 0 {
        return 5;
    }
    if ml.moves[31].to != 1 {
        return 6;
    }
    assert ml.moves[31].disk == 6;
    assert ml.moves[31].from == 0;
    assert ml.moves[31].to == 1;

    // Last move: smallest disk (1) from peg 2 to peg 1.
    if ml.moves[62].disk != 1 {
        return 7;
    }
    if ml.moves[62].from != 2 {
        return 8;
    }
    if ml.moves[62].to != 1 {
        return 9;
    }
    assert ml.moves[62].disk == 1;
    assert ml.moves[62].from == 2;
    assert ml.moves[62].to == 1;
    return 0;
}

/// Peg state: array of 3 pegs, each holding up to NUM_DISKS disks.
/// top[p] = number of disks currently on peg p.

    };

    // Initialize: all disks on peg 0, largest at bottom.
    let mut d: u32 = NUM_DISKS;
    while d >= 1 {
        if not pegPush(&mut pegs, 0, d) {
            return 1;
        }
        assert pegPush(&mut pegs, 0, d);
        if d == 0 {
            break;
        }
        d -= 1;
    }

    // Replay all moves.
    let mut i: u32 = 0;
    while i < ml.count {
        let m = ml.moves[i];
        let disk = pegPop(&mut pegs, m.from);
        if disk != m.disk {
            return 2;
        }
        if not pegPush(&mut pegs, m.to, disk) {
            return 3;
        }
        assert disk == m.disk;
        assert pegPush(&mut pegs, m.to, disk);
        i += 1;
    }

    // All disks should be on peg 1.
    if pegs.top[0] != 0 {
        return 4;
    }
    if pegs.top[1] != NUM_DISKS {
        return 5;
    }
    if pegs.top[2] != 0 {
        return 6;
    }
    assert pegs.top[0] == 0;
    assert pegs.top[1] == NUM_DISKS;
    assert pegs.top[2] == 0;
    return 0;
}

@default fn main() -> i32 {
    let mut ml = MoveLog {

lib/std/arch/rv64/tests/prog.huffman.rad +12 -36


fn testBasic(s: *mut HuffState) -> i32 {
    let freqs: [u32; 5] = [5, 9, 12, 13, 16];
    let root: u32 = buildTree(s, &freqs[..]);

    if s.nodes[root].freq != 55 {
        return 1;
    }
    assert s.nodes[root].freq == 55;

    resetCodes(s);
    generateCodes(s, root, 0, 0);

    // All symbols should have non-zero code lengths.
    let mut i: u32 = 0;
    while i < 5 {
        if s.codeLen[i] == 0 {
            return 2;
        }
        assert s.codeLen[i] != 0;
        i += 1;
    }

    // No two symbols at the same depth should have the same code.
    let mut a: u32 = 0;
    while a < 5 {
        let mut b: u32 = a + 1;
        while b < 5 {
            if s.codeLen[a] == s.codeLen[b] {
                if s.codeBits[a] == s.codeBits[b] {
                    return 3;
                }
                assert s.codeBits[a] != s.codeBits[b];
            }
            b += 1;
        }
        a += 1;
    }

    encode(s, &msg[..]);

    let mut decoded: [u32; 16] = [0; 16];
    let count: u32 = decode(s, root, 16, &mut decoded[..]);

    if count != 16 {
        return 1;
    }
    assert count == 16;

    // Verify round-trip.
    for expected, i in msg {
        if decoded[i] != expected {
            return i as i32 + 2;

            shortestLen = s.codeLen[i];
            shortestSym = i;
        }
        i += 1;
    }
    if shortestSym != 0 {
        return 1;
    }
    assert shortestSym == 0;

    let msg: [u32; 12] = [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2];
    encode(s, &msg[..]);

    let mut decoded: [u32; 12] = [0; 12];
    let count: u32 = decode(s, root, 12, &mut decoded[..]);
    if count != 12 {
        return 2;
    }
    assert count == 12;

    for expected, i in msg {
        if decoded[i] != expected {
            return 3;
        }
        assert decoded[i] == expected;
    }

    return 0;
}

fn testUniform(s: *mut HuffState) -> i32 {
    let freqs: [u32; 8] = [10, 10, 10, 10, 10, 10, 10, 10];
    let root: u32 = buildTree(s, &freqs[..]);

    if s.nodes[root].freq != 80 {
        return 1;
    }
    assert s.nodes[root].freq == 80;

    resetCodes(s);
    generateCodes(s, root, 0, 0);

    // All 8 symbols should have code length 3 (8 = 2^3).
    let mut i: u32 = 0;
    while i < 8 {
        if s.codeLen[i] != 3 {
            return 2;
        }
        assert s.codeLen[i] == 3;
        i += 1;
    }

    let msg: [u32; 8] = [0, 1, 2, 3, 4, 5, 6, 7];
    encode(s, &msg[..]);

    if s.bitCount != 24 {
        return 3;
    }
    assert s.bitCount == 24;

    let mut decoded: [u32; 8] = [0; 8];
    let count: u32 = decode(s, root, 8, &mut decoded[..]);
    if count != 8 {
        return 4;
    }
    assert count == 8;
    for expected, i in msg {
        if decoded[i] != expected {
            return 5;
        }
        assert decoded[i] == expected;
    }

    return 0;
}


lib/std/arch/rv64/tests/prog.hybridsort.rad +4 -12

    // Sort with insertion sort.
    let mut a: [i32; 24] = [0; 24];
    copy(&mut a[..], &orig[..]);
    insertionSort(&mut a[..]);

    if not isSorted(&a[..]) {
        return 1;
    }
    if sum(&a[..]) != origSum {
        return 2;
    }
    assert isSorted(&a[..]);
    assert sum(&a[..]) == origSum;

    // Sort with selection sort.
    let mut b: [i32; 24] = [0; 24];
    copy(&mut b[..], &orig[..]);
    selectionSort(&mut b[..]);

    if not isSorted(&b[..]) {
        return 3;
    }
    if sum(&b[..]) != origSum {
        return 4;
    }
    assert isSorted(&b[..]);
    assert sum(&b[..]) == origSum;

    // Both algorithms must produce the same result.
    let r = arraysEqual(&a[..], &b[..]);
    if r != 0 {
        return 10 + r;

lib/std/arch/rv64/tests/prog.linkedlist.rad +25 -75

fn testPushLength(list: *mut List) -> i32 {
    push(list, 10);
    push(list, 20);
    push(list, 30);

    if length(list) != 3 {
        return 1;
    }
    assert length(list) == 3;
    // Head should be most recently pushed.
    let v0 = valueAt(list, 0) else {
        return 2;
    };
    if v0 != 30 {
        return 2;
    }
    assert v0 == 30;
    let v1 = valueAt(list, 1) else {
        return 3;
    };
    if v1 != 20 {
        return 3;
    }
    assert v1 == 20;
    let v2 = valueAt(list, 2) else {
        return 4;
    };
    if v2 != 10 {
        return 4;
    }
    assert v2 == 10;
    return 0;
}

/// Test pop.
fn testPop(list: *mut List) -> i32 {
    let v = pop(list) else {
        return 1;
    };
    if v != 30 {
        return 1;
    }
    if length(list) != 2 {
        return 2;
    }
    assert v == 30;
    assert length(list) == 2;
    let v0 = valueAt(list, 0) else {
        return 3;
    };
    if v0 != 20 {
        return 3;
    }
    assert v0 == 20;
    return 0;
}

/// Test find.
fn testFind(list: *mut List) -> i32 {
    // 20 should be found.
    if find(list, 20) == nil {
        return 1;
    }
    assert find(list, 20) != nil;
    // 10 should be found.
    if find(list, 10) == nil {
        return 2;
    }
    assert find(list, 10) != nil;
    // 30 was popped, should not be found.
    if find(list, 30) != nil {
        return 3;
    }
    assert find(list, 30) == nil;
    // 99 never inserted.
    if find(list, 99) != nil {
        return 4;
    }
    assert find(list, 99) == nil;
    return 0;
}

/// Test reverse.
fn testReverse(list: *mut List) -> i32 {

    let sumBefore = sum(list);

    reverse(list);
    // List should be: 10 -> 20 -> 40 -> 50

    if length(list) != 4 {
        return 1;
    }
    assert length(list) == 4;

    let v0 = valueAt(list, 0) else {
        return 2;
    };
    if v0 != 10 {
        return 2;
    }
    assert v0 == 10;
    let v1 = valueAt(list, 1) else {
        return 3;
    };
    if v1 != 20 {
        return 3;
    }
    assert v1 == 20;
    let v2 = valueAt(list, 2) else {
        return 4;
    };
    if v2 != 40 {
        return 4;
    }
    assert v2 == 40;
    let v3 = valueAt(list, 3) else {
        return 5;
    };
    if v3 != 50 {
        return 5;
    }
    assert v3 == 50;

    if sum(list) != sumBefore {
        return 6;
    }
    assert sum(list) == sumBefore;
    return 0;
}

/// Test building a larger list.
fn testLargerList(list: *mut List) -> i32 {

    while i < 32 {
        push(list, i as i32 * 3);
        i += 1;
    }

    if length(list) != 32 {
        return 1;
    }
    assert length(list) == 32;

    // Sum should be 3 * (0 + 1 + ... + 31) = 3 * 496 = 1488
    if sum(list) != 1488 {
        return 2;
    }
    assert sum(list) == 1488;

    // Reverse and verify sum is preserved.
    reverse(list);
    if sum(list) != 1488 {
        return 3;
    }
    assert sum(list) == 1488;

    // After reverse, head should be 0 (first pushed), tail should be 93 (last pushed).
    let head = valueAt(list, 0) else {
        return 4;
    };
    if head != 0 {
        return 4;
    }
    assert head == 0;
    let tail = valueAt(list, 31) else {
        return 5;
    };
    if tail != 93 {
        return 5;
    }
    assert tail == 93;

    // Pop all and verify decreasing original order.
    let mut j: u32 = 0;
    while j < 32 {
        let v = pop(list) else {
            return 6;
        };
        let expected = j as i32 * 3;
        if v != expected {
            return 6;
        }
        assert v == expected;
        j += 1;
    }

    if length(list) != 0 {
        return 7;
    }
    assert length(list) == 0;

    // Pop from empty list should return nil.
    if pop(list) != nil {
        return 8;
    }
    assert pop(list) == nil;
    return 0;
}

@default fn main() -> i32 {
    let mut list: List = List {

lib/std/arch/rv64/tests/prog.lzw.rad +16 -16


fn testSimple(s: *mut LzwState) -> i32 {
    let data: *[u8] = "ABABABABAB";
    encode(s, data);

    if s.encoded[s.encLen - 1] != EOI_CODE { return 1; }
    assert s.encoded[s.encLen - 1] == EOI_CODE;

    decode(s);
    if s.decLen != 10 { return 2; }
    assert s.decLen == 10;
    let mut i: u32 = 0;
    while i < 10 {
        if s.decoded[i] != data[i] { return 3; }
        assert s.decoded[i] == data[i];
        i += 1;
    }
    return 0;
}

fn testDistinct(s: *mut LzwState) -> i32 {
    let data: [u8; 16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
    encode(s, &data[..]);

    decode(s);
    if s.decLen != 16 { return 1; }
    assert s.decLen == 16;
    let mut i: u32 = 0;
    while i < 16 {
        if s.decoded[i] != data[i] { return 2; }
        assert s.decoded[i] == data[i];
        i += 1;
    }
    return 0;
}

fn testRepetitive(s: *mut LzwState) -> i32 {
    let mut data: [u8; 64] = [65; 64];
    encode(s, &data[..]);

    if s.encLen >= 32 { return 1; }
    assert s.encLen < 32;

    decode(s);
    if s.decLen != 64 { return 2; }
    assert s.decLen == 64;
    let mut i: u32 = 0;
    while i < 64 {
        if s.decoded[i] != 65 { return 3; }
        assert s.decoded[i] == 65;
        i += 1;
    }
    return 0;
}

fn testMixed(s: *mut LzwState) -> i32 {
    let data: *[u8] = "TOBEORNOTTOBEORTOBEORNOT";
    encode(s, data);

    decode(s);
    if s.decLen != 24 { return 1; }
    assert s.decLen == 24;
    let mut i: u32 = 0;
    while i < 24 {
        if s.decoded[i] != data[i] { return 2; }
        assert s.decoded[i] == data[i];
        i += 1;
    }

    if s.encLen - 1 >= 24 { return 3; }
    assert s.encLen - 1 < 24;

    return 0;
}

fn testEmpty(s: *mut LzwState) -> i32 {
    encode(s, &[]);
    if s.encLen != 1 { return 1; }
    if s.encoded[0] != EOI_CODE { return 2; }
    assert s.encLen == 1;
    assert s.encoded[0] == EOI_CODE;

    decode(s);
    if s.decLen != 0 { return 3; }
    assert s.decLen == 0;
    return 0;
}

fn testSingle(s: *mut LzwState) -> i32 {
    let data: *[u8] = "*";
    encode(s, data);

    decode(s);
    if s.decLen != 1 { return 1; }
    if s.decoded[0] != 42 { return 2; }
    assert s.decLen == 1;
    assert s.decoded[0] == 42;
    return 0;
}

@default fn main() -> i32 {
    let mut encDict: [DictEntry; 512] = [DictEntry { prefix: 0xFFFF, suffix: 0 }; 512];

lib/std/arch/rv64/tests/prog.matmul.rad +2 -6

}

/// Multiply matrices multiple times to test repeated computation.
fn testRepeatedMultiply(c: *mut Mat4, a: *Mat4, b: *Mat4) -> i32 {
    // First pass already done, trace = 13+43+43+85 = 184.
    if trace(c) != 184 {
        return 1;
    }
    assert trace(c) == 184;

    // Zero out c and re-multiply to ensure idempotent.
    zero(c);
    matmul(c, a, b);
    if trace(c) != 184 {
        return 2;
    }
    assert trace(c) == 184;
    return 0;
}

@default fn main() -> i32 {
    let a = Mat4 { rows: [

lib/std/arch/rv64/tests/prog.mersenne.rad +16 -16

86	86
87	87		fn testKnownSequence(s: *mut MtState) -> i32 {
88	88		mtInit(s, 1);
89	89
90	90		let v0: u32 = mtNext(s);
91		-	if v0 != 1791095845 { return 1; }
	91	+	assert v0 == 1791095845;
92	92
93	93		let v1: u32 = mtNext(s);
94		-	if v1 != 4282876139 { return 2; }
	94	+	assert v1 == 4282876139;
95	95
96	96		let v2: u32 = mtNext(s);
97		-	if v2 != 3093770124 { return 3; }
	97	+	assert v2 == 3093770124;
98	98
99	99		let v3: u32 = mtNext(s);
100		-	if v3 != 4005303368 { return 4; }
	100	+	assert v3 == 4005303368;
101	101
102	102		let v4: u32 = mtNext(s);
103		-	if v4 != 491263 { return 5; }
	103	+	assert v4 == 491263;
104	104
105	105		return 0;
106	106		}
107	107
108	108		fn testDeterminism(s: *mut MtState) -> i32 {

    let b: u32 = mtNext(s);

    mtInit(s, 3);
    let c: u32 = mtNext(s);

    if a == b { return 1; }
    if b == c { return 2; }
    if a == c { return 3; }
    assert a != b;
    assert b != c;
    assert a != c;

    return 0;
}

fn testChiSquared(s: *mut MtState) -> i32 {

        let diff: i32 = obs - exp;
        chi2Scaled += (diff * diff) as u32;
        b += 1;
    }

    if chi2Scaled > 5000 { return 1; }
    assert chi2Scaled <= 5000;

    b = 0;
    while b < NUM_BINS {
        if bins[b] == 0 { return 2; }
        assert bins[b] != 0;
        b += 1;
    }

    b = 0;
    while b < NUM_BINS {
        if bins[b] > NUM_SAMPLES / 2 { return 3; }
        assert bins[b] <= NUM_SAMPLES / 2;
        b += 1;
    }

    return 0;
}

    while i < 700 {
        last2 = mtNext(s);
        i += 1;
    }

    if last != last2 { return 1; }
    assert last == last2;

    let mut more: u32 = 0;
    i = 0;
    while i < 700 {
        more = mtNext(s);
        i += 1;
    }
    if more == 0 { return 2; }
    assert more != 0;

    return 0;
}

fn testBitCoverage(s: *mut MtState) -> i32 {

        orAll |= v;
        andAll &= v;
        i += 1;
    }

    if orAll != 0xFFFFFFFF { return 1; }
    if andAll == 0xFFFFFFFF { return 2; }
    if andAll != 0 { return 3; }
    assert orAll == 0xFFFFFFFF;
    assert andAll != 0xFFFFFFFF;
    assert andAll == 0;

    return 0;
}

@default fn main() -> i32 {

lib/std/arch/rv64/tests/prog.nqueens.rad +10 -14


    let mut i: u32 = 0;
    while i < 8 {
        let mut j: u32 = i + 1;
        while j < 8 {
            if solution[i] == solution[j] {
                return 1;
            }
            assert solution[i] != solution[j];
            let rowDiff: i32 = j as i32 - i as i32;
            let colDiff: i32 = solution[j] - solution[i];
            if colDiff == rowDiff or colDiff == 0 - rowDiff {
                return 2;
            }
            assert colDiff != rowDiff and colDiff != 0 - rowDiff;
            j += 1;
        }
        i += 1;
    }


fn testDeterminism(b: *mut Board) -> i32 {
    let count1: u32 = solveNQueens(b, 8);
    let count2: u32 = solveNQueens(b, 8);
    let count3: u32 = solveNQueens(b, 8);

    if count1 != 92 { return 1; }
    if count2 != 92 { return 2; }
    if count3 != 92 { return 3; }
    assert count1 == 92;
    assert count2 == 92;
    assert count3 == 92;
    return 0;
}

fn testProperties() -> i32 {
    let expected: [u32; 9] = [0, 1, 0, 0, 2, 10, 4, 40, 92];

    let mut n: u32 = 4;
    while n <= 8 {
        if expected[n] == 0 { return 1; }
        assert expected[n] != 0;
        n += 1;
    }

    if expected[2] != 0 { return 2; }
    if expected[3] != 0 { return 3; }
    if expected[7] <= expected[6] { return 4; }
    if expected[8] <= expected[7] { return 5; }
    assert expected[2] == 0;
    assert expected[3] == 0;
    assert expected[7] > expected[6];
    assert expected[8] > expected[7];

    return 0;
}

@default fn main() -> i32 {

lib/std/arch/rv64/tests/prog.rbtree.rad +21 -21

    while i < 32 {
        insert(t, i);
        i += 1;
    }

    if countNodes(t, t.root) != 32 { return 1; }
    if t.pool[t.root].color != BLACK { return 2; }
    assert countNodes(t, t.root) == 32;
    assert t.pool[t.root].color == BLACK;

    let bh: i32 = blackHeight(t, t.root);
    if bh == -1 { return 3; }
    assert bh != -1;

    if not noRedRed(t, t.root) { return 4; }
    assert noRedRed(t, t.root);

    t.inorderCount = 0;
    inorderWalk(t, t.root);
    if t.inorderCount != 32 { return 5; }
    assert t.inorderCount == 32;
    let mut j: u32 = 0;
    while j < 32 {
        if t.inorder[j] != j as i32 { return 6; }
        assert t.inorder[j] == j as i32;
        j += 1;
    }

    return 0;
}

            break;
        }
        i -= 1;
    }

    if countNodes(t, t.root) != 32 { return 1; }
    if blackHeight(t, t.root) == -1 { return 2; }
    if not noRedRed(t, t.root) { return 3; }
    assert countNodes(t, t.root) == 32;
    assert blackHeight(t, t.root) != -1;
    assert noRedRed(t, t.root);

    t.inorderCount = 0;
    inorderWalk(t, t.root);
    let mut j: u32 = 0;
    while j < 32 {
        if t.inorder[j] != j as i32 { return 4; }
        assert t.inorder[j] == j as i32;
        j += 1;
    }

    return 0;
}

            inserted[val] = true;
            count += 1;
        }
    }

    if countNodes(t, t.root) != 48 { return 1; }
    if blackHeight(t, t.root) == -1 { return 2; }
    if not noRedRed(t, t.root) { return 3; }
    assert countNodes(t, t.root) == 48;
    assert blackHeight(t, t.root) != -1;
    assert noRedRed(t, t.root);

    let mut i: i32 = 0;
    while i < 48 {
        if not search(t, i) { return 4; }
        assert search(t, i);
        i += 1;
    }

    if search(t, -1) { return 5; }
    if search(t, 48) { return 6; }
    if search(t, 100) { return 7; }
    assert not search(t, -1);
    assert not search(t, 48);
    assert not search(t, 100);

    t.inorderCount = 0;
    inorderWalk(t, t.root);
    if t.inorderCount != 48 { return 8; }
    assert t.inorderCount == 48;
    let mut j: u32 = 0;
    while j < 48 {
        if t.inorder[j] != j as i32 { return 9; }
        assert t.inorder[j] == j as i32;
        j += 1;
    }

    return 0;
}

        insert(t, i);
        i += 1;
    }

    let bh: i32 = blackHeight(t, t.root);
    if bh < 3 { return 1; }
    if bh > 7 { return 2; }
    assert bh >= 3;
    assert bh <= 7;

    return 0;
}

@default fn main() -> i32 {

lib/std/arch/rv64/tests/prog.regex.rad +17 -17

}

fn testLiteral(nfa: *mut NfaState) -> i32 {
    let start: u32 = compile(nfa, "abc");

    if not nfaMatches(nfa, start, "abc") { return 1; }
    assert nfaMatches(nfa, start, "abc");
    if nfaMatches(nfa, start, "ab") { return 2; }
    if nfaMatches(nfa, start, "abcd") { return 3; }
    if nfaMatches(nfa, start, "abd") { return 4; }

    return 0;
}

fn testStar(nfa: *mut NfaState) -> i32 {
    let start: u32 = compile(nfa, "a*");

    if not nfaMatches(nfa, start, "") { return 1; }
    if not nfaMatches(nfa, start, "a") { return 2; }
    if not nfaMatches(nfa, start, "aaa") { return 3; }
    assert nfaMatches(nfa, start, "");
    assert nfaMatches(nfa, start, "a");
    assert nfaMatches(nfa, start, "aaa");
    if nfaMatches(nfa, start, "b") { return 4; }

    return 0;
}

fn testPlus(nfa: *mut NfaState) -> i32 {
    let start: u32 = compile(nfa, "a+");

    if nfaMatches(nfa, start, "") { return 1; }
    if not nfaMatches(nfa, start, "a") { return 2; }
    if not nfaMatches(nfa, start, "aaaaa") { return 3; }
    assert nfaMatches(nfa, start, "a");
    assert nfaMatches(nfa, start, "aaaaa");

    return 0;
}

fn testQuestion(nfa: *mut NfaState) -> i32 {
    let start: u32 = compile(nfa, "a?");

    if not nfaMatches(nfa, start, "") { return 1; }
    if not nfaMatches(nfa, start, "a") { return 2; }
    assert nfaMatches(nfa, start, "");
    assert nfaMatches(nfa, start, "a");
    if nfaMatches(nfa, start, "aa") { return 3; }

    return 0;
}

fn testDot(nfa: *mut NfaState) -> i32 {
    let start: u32 = compile(nfa, "..");

    if not nfaMatches(nfa, start, "ab") { return 1; }
    if not nfaMatches(nfa, start, "zz") { return 2; }
    assert nfaMatches(nfa, start, "ab");
    assert nfaMatches(nfa, start, "zz");
    if nfaMatches(nfa, start, "a") { return 3; }
    if nfaMatches(nfa, start, "abc") { return 4; }

    return 0;
}

fn testComplex(nfa: *mut NfaState) -> i32 {
    let start: u32 = compile(nfa, "ab*c");

    if not nfaMatches(nfa, start, "ac") { return 1; }
    if not nfaMatches(nfa, start, "abc") { return 2; }
    if not nfaMatches(nfa, start, "abbc") { return 3; }
    if not nfaMatches(nfa, start, "abbbc") { return 4; }
    assert nfaMatches(nfa, start, "ac");
    assert nfaMatches(nfa, start, "abc");
    assert nfaMatches(nfa, start, "abbc");
    assert nfaMatches(nfa, start, "abbbc");
    if nfaMatches(nfa, start, "a") { return 5; }
    if nfaMatches(nfa, start, "adc") { return 6; }

    return 0;
}

fn testDotStar(nfa: *mut NfaState) -> i32 {
    let start: u32 = compile(nfa, ".*");

    if not nfaMatches(nfa, start, "") { return 1; }
    if not nfaMatches(nfa, start, "hello") { return 2; }
    if not nfaMatches(nfa, start, "x") { return 3; }
    assert nfaMatches(nfa, start, "");
    assert nfaMatches(nfa, start, "hello");
    assert nfaMatches(nfa, start, "x");

    return 0;
}

@default fn main() -> i32 {

lib/std/arch/rv64/tests/prog.sha256.rad +24 -68

}

/// Test SHA-256 of the empty string "".
/// Expected: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
fn testEmpty(s: *mut Sha256, k: *[u32]) -> i32 {
    if hashMessage(s, k, &[]) != 0 {
        return 1;
    }

    if s.h[0] != 0xE3B0C442 {
        return 2;
    }
    if s.h[1] != 0x98FC1C14 {
        return 3;
    }
    if s.h[2] != 0x9AFBF4C8 {
        return 4;
    }
    if s.h[3] != 0x996FB924 {
        return 5;
    }
    if s.h[4] != 0x27AE41E4 {
        return 6;
    }
    if s.h[5] != 0x649B934C {
        return 7;
    }
    if s.h[6] != 0xA495991B {
        return 8;
    }
    if s.h[7] != 0x7852B855 {
        return 9;
    }
    assert hashMessage(s, k, &[]) == 0;

    assert s.h[0] == 0xE3B0C442;
    assert s.h[1] == 0x98FC1C14;
    assert s.h[2] == 0x9AFBF4C8;
    assert s.h[3] == 0x996FB924;
    assert s.h[4] == 0x27AE41E4;
    assert s.h[5] == 0x649B934C;
    assert s.h[6] == 0xA495991B;
    assert s.h[7] == 0x7852B855;
    return 0;
}

/// Test SHA-256 of "abc".
/// Expected: ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad
fn testAbc(s: *mut Sha256, k: *[u32]) -> i32 {
    let msg: [u8; 3] = [0x61, 0x62, 0x63];
    if hashMessage(s, k, &msg[..]) != 0 {
        return 1;
    }

    if s.h[0] != 0xBA7816BF {
        return 2;
    }
    if s.h[1] != 0x8F01CFEA {
        return 3;
    }
    if s.h[2] != 0x414140DE {
        return 4;
    }
    if s.h[3] != 0x5DAE2223 {
        return 5;
    }
    if s.h[4] != 0xB00361A3 {
        return 6;
    }
    if s.h[5] != 0x96177A9C {
        return 7;
    }
    if s.h[6] != 0xB410FF61 {
        return 8;
    }
    if s.h[7] != 0xF20015AD {
        return 9;
    }
    assert hashMessage(s, k, &msg[..]) == 0;

    assert s.h[0] == 0xBA7816BF;
    assert s.h[1] == 0x8F01CFEA;
    assert s.h[2] == 0x414140DE;
    assert s.h[3] == 0x5DAE2223;
    assert s.h[4] == 0xB00361A3;
    assert s.h[5] == 0x96177A9C;
    assert s.h[6] == 0xB410FF61;
    assert s.h[7] == 0xF20015AD;
    return 0;
}

/// Test the helper functions directly.
fn testHelpers() -> i32 {
    // rotr(1, 1) should be 0x80000000
    if rotr(1, 1) != 0x80000000 {
        return 1;
    }
    assert rotr(1, 1) == 0x80000000;
    // rotr(0xFF000000, 8) should be 0x00FF0000
    if rotr(0xFF000000, 8) != 0x00FF0000 {
        return 2;
    }
    assert rotr(0xFF000000, 8) == 0x00FF0000;
    // ch(0xFF, 0x0F, 0xF0):
    //   0xFF & 0x0F = 0x0F
    //   ~0xFF = 0xFFFFFF00, & 0xF0 = 0x00
    //   result = 0x0F ^ 0x00 = 0x0F
    if ch(0xFF, 0x0F, 0xF0) != 0x0F {
        return 3;
    }
    assert ch(0xFF, 0x0F, 0xF0) == 0x0F;
    // maj(0xFF, 0x0F, 0xF0):
    //   0xFF & 0x0F = 0x0F
    //   0xFF & 0xF0 = 0xF0
    //   0x0F & 0xF0 = 0x00
    //   result = 0x0F ^ 0xF0 ^ 0x00 = 0xFF
    if maj(0xFF, 0x0F, 0xF0) != 0xFF {
        return 4;
    }
    assert maj(0xFF, 0x0F, 0xF0) == 0xFF;
    return 0;
}

@default fn main() -> i32 {
    // SHA-256 round constants (first 32 bits of fractional parts of cube roots

lib/std/arch/rv64/tests/prog.sieve.rad +8 -24

        }
    }
    // Known small composites.
    let composites: [u32; 5] = [4, 6, 8, 9, 10];
    for c in composites {
        if not sieve[c] {
            return 7;
        }
        assert sieve[c];
    }
    // Larger primes.
    if sieve[97] {
        return 12;
    }
    if sieve[251] {
        return 13;
    }
    // Larger composites.
    if not sieve[100] {
        return 14;
    }
    if not sieve[250] {
        return 15;
    }
    assert sieve[100];
    assert sieve[250];
    return 0;
}

/// Verify that collected primes are in ascending order and all valid.
fn verifyCollected(sieve: *[bool]) -> i32 {
    let mut primesBuf: [u32; 64] = [0; 64];
    let count = collectPrimes(sieve, &mut primesBuf[..]);

    if count != 54 {
        return 1;
    }
    assert count == 54;

    // First prime should be 2.
    if primesBuf[0] != 2 {
        return 2;
    }
    assert primesBuf[0] == 2;
    // Last prime should be 251.
    if primesBuf[count - 1] != 251 {
        return 3;
    }
    assert primesBuf[count - 1] == 251;

    // Verify ascending order.
    let collected = &primesBuf[0..count];
    let mut prev: ?u32 = nil;
    for p in collected {
        if let prevVal = prev {
            if prevVal >= p {
                return 4;
            }
            assert prevVal < p;
        }
        prev = p;
    }
    return 0;
}

124	110		if r1 != 0 {
125	111		return 10 + r1;
126	112		}
127	113
128	114		// There are 54 primes <= 255 (2, 3, 5, ..., 251).
129		-	if countPrimes(&sieve[..]) != 54 {
130		-	return 30;
131		-	}
	115	+	assert countPrimes(&sieve[..]) == 54;
132	116
133	117		let r3 = verifyCollected(&sieve[..]);
134	118		if r3 != 0 {
135	119		return 40 + r3;
136	120		}

lib/std/arch/rv64/tests/prog.symtab.rad +15 -43

    define(tab, "z", 30);

    let x = lookup(tab, "x") else {
        return 1;
    };
    if x != 10 {
        return 2;
    }
    assert x == 10;

    let y = lookup(tab, "y") else {
        return 3;
    };
    if y != 20 {
        return 4;
    }
    assert y == 20;

    let z = lookup(tab, "z") else {
        return 5;
    };
    if z != 30 {
        return 6;
    }
    assert z == 30;

    // Lookup nonexistent symbol.
    if let val = lookup(tab, "w") {
        return 7;
    }


    // Verify outer x.
    let x1 = lookup(tab, "x") else {
        return 1;
    };
    if x1 != 1 {
        return 2;
    }
    assert x1 == 1;

    // Push inner scope, shadow x.
    pushScope(tab);
    define(tab, "x", 2);

    let x2 = lookup(tab, "x") else {
        return 3;
    };
    if x2 != 2 {
        return 4;
    }
    assert x2 == 2;

    // Pop inner scope, x should revert.
    popScope(tab);

    let x3 = lookup(tab, "x") else {
        return 5;
    };
    if x3 != 1 {
        return 6;
    }
    assert x3 == 1;

    popScope(tab);
    return 0;
}



    // x should be the innermost value.
    let x = lookup(tab, "x") else {
        return 1;
    };
    if x != 70 {
        return 2;
    }
    assert x == 70;

    // Pop scopes one by one and check.
    i = 7;
    while i > 0 {
        popScope(tab);
        let val = lookup(tab, "x") else {
            return 3;
        };
        let expected = (i - 1) as i32 * 10;
        if val != expected {
            return 4;
        }
        assert val == expected;
        i -= 1;
    }

    popScope(tab);
    return 0;

295	279		return 1;
296	280		}
297	281		}
298	282
299	283		// 1+2+3+4+5+6+7+8 = 36
300		-	if sum != 36 {
301		-	return 2;
302		-	}
	284	+	assert sum == 36;
303	285
304	286		popScope(tab);
305	287		return 0;
306	288		}
307	289

    let mut i: u32 = 0;
    while i < 10 {
        let cur = lookup(tab, "counter") else {
            return 1;
        };
        if not update(tab, "counter", cur + 1) {
            return 2;
        }
        assert update(tab, "counter", cur + 1);
        i += 1;
    }

    let final_val = lookup(tab, "counter") else {
    let finalVal = lookup(tab, "counter") else {
        return 3;
    };
    if final_val != 10 {
        return 4;
    }
    assert finalVal == 10;

    // Update nonexistent symbol should fail.
    if update(tab, "nonexistent", 99) {
        return 5;
    }

    pushScope(tab);
    define(tab, "inner", 2);

    // Both visible.
    if let val = lookup(tab, "outer") {
        if val != 1 {
            return 1;
        }
        assert val == 1;
    } else {
        return 2;
    }
    if let val = lookup(tab, "inner") {
        if val != 2 {
            return 3;
        }
        assert val == 2;
    } else {
        return 4;
    }

    popScope(tab);

    // outer still visible, inner gone.
    if let val = lookup(tab, "outer") {
        if val != 1 {
            return 5;
        }
        assert val == 1;
    } else {
        return 6;
    }
    if let val = lookup(tab, "inner") {
        return 7;

lib/std/arch/rv64/tests/prog.tokenizer.rad +14 -42

/// Test simple number.
fn testNumber(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
    let result = evaluate("42", tokenBuf, exprBuf) else {
        return 1;
    };
    if result != 42 {
        return 2;
    }
    assert result == 42;
    return 0;
}

/// Test addition.
fn testAdd(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
    let result = evaluate("3 + 4", tokenBuf, exprBuf) else {
        return 1;
    };
    if result != 7 {
        return 2;
    }
    assert result == 7;
    return 0;
}

/// Test precedence: multiplication before addition.
fn testPrecedence(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
    let result = evaluate("2 + 3 * 4", tokenBuf, exprBuf) else {
        return 1;
    };
    if result != 14 {
        return 2;
    }
    assert result == 14;
    return 0;
}

/// Test parenthesized expression.
fn testParens(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
    let result = evaluate("(2 + 3) * 4", tokenBuf, exprBuf) else {
        return 1;
    };
    if result != 20 {
        return 2;
    }
    assert result == 20;
    return 0;
}

/// Test negation.
fn testNeg(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
    let result = evaluate("-5 + 8", tokenBuf, exprBuf) else {
        return 1;
    };
    if result != 3 {
        return 2;
    }
    assert result == 3;
    return 0;
}

/// Test complex expression.
fn testComplex(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
    // (10 - 3) * (2 + 1) = 7 * 3 = 21
    let result = evaluate("(10 - 3) * (2 + 1)", tokenBuf, exprBuf) else {
        return 1;
    };
    if result != 21 {
        return 2;
    }
    assert result == 21;
    return 0;
}

/// Test chained operations.
fn testChained(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
    // 100 - 20 - 30 - 10 = 40
    let result = evaluate("100 - 20 - 30 - 10", tokenBuf, exprBuf) else {
        return 1;
    };
    if result != 40 {
        return 2;
    }
    assert result == 40;
    return 0;
}

/// Test token counting via for-in.
fn testTokenCount(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
    let mut lex = Lexer { source: "1 + 2 * 3", pos: 0 };
    let mut list = TokenList { tokens: tokenBuf, count: 0 };
    if not tokenize(&mut lex, &mut list) {
        return 1;
    }
    assert tokenize(&mut lex, &mut list);

    // Should be: 1, +, 2, *, 3, Eof = 6 tokens
    if list.count != 6 {
        return 2;
    }
    assert list.count == 6;

    // Count number tokens using for-in.
    let mut numCount: u32 = 0;
    let slice = &tokenBuf[0..list.count];
    for tok in slice {

                numCount += 1;
            }
            else => {}
        }
    }
    if numCount != 3 {
        return 3;
    }
    assert numCount == 3;

    return 0;
}

/// Test division and mixed operations.
fn testDivision(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
    // 20 / 4 + 3 = 5 + 3 = 8
    let result = evaluate("20 / 4 + 3", tokenBuf, exprBuf) else {
        return 1;
    };
    if result != 8 {
        return 2;
    }
    assert result == 8;
    return 0;
}

/// Test deeply nested parentheses.
fn testDeepNesting(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
    // ((((5)))) = 5
    let result = evaluate("((((5))))", tokenBuf, exprBuf) else {
        return 1;
    };
    if result != 5 {
        return 2;
    }
    assert result == 5;
    return 0;
}

/// Test node count of complex expression.
fn testNodeCount(tokenBuf: *mut [Token], exprBuf: *mut [Expr]) -> i32 {
    let mut lex = Lexer { source: "1 + 2 * 3", pos: 0 };
    let mut list = TokenList { tokens: tokenBuf, count: 0 };
    if not tokenize(&mut lex, &mut list) {
        return 1;
    }
    assert tokenize(&mut lex, &mut list);

    let mut pool = ExprPool { nodes: exprBuf, count: 0 };
    let mut parser = Parser {
        tokens: tokenBuf,
        tokenCount: list.count,

        return 2;
    };

    // 1 + (2 * 3) = 5 nodes: Num(1), Num(2), Num(3), BinOp(*), BinOp(+)
    let count = countNodes(exprBuf, root);
    if count != 5 {
        return 3;
    }
    assert count == 5;
    return 0;
}

@default fn main() -> i32 {
    let mut tokenBuf: [Token; 128] = [Token::Eof; 128];

lib/std/arch/rv64/tests/prog.vm.rad +13 -39

    code[3] = Op::Mul;
    code[4] = Op::Add;
    code[5] = Op::Halt;

    let result: i32 = try! runProgram(&code[..], 6, stackBuf, localsBuf, framesBuf);
    if result != 11 {
        return 1;
    }
    assert result == 11;
    return 0;
}

/// Test local variables: x = 5, y = 7, push x + y.
fn testLocals(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {

    code[5] = Op::Load(1);    // push y
    code[6] = Op::Add;        // x + y
    code[7] = Op::Halt;

    let result: i32 = try! runProgram(&code[..], 8, stackBuf, localsBuf, framesBuf);
    if result != 12 {
        return 1;
    }
    assert result == 12;
    return 0;
}

/// Test conditional jump: if 3 > 2 then push 42 else push 99.
fn testConditional(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {

    code[5] = Op::Jump(7);       // skip false branch
    code[6] = Op::Push(99);      // false branch
    code[7] = Op::Halt;

    let result: i32 = try! runProgram(&code[..], 8, stackBuf, localsBuf, framesBuf);
    if result != 42 {
        return 1;
    }
    assert result == 42;
    return 0;
}

/// Test loop: sum 1..5 using jumps.
/// local[0] = counter (starts at 1), local[1] = sum (starts at 0).

    code[17] = Op::Load(1);      // push sum
    code[18] = Op::Halt;

    let result: i32 = try! runProgram(&code[..], 19, stackBuf, localsBuf, framesBuf);
    // sum = 1+2+3+4+5 = 15
    if result != 15 {
        return 1;
    }
    assert result == 15;
    return 0;
}

/// Test function call: call a function that computes n*2+1 for n=10.
fn testCall(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {

    code[10] = Op::Add;          // n * 2 + 1
    code[11] = Op::Ret;          // return (result on stack)

    let result: i32 = try! runProgram(&code[..], 12, stackBuf, localsBuf, framesBuf);
    // 10 * 2 + 1 = 21
    if result != 21 {
        return 1;
    }
    assert result == 21;
    return 0;
}

/// Test division by zero detection using try...catch with error binding.
fn testDivByZero(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {

            caught = 1;
        } else {
            caught = 2;
        }
    };
    if caught != 1 {
        return 1;
    }
    assert caught == 1;
    return 0;
}

/// Test negation and equality.
fn testNegAndEq(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {

    code[2] = Op::Push(-5);
    code[3] = Op::Eq;            // -5 == -5 => 1
    code[4] = Op::Halt;

    let result: i32 = try! runProgram(&code[..], 5, stackBuf, localsBuf, framesBuf);
    if result != 1 {
        return 1;
    }
    assert result == 1;
    return 0;
}

/// Test factorial using recursive calls: fact(6) = 720.
fn testFactorial(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {

    code[15] = Op::Load(0);      // push n
    code[16] = Op::Mul;          // fact(n-1) * n
    code[17] = Op::Ret;

    let result: i32 = try! runProgram(&code[..], 18, stackBuf, localsBuf, framesBuf);
    if result != 720 {
        return 1;
    }
    assert result == 720;
    return 0;
}

/// Test dup instruction.
fn testDup(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {

    code[1] = Op::Dup;
    code[2] = Op::Add;           // 7 + 7 = 14
    code[3] = Op::Halt;

    let result: i32 = try! runProgram(&code[..], 4, stackBuf, localsBuf, framesBuf);
    if result != 14 {
        return 1;
    }
    assert result == 14;
    return 0;
}

/// Test stack underflow detection using try...catch with error binding.
fn testStackUnderflow(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {

            caught = 1;
        } else {
            caught = 2;
        }
    };
    if caught != 1 {
        return 1;
    }
    assert caught == 1;
    return 0;
}

/// Test that try...catch on success path does not execute catch block.
fn testSuccessNoCatch(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {

    let result: i32 = try runProgram(&code[..], 2, stackBuf, localsBuf, framesBuf) catch e {
        caught = 1;
        return 1;
    };
    // Catch block should not have run.
    if caught != 0 {
        return 2;
    }
    assert caught == 0;
    // Should have the success value.
    if result != 99 {
        return 3;
    }
    assert result == 99;
    return 0;
}

/// Test call overflow detection by exhausting frames.
fn testCallOverflow(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {

            caught = 1;
        } else {
            caught = 2;
        }
    };
    if caught != 1 {
        return 1;
    }
    assert caught == 1;
    return 0;
}

/// Test that catch with no binding works (discard the error).
fn testCatchNoBinding(stackBuf: *mut [i32], localsBuf: *mut [i32], framesBuf: *mut [Frame]) -> i32 {

lib/std/arch/rv64/tests/ptr.eq.rad +3 -9


    return not (a == b);  // Different addresses, should NOT be equal.
}

@default fn main() -> i32 {
    if not testPtrSameAddress() {
        return 1;
    }
    if not testPtrDifferentAddressSameValues() {
        return 2;
    }
    if not testPtrDifferentAddressDifferentValues() {
        return 3;
    }
    assert testPtrSameAddress();
    assert testPtrDifferentAddressSameValues();
    assert testPtrDifferentAddressDifferentValues();
    return 0;
}

lib/std/arch/rv64/tests/ptr.opaque.rad +4 -12

    }
    return false;
}

@default fn main() -> u32 {
    if not testOpaqueCasting() {
        return 1;
    }
    if not testOpaqueParams() {
        return 2;
    }
    if not testOpaqueReturn() {
        return 3;
    }
    if not testNullableOpaque() {
        return 4;
    }
    assert testOpaqueCasting();
    assert testOpaqueParams();
    assert testOpaqueReturn();
    assert testNullableOpaque();
    return 0;
}

lib/std/arch/rv64/tests/record.alignment.rad +2 -6

    a: i32,
    b: i32,
}

@default fn main() -> i32 {
    if @alignOf(R) != 4 {
        return 1;
    }
    if @sizeOf(R) != 8 {
        return 2;
    }
    assert @alignOf(R) == 4;
    assert @sizeOf(R) == 8;
    return 0;
}

lib/std/arch/rv64/tests/record.copy.rad +26 -78

18	18		let mut m: S = s;
19	19		m.x = 112;
20	20		m.y = 582;
21	21		m.z = 281;
22	22
23		-	if m.x != 112 {
24		-	return 1;
25		-	}
26		-	if m.y != 582 {
27		-	return 2;
28		-	}
29		-	if m.z != 281 {
30		-	return 3;
31		-	}
	23	+	assert m.x == 112;
	24	+	assert m.y == 582;
	25	+	assert m.z == 281;
32	26		return 0;
33	27		}
34	28
35	29		fn func2(s: S) -> i32 {
36	30		let p: i32 = 0;

43	37		t.y = 52;
44	38		u.y = 54;
45	39		t.z = 21;
46	40		u.z = 25;
47	41
48		-	if t.x != 12 {
49		-	return 1;
50		-	}
51		-	if t.y != 52 {
52		-	return 2;
53		-	}
54		-	if t.z != 21 {
55		-	return 3;
56		-	}
57		-	if u.x != 13 {
58		-	return 4;
59		-	}
60		-	if u.y != 54 {
61		-	return 5;
62		-	}
63		-	if u.z != 25 {
64		-	return 6;
65		-	}
	42	+	assert t.x == 12;
	43	+	assert t.y == 52;
	44	+	assert t.z == 21;
	45	+	assert u.x == 13;
	46	+	assert u.y == 54;
	47	+	assert u.z == 25;
66	48		return 0;
67	49		}
68	50
69	51		fn func3(s: S) -> i32 {
70	52		let mut a: [S; 4] = [s; 4];

75	57		t.z = 52;
76	58
77	59		a[1] = t;
78	60		a[3] = a[1];
79	61
80		-	if a[0].x != 561 {
81		-	return 1;
82		-	}
83		-	if a[0].y != 938 {
84		-	return 2;
85		-	}
86		-	if a[0].z != 102 {
87		-	return 3;
88		-	}
89		-	if a[1].x != 12 {
90		-	return 4;
91		-	}
92		-	if a[1].y != 13 {
93		-	return 5;
94		-	}
95		-	if a[1].z != 52 {
96		-	return 6;
97		-	}
98		-	if a[2].x != 561 {
99		-	return 7;
100		-	}
101		-	if a[3].x != 12 {
102		-	return 8;
103		-	}
	62	+	assert a[0].x == 561;
	63	+	assert a[0].y == 938;
	64	+	assert a[0].z == 102;
	65	+	assert a[1].x == 12;
	66	+	assert a[1].y == 13;
	67	+	assert a[1].z == 52;
	68	+	assert a[2].x == 561;
	69	+	assert a[3].x == 12;
104	70		return 0;
105	71		}
106	72
107	73		fn func4(s: S) -> i32 {
108	74		let mut a: [S; 2] = undefined;
109	75		a[0] = s;
110	76
111		-	if a[0].x != 561 {
112		-	return 1;
113		-	}
114		-	if a[0].y != 938 {
115		-	return 2;
116		-	}
117		-	if a[0].z != 102 {
118		-	return 3;
119		-	}
	77	+	assert a[0].x == 561;
	78	+	assert a[0].y == 938;
	79	+	assert a[0].z == 102;
120	80		return 0;
121	81		}
122	82
123	83		fn func5(s: S) -> i32 {
124	84		let mut a: [S; 2] = undefined;
125	85		let t: S = makeS(s.x, s.y, s.z);
126	86		a[0] = t;
127	87
128		-	if a[0].x != 561 {
129		-	return 1;
130		-	}
131		-	if a[0].y != 938 {
132		-	return 2;
133		-	}
134		-	if a[0].z != 102 {
135		-	return 3;
136		-	}
	88	+	assert a[0].x == 561;
	89	+	assert a[0].y == 938;
	90	+	assert a[0].z == 102;
137	91		return 0;
138	92		}
139	93
140	94		@default fn main() -> i32 {
141	95		let s: S = S { x: 561, y: 938, z: 102 };
142	96
143	97		let r1: i32 = func1(s);
144	98		if r1 != 0 {
145	99		return 10 + r1;
146	100		}
147		-	if s.x != 561 {
148		-	return 20;
149		-	}
150		-	if s.y != 938 {
151		-	return 21;
152		-	}
153		-	if s.z != 102 {
154		-	return 22;
155		-	}
	101	+	assert s.x == 561;
	102	+	assert s.y == 938;
	103	+	assert s.z == 102;
156	104
157	105		let r2: i32 = func2(s);
158	106		if r2 != 0 {
159	107		return 30 + r2;
160	108		}

lib/std/arch/rv64/tests/record.nested.calls.2.rad +1 -3

22	22		scale(p, 2), // (6, 8)
23	23		scale(q, 2) // (10, 12)
24	24		); // (16, 20)
25	25
26	26		// p.x + p.y = 16 + 20 = 36
27		-	if p.x + p.y != 36 {
28		-	return 1;
29		-	}
	27	+	assert p.x + p.y == 36;
30	28		return 0;
31	29		}

lib/std/arch/rv64/tests/record.nested.calls.3.rad +1 -3

    return Point { x: id(2), y: id(3) };
}

@default fn main() -> i32 {
    let result: i32 = compute(point()).y - compute(point()).x;
    if result != 2 {
        return 1;
    }
    assert result == 2;
    return 0;
}

lib/std/arch/rv64/tests/ref.if.bug.rad +2 -6

    }
    return val;
}

@default fn main() -> i32 {
    if testIfBranch(false) != 42 {
        return 1;
    }
    if testIfBranch(true) != 99 {
        return 2;
    }
    assert testIfBranch(false) == 42;
    assert testIfBranch(true) == 99;
    return 0;
}

lib/std/arch/rv64/tests/ref.immut.loop.bug.rad +2 -6

    }
    return val;
}

@default fn main() -> i32 {
    if testZeroIter(0) != 42 {
        return 1;
    }
    if testZeroIter(3) != 42 {
        return 2;
    }
    assert testZeroIter(0) == 42;
    assert testZeroIter(3) == 42;
    return 0;
}

lib/std/arch/rv64/tests/regalloc.callee.save.rad +1 -3

39	39		let v12: i32 = consume(v0);
40	40
41	41		let total: i32 = v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12;
42	42		// v1..v10 = 2+3+...+11 = 65, v11 = 12, v12 = consume(1) = 2
43	43		// total = 65 + 12 + 2 = 79
44		-	if total != 79 {
45		-	return 1;
46		-	}
	44	+	assert total == 79;
47	45		return 0;
48	46		}

lib/std/arch/rv64/tests/regalloc.spill.reuse.rad +1 -3

    let saved: u32 = old + 1;

    let first: u32 = callPressure(1, 2, 3, 4, 5, 6, 7, 8);
    let second: u32 = callPressure(8, 7, 6, 5, 4, 3, 2, 1);

    if first == 0 or second == 0 {
        return 99;
    }
    assert first != 0 and second != 0;

    return saved;
}

@default fn main() -> i32 {

lib/std/arch/rv64/tests/reserve.loop.rad +1 -3

8	8		total += p.a + p.b;
9	9		i += 1;
10	10		}
11	11		// Expected: sum(i) + sum(i+1) for i=0..9999
12	12		// = 2 * 9999*10000/2 + 10000 = 99990000 + 10000 = 100000000
13		-	if total != 100000000 {
14		-	return 1;
15		-	}
	13	+	assert total == 100000000;
16	14		return 0;
17	15		}

lib/std/arch/rv64/tests/slice.alloc.loop.rad +2 -6


@default fn main() -> i32 {
    let mut buf: [u8; 64] = undefined;

    let n = initSlice(&mut buf[..], 5);
    if n != 5 {
        return 1;
    }
    assert n == 5;

    let n2 = initSlice(&mut buf[..], 0);
    if n2 != 0 {
        return 2;
    }
    assert n2 == 0;

    return 0;
}

lib/std/arch/rv64/tests/slice.of.rad +4 -12


@default fn main() -> i32 {
    let mut arr: [i32; 4] = [10, 20, 30, 40];
    let s = makeSlice(&mut arr[0], 4);

    if s.len != 4 {
        return 1;
    }
    if s[0] != 10 {
        return 2;
    }
    if s[3] != 40 {
        return 3;
    }
    assert s.len == 4;
    assert s[0] == 10;
    assert s[3] == 40;

    // Test with count=0.
    let empty = makeSlice(&mut arr[0], 0);
    if empty.len != 0 {
        return 4;
    }
    assert empty.len == 0;
    return 0;
}

lib/std/arch/rv64/tests/spill.blockarg.clobber.rad +2 -6


    prepareSchedule(&mut s, &block[..]);
    compress(&mut s, &k[..]);

    // SHA-256("") = e3b0c442 98fc1c14 ...
    if s.h[0] != 0xE3B0C442 {
        return 1;
    }
    if s.h[1] != 0x98FC1C14 {
        return 2;
    }
    assert s.h[0] == 0xE3B0C442;
    assert s.h[1] == 0x98FC1C14;
    return 0;
}

lib/std/arch/rv64/tests/spill.loop.rad +4 -12


@default fn main() -> i32 {
    // Two u32 fields (tag 2 = size=4, align=4).
    let mut tags: [u8; 2] = [2, 2];
    let layout = computeRecordLayout(&tags[0..2]);
    if layout.alignment != 4 {
        return 1;
    }
    if layout.size != 8 {
        return 2;
    }
    assert layout.alignment == 4;
    assert layout.size == 8;

    // Mixed: u8 then u32.
    let mut tags2: [u8; 2] = [0, 2];
    let layout2 = computeRecordLayout(&tags2[0..2]);
    if layout2.alignment != 4 {
        return 3;
    }
    if layout2.size != 8 {
        return 4;
    }
    assert layout2.alignment == 4;
    assert layout2.size == 8;
    return 0;
}

lib/std/arch/rv64/tests/stack.local.corrupt.rad +2 -6


@default fn main() -> i32 {
    let mut local: i32 = 42;
    let result = identity(10);
    // Check that local wasn't corrupted by the call
    if local != 42 {
        return 1;
    }
    if result != 10 {
        return 2;
    }
    assert local == 42;
    assert result == 10;
    return 0;
}

lib/std/arch/rv64/tests/static.array.mutate.rad +1 -3

11	11		let a: i32 = bump(0, 4);
12	12		let b: i32 = bump(1, 5);
13	13		let c: i32 = bump(2, 6);
14	14
15	15		// a=10, b=15, c=21 => total=46
16		-	if a + b + c != 46 {
17		-	return 1;
18		-	}
	16	+	assert a + b + c == 46;
19	17		return 0;
20	18		}

lib/std/arch/rv64/tests/static.fn.array.rad +3 -9

18	18		static OPS: [fn(i32) -> i32; 3] = [double, negate, identity];
19	19
20	20		@default fn main() -> i32 {
21	21		// double(5) == 10
22	22		let r0 = OPS[0](5);
23		-	if r0 != 10 {
24		-	return 1;
25		-	}
	23	+	assert r0 == 10;
26	24		// negate(5) == -5
27	25		let r1 = OPS[1](5);
28		-	if r1 != 0 - 5 {
29		-	return 2;
30		-	}
	26	+	assert r1 == 0 - 5;
31	27		// identity(5) == 5
32	28		let r2 = OPS[2](5);
33		-	if r2 != 5 {
34		-	return 3;
35		-	}
	29	+	assert r2 == 5;
36	30		return 0;
37	31		}

lib/std/arch/rv64/tests/static.record.array.rad +1 -3


@default fn main() -> i32 {
    let first: i32 = rebalance();
    let second: i32 = TABLE.values[1] + TABLE.values[2];

    if first + second != 26 {
        return 1;
    }
    assert first + second == 26;
    return 0;
}

lib/std/arch/rv64/tests/static.slice.offset.rad +2 -6

    TBL.len     = 0;

    TBL.entries[TBL.len] = Entry { a: 7, b: 9 };
    TBL.len += 1;

    if STORAGE[0].a != 7 or STORAGE[0].b != 9 {
        return 1;
    }
    if SCRATCH[0].a != 0 or SCRATCH[0].b != 0 {
        return 2;
    }
    assert STORAGE[0].a == 7 and STORAGE[0].b == 9;
    assert SCRATCH[0].a == 0 and SCRATCH[0].b == 0;
    return 0;
}

lib/std/arch/rv64/tests/switch.blockargs.clobber.rad +5 -15

@default fn main() -> i32 {
    // Critical case: two payload values that differ.
    // With the bug, the switch clobber makes this return true.
    let a: Val = Val::data(42);
    let b: Val = Val::data(99);
    if a == b {
        return 1;
    }
    assert a != b;

    // Same payload - should be equal.
    let c: Val = Val::data(42);
    let d: Val = Val::data(42);
    if c != d {
        return 2;
    }
    assert c == d;

    // Both void (none) - should be equal.
    let e: Val = Val::none;
    let f: Val = Val::none;
    if e != f {
        return 3;
    }
    assert e == f;

    // Both void (empty) - should be equal.
    let g: Val = Val::empty;
    let h: Val = Val::empty;
    if g != h {
        return 4;
    }
    assert g == h;

    // Different variants - should not be equal.
    let i: Val = Val::none;
    let j: Val = Val::data(42);
    if i == j {
        return 5;
    }
    assert i != j;
    return 0;
}

lib/std/arch/rv64/tests/trait.aggregate.ret.rad +6 -18

    let c = Circle { cx: 10, cy: 20, radius: 5 };
    let g: *opaque Geometry = &c;

    // Small struct return (Point, 8 bytes = pointer size).
    let p = g.origin();
    if p.x != 10 {
        return 1;
    }
    if p.y != 20 {
        return 2;
    }
    assert p.x == 10;
    assert p.y == 20;

    // Larger struct return (Vec3, 12 bytes > pointer size).
    let v = g.center();
    if v.x != 10 {
        return 3;
    }
    if v.y != 20 {
        return 4;
    }
    if v.z != 0 {
        return 5;
    }
    assert v.x == 10;
    assert v.y == 20;
    assert v.z == 0;

    // Optional return - Some case.
    let m = g.maybe();
    if let val = m {
        if val != 5 {
            return 6;
        }
        assert val == 5;
    } else {
        return 7;
    }

    // Optional return - None case.

lib/std/arch/rv64/tests/trait.array.optional.rad +3 -9


    // Array of trait objects.
    let transforms: [*opaque Transform; 3] = [t1, t2, t3];
    // Chain: (1 + 10) * 3 + 5 = 38
    let result = applyAll(&transforms[..], 1);
    if result != 38 {
        return 1;
    }
    assert result == 38;

    // Optional trait object - Some case.
    let opt: ?*opaque Transform = t1;
    let r2 = applyMaybe(opt, 5);
    if r2 != 15 {
        return 2;
    }
    assert r2 == 15;

    // Optional trait object - None case.
    let none: ?*opaque Transform = nil;
    let r3 = applyMaybe(none, 5);
    if r3 != 5 {
        return 3;
    }
    assert r3 == 5;

    return 0;
}

lib/std/arch/rv64/tests/trait.basic.rad +2 -6

    let mut c = Counter { value: 10 };
    let a: *mut opaque Adder = &mut c;

    let result = a.add(5);
    // c.value should be 15 now.
    if result != 15 {
        return 1;
    }
    assert result == 15;
    let result2 = a.add(3);
    // c.value should be 18 now.
    if result2 != 18 {
        return 2;
    }
    assert result2 == 18;
    return 0;
}

lib/std/arch/rv64/tests/trait.control.flow.rad +4 -12

    let mut i: i32 = 0;
    while i < 5 {
        s.step();
        i = i + 1;
    }
    if s.current() != 5 {
        return 1;
    }
    assert s.current() == 5;

    // Dispatch in a conditional.
    if s.current() > 3 {
        s.step();
    }
    if s.current() != 6 {
        return 2;
    }
    assert s.current() == 6;

    // Dispatch result used as loop condition.
    while s.current() < 10 {
        s.step();
    }
    if s.current() != 10 {
        return 3;
    }
    assert s.current() == 10;

    // Dispatch result used in conditional expression.
    let v = s.current();
    if v != 10 {
        return 4;
    }
    assert v == 10;
    return 0;
}

lib/std/arch/rv64/tests/trait.fn.param.rad +4 -12

    let s = Square { side: 4 };

    // Pass immutable trait objects to function.
    let cs: *opaque Shape = &c;
    let ca = getArea(cs);
    if ca != 75 {
        return 1;
    }
    assert ca == 75;

    let ss: *opaque Shape = &s;
    let sa = getArea(ss);
    if sa != 16 {
        return 2;
    }
    assert sa == 16;

    // Pass two different trait objects to same function.
    let total = totalArea(cs, ss);
    if total != 91 {
        return 3;
    }
    assert total == 91;

    // Pass mutable trait object to function.
    let mut c2 = Circle { radius: 3 };
    let sc: *mut opaque Scalable = &mut c2;
    doubleSize(sc);
    if c2.radius != 6 {
        return 4;
    }
    assert c2.radius == 6;
    return 0;
}

lib/std/arch/rv64/tests/trait.multiple.methods.rad +5 -15

@default fn main() -> i32 {
    let mut acc = Accumulator { total: 0 };
    let c: *mut opaque Collector = &mut acc;

    // Initially empty.
    if not c.isEmpty() {
        return 1;
    }
    assert c.isEmpty();

    // Add returns running total.
    let v1 = c.add(10);
    if v1 != 10 {
        return 2;
    }
    assert v1 == 10;

    let v2 = c.add(20);
    if v2 != 30 {
        return 3;
    }
    assert v2 == 30;

    // No longer empty.
    if c.isEmpty() {
        return 4;
    }

    // Void return: clear.
    c.clear();
    if acc.total != 0 {
        return 5;
    }
    if not c.isEmpty() {
        return 6;
    }
    assert acc.total == 0;
    assert c.isEmpty();
    return 0;
}

lib/std/arch/rv64/tests/trait.multiple.traits.rad +4 -12

    let mut c = Counter { value: 10 };

    // Dispatch through Incrementable.
    let i: *mut opaque Incrementable = &mut c;
    let v1 = i.inc();
    if v1 != 11 {
        return 1;
    }
    assert v1 == 11;

    // Dispatch through Resettable.
    let r: *mut opaque Resettable = &mut c;
    if r.isZero() {
        return 2;
    }
    r.reset();
    if not r.isZero() {
        return 3;
    }
    if c.value != 0 {
        return 4;
    }
    assert r.isZero();
    assert c.value == 0;

    // Increment again after reset.
    let v2 = i.inc();
    if v2 != 1 {
        return 5;
    }
    assert v2 == 1;
    return 0;
}

lib/std/arch/rv64/tests/trait.multiple.types.rad +3 -9

    let c = Cat { lives: 9 };

    // Immutable trait object from Dog.
    let sd: *opaque Speaker = &d;
    let v1 = sd.speak();
    if v1 != 5 {
        return 1;
    }
    assert v1 == 5;
    if sd.isOld() {
        return 2;
    }

    // Immutable trait object from Cat.
    let sc: *opaque Speaker = &c;
    let v2 = sc.speak();
    if v2 != 90 {
        return 3;
    }
    assert v2 == 90;
    if sc.isOld() {
        return 4;
    }

    // Old dog.
    let oldDog = Dog { age: 15 };
    let so: *opaque Speaker = &oldDog;
    if not so.isOld() {
        return 5;
    }
    assert so.isOld();
    return 0;
}

lib/std/arch/rv64/tests/trait.supertrait.rad +7 -21

    // Test 1: Use as ReadWriter trait object.
    let rw: *mut opaque ReadWriter = &mut sock;

    // Test 2: Write through the ReadWriter (dispatches via Writer supertrait).
    let wn = rw.write("abc");
    if wn != 3 {
        return 1;
    }
    if sock.wpos != 3 {
        return 2;
    }
    assert wn == 3;
    assert sock.wpos == 3;

    // Test 3: Read through the ReadWriter (dispatches via Reader supertrait).
    let mut rbuf: [u8; 8] = undefined;
    let rn = rw.read(&mut rbuf[0..8]);
    if rn != 5 {
        return 3;
    }
    if rbuf[0] != 'h' as u8 {
        return 4;
    }
    if rbuf[4] != 'o' as u8 {
        return 5;
    }
    assert rn == 5;
    assert rbuf[0] == 'h' as u8;
    assert rbuf[4] == 'o' as u8;

    // Test 4: Call ReadWriter's own method.
    let flushed = rw.flush();
    if flushed != 3 {
        return 6;
    }
    if sock.wpos != 0 {
        return 7;
    }
    assert flushed == 3;
    assert sock.wpos == 0;
    return 0;
}

lib/std/arch/rv64/tests/trait.throws.rad +3 -9


    // Success path.
    let r1 = try p.parse(5) catch {
        return 1;
    };
    if r1 != 10 {
        return 2;
    }
    assert r1 == 10;

    // Error path: negative input.
    let mut caught = false;
    let r2 = try p.parse(-1) catch {
        caught = true;
        0
    };
    if not caught {
        return 3;
    }
    assert caught;

    // Error path: overflow.
    caught = false;
    let r3 = try p.parse(200) catch {
        caught = true;
        0
    };
    if not caught {
        return 4;
    }
    assert caught;

    return 0;
}

lib/std/arch/rv64/tests/trait.writer.rad +13 -39

@default fn main() -> i32 {
    // Direct BufferWriter usage through trait.
    let mut buf = BufferWriter { buf: undefined, pos: 0 };
    let w: *mut opaque Writer = &mut buf;
    emit(w, "hello");
    if w.total() != 5 {
        return 1;
    }
    assert w.total() == 5;
    emit(w, " world");
    if w.total() != 11 {
        return 2;
    }
    assert w.total() == 11;

    // Verify buffer contents.
    if buf.buf[0] != 'h' as u8 {
        return 3;
    }
    if buf.buf[4] != 'o' as u8 {
        return 4;
    }
    if buf.buf[5] != ' ' as u8 {
        return 5;
    }
    if buf.buf[10] != 'd' as u8 {
        return 6;
    }
    assert buf.buf[0] == 'h' as u8;
    assert buf.buf[4] == 'o' as u8;
    assert buf.buf[5] == ' ' as u8;
    assert buf.buf[10] == 'd' as u8;

    // Counting writer wrapping a buffer writer.
    let mut buf2 = BufferWriter { buf: undefined, pos: 0 };
    let bw2: *mut opaque Writer = &mut buf2;
    let mut cw = CountingWriter { inner: bw2, count: 0 };
    let w2: *mut opaque Writer = &mut cw;

    emit(w2, "abc");
    if cw.count != 3 {
        return 7;
    }
    assert cw.count == 3;
    // Underlying buffer also received the bytes.
    if buf2.pos != 3 {
        return 8;
    }
    assert buf2.pos == 3;

    emit(w2, "defgh");
    if cw.count != 8 {
        return 9;
    }
    if buf2.pos != 8 {
        return 10;
    }
    assert cw.count == 8;
    assert buf2.pos == 8;

    // Check buf2 contents were forwarded correctly.
    if buf2.buf[0] != 'a' as u8 {
        return 11;
    }
    if buf2.buf[3] != 'd' as u8 {
        return 12;
    }
    if buf2.buf[7] != 'h' as u8 {
        return 13;
    }
    assert buf2.buf[0] == 'a' as u8;
    assert buf2.buf[3] == 'd' as u8;
    assert buf2.buf[7] == 'h' as u8;
    return 0;
}

lib/std/arch/rv64/tests/type.unify.rad +8 -8

fn testSizePromotion() -> bool {
    let small: i8 = 5;
    let large: i32 = 100;
    let result: i32 = small as i32 + large;

    let small_u: u8 = 10;
    let large_u: u32 = 200;
    let result2: u32 = small_u as u32 + large_u;
    let smallU: u8 = 10;
    let largeU: u32 = 200;
    let result2: u32 = smallU as u32 + largeU;

    return true;
}

/// Verifies basic optional assignments between values of the same optional type.


/// Verifies coercion from pointer values to optional pointer values.
fn testPointerToOptional() -> bool {
    let value: i32 = 42;
    let ptr: *i32 = &value;
    let opt_ptr: ?*i32 = ptr;
    let optPtr: ?*i32 = ptr;

    return true;
}

/// Verifies creation of slices for different, but internally consistent, element types.
fn testSliceElementUnification() -> bool {
    let arr_small: [i8; 3] = [1, 2, 3];
    let slice_small: *[i8] = &arr_small[..];
    let arrSmall: [i8; 3] = [1, 2, 3];
    let sliceSmall: *[i8] = &arrSmall[..];

    let arr_large: [i32; 3] = [10, 20, 30];
    let slice_large: *[i32] = &arr_large[..];
    let arrLarge: [i32; 3] = [10, 20, 30];
    let sliceLarge: *[i32] = &arrLarge[..];

    return true;
}

/// Verifies optional assignments involving `nil` and concrete values.

lib/std/arch/rv64/tests/undefined.rad +7 -21

8	8		ary[1] = 2;
9	9		ary[2] = 3;
10	10		ary[3] = 4;
11	11		ary[4] = 5;
12	12
13		-	if x != 8 {
14		-	return 1;
15		-	}
16		-	if y != 9 {
17		-	return 2;
18		-	}
19		-	if ary[0] != 1 {
20		-	return 3;
21		-	}
22		-	if ary[1] != 2 {
23		-	return 4;
24		-	}
25		-	if ary[2] != 3 {
26		-	return 5;
27		-	}
28		-	if ary[3] != 4 {
29		-	return 6;
30		-	}
31		-	if ary[4] != 5 {
32		-	return 7;
33		-	}
	13	+	assert x == 8;
	14	+	assert y == 9;
	15	+	assert ary[0] == 1;
	16	+	assert ary[1] == 2;
	17	+	assert ary[2] == 3;
	18	+	assert ary[3] == 4;
	19	+	assert ary[4] == 5;
34	20		return 0;
35	21		}

lib/std/arch/rv64/tests/union-tag.rad +7 -21

    return *p;
}

@default fn main() -> i32 {
    let v0 = BigUnion::V0;
    if tag(&v0) != 0 {
        return 1;
    }
    assert tag(&v0) == 0;
    let v7 = BigUnion::V7;
    if tag(&v7) != 7 {
        return 2;
    }
    assert tag(&v7) == 7;
    let v13 = BigUnion::V13;
    if tag(&v13) != 13 {
        return 3;
    }
    assert tag(&v13) == 13;
    let v14 = BigUnion::V14 { a: 1, b: 2 };
    if tag(&v14) != 14 {
        return 4;
    }
    assert tag(&v14) == 14;
    let v15 = BigUnion::V15 { x: 3, y: true };
    if tag(&v15) != 15 {
        return 5;
    }
    assert tag(&v15) == 15;
    let v16 = BigUnion::V16 { p: 4, q: false };
    if tag(&v16) != 16 {
        return 6;
    }
    assert tag(&v16) == 16;
    let v20 = BigUnion::V20;
    if tag(&v20) != 20 {
        return 7;
    }
    assert tag(&v20) == 20;
    return 0;
}

lib/std/arch/rv64/tests/union.discriminant.cast.rad +4 -12

10	10		@default fn main() -> i32 {
11	11		let a: i32 = U::A as i32;
12	12		let b: i32 = U::B as i32;
13	13		let c: i32 = U::C as i32;
14	14
15		-	if a != 7 {
16		-	return 1;
17		-	}
18		-	if b != 42 {
19		-	return 2;
20		-	}
21		-	if c != 255 {
22		-	return 3;
23		-	}
24		-	if (U::A as i32) + (U::B as i32) != 49 {
25		-	return 4;
26		-	}
	15	+	assert a == 7;
	16	+	assert b == 42;
	17	+	assert c == 255;
	18	+	assert (U::A as i32) + (U::B as i32) == 49;
27	19		return 0;
28	20		}

lib/std/arch/rv64/tests/union.edge.case.3.rad +1 -3

@default fn main() -> u32 {
    let mut parser = Parser { root: undefined };

    match *nodeBool(&mut parser, true) {
        case Node::Bool(v) => {
            if v != true {
                return 1;
            }
            assert v == true;
            return 0;
        }
        else => {
            return 2;
        }

lib/std/arch/rv64/tests/union.mixed.assign.rad +3 -9

    let mut holder = Holder { value: Mixed::Final };

    storePayload(&mut holder, 42);
    let case Mixed::Payload(v) = holder.value
        else return 1;
    if v != 42 {
        return 2;
    }
    assert v == 42;

    if checkIfLet(Mixed::Standalone) != 0 {
        return 3;
    }
    assert checkIfLet(Mixed::Standalone) == 0;

    storeFinal(&mut holder);
    if checkIfLet(holder.value) != 0 {
        return 4;
    }
    assert checkIfLet(holder.value) == 0;

    if let case Mixed::Payload(_) = Mixed::Standalone {
        return 5;
    }


lib/std/arch/rv64/tests/union.payload.mutref.rad +6 -18

        padding2: 0,
        state: Sealed::No { items: U32List { data: &mut buf[0..8], len: 0 } },
    };

    // Add first item.
    if not addItemViaMatchRef(&mut blk, 10) {
        return 1;
    }
    assert addItemViaMatchRef(&mut blk, 10);

    // Verify length was updated.
    let case Sealed::No { items } = blk.state else {
        return 2;
    };
    if items.len != 1 {
        return 3;
    }
    assert items.len == 1;

    // Add second item.
    if not addItemViaMatchRef(&mut blk, 20) {
        return 4;
    }
    assert addItemViaMatchRef(&mut blk, 20);

    // Verify length is 2.
    let case Sealed::No { items: items2 } = blk.state else {
        return 5;
    };
    if items2.len != 2 {
        return 6;
    }
    assert items2.len == 2;

    // Verify values.
    if items2.data[0] != 10 {
        return 7;
    }
    if items2.data[1] != 20 {
        return 8;
    }
    assert items2.data[0] == 10;
    assert items2.data[1] == 20;
    return 0;
}

lib/std/arch/rv64/tests/union.payload.rad +1 -3

        else => { return 1; }
    }
    // Test match `Some`.
    match some {
        case Option::Some(x) => {
            if x != 42 {
                return 2;
            }
            assert x == 42;
        }
        else => { return 3; }
    }
    // Test `None` doesn't match `Some`.
    match none {

lib/std/arch/rv64/tests/union.record.forward.rad +1 -3

    return result;
}

@default fn main() -> i32 {
    let value = blowUp();
    if value != 29 {
        return 1;
    }
    assert value == 29;
    return 0;
}

lib/std/arch/rv64/tests/union.void.match.rad +3 -9

        case Color::Blue => return 30,
    }
}

@default fn main() -> i32 {
    if getColorValue(Color::Red) != 10 {
        return 1;
    }
    if getColorValue(Color::Green) != 20 {
        return 2;
    }
    if getColorValue(Color::Blue) != 30 {
        return 3;
    }
    assert getColorValue(Color::Red) == 10;
    assert getColorValue(Color::Green) == 20;
    assert getColorValue(Color::Blue) == 30;
    return 0;
}

65	65		}
66	66
67	67		/// Test 1-byte record.
68	68		fn testByte() -> i32 {
69	69		let b = makeByte(42);
70		-	if b.x != 42 {
71		-	return 1;
72		-	}
	70	+	assert b.x == 42;
73	71		return 0;
74	72		}
75	73
76	74		/// Test 2-byte record.
77	75		fn testShort() -> i32 {
78	76		let s = makeShort(1234);
79		-	if s.x != 1234 {
80		-	return 1;
81		-	}
	77	+	assert s.x == 1234;
82	78		return 0;
83	79		}
84	80
85	81		/// Test 4-byte record.
86	82		fn testWord() -> i32 {
87	83		let w = makeWord(0xDEAD);
88		-	if w.x != 0xDEAD {
89		-	return 1;
90		-	}
	84	+	assert w.x == 0xDEAD;
91	85		return 0;
92	86		}
93	87
94	88		/// Test 8-byte record (boundary case, should be by value).
95	89		fn testPair() -> i32 {
96	90		let p = makePair(10, 20);
97		-	if p.a != 10 {
98		-	return 1;
99		-	}
100		-	if p.b != 20 {
101		-	return 2;
102		-	}
	91	+	assert p.a == 10;
	92	+	assert p.b == 20;
103	93		return 0;
104	94		}
105	95
106	96		/// Test 12-byte record (should be by reference).
107	97		fn testTriple() -> i32 {
108	98		let t = makeTriple(100, 200, 300);
109		-	if t.x != 100 {
110		-	return 1;
111		-	}
112		-	if t.y != 200 {
113		-	return 2;
114		-	}
115		-	if t.z != 300 {
116		-	return 3;
117		-	}
	99	+	assert t.x == 100;
	100	+	assert t.y == 200;
	101	+	assert t.z == 300;
118	102		return 0;
119	103		}
120	104
121	105		/// Test passing small aggregate as parameter and returning it.
122	106		fn testIdentity() -> i32 {
123	107		let p = makePair(5, 6);
124	108		let q = identity(p);
125		-	if q.a != 5 {
126		-	return 1;
127		-	}
128		-	if q.b != 6 {
129		-	return 2;
130		-	}
	109	+	assert q.a == 5;
	110	+	assert q.b == 6;
131	111		return 0;
132	112		}
133	113
134	114		/// Test multiple small aggregate args.
135	115		fn testAddPairs() -> i32 {
136	116		let a = makePair(1, 2);
137	117		let b = makePair(3, 4);
138	118		let c = addPairs(a, b);
139		-	if c.a != 4 {
140		-	return 1;
141		-	}
142		-	if c.b != 6 {
143		-	return 2;
144		-	}
	119	+	assert c.a == 4;
	120	+	assert c.b == 6;
145	121		return 0;
146	122		}
147	123
148	124		/// Test chained calls.
149	125		fn testDoublePair() -> i32 {
150	126		let p = makePair(10, 20);
151	127		let d = doublePair(p);
152		-	if d.a != 20 {
153		-	return 1;
154		-	}
155		-	if d.b != 40 {
156		-	return 2;
157		-	}
	128	+	assert d.a == 20;
	129	+	assert d.b == 40;
158	130		return 0;
159	131		}
160	132
161	133		/// Test multiple returns don't interfere.
162	134		fn testMultipleReturns() -> i32 {
163	135		let p1 = makePair(1, 2);
164	136		let p2 = makePair(3, 4);
165		-	if p1.a != 1 {
166		-	return 1;
167		-	}
168		-	if p1.b != 2 {
169		-	return 2;
170		-	}
171		-	if p2.a != 3 {
172		-	return 3;
173		-	}
174		-	if p2.b != 4 {
175		-	return 4;
176		-	}
	137	+	assert p1.a == 1;
	138	+	assert p1.b == 2;
	139	+	assert p2.a == 3;
	140	+	assert p2.b == 4;
177	141		return 0;
178	142		}
179	143
180	144		@default fn main() -> i32 {
181	145		let r1 = testByte();

35	35		fn testReturnDoesNotCorruptLocals() -> i32 {
36	36		let sentinel: u32 = 0xDEAD;
37	37		let p: Pair = makePair(10, 20);
38	38		let sentinel2: u32 = 0xBEEF;
39	39
40		-	if p.a != 10 {
41		-	return 1;
42		-	}
43		-	if p.b != 20 {
44		-	return 2;
45		-	}
46		-	if sentinel != 0xDEAD {
47		-	return 3;
48		-	}
49		-	if sentinel2 != 0xBEEF {
50		-	return 4;
51		-	}
	40	+	assert p.a == 10;
	41	+	assert p.b == 20;
	42	+	assert sentinel == 0xDEAD;
	43	+	assert sentinel2 == 0xBEEF;
52	44		return 0;
53	45		}
54	46
55	47		/// Two consecutive aggregate returns must not interfere.
56	48		fn testMultipleReturns() -> i32 {
57	49		let p1: Pair = makePair(1, 2);
58	50		let p2: Pair = makePair(3, 4);
59	51
60		-	if p1.a != 1 {
61		-	return 1;
62		-	}
63		-	if p1.b != 2 {
64		-	return 2;
65		-	}
66		-	if p2.a != 3 {
67		-	return 3;
68		-	}
69		-	if p2.b != 4 {
70		-	return 4;
71		-	}
	52	+	assert p1.a == 1;
	53	+	assert p1.b == 2;
	54	+	assert p2.a == 3;
	55	+	assert p2.b == 4;
72	56		return 0;
73	57		}
74	58
75	59		/// Mutating a returned aggregate must not corrupt the stack.
76	60		fn testMutateReturnedAggregate() -> i32 {

79	63		let after: u32 = 99;
80	64
81	65		p.a = 100;
82	66		p.b = 200;
83	67
84		-	if before != 42 {
85		-	return 1;
86		-	}
87		-	if after != 99 {
88		-	return 2;
89		-	}
90		-	if p.a != 100 {
91		-	return 3;
92		-	}
93		-	if p.b != 200 {
94		-	return 4;
95		-	}
	68	+	assert before == 42;
	69	+	assert after == 99;
	70	+	assert p.a == 100;
	71	+	assert p.b == 200;
96	72		return 0;
97	73		}
98	74
99	75		/// Aggregate return inside a loop must not corrupt accumulator state.
100	76		fn testAggregateReturnInLoop() -> i32 {

104	80		let p: Pair = makePair(idx, idx + 10);
105	81		total += p.a + p.b;
106	82		idx += 1;
107	83		}
108	84		// total = sum(i + i+10 for i in 0..5) = sum(2i+10) = 2*(0+1+2+3+4) + 50 = 20 + 50 = 70
109		-	if total != 70 {
110		-	return 1;
111		-	}
	85	+	assert total == 70;
112	86		return 0;
113	87		}
114	88
115	89		/// Throwing function returning aggregate (result buffer) must not corrupt stack.
116	90		fn testThrowingAggregateReturn() -> i32 {
117	91		let sentinel: u32 = 0xCAFE;
118	92		let p: Pair = try! makePairOrFail(10, 20, false);
119	93		let sentinel2: u32 = 0xFACE;
120	94
121		-	if p.a != 10 {
122		-	return 1;
123		-	}
124		-	if p.b != 20 {
125		-	return 2;
126		-	}
127		-	if sentinel != 0xCAFE {
128		-	return 3;
129		-	}
130		-	if sentinel2 != 0xFACE {
131		-	return 4;
132		-	}
	95	+	assert p.a == 10;
	96	+	assert p.b == 20;
	97	+	assert sentinel == 0xCAFE;
	98	+	assert sentinel2 == 0xFACE;
133	99		return 0;
134	100		}
135	101
136	102		/// Catching a thrown error from aggregate-returning function.
137	103		fn testThrowingAggregateCatch() -> i32 {
138	104		let sentinel: u32 = 0xBEEF;
139	105		try makePairOrFail(10, 20, true) catch {};
140		-	if sentinel != 0xBEEF {
141		-	return 1;
142		-	}
	106	+	assert sentinel == 0xBEEF;
143	107		return 0;
144	108		}
145	109
146	110		/// Triple (12 bytes) aggregate return.
147	111		fn testTripleReturn() -> i32 {
148	112		let t: Triple = makeTriple(100, 200, 300);
149		-	if t.x != 100 {
150		-	return 1;
151		-	}
152		-	if t.y != 200 {
153		-	return 2;
154		-	}
155		-	if t.z != 300 {
156		-	return 3;
157		-	}
	113	+	assert t.x == 100;
	114	+	assert t.y == 200;
	115	+	assert t.z == 300;
158	116		return 0;
159	117		}
160	118
161	119		/// Multiple aggregate calls interleaved with scalar work.
162	120		fn testInterleavedCalls() -> i32 {
163	121		let p1: Pair = makePair(5, 6);
164	122		let scalar: u32 = p1.a + p1.b;
165	123		let t: Triple = makeTriple(scalar, scalar + 1, scalar + 2);
166	124		let p2: Pair = makePair(t.x, t.z);
167	125
168		-	if scalar != 11 {
169		-	return 1;
170		-	}
171		-	if t.x != 11 {
172		-	return 2;
173		-	}
174		-	if t.y != 12 {
175		-	return 3;
176		-	}
177		-	if t.z != 13 {
178		-	return 4;
179		-	}
180		-	if p2.a != 11 {
181		-	return 5;
182		-	}
183		-	if p2.b != 13 {
184		-	return 6;
185		-	}
	126	+	assert scalar == 11;
	127	+	assert t.x == 11;
	128	+	assert t.y == 12;
	129	+	assert t.z == 13;
	130	+	assert p2.a == 11;
	131	+	assert p2.b == 13;
186	132		return 0;
187	133		}
188	134
189	135		@default fn main() -> i32 {
190	136		let r1: i32 = testReturnDoesNotCorruptLocals();

162	162		}
163	163		return true;
164	164		}
165	165
166	166		@default fn main() -> i32 {
167		-	if not testI8Overflow() {
168		-	return 1;
169		-	}
170		-	if not testU8Overflow() {
171		-	return 2;
172		-	}
173		-	if not testI8Subtraction() {
174		-	return 3;
175		-	}
176		-	if not testU8Subtraction() {
177		-	return 4;
178		-	}
179		-	if not testI16Overflow() {
180		-	return 5;
181		-	}
182		-	if not testU16Overflow() {
183		-	return 6;
184		-	}
185		-	if not testI8Multiply() {
186		-	return 7;
187		-	}
188		-	if not testU8Multiply() {
189		-	return 8;
190		-	}
191		-	if not testI8Comparison() {
192		-	return 9;
193		-	}
194		-	if not testU8Comparison() {
195		-	return 10;
196		-	}
197		-	if not testNarrowingCast() {
198		-	return 11;
199		-	}
200		-	if not testW32ShiftRight() {
201		-	return 12;
202		-	}
203		-	if not testI8NegOverflow() {
204		-	return 13;
205		-	}
206		-	if not testU8BitNot() {
207		-	return 14;
208		-	}
209		-	if not testW32ShiftLargeImmediate() {
210		-	return 15;
211		-	}
	167	+	assert testI8Overflow();
	168	+	assert testU8Overflow();
	169	+	assert testI8Subtraction();
	170	+	assert testU8Subtraction();
	171	+	assert testI16Overflow();
	172	+	assert testU16Overflow();
	173	+	assert testI8Multiply();
	174	+	assert testU8Multiply();
	175	+	assert testI8Comparison();
	176	+	assert testU8Comparison();
	177	+	assert testNarrowingCast();
	178	+	assert testW32ShiftRight();
	179	+	assert testI8NegOverflow();
	180	+	assert testU8BitNot();
	181	+	assert testW32ShiftLargeImmediate();
212	182		return 0;
213	183		}

195	195		}
196	196		return true;
197	197		}
198	198
199	199		@default fn main() -> i32 {
200		-	if not testI64Add() {
201		-	return 1;
202		-	}
203		-	if not testU64Add() {
204		-	return 2;
205		-	}
206		-	if not testI64Sub() {
207		-	return 3;
208		-	}
209		-	if not testI64Mul() {
210		-	return 4;
211		-	}
212		-	if not testI64Div() {
213		-	return 5;
214		-	}
215		-	if not testU64Div() {
216		-	return 6;
217		-	}
218		-	if not testI64Neg() {
219		-	return 7;
220		-	}
221		-	if not testI64Shift() {
222		-	return 8;
223		-	}
224		-	if not testU64Shift() {
225		-	return 9;
226		-	}
227		-	if not testI64Bitwise() {
228		-	return 10;
229		-	}
230		-	if not testWidenI32ToI64() {
231		-	return 11;
232		-	}
233		-	if not testWidenU32ToU64() {
234		-	return 12;
235		-	}
236		-	if not testNarrowI64ToI32() {
237		-	return 13;
238		-	}
239		-	if not testNarrowU64ToU32() {
240		-	return 14;
241		-	}
242		-	if not testI64Compare() {
243		-	return 15;
244		-	}
245		-	if not testU64Compare() {
246		-	return 16;
247		-	}
248		-	if not testI64Modulo() {
249		-	return 17;
250		-	}
251		-	if not testU64Modulo() {
252		-	return 18;
253		-	}
	200	+	assert testI64Add();
	201	+	assert testU64Add();
	202	+	assert testI64Sub();
	203	+	assert testI64Mul();
	204	+	assert testI64Div();
	205	+	assert testU64Div();
	206	+	assert testI64Neg();
	207	+	assert testI64Shift();
	208	+	assert testU64Shift();
	209	+	assert testI64Bitwise();
	210	+	assert testWidenI32ToI64();
	211	+	assert testWidenU32ToU64();
	212	+	assert testNarrowI64ToI32();
	213	+	assert testNarrowU64ToU32();
	214	+	assert testI64Compare();
	215	+	assert testU64Compare();
	216	+	assert testI64Modulo();
	217	+	assert testU64Modulo();
254	218		return 0;
255	219		}

15	15		sum += arr[1];
16	16		sum += arr[2];
17	17		sum += arr[3];
18	18		sum -= arr[4];
19	19
20		-	if sum != 50 {
21		-	return 1;
22		-	}
	20	+	assert sum == 50;
23	21		return 0;
24	22		}

6	6		let slice1: *[i32] = &arr[..];
7	7		let slice2: *[i32] = &arr[1..4];
8	8		let slice3: *[i32] = &arr[..3];
9	9		let slice4: *[i32] = &arr[2..];
10	10
11		-	if slice1.len != 5 {
12		-	return 1;
13		-	}
14		-	if slice2.len != 3 {
15		-	return 2;
16		-	}
17		-	if slice3.len != 3 {
18		-	return 3;
19		-	}
20		-	if slice4.len != 3 {
21		-	return 4;
22		-	}
	11	+	assert slice1.len == 5;
	12	+	assert slice2.len == 3;
	13	+	assert slice3.len == 3;
	14	+	assert slice4.len == 3;
23	15
24	16		let slice5: *[i32] = slice3;
25	17
26		-	if slice5.len != 3 {
27		-	return 5;
28		-	}
29		-	if slice5.ptr != slice3.ptr {
30		-	return 6;
31		-	}
	18	+	assert slice5.len == 3;
	19	+	assert slice5.ptr == slice3.ptr;
32	20
33	21		let sum1: i32 = slice1[0] + slice1[4]; // 6
34	22		let sum2: i32 = slice2[0] + slice2[1]; // 5
35	23		let sum3: i32 = slice3[0] + slice3[2]; // 4
36	24		let sum4: i32 = slice4[0] + slice4[2]; // 8
37	25
38	26		let total: i32 = sum1 + sum2 + sum3 + sum4;
39		-	if total != 23 {
40		-	return 7;
41		-	}
	27	+	assert total == 23;
42	28
43	29		return 0;
44	30		}

45	45		};
46	46		return c1 != c2;
47	47		}
48	48
49	49		@default fn main() -> i32 {
50		-	if not testNestedEqual() {
51		-	return 1;
52		-	}
53		-	if not testNestedNotEqualCenter() {
54		-	return 2;
55		-	}
56		-	if not testNestedNotEqualRadius() {
57		-	return 3;
58		-	}
	50	+	assert testNestedEqual();
	51	+	assert testNestedNotEqualCenter();
	52	+	assert testNestedNotEqualRadius();
59	53		return 0;
60	54		}

43	43
44	44		return r1 != r2;
45	45		}
46	46
47	47		@default fn main() -> i32 {
48		-	if not testPointEqual() {
49		-	return 1;
50		-	}
51		-	if not testPointNotEqualX() {
52		-	return 2;
53		-	}
54		-	if not testPointNotEqualY() {
55		-	return 3;
56		-	}
57		-	if not testRectEqual() {
58		-	return 4;
59		-	}
60		-	if not testRectNotEqual() {
61		-	return 5;
62		-	}
	48	+	assert testPointEqual();
	49	+	assert testPointNotEqualX();
	50	+	assert testPointNotEqualY();
	51	+	assert testRectEqual();
	52	+	assert testRectNotEqual();
63	53		return 0;
64	54		}

65	65
66	66		return not lineEqual(line1, line2);
67	67		}
68	68
69	69		@default fn main() -> i32 {
70		-	if not testSliceStructEqual() {
71		-	return 1;
72		-	}
73		-	if not testSliceStructNotEqualContent() {
74		-	return 2;
75		-	}
76		-	if not testSliceStructNotEqualLength() {
77		-	return 3;
78		-	}
79		-	if not testStructWithSliceFieldEqual() {
80		-	return 4;
81		-	}
82		-	if not testStructWithSliceFieldNotEqual() {
83		-	return 5;
84		-	}
	70	+	assert testSliceStructEqual();
	71	+	assert testSliceStructNotEqualContent();
	72	+	assert testSliceStructNotEqualLength();
	73	+	assert testStructWithSliceFieldEqual();
	74	+	assert testStructWithSliceFieldNotEqual();
85	75		return 0;
86	76		}

94	94
95	95		return not shapeEqual(s1, s2);
96	96		}
97	97
98	98		@default fn main() -> i32 {
99		-	if not testEnumSliceEqual() {
100		-	return 1;
101		-	}
102		-	if not testEnumSliceNotEqual() {
103		-	return 2;
104		-	}
105		-	if not testEnumSizesSliceEqual() {
106		-	return 3;
107		-	}
108		-	if not testEnumDifferentVariants() {
109		-	return 4;
110		-	}
	99	+	assert testEnumSliceEqual();
	100	+	assert testEnumSliceNotEqual();
	101	+	assert testEnumSizesSliceEqual();
	102	+	assert testEnumDifferentVariants();
111	103		return 0;
112	104		}

22	22		let a: Op = Op::Add;
23	23		let s: Op = Op::Sub;
24	24		let m: Op = Op::Mul;
25	25
26	26		// isAdd tests
27		-	if not isAdd(a) {
28		-	return 1;
29		-	}
	27	+	assert isAdd(a);
30	28		if isAdd(s) {
31	29		return 2;
32	30		}
33	31		if isAdd(m) {
34	32		return 3;
35	33		}
36	34		// isSub tests
37		-	if not isSub(s) {
38		-	return 4;
39		-	}
	35	+	assert isSub(s);
40	36		if isSub(a) {
41	37		return 5;
42	38		}
43	39		// isMul tests
44		-	if not isMul(m) {
45		-	return 6;
46		-	}
	40	+	assert isMul(m);
47	41		if isMul(a) {
48	42		return 7;
49	43		}
50	44		return 0;
51	45		}

46	46
47	47		return a != b;
48	48		}
49	49
50	50		@default fn main() -> i32 {
51		-	if not testSameVariantNoPayload() {
52		-	return 1;
53		-	}
54		-	if not testDifferentVariants() {
55		-	return 2;
56		-	}
57		-	if not testSameVariantSamePayload() {
58		-	return 3;
59		-	}
60		-	if not testSameVariantDifferentPayload() {
61		-	return 4;
62		-	}
63		-	if not testBoolPayloadSame() {
64		-	return 5;
65		-	}
66		-	if not testBoolPayloadDifferent() {
67		-	return 6;
68		-	}
	51	+	assert testSameVariantNoPayload();
	52	+	assert testDifferentVariants();
	53	+	assert testSameVariantSamePayload();
	54	+	assert testSameVariantDifferentPayload();
	55	+	assert testBoolPayloadSame();
	56	+	assert testBoolPayloadDifferent();
69	57		return 0;
70	58		}

14	14		circle(u32),
15	15		point(Point),
16	16		rect(Size),
17	17		}
18	18
19		-	fn test_same_variant_primitive() -> bool {
	19	+	fn testSameVariantPrimitive() -> bool {
20	20		let s1: Shape = Shape::circle(10);
21	21		let s2: Shape = Shape::circle(10);
22	22		return s1 == s2;
23	23		}
24	24
25		-	fn test_different_variant() -> bool {
	25	+	fn testDifferentVariant() -> bool {
26	26		let s1: Shape = Shape::circle(10);
27	27		let s2: Shape = Shape::point(Point { x: 5, y: 5 });
28	28		return s1 != s2;
29	29		}
30	30
31		-	fn test_same_variant_struct_equal() -> bool {
	31	+	fn testSameVariantStructEqual() -> bool {
32	32		let s1: Shape = Shape::point(Point { x: 10, y: 20 });
33	33		let s2: Shape = Shape::point(Point { x: 10, y: 20 });
34	34		return s1 == s2;
35	35		}
36	36
37		-	fn test_same_variant_struct_not_equal() -> bool {
	37	+	fn testSameVariantStructNotEqual() -> bool {
38	38		let s1: Shape = Shape::point(Point { x: 10, y: 20 });
39	39		let s2: Shape = Shape::point(Point { x: 10, y: 25 });
40	40		return s1 != s2;
41	41		}
42	42
43		-	fn test_rect_variant_equal() -> bool {
	43	+	fn testRectVariantEqual() -> bool {
44	44		let s1: Shape = Shape::rect(Size { width: 100, height: 50 });
45	45		let s2: Shape = Shape::rect(Size { width: 100, height: 50 });
46	46		return s1 == s2;
47	47		}
48	48
49		-	fn test_rect_variant_not_equal() -> bool {
	49	+	fn testRectVariantNotEqual() -> bool {
50	50		let s1: Shape = Shape::rect(Size { width: 100, height: 50 });
51	51		let s2: Shape = Shape::rect(Size { width: 100, height: 60 });
52	52		return s1 != s2;
53	53		}
54	54
55	55		@default fn main() -> i32 {
56		-	if not test_same_variant_primitive() {
57		-	return 1;
58		-	}
59		-	if not test_different_variant() {
60		-	return 2;
61		-	}
62		-	if not test_same_variant_struct_equal() {
63		-	return 3;
64		-	}
65		-	if not test_same_variant_struct_not_equal() {
66		-	return 4;
67		-	}
68		-	if not test_rect_variant_equal() {
69		-	return 5;
70		-	}
71		-	if not test_rect_variant_not_equal() {
72		-	return 6;
73		-	}
	56	+	assert testSameVariantPrimitive();
	57	+	assert testDifferentVariant();
	58	+	assert testSameVariantStructEqual();
	59	+	assert testSameVariantStructNotEqual();
	60	+	assert testRectVariantEqual();
	61	+	assert testRectVariantNotEqual();
74	62		return 0;
75	63		}

8	8		@default fn main() -> i32 {
9	9		let r1: Color = Color::red;
10	10		let r2: Color = Color::red;
11	11		let g: Color = Color::green;
12	12
13		-	if r1 != r2 {
14		-	return 1;
15		-	}
16		-	if r1 == g {
17		-	return 2;
18		-	}
	13	+	assert r1 == r2;
	14	+	assert r1 != g;
19	15		return 0;
20	16		}

6	6
7	7		@default fn main() -> i32 {
8	8		// Test 'and' short-circuits when first operand is false.
9	9		let mut x1: i32 = 0;
10	10		let r1: bool = modify(&mut x1, false) and modify(&mut x1, true);
11		-	if r1 {
12		-	return 1;
13		-	}
14		-	if x1 != 1 {
15		-	return 2;
16		-	}
	11	+	assert not r1;
	12	+	assert x1 == 1;
17	13
18	14		// Test 'and' does not short-circuit when first operand is true.
19	15		let mut x2: i32 = 0;
20	16		let r2: bool = modify(&mut x2, true) and modify(&mut x2, true);
21		-	if not r2 {
22		-	return 3;
23		-	}
24		-	if x2 != 2 {
25		-	return 4;
26		-	}
	17	+	assert r2;
	18	+	assert x2 == 2;
27	19
28	20		// Test 'and' evaluates both when first is true, second is false.
29	21		let mut x3: i32 = 0;
30	22		let r3: bool = modify(&mut x3, true) and modify(&mut x3, false);
31		-	if r3 {
32		-	return 5;
33		-	}
34		-	if x3 != 2 {
35		-	return 6;
36		-	}
	23	+	assert not r3;
	24	+	assert x3 == 2;
37	25
38	26		// Test 'or' short-circuits when first operand is true.
39	27		let mut x4: i32 = 0;
40	28		let r4: bool = modify(&mut x4, true) or modify(&mut x4, true);
41		-	if x4 != 1 {
42		-	return 7;
43		-	}
44		-	if not r4 {
45		-	return 8;
46		-	}
	29	+	assert x4 == 1;
	30	+	assert r4;
47	31
48	32		// Test 'or' does not short-circuit when first operand is false.
49	33		let mut x5: i32 = 0;
50	34		let r5: bool = modify(&mut x5, false) or modify(&mut x5, true);
51		-	if x5 != 2 {
52		-	return 9;
53		-	}
54		-	if not r5 {
55		-	return 10;
56		-	}
	35	+	assert x5 == 2;
	36	+	assert r5;
57	37
58	38		let mut y5: i32 = 0;
59	39		let t5: bool = modify(&mut y5, false) or modify(&mut y5, false);
60		-	if y5 != 2 {
61		-	return 11;
62		-	}
63		-	if t5 {
64		-	return 12;
65		-	}
	40	+	assert y5 == 2;
	41	+	assert not t5;
66	42
67	43		// Test complex short-circuiting with nested expressions.
68	44		let mut a6: i32 = 0;
69	45		let r6: bool =
70	46		modify(&mut a6, false) and
71	47		(modify(&mut a6, true) or modify(&mut a6, false));
72		-	if r6 {
73		-	return 13;
74		-	}
75		-	if a6 != 1 {
76		-	return 14;
77		-	}
	48	+	assert not r6;
	49	+	assert a6 == 1;
78	50
79	51		let mut b6: i32 = 0;
80	52		let t6: bool = modify(&mut b6, true) and
81	53		(modify(&mut b6, false) or modify(&mut b6, false));
82		-	if t6 {
83		-	return 15;
84		-	}
85		-	if b6 != 3 {
86		-	return 16;
87		-	}
	54	+	assert not t6;
	55	+	assert b6 == 3;
88	56
89	57		// Test nested or short-circuit.
90	58		let mut a7: i32 = 0;
91	59		let r7: bool = modify(&mut a7, false) or
92	60		(modify(&mut a7, true) and modify(&mut a7, true));
93		-	if not r7 {
94		-	return 17;
95		-	}
96		-	if a7 != 3 {
97		-	return 18;
98		-	}
	61	+	assert r7;
	62	+	assert a7 == 3;
99	63
100	64		// Test chained 'and' short-circuit.
101	65		let mut a8: i32 = 0;
102	66		let mut r8: bool =
103	67		modify(&mut a8, true) and
104	68		modify(&mut a8, false) and
105	69		modify(&mut a8, false);
106		-	if r8 {
107		-	return 19;
108		-	}
109		-	if a8 != 2 {
110		-	return 20;
111		-	}
	70	+	assert not r8;
	71	+	assert a8 == 2;
112	72
113	73		// Test chained 'or' short-circuit.
114	74		let mut a9: i32 = 0;
115	75		let mut r9: bool =
116	76		modify(&mut a9, false) or
117	77		modify(&mut a9, true) or
118	78		modify(&mut a9, false);
119		-	if not r9 {
120		-	return 21;
121		-	}
122		-	if a9 != 2 {
123		-	return 22;
124		-	}
	79	+	assert r9;
	80	+	assert a9 == 2;
125	81
126	82		return 0;
127	83		}

4	4		let t: bool = true;
5	5		let f: bool = false;
6	6
7	7		// Assign `and` results to variables.
8	8		let a: bool = t and t;
9		-	if not a {
10		-	return 1;
11		-	}
	9	+	assert a;
12	10
13	11		let b: bool = t and f;
14		-	if b {
15		-	return 2;
16		-	}
	12	+	assert not b;
17	13
18	14		let c: bool = f and t;
19		-	if c {
20		-	return 3;
21		-	}
	15	+	assert not c;
22	16
23	17		let d: bool = f and f;
24		-	if d {
25		-	return 4;
26		-	}
	18	+	assert not d;
27	19
28	20		// Assign `or` results to variables.
29	21		let e: bool = t or f;
30		-	if not e {
31		-	return 5;
32		-	}
	22	+	assert e;
33	23
34	24		let g: bool = f or t;
35		-	if not g {
36		-	return 6;
37		-	}
	25	+	assert g;
38	26
39	27		let h: bool = t or t;
40		-	if not h {
41		-	return 7;
42		-	}
	28	+	assert h;
43	29
44	30		let i: bool = f or f;
45		-	if i {
46		-	return 8;
47		-	}
	31	+	assert not i;
48	32
49	33		// Nested expressions.
50	34		let j: bool = (t and t) or f;
51		-	if not j {
52		-	return 9;
53		-	}
	35	+	assert j;
54	36
55	37		let k: bool = f or (t and t);
56		-	if not k {
57		-	return 10;
58		-	}
	38	+	assert k;
59	39
60	40		let l: bool = (t or f) and (f or t);
61		-	if not l {
62		-	return 11;
63		-	}
	41	+	assert l;
64	42		return 0;
65	43		}

5	5		}
6	6
7	7		@default fn main() -> i32 {
8	8		let mut x: i32 = 0;
9	9		let r: bool = modify(&mut x, false);
10		-	if x != 1 {
11		-	return 1;
12		-	}
13		-	if r {
14		-	return 2;
15		-	}
	10	+	assert x == 1;
	11	+	assert not r;
16	12
17	13		// Pointer live across call.
18	14		let mut y: i32 = 42;
19	15		let p: *mut i32 = &mut y;
20	16		let r2: bool = modify(p, true);
21		-	if *p != 43 {
22		-	return 3;
23		-	}
24		-	if not r2 {
25		-	return 4;
26		-	}
	17	+	assert *p == 43;
	18	+	assert r2;
27	19		return 0;
28	20		}

1	1		@default fn main() -> i32 {
2	2		// Test i8 -> u8 cast: -1 should become 255.
3	3		let x: i8 = -1;
4	4		let a: u8 = x as u8;
5		-	if a != 255 {
6		-	return 1;
7		-	}
	5	+	assert a == 255;
8	6
9	7		// Test u8 -> i8 cast: 255 should become -1.
10	8		let y: u8 = 255;
11	9		let b: i8 = y as i8;
12		-	if b != -1 {
13		-	return 2;
14		-	}
	10	+	assert b == -1;
15	11
16	12		// Test i8 -> u8 with boundary value: -128 should become 128.
17	13		let z: i8 = -128;
18	14		let c: u8 = z as u8;
19		-	if c != 128 {
20		-	return 3;
21		-	}
	15	+	assert c == 128;
22	16
23	17		// Test u8 -> i8 with boundary value: 128 should become -128.
24	18		let w: u8 = 128;
25	19		let d: i8 = w as i8;
26		-	if d != -128 {
27		-	return 4;
28		-	}
	20	+	assert d == -128;
29	21
30	22		// Test i16 -> u16 cast: -1 should become 65535.
31	23		let p: i16 = -1;
32	24		let q: u16 = p as u16;
33		-	if q != 65535 {
34		-	return 5;
35		-	}
	25	+	assert q == 65535;
36	26
37	27		// Test u16 -> i16 cast: 65535 should become -1.
38	28		let r: u16 = 65535;
39	29		let s: i16 = r as i16;
40		-	if s != -1 {
41		-	return 6;
42		-	}
	30	+	assert s == -1;
43	31
44	32		// Eq/Ne used as values must compare at the declared width.
45	33		let eqU8: bool = a == 255;
46		-	if not eqU8 {
47		-	return 7;
48		-	}
	34	+	assert eqU8;
49	35		let eqI8: bool = b == -1;
50		-	if not eqI8 {
51		-	return 8;
52		-	}
	36	+	assert eqI8;
53	37		let neU8: bool = a != 255;
54		-	if neU8 {
55		-	return 9;
56		-	}
	38	+	assert not neU8;
57	39		let neI8: bool = b != -1;
58		-	if neI8 {
59		-	return 10;
60		-	}
	40	+	assert not neI8;
61	41		return 0;
62	42		}

66	66
67	67		return y == -2147483648 and z == 2147483648;
68	68		}
69	69
70	70		@default fn main() -> i32 {
71		-	if not casting() {
72		-	return 1;
73		-	}
74		-	if not zeroExtension() {
75		-	return 2;
76		-	}
77		-	if not signedCasting() {
78		-	return 3;
79		-	}
80		-	if not unsignedToSigned() {
81		-	return 4;
82		-	}
83		-	if not signed16bitCasting() {
84		-	return 5;
85		-	}
86		-	if not maxU8Casting() {
87		-	return 6;
88		-	}
89		-	if not truncationTest() {
90		-	return 7;
91		-	}
92		-	if not sameSizeCasting() {
93		-	return 8;
94		-	}
	71	+	assert casting();
	72	+	assert zeroExtension();
	73	+	assert signedCasting();
	74	+	assert unsignedToSigned();
	75	+	assert signed16bitCasting();
	76	+	assert maxU8Casting();
	77	+	assert truncationTest();
	78	+	assert sameSizeCasting();
95	79		return 0;
96	80		}

1	1		//! Test character literals including escaped chars.
2	2		@default fn main() -> i32 {
3		-	if 'a' != 97 {
4		-	return 1;
5		-	}
6		-	if '\'' != 39 {
7		-	return 2;
8		-	}
9		-	if '\\' != 92 {
10		-	return 3;
11		-	}
	3	+	assert 'a' == 97;
	4	+	assert '\'' == 39;
	5	+	assert '\\' == 92;
12	6		return 0;
13	7		}

2	2		@default fn main() -> i32 {
3	3		let mut a: i32 = 10;
4	4
5	5		// Test +=
6	6		a += 5;
7		-	if a != 15 {
8		-	return 1;
9		-	}
	7	+	assert a == 15;
10	8
11	9		// Test -=
12	10		a -= 3;
13		-	if a != 12 {
14		-	return 2;
15		-	}
	11	+	assert a == 12;
16	12
17	13		// Test *=
18	14		a *= 2;
19		-	if a != 24 {
20		-	return 3;
21		-	}
	15	+	assert a == 24;
22	16
23	17		// Test /=
24	18		a /= 4;
25		-	if a != 6 {
26		-	return 4;
27		-	}
	19	+	assert a == 6;
28	20
29	21		// Test %=
30	22		a %= 4;
31		-	if a != 2 {
32		-	return 5;
33		-	}
	23	+	assert a == 2;
34	24
35	25		// Test &=
36	26		let mut b: i32 = 0xFF;
37	27		b &= 0x0F;
38		-	if b != 0x0F {
39		-	return 6;
40		-	}
	28	+	assert b == 0x0F;
41	29
42	30		// Test \|=
43	31		b \|= 0xF0;
44		-	if b != 0xFF {
45		-	return 7;
46		-	}
	32	+	assert b == 0xFF;
47	33
48	34		// Test ^=
49	35		b ^= 0x0F;
50		-	if b != 0xF0 {
51		-	return 8;
52		-	}
	36	+	assert b == 0xF0;
53	37
54	38		// Test <<=
55	39		let mut c: i32 = 1;
56	40		c <<= 4;
57		-	if c != 16 {
58		-	return 9;
59		-	}
	41	+	assert c == 16;
60	42
61	43		// Test >>=
62	44		c >>= 2;
63		-	if c != 4 {
64		-	return 10;
65		-	}
	45	+	assert c == 4;
66	46
67	47		// Test compound assignment with array subscript.
68	48		let mut arr: [i32; 3] = [10, 20, 30];
69	49		arr[1] += 5;
70		-	if arr[1] != 25 {
71		-	return 11;
72		-	}
	50	+	assert arr[1] == 25;
73	51
74	52		// Test compound assignment with pointer dereference.
75	53		let mut val: i32 = 100;
76	54		let p: *mut i32 = &mut val;
77	55		*p += 50;
78		-	if val != 150 {
79		-	return 12;
80		-	}
	56	+	assert val == 150;
81	57
82	58		// Test chained compound assignments.
83	59		let mut x: i32 = 1;
84	60		x += 2;
85	61		x *= 3;
86	62		x -= 1;
87		-	if x != 8 {
88		-	return 13;
89		-	}
	63	+	assert x == 8;
90	64
91	65		return 0;
92	66		}

15	15
16	16		/// Test tagged union conditional expression.
17	17		fn testUnion() -> i32 {
18	18		let v1 = pickVal(true, 7);
19	19		if let case Val::Reg(r) = v1 {
20		-	if r != 7 {
21		-	return 1;
22		-	}
	20	+	assert r == 7;
23	21		} else {
24	22		return 2;
25	23		}
26	24
27	25		let v2 = pickVal(false, 7);
28	26		if let case Val::Imm(i) = v2 {
29		-	if i != 99 {
30		-	return 3;
31		-	}
	27	+	assert i == 99;
32	28		} else {
33	29		return 4;
34	30		}
35	31		return 0;
36	32		}

15	15		}
16	16
17	17		/// Test basic scalar conditional expression.
18	18		fn testScalar() -> i32 {
19	19		let x: i32 = 10 if true else 20;
20		-	if x != 10 {
21		-	return 1;
22		-	}
	20	+	assert x == 10;
23	21		let y: i32 = 10 if false else 20;
24		-	if y != 20 {
25		-	return 2;
26		-	}
	22	+	assert y == 20;
27	23		return 0;
28	24		}
29	25
30	26		/// Test min-value pattern.
31	27		fn testMin() -> i32 {
32		-	if min(5, 3) != 3 {
33		-	return 10;
34		-	}
35		-	if min(3, 5) != 3 {
36		-	return 11;
37		-	}
38		-	if min(4, 4) != 4 {
39		-	return 12;
40		-	}
	28	+	assert min(5, 3) == 3;
	29	+	assert min(3, 5) == 3;
	30	+	assert min(4, 4) == 4;
41	31		return 0;
42	32		}
43	33
44	34		/// Test with function argument as condition.
45	35		fn testFnArg() -> i32 {
46		-	if pick(true, 42, 99) != 42 {
47		-	return 20;
48		-	}
49		-	if pick(false, 42, 99) != 99 {
50		-	return 21;
51		-	}
	36	+	assert pick(true, 42, 99) == 42;
	37	+	assert pick(false, 42, 99) == 99;
52	38		return 0;
53	39		}
54	40
55	41		/// Test with enum values.
56	42		fn testEnum() -> i32 {
57	43		let c1 = colorPick(true);
58		-	if c1 != Color::Red {
59		-	return 30;
60		-	}
	44	+	assert c1 == Color::Red;
61	45		let c2 = colorPick(false);
62		-	if c2 != Color::Blue {
63		-	return 31;
64		-	}
	46	+	assert c2 == Color::Blue;
65	47		return 0;
66	48		}
67	49
68	50		/// Test nested conditional expression (right-associative).
69	51		fn testNested() -> i32 {

71	53		let b: i32 = 1;
72	54		let c: i32 = 2;
73	55
74	56		// a if false else b if false else c => a if false else (b if false else c) => c
75	57		let result: i32 = a if false else b if false else c;
76		-	if result != 2 {
77		-	return 40;
78		-	}
	58	+	assert result == 2;
79	59
80	60		// a if true else b if false else c => a
81	61		let result2: i32 = a if true else b if false else c;
82		-	if result2 != 0 {
83		-	return 41;
84		-	}
	62	+	assert result2 == 0;
85	63		return 0;
86	64		}
87	65
88	66		@default fn main() -> i32 {
89	67		let r1 = testScalar();

5	5		let mut count: i32 = 0;
6	6
7	7		for i in start..end {
8	8		count += 1;
9	9		}
10		-	if count != 1 {
11		-	return 1;
12		-	}
	10	+	assert count == 1;
13	11
14	12		// Unsigned range above signed boundary.
15	13		let start2: u32 = 2147483648;
16	14		let end2: u32 = 2147483651;
17	15		let mut count2: i32 = 0;
18	16
19	17		for i in start2..end2 {
20	18		count2 += 1;
21	19		}
22		-	if count2 != 3 {
23		-	return 2;
24		-	}
	20	+	assert count2 == 3;
25	21
26	22		// Signed range still uses signed ordering.
27	23		let mut sum: i32 = 0;
28	24		for i in -2..2 {
29	25		sum += i;
30	26		}
31		-	if sum != -2 {
32		-	return 3;
33		-	}
	27	+	assert sum == -2;
34	28
35	29		return 0;
36	30		}

7	7		return 1;
8	8		}
9	9
10	10		// Basic `if` with `false`.
11	11		let f: bool = false;
12		-	if f {
13		-	return 2;
14		-	}
	12	+	assert not f;
15	13
16	14		// Boolean `not`.
17	15		if not f {
18	16		} else {
19	17		return 3;
20	18		}
21		-	if not t {
22		-	return 4;
23		-	}
	19	+	assert t;
24	20
25	21		// Comparison in condition.
26	22		let a: i32 = 5;
27	23		let b: i32 = 10;
28	24		if a < b {
29	25		// Ignore.
30	26		} else {
31	27		return 5;
32	28		}
33		-	if a > b {
34		-	return 6;
35		-	}
	29	+	assert a <= b;
36	30		if a == a {
37	31		// Ignore.
38	32		} else {
39	33		return 7;
40	34		}

44	38		return 8;
45	39		}
46	40
47	41		// Nested if.
48	42		if t {
49		-	if f {
50		-	return 9;
51		-	}
	43	+	assert not f;
52	44		}
53	45
54	46		// `if` in `else` branch.
55	47		if f {
56	48		return 10;

40	40		}
41	41		}
42	42		}
43	43
44	44		@default fn main() -> i32 {
45		-	if checkStmt(OptionNum::Some(5)) != 5 {
46		-	return 1;
47		-	}
48		-	if checkStmt(OptionNum::Some(2)) != -2 {
49		-	return 2;
50		-	}
51		-	if checkStmt(OptionNum::Other(7)) != 14 {
52		-	return 3;
53		-	}
54		-	if checkStmt(OptionNum::Other(3)) != 0 {
55		-	return 4;
56		-	}
57		-	if checkStmt(OptionNum::None) != 0 {
58		-	return 5;
59		-	}
60		-	if checkExpr(OptionNum::Some(5)) != 6 {
61		-	return 6;
62		-	}
63		-	if checkExpr(OptionNum::Some(9)) != 11 {
64		-	return 7;
65		-	}
66		-	if checkExpr(OptionNum::Other(7)) != 10 {
67		-	return 8;
68		-	}
69		-	if checkExpr(OptionNum::Other(3)) != 0 {
70		-	return 9;
71		-	}
72		-	if checkExpr(OptionNum::None) != 0 {
73		-	return 10;
74		-	}
	45	+	assert checkStmt(OptionNum::Some(5)) == 5;
	46	+	assert checkStmt(OptionNum::Some(2)) == -2;
	47	+	assert checkStmt(OptionNum::Other(7)) == 14;
	48	+	assert checkStmt(OptionNum::Other(3)) == 0;
	49	+	assert checkStmt(OptionNum::None) == 0;
	50	+	assert checkExpr(OptionNum::Some(5)) == 6;
	51	+	assert checkExpr(OptionNum::Some(9)) == 11;
	52	+	assert checkExpr(OptionNum::Other(7)) == 10;
	53	+	assert checkExpr(OptionNum::Other(3)) == 0;
	54	+	assert checkExpr(OptionNum::None) == 0;
75	55		return 0;
76	56		}