minerva 0.2.0

Causal ordering for distributed systems
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

use crate::kairos::Kairos;
use proptest::prelude::*;

proptest! {
    /// Round-trip: every field survives packing and unpacking unchanged.
    #[test]
    fn prop_kairos_fields_round_trip(
        physical in any::<u64>(),
        logical in any::<u16>(),
        kairotic in any::<u16>(),
        station_id in any::<u32>(),
    ) {
        let k = Kairos::new(physical, logical, station_id, kairotic);
        prop_assert_eq!(k.physical(), physical);
        prop_assert_eq!(k.logical(), logical);
        prop_assert_eq!(k.kairotic(), kairotic);
        prop_assert_eq!(k.station_id(), station_id);
    }

    /// Order: derived `Ord` is exactly `(physical, logical, kairotic, station_id)`.
    #[test]
    fn prop_kairos_order_matches_field_priority(
        a in any::<(u64, u16, u16, u32)>(),
        b in any::<(u64, u16, u16, u32)>(),
    ) {
        let ka = Kairos::new(a.0, a.1, a.3, a.2);
        let kb = Kairos::new(b.0, b.1, b.3, b.2);
        prop_assert_eq!(ka.cmp(&kb), a.cmp(&b));
    }

    /// Byte round-trip: `from_bytes(to_bytes(k)) == k`.
    #[test]
    fn prop_bytes_round_trip(
        physical in any::<u64>(),
        logical in any::<u16>(),
        kairotic in any::<u16>(),
        station_id in any::<u32>(),
    ) {
        let k = Kairos::new(physical, logical, station_id, kairotic);
        prop_assert_eq!(Kairos::from_bytes(&k.to_bytes()), Ok(k));
    }

    /// Byte order preservation: same-version frame order equals stamp order.
    #[test]
    fn prop_bytes_preserve_order(
        a in any::<(u64, u16, u16, u32)>(),
        b in any::<(u64, u16, u16, u32)>(),
    ) {
        let ka = Kairos::new(a.0, a.1, a.3, a.2);
        let kb = Kairos::new(b.0, b.1, b.3, b.2);
        prop_assert_eq!(ka.to_bytes().cmp(&kb.to_bytes()), ka.cmp(&kb));
    }

    /// Arbitrary bytes decode to `Ok` or `Err`, never panic; accepted frames are canonical.
    #[test]
    fn prop_from_bytes_never_panics(bytes in prop::collection::vec(any::<u8>(), 0..64)) {
        if let Ok(k) = Kairos::from_bytes(&bytes) {
            let encoded = k.to_bytes();
            prop_assert_eq!(encoded.as_slice(), bytes.as_slice());
        }
    }
}