vyre-primitives 0.7.2

Compositional primitives for vyre - marker types (always on) + Tier 2.5 LEGO substrate (feature-gated per domain).
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Shared property-test helpers for bitset law integration tests.

#![allow(unused_macros)]

pub(crate) fn manual_bitset_binary(
    lhs: &[u32],
    rhs: &[u32],
    op: impl Fn(u32, u32) -> u32,
) -> Vec<u32> {
    lhs.iter()
        .zip(rhs.iter())
        .map(|(a, b)| op(*a, *b))
        .collect()
}

macro_rules! bitset_and_law_tests {
    ($cpu_ref:path) => {
        proptest! {
            #![proptest_config(ProptestConfig::with_cases(10_000))]

            #[test]
            fn cpu_ref_matches_manual_and(
                lhs in proptest::collection::vec(any::<u32>(), 0..=32),
                rhs in proptest::collection::vec(any::<u32>(), 0..=32),
            ) {
                prop_assert_eq!(
                    $cpu_ref(&lhs, &rhs),
                    crate::bitset_law_support::manual_bitset_binary(&lhs, &rhs, |a, b| a & b)
                );
            }

            #[test]
            fn and_is_commutative(
                lhs in proptest::collection::vec(any::<u32>(), 1..=16),
                rhs in proptest::collection::vec(any::<u32>(), 1..=16),
            ) {
                let n = lhs.len().min(rhs.len());
                let l = &lhs[..n];
                let r = &rhs[..n];
                prop_assert_eq!($cpu_ref(l, r), $cpu_ref(r, l));
            }

            #[test]
            fn and_with_zero_rhs_is_zero(
                lhs in proptest::collection::vec(any::<u32>(), 1..=16),
            ) {
                let zero = vec![0u32; lhs.len()];
                let out = $cpu_ref(&lhs, &zero);
                prop_assert!(out.iter().all(|w| *w == 0));
            }

            #[test]
            fn and_with_ones_rhs_preserves_lhs(
                lhs in proptest::collection::vec(any::<u32>(), 1..=16),
            ) {
                let ones = vec![u32::MAX; lhs.len()];
                prop_assert_eq!($cpu_ref(&lhs, &ones), lhs);
            }

            #[test]
            fn and_is_idempotent(
                v in proptest::collection::vec(any::<u32>(), 0..=16),
            ) {
                prop_assert_eq!($cpu_ref(&v, &v), v);
            }
        }
    };
}

macro_rules! bitset_or_law_tests {
    ($cpu_ref:path) => {
        proptest! {
            #![proptest_config(ProptestConfig::with_cases(10_000))]

            #[test]
            fn cpu_ref_matches_manual_or(
                lhs in proptest::collection::vec(any::<u32>(), 0..=32),
                rhs in proptest::collection::vec(any::<u32>(), 0..=32),
            ) {
                prop_assert_eq!(
                    $cpu_ref(&lhs, &rhs),
                    crate::bitset_law_support::manual_bitset_binary(&lhs, &rhs, |a, b| a | b)
                );
            }

            #[test]
            fn or_is_commutative(
                lhs in proptest::collection::vec(any::<u32>(), 1..=16),
                rhs in proptest::collection::vec(any::<u32>(), 1..=16),
            ) {
                let n = lhs.len().min(rhs.len());
                let l = &lhs[..n];
                let r = &rhs[..n];
                prop_assert_eq!($cpu_ref(l, r), $cpu_ref(r, l));
            }

            #[test]
            fn or_with_zero_rhs_is_identity(
                lhs in proptest::collection::vec(any::<u32>(), 1..=16),
            ) {
                let zero = vec![0u32; lhs.len()];
                prop_assert_eq!($cpu_ref(&lhs, &zero), lhs);
            }

            #[test]
            fn or_with_ones_rhs_is_all_ones(
                lhs in proptest::collection::vec(any::<u32>(), 1..=16),
            ) {
                let ones = vec![u32::MAX; lhs.len()];
                prop_assert_eq!($cpu_ref(&lhs, &ones), ones);
            }

            #[test]
            fn or_is_idempotent(
                v in proptest::collection::vec(any::<u32>(), 0..=16),
            ) {
                prop_assert_eq!($cpu_ref(&v, &v), v);
            }
        }
    };
}