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

extern crate alloc;

use super::super::editor::{Replica, gossip_cursors};

#[test]
fn test_cursors_converge_as_registers() {
    // One device key behaves as a superseding register; distinct device keys
    // stay independent, and concurrent same-key writes read as siblings.
    let roster = [1u32, 2u32];
    let mut a = Replica::new(1, &roster);
    let mut b = Replica::new(2, &roster);

    a.move_cursor(10, 3);
    a.move_cursor(10, 7);
    assert_eq!(a.cursor_positions(10), alloc::vec![7]);

    a.move_cursor(20, 42);
    assert_eq!(a.cursor_positions(20), alloc::vec![42]);

    gossip_cursors(&a, &mut b);
    assert_eq!(b.cursor_positions(10), alloc::vec![7]);
    assert_eq!(b.cursor_positions(20), alloc::vec![42]);

    let mut c = Replica::new(1, &roster);
    let mut d = Replica::new(2, &roster);
    c.move_cursor(30, 100);
    d.move_cursor(30, 200);

    gossip_cursors(&d, &mut c);
    gossip_cursors(&c, &mut d);
    let mut c_vals = c.cursor_positions(30);
    let mut d_vals = d.cursor_positions(30);
    c_vals.sort_unstable();
    d_vals.sort_unstable();
    assert_eq!(
        c_vals,
        alloc::vec![100, 200],
        "concurrent same-key writes are siblings"
    );
    assert_eq!(c_vals, d_vals);
}