autowrap 1.1.0

Ergonomic smart pointer and interior mutability extensions
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

#[cfg(test)]
mod tests {
    use autowrap::WrapExt;

    #[test]
    fn test_cell_wrap() {
        let c = 10u32.cell();
        assert_eq!(c.get(), 10);

        c.set(20);
        assert_eq!(c.get(), 20);
    }

    #[cfg(feature = "std")]
    mod std_tests {
        use std::rc::Rc;
        use autowrap::WrapExt;

        #[test]
        fn test_refcell_wrap() {
            let r = 5u32.refcell();
            *r.borrow_mut() = 8;
            assert_eq!(*r.borrow(), 8);
        }

        #[test]
        fn test_rc_wrap() {
            let rc = 42u32.rc();
            assert_eq!(*rc, 42);

            let rc2 = Rc::clone(&rc);
            assert_eq!(Rc::strong_count(&rc2), 2);
        }

        #[test]
        fn test_rc_refcell_wrap() {
            let value = 100u32.rc_refcell();
            *value.borrow_mut() = 200;
            assert_eq!(*value.borrow(), 200);

            let cloned = Rc::clone(&value);
            assert_eq!(Rc::strong_count(&cloned), 2);
        }

        #[cfg(feature = "sync")]
        mod sync_tests {
            use super::*;
            use std::sync::{Arc, Mutex};
            use std::thread;

            #[test]
            fn test_arc_wrap() {
                let arc = 99u32.arc();
                assert_eq!(*arc, 99);

                let arc2 = Arc::clone(&arc);
                assert_eq!(Arc::strong_count(&arc2), 2);
            }

            #[test]
            fn test_arc_mutex_wrap() {
                let value = 1u32.arc_mutex();

                {
                    let mut lock = value.lock().unwrap();
                    *lock = 10;
                }

                assert_eq!(*value.lock().unwrap(), 10);

                let cloned = Arc::clone(&value);
                let handle = thread::spawn(move || {
                    let mut data = cloned.lock().unwrap();
                    *data += 5;
                });

                handle.join().unwrap();
                assert_eq!(*value.lock().unwrap(), 15);
            }
        }
    }
}