vyre-reference 0.6.5

Pure-Rust CPU reference interpreter for vyre IR; byte-identical oracle for backend conformance
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

//! Generated property coverage for sequential atomic oracle semantics.

use proptest::prelude::*;
use vyre::ir::AtomicOp;
use vyre_reference::atomics;

proptest! {
    #[test]
    fn generated_atomic_binary_ops_return_old_and_expected_new_value(old in any::<u32>(), value in any::<u32>()) {
        let cases = [
            (AtomicOp::Add, old.wrapping_add(value)),
            (AtomicOp::Or, old | value),
            (AtomicOp::And, old & value),
            (AtomicOp::Xor, old ^ value),
            (AtomicOp::Min, old.min(value)),
            (AtomicOp::Max, old.max(value)),
            (AtomicOp::Exchange, value),
            (AtomicOp::LruUpdate, old.max(value)),
        ];

        for (op, expected_new) in cases {
            let (observed_old, observed_new) = atomics::apply(op, old, None, value)
                .expect("Fix: supported atomic op must have sequential reference semantics");
            prop_assert_eq!(observed_old, old);
            prop_assert_eq!(
                observed_new,
                expected_new,
                "Fix: atomic {:?} produced wrong new value",
                op
            );
        }
    }

    #[test]
    fn generated_compare_exchange_updates_only_on_expected_match(
        old in any::<u32>(),
        expected in any::<u32>(),
        value in any::<u32>(),
    ) {
        let (observed_old, observed_new) = atomics::apply(
            AtomicOp::CompareExchange,
            old,
            Some(expected),
            value,
        )
        .expect("Fix: compare-exchange with expected value must be supported");

        prop_assert_eq!(observed_old, old);
        prop_assert_eq!(observed_new, if old == expected { value } else { old });
    }

    #[test]
    fn generated_compare_exchange_without_expected_is_rejected(old in any::<u32>(), value in any::<u32>()) {
        let err = atomics::apply(AtomicOp::CompareExchange, old, None, value)
            .expect_err("Fix: compare-exchange without expected value must be rejected");
        prop_assert!(
            err.to_string().contains("expected value"),
            "Fix: compare-exchange rejection must explain the missing expected value, got {}",
            err
        );
    }
}