radiance · Radiance self-hosting compiler

lib/std/arch/rv64/tests/bool.short.circuit.rad 2.3 KiB raw

//! Test short-circuiting behavior of 'and' and 'or' operators.
fn modify(counter: *mut i32, ret: bool) -> bool {
    *counter += 1;
    return ret;
}

@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);
    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);
    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);
    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);
    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);
    assert x5 == 2;
    assert r5;

    let mut y5: i32 = 0;
    let t5: bool = modify(&mut y5, false) or modify(&mut y5, false);
    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));
    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));
    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));
    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);
    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);
    assert r9;
    assert a9 == 2;

    return 0;
}

1	//! Test short-circuiting behavior of 'and' and 'or' operators.
2	fn modify(counter: *mut i32, ret: bool) -> bool {
3	*counter += 1;
4	return ret;
5	}
6
7	@default fn main() -> i32 {
8	// Test 'and' short-circuits when first operand is false.
9	let mut x1: i32 = 0;
10	let r1: bool = modify(&mut x1, false) and modify(&mut x1, true);
11	assert not r1;
12	assert x1 == 1;
13
14	// Test 'and' does not short-circuit when first operand is true.
15	let mut x2: i32 = 0;
16	let r2: bool = modify(&mut x2, true) and modify(&mut x2, true);
17	assert r2;
18	assert x2 == 2;
19
20	// Test 'and' evaluates both when first is true, second is false.
21	let mut x3: i32 = 0;
22	let r3: bool = modify(&mut x3, true) and modify(&mut x3, false);
23	assert not r3;
24	assert x3 == 2;
25
26	// Test 'or' short-circuits when first operand is true.
27	let mut x4: i32 = 0;
28	let r4: bool = modify(&mut x4, true) or modify(&mut x4, true);
29	assert x4 == 1;
30	assert r4;
31
32	// Test 'or' does not short-circuit when first operand is false.
33	let mut x5: i32 = 0;
34	let r5: bool = modify(&mut x5, false) or modify(&mut x5, true);
35	assert x5 == 2;
36	assert r5;
37
38	let mut y5: i32 = 0;
39	let t5: bool = modify(&mut y5, false) or modify(&mut y5, false);
40	assert y5 == 2;
41	assert not t5;
42
43	// Test complex short-circuiting with nested expressions.
44	let mut a6: i32 = 0;
45	let r6: bool =
46	modify(&mut a6, false) and
47	(modify(&mut a6, true) or modify(&mut a6, false));
48	assert not r6;
49	assert a6 == 1;
50
51	let mut b6: i32 = 0;
52	let t6: bool = modify(&mut b6, true) and
53	(modify(&mut b6, false) or modify(&mut b6, false));
54	assert not t6;
55	assert b6 == 3;
56
57	// Test nested or short-circuit.
58	let mut a7: i32 = 0;
59	let r7: bool = modify(&mut a7, false) or
60	(modify(&mut a7, true) and modify(&mut a7, true));
61	assert r7;
62	assert a7 == 3;
63
64	// Test chained 'and' short-circuit.
65	let mut a8: i32 = 0;
66	let mut r8: bool =
67	modify(&mut a8, true) and
68	modify(&mut a8, false) and
69	modify(&mut a8, false);
70	assert not r8;
71	assert a8 == 2;
72
73	// Test chained 'or' short-circuit.
74	let mut a9: i32 = 0;
75	let mut r9: bool =
76	modify(&mut a9, false) or
77	modify(&mut a9, true) or
78	modify(&mut a9, false);
79	assert r9;
80	assert a9 == 2;
81
82	return 0;
83	}