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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

#![allow(incomplete_features)]
#![feature(specialization)]
#![feature(unsize)]
#![feature(coerce_unsized)]
#![feature(thread_id_value)]
#![feature(arbitrary_self_types)]

pub mod address;
pub mod own;
pub(crate) mod ref_counters;
pub mod rglica;
pub mod stats;
pub mod strong;
pub mod to_own;
pub mod to_rglica;
pub mod to_weak;
pub mod total_size;
pub mod utils;
pub mod vec;
pub mod weak;

pub use address::*;
pub use own::*;
pub(crate) use ref_counters::*;
pub use rglica::*;
pub use stats::*;
pub use strong::*;
pub use to_own::*;
pub use to_rglica::*;
pub use to_weak::*;
pub use total_size::*;
pub use utils::*;
pub use weak::*;

#[cfg(test)]
mod tests {
    use std::{ops::Deref, thread::spawn};

    use serial_test::serial;

    use crate::{ref_counters::RefCounters, set_current_thread_as_main, Own, Strong, ToWeak, Weak};

    #[test]
    #[serial]
    fn deref() {
        set_current_thread_as_main();
        let num = Own::new(5);
        assert_eq!(num.deref(), &5);
        assert_eq!(num.weak().deref(), &5);
    }

    #[test]
    #[serial]
    fn deref_mut() {
        set_current_thread_as_main();
        let mut num = Own::new(5);
        *num = 10;
        assert_eq!(num.deref(), &10);
        assert_eq!(num.weak().deref(), &10);
    }

    #[test]
    #[should_panic]
    #[serial]
    fn deref_async() {
        set_current_thread_as_main();
        let num = Own::new(5);
        let weak = num.weak();
        spawn(move || {
            assert_eq!(weak.deref(), &5);
        })
        .join()
        .unwrap();
    }

    #[test]
    #[serial]
    fn counters() {
        set_current_thread_as_main();
        let num = Strong::new(5);
        assert_eq!(num.ref_count(), 1);
        let num2 = num.clone();
        assert_eq!(num.ref_count(), 2);
        drop(num2);
        assert_eq!(num.ref_count(), 1);
        let address = num.address();
        drop(num);
        assert_eq!(RefCounters::strong_count(address), 0);
    }

    #[test]
    #[should_panic]
    #[serial]
    fn deref_null() {
        set_current_thread_as_main();
        let null = Weak::<u32>::default();
        dbg!(&null);
    }

    #[test]
    #[should_panic]
    #[serial]
    fn deref_freed() {
        set_current_thread_as_main();
        let num = Strong::new(5);
        let weak = num.weak();
        drop(num);
        dbg!(weak);
    }

    #[test]
    #[serial]
    fn check_freed() {
        set_current_thread_as_main();
        let num = Strong::new(5);
        let weak = num.weak();
        assert!(!weak.freed());
        drop(num);
        assert!(weak.freed());
    }

    #[test]
    #[serial]
    fn from_ref_ok() {
        set_current_thread_as_main();
        let num = Strong::new(5);
        let rf = num.deref();
        let weak = Weak::from_ref(rf);
        assert!(weak.is_ok());
        _ = weak.deref();
    }

    #[test]
    #[should_panic]
    #[serial]
    fn from_ref_fail() {
        set_current_thread_as_main();
        let _weak = Weak::from_ref(&5);
    }

    static WEAK: Weak<bool> = Weak::const_default();

    #[test]
    #[serial]
    fn const_weak_default() {
        set_current_thread_as_main();
        assert!(WEAK.is_null());
    }
}