vyre-conform 0.1.0

Conformance suite for vyre backends — proves byte-identical output to CPU reference
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

pub use fake_identity_unary::fake_identity_unary;


use crate::properties::tests::{pair, primitive, result_u32, unary};
use crate::spec::law::AlgebraicLaw;

#[inline]
pub fn fake_identity_unary(input: &[u8]) -> Vec<u8> {
    input[..4].to_vec()
}


#[inline]
pub fn verify_absorbing(spec: &crate::spec::types::OpSpec, element: u32) {
    for a in SAMPLE {
        let lhs = call_u32(spec, &pair(a, element));
        assert_eq!(
            lhs, element,
            "{} violates Absorbing({element}) right at {a}",
            spec.id
        );
        let rhs = call_u32(spec, &pair(element, a));
        assert_eq!(
            rhs, element,
            "{} violates Absorbing({element}) left at {a}",
            spec.id
        );
    }
}


#[inline]
pub fn verify_idempotent(spec: &crate::spec::types::OpSpec) {
    for a in SAMPLE {
        let val = call_u32(spec, &pair(a, a));
        assert_eq!(val, a, "{} violates Idempotent at {a}", spec.id);
    }
}


#[inline]
pub fn verify_identity(spec: &crate::spec::types::OpSpec, element: u32) {
    for a in SAMPLE {
        let lhs = call_u32(spec, &pair(a, element));
        assert_eq!(
            lhs, a,
            "{} violates Identity({element}) right at {a}",
            spec.id
        );
        let rhs = call_u32(spec, &pair(element, a));
        assert_eq!(
            rhs, a,
            "{} violates Identity({element}) left at {a}",
            spec.id
        );
    }
}


#[inline]
pub fn verify_involution(spec: &crate::spec::types::OpSpec) {
    for a in SAMPLE {
        let once = call_u32(spec, &unary(a));
        let twice = call_u32(spec, &unary(once));
        assert_eq!(twice, a, "{} violates Involution at {a}", spec.id);
    }
}


#[inline]
pub fn verify_self_inverse(spec: &crate::spec::types::OpSpec, result: u32) {
    for a in SAMPLE {
        let val = call_u32(spec, &pair(a, a));
        assert_eq!(
            val, result,
            "{} violates SelfInverse({result}) at {a}",
            spec.id
        );
    }
}