weakref 0.2.2

Copy+static reference type which checks liveness at runtime.
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
116
117
118
119
120
121
122
123
124
125
126
127

use crate::{Own, pin, refer};

#[cfg(not(loom))]
compile_error! { r#"test with `RUSTFLAGS="--cfg loom" cargo test`"# }

#[test]
pub fn concurrent_drop_get() {
    loom::model(|| {
        crate::guts::empty_recycler();
        let o = Own::new_box(42);
        let r = o.refer();
        loom::thread::spawn(move || {
            drop(o);
        });
        loom::thread::spawn(move || {
            let g = pin();
            assert!(matches!(r.get(&g), Some(&42) | None));
        });
    });
}

#[test]
pub fn concurrent_reuse_get() {
    loom::model(|| {
        crate::guts::empty_recycler();
        let o = Own::new_box(42);
        loom::thread::spawn(move || {
            let g = pin();
            assert!(matches!(refer!(o).get(&g), Some(&42) | None));
        });
        loom::thread::spawn(move || {
            let o2 = Own::new_from(Box::new(43), o);
            assert_eq!(*o2, 43);
        });
    });
}

#[test]
pub fn concurrent_multiple_refs() {
    loom::model(|| {
        crate::guts::empty_recycler();
        let o = Own::new_box(42);
        let r1 = o.refer();
        let r2 = o.refer();
        loom::thread::spawn(move || {
            let g = pin();
            assert!(matches!(r1.get(&g), Some(&42) | None));
        });
        loom::thread::spawn(move || {
            let g = pin();
            assert!(matches!(r2.get(&g), Some(&42) | None));
        });
        loom::thread::spawn(move || {
            drop(o);
        });
    });
}

#[test]
pub fn concurrent_chain_reuse() {
    loom::model(|| {
        crate::guts::empty_recycler();
        let o1 = Own::new_box(1);
        let r1 = o1.refer();
        let o2 = Own::new_from(Box::new(2), o1);
        let r2 = o2.refer();
        loom::thread::spawn(move || {
            let g = pin();
            assert!(matches!(r1.get(&g), None));
            assert!(matches!(r2.get(&g), Some(&2) | None));
        });
        loom::thread::spawn(move || {
            let o3 = Own::new_from(Box::new(3), o2);
            assert_eq!(*o3, 3);
        });
    });
}

#[test]
pub fn concurrent_recycler_stress() {
    loom::model(|| {
        crate::guts::empty_recycler();
        let o1 = Own::new_box(1);
        let r1 = o1.refer();
        let o2 = Own::new_from(Box::new(2), o1);
        let o3 = Own::new_from(Box::new(3), o2);
        let r3 = o3.refer();

        loom::thread::spawn(move || {
            let g = pin();
            assert!(matches!(r1.get(&g), None));
        });
        loom::thread::spawn(move || {
            let g = pin();
            assert!(matches!(r3.get(&g), Some(&3) | None));
        });
        loom::thread::spawn(move || {
            drop(o3);
        });
    });
}

/*
#[test]
pub fn concurrent_replace_with_bad() {
    use std::mem::ManuallyDrop;
    use std::panic::catch_unwind;
    loom::model(|| {
        crate::guts::empty_recycler();
        let mut orig = ManuallyDrop::new(Own::new_box(42));
        let mut dupl = ManuallyDrop::new(Own::new_box(0));
        dupl.refer() = orig.refer();
        loom::thread::spawn(move || {
            // panicing is good behavior
            // the unsafe is not needed, just lets us test better
            let _ = catch_unwind(move || unsafe { ManuallyDrop::drop(&mut dupl) });
        });
        loom::thread::spawn(move || {
            // USE AFTER FREE!
            println!("{}", &**orig);
            // panicing is good behavior
            // the unsafe is not needed, just lets us test better
            let _ = catch_unwind(move || unsafe { ManuallyDrop::drop(&mut orig) });
        });
    });
}
*/