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
63
64
65
66
67
68
69
70
71
72
73
74
75

extern crate alloc;

use super::super::super::support::{dot, vv};
use super::cut;
use crate::metis::{Cut, DotSet, VersionVector};

#[test]
fn test_bottom_is_merge_identity_and_meet_absorber() {
    let cut = Cut::floor_of(&{
        let mut set = DotSet::new();
        assert!(set.insert(dot(1, 1)));
        assert!(set.insert(dot(1, 2)));
        assert!(set.insert(dot(3, 1)));
        set
    });
    let bottom = Cut::bottom();

    assert_eq!(cut.merge(&bottom), cut);
    assert_eq!(bottom.merge(&cut), cut);
    assert_eq!(cut.meet(&bottom), bottom);
    assert_eq!(bottom.meet(&cut), bottom);
}

#[test]
fn test_partial_order_is_pointwise() {
    let low = cut(&[(1, 2), (2, 1)]);
    let high = cut(&[(1, 3), (2, 4)]);
    assert!(low < high);
    assert!(high > low);
    assert_eq!(low.partial_cmp(&low), Some(core::cmp::Ordering::Equal));

    let a = cut(&[(1, 3), (2, 1)]);
    let b = cut(&[(1, 1), (2, 3)]);
    assert_eq!(a.partial_cmp(&b), None);
    assert_ne!(a, b);
}

#[test]
fn test_difference_owed_vector_carries_the_claim() {
    let mine = cut(&[(1, 5), (2, 2)]);
    let yours = cut(&[(1, 3), (2, 2)]);
    let owed = mine.difference(&yours);

    assert_eq!(owed, vv(&[(1, 5)]));
    assert_eq!(
        yours.as_vector().merge(&owed),
        mine.merge(&yours).into_vector()
    );
    assert_eq!(mine.difference(&mine), VersionVector::new());
    assert_eq!(yours.difference(&mine), VersionVector::new());

    let owed_dots: alloc::vec::Vec<_> = mine
        .to_have_set()
        .difference(&yours.to_have_set())
        .collect();
    assert_eq!(owed_dots, [dot(1, 4), dot(1, 5)]);
}

#[test]
fn test_restrict_selects_whole_fibers() {
    let cut = Cut::floor_of(&{
        let mut set = DotSet::new();
        for counter in [1, 2] {
            assert!(set.insert(dot(1, counter)));
        }
        for counter in [1, 2, 3] {
            assert!(set.insert(dot(2, counter)));
        }
        assert!(set.insert(dot(5, 1)));
        set
    });

    let restricted = cut.restrict([1u32, 5]);
    assert_eq!(restricted.as_vector(), &vv(&[(1, 2), (5, 1)]));
}