surelock 0.1.0

Deadlock-free locks for Rust with compile time guarantees, incremental locks, and atomic lock sets.
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

//! Property-based tests using bolero.

#![allow(clippy::unwrap_used, clippy::indexing_slicing)]

use surelock::{key::lock_scope, mutex::Mutex, set::LockSet};

/// `LockId`s are strictly monotonically increasing: for any sequence
/// of N mutexes created in order, each ID is greater than the last.
#[test]
fn lockid_monotonicity() {
    bolero::check!().with_type::<u8>().for_each(|&count| {
        let n = (count as usize).min(64); // cap to avoid OOM
        let mutexes: Vec<Mutex<()>> = (0..n).map(|_| Mutex::new(())).collect();
        for window in mutexes.windows(2) {
            assert!(
                window[0].id() < window[1].id(),
                "LockId must be strictly monotonically increasing"
            );
        }
    });
}

/// For any pair of mutexes provided in any order, `LockSet` acquires
/// both successfully and the guards correspond to the original mutexes.
#[test]
fn lockset_sort_invariant_2tuple() {
    bolero::check!()
        .with_type::<(u32, u32, bool)>()
        .for_each(|&(val_a, val_b, reverse)| {
            let a: Mutex<u32> = Mutex::new(val_a);
            let b: Mutex<u32> = Mutex::new(val_b);

            let set = if reverse {
                LockSet::new((&b, &a))
            } else {
                LockSet::new((&a, &b))
            };

            lock_scope(|key| {
                let ((g1, g2), _key) = key.lock(&set);
                if reverse {
                    assert_eq!(*g1, val_b, "first guard should match b");
                    assert_eq!(*g2, val_a, "second guard should match a");
                } else {
                    assert_eq!(*g1, val_a, "first guard should match a");
                    assert_eq!(*g2, val_b, "second guard should match b");
                }
            });
        });
}

/// For any slice of N mutexes, `LockSet` acquires all of them and
/// the guards contain the correct values (sum is preserved).
#[test]
fn lockset_slice_preserves_values() {
    bolero::check!().with_type::<u8>().for_each(|&count| {
        let n = (count as usize).clamp(1, 16);
        let mutexes: Vec<Mutex<u64>> = (0..n).map(|i| Mutex::new(i as u64)).collect();
        let expected_sum: u64 = (0..n as u64).sum();

        let set = LockSet::new(mutexes.as_slice());
        lock_scope(|key| {
            let (guards, _key) = key.lock(&set);
            let actual_sum: u64 = guards.iter().map(|g| **g).sum();
            assert_eq!(
                actual_sum, expected_sum,
                "sum of locked values must match sum of original values"
            );
        });
    });
}