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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use super::super::*;

#[test]
fn mod_i32_by_zero_errors() {
    let program = empty_program();
    let expr = Expr::BinOp {
        op: BinOp::Mod,
        left: Box::new(Expr::i32(42)),
        right: Box::new(Expr::i32(0)),
    };
    let result = eval_expr::eval(
        &expr,
        &mut zero_invocation(&program),
        &mut Memory::empty(),
        &program,
    );
    assert!(matches!(result, Err(_)), "i32 remainder by zero must error");
}

#[test]
fn div_i32_min_by_neg_one_errors() {
    let program = empty_program();
    let expr = Expr::BinOp {
        op: BinOp::Div,
        left: Box::new(Expr::i32(i32::MIN)),
        right: Box::new(Expr::i32(-1)),
    };
    let result = eval_expr::eval(
        &expr,
        &mut zero_invocation(&program),
        &mut Memory::empty(),
        &program,
    );
    assert!(matches!(result, Err(_)), "i32 MIN / -1 overflow must error");
}

// ---------------------------------------------------------------------------
// BinOp – f32
// ---------------------------------------------------------------------------

proptest! {
    #![proptest_config(ProptestConfig::with_cases(256))]

    #[test]
    fn prop_binop_add_f32(a in any::<f32>(), b in any::<f32>()) {
        let expected = expected_f32(canonical_f32(a) + canonical_f32(b));
        prop_assert_eq!(eval_binop_f32(BinOp::Add, a, b), expected);
    }

    #[test]
    fn prop_binop_sub_f32(a in any::<f32>(), b in any::<f32>()) {
        let expected = expected_f32(canonical_f32(a) - canonical_f32(b));
        prop_assert_eq!(eval_binop_f32(BinOp::Sub, a, b), expected);
    }

    #[test]
    fn prop_binop_mul_f32(a in any::<f32>(), b in any::<f32>()) {
        let expected = expected_f32(canonical_f32(a) * canonical_f32(b));
        prop_assert_eq!(eval_binop_f32(BinOp::Mul, a, b), expected);
    }

    #[test]
    fn prop_binop_div_f32(a in any::<f32>(), b in any::<f32>()) {
        let expected = expected_f32(canonical_f32(a) / canonical_f32(b));
        prop_assert_eq!(eval_binop_f32(BinOp::Div, a, b), expected);
    }

    #[test]
    fn prop_binop_min_f32(a in any::<f32>(), b in any::<f32>()) {
        let expected = expected_f32(canonical_f32(a).min(canonical_f32(b)));
        prop_assert_eq!(eval_binop_f32(BinOp::Min, a, b), expected);
    }

    #[test]
    fn prop_binop_max_f32(a in any::<f32>(), b in any::<f32>()) {
        let expected = expected_f32(canonical_f32(a).max(canonical_f32(b)));
        prop_assert_eq!(eval_binop_f32(BinOp::Max, a, b), expected);
    }

    #[test]
    fn prop_binop_eq_f32(a in any::<f32>(), b in any::<f32>()) {
        prop_assert_eq!(eval_binop_f32(BinOp::Eq, a, b), Value::Bool(canonical_f32(a) == canonical_f32(b)));
    }

    #[test]
    fn prop_binop_lt_f32(a in any::<f32>(), b in any::<f32>()) {
        prop_assert_eq!(eval_binop_f32(BinOp::Lt, a, b), Value::Bool(canonical_f32(a) < canonical_f32(b)));
    }
}

// ---------------------------------------------------------------------------
// UnOp – u32
// ---------------------------------------------------------------------------