threadcell 1.0.3

A cell whose value can only be accessed by a owning thread
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

use threadcell::ThreadCell;

#[test]
fn guard() {
    static DISOWNED: ThreadCell<i32> = ThreadCell::new_disowned(234);

    std::thread::spawn(|| {
        let guard = DISOWNED.acquire_guard();
        assert_eq!(*guard, 234);
    })
    .join()
    .unwrap();
}

#[test]
#[should_panic]
fn guard_panic() {
    static DISOWNED: ThreadCell<i32> = ThreadCell::new_disowned(234);

    let guard = DISOWNED.acquire_guard();
    assert_eq!(*guard, 234);

    std::thread::spawn(|| {
        let _guard = DISOWNED.acquire_guard();
    })
    .join()
    .unwrap();
}

#[test]
fn guard_drop() {
    static DISOWNED: ThreadCell<i32> = ThreadCell::new_disowned(234);

    let guard = DISOWNED.acquire_guard();
    assert_eq!(*guard, 234);
    drop(guard);

    std::thread::spawn(|| {
        let guard = DISOWNED.acquire_guard();
        assert_eq!(*guard, 234);
    })
    .join()
    .unwrap();
}

#[test]
fn guard_mut() {
    static mut DISOWNED: ThreadCell<i32> = ThreadCell::new_disowned(234);

    let mut guard = unsafe { DISOWNED.acquire_guard_mut() };
    assert_eq!(*guard, 234);
    *guard = 345;
    drop(guard);

    std::thread::spawn(|| {
        let guard = unsafe { DISOWNED.acquire_guard() };
        assert_eq!(*guard, 345);
    })
    .join()
    .unwrap();
}

#[test]
fn try_acquire_guard() {
    let threadcell: ThreadCell<i32> = ThreadCell::new_disowned(0);

    let guard = threadcell.try_acquire_guard().expect("Some(Guard)");
    assert_eq!(*guard, i32::default());
}

#[test]
fn try_acquire_guard_mut() {
    let mut threadcell: ThreadCell<i32> = ThreadCell::new_disowned(0);

    *threadcell.try_acquire_guard_mut().expect("Some(Guard)") = 234;
    assert_eq!(*threadcell.acquire_get(), 234);
}

#[test]
#[should_panic]
fn two_guard_panic() {
    let threadcell: ThreadCell<i32> = ThreadCell::new_disowned(0);

    let _guard1 = threadcell.acquire_guard();
    let _guard2 = threadcell.acquire_guard();
}

#[test]
fn no_guard_after_acquire() {
    let threadcell: ThreadCell<i32> = ThreadCell::new_disowned(0);

    threadcell.try_acquire();
    assert!(threadcell.is_acquired());
    assert!(!threadcell.is_guarded());
    assert!(threadcell.try_acquire_guard().is_none());
}

#[test]
fn no_acquire_after_guard() {
    let threadcell: ThreadCell<i32> = ThreadCell::new_disowned(0);

    let _guard = threadcell.try_acquire_guard().expect("Some(Guard)");
    assert!(threadcell.is_guarded());
    assert!(!threadcell.try_acquire());
}

#[test]
#[should_panic]
fn cant_release_guarded() {
    let threadcell: ThreadCell<i32> = ThreadCell::new_disowned(0);

    let _guard = threadcell.try_acquire_guard().expect("Some(Guard)");
    assert!(threadcell.is_guarded());
    threadcell.release();
}