1 use std::{
2 cell::Cell,
3 sync::atomic::{AtomicUsize, Ordering::SeqCst},
4 thread::scope,
5 };
6
7 use once_cell::sync::{Lazy, OnceCell};
8
9 #[test]
lazy_new()10 fn lazy_new() {
11 let called = AtomicUsize::new(0);
12 let x = Lazy::new(|| {
13 called.fetch_add(1, SeqCst);
14 92
15 });
16
17 assert_eq!(called.load(SeqCst), 0);
18
19 scope(|s| {
20 s.spawn(|| {
21 let y = *x - 30;
22 assert_eq!(y, 62);
23 assert_eq!(called.load(SeqCst), 1);
24 });
25 });
26
27 let y = *x - 30;
28 assert_eq!(y, 62);
29 assert_eq!(called.load(SeqCst), 1);
30 }
31
32 #[test]
lazy_deref_mut()33 fn lazy_deref_mut() {
34 let called = AtomicUsize::new(0);
35 let mut x = Lazy::new(|| {
36 called.fetch_add(1, SeqCst);
37 92
38 });
39
40 assert_eq!(called.load(SeqCst), 0);
41
42 let y = *x - 30;
43 assert_eq!(y, 62);
44 assert_eq!(called.load(SeqCst), 1);
45
46 *x /= 2;
47 assert_eq!(*x, 46);
48 assert_eq!(called.load(SeqCst), 1);
49 }
50
51 #[test]
lazy_force_mut()52 fn lazy_force_mut() {
53 let called = Cell::new(0);
54 let mut x = Lazy::new(|| {
55 called.set(called.get() + 1);
56 92
57 });
58 assert_eq!(called.get(), 0);
59 let v = Lazy::force_mut(&mut x);
60 assert_eq!(called.get(), 1);
61
62 *v /= 2;
63 assert_eq!(*x, 46);
64 assert_eq!(called.get(), 1);
65 }
66
67 #[test]
lazy_get_mut()68 fn lazy_get_mut() {
69 let called = Cell::new(0);
70 let mut x: Lazy<u32, _> = Lazy::new(|| {
71 called.set(called.get() + 1);
72 92
73 });
74
75 assert_eq!(called.get(), 0);
76 assert_eq!(*x, 92);
77
78 let mut_ref: &mut u32 = Lazy::get_mut(&mut x).unwrap();
79 assert_eq!(called.get(), 1);
80
81 *mut_ref /= 2;
82 assert_eq!(*x, 46);
83 assert_eq!(called.get(), 1);
84 }
85
86 #[test]
lazy_default()87 fn lazy_default() {
88 static CALLED: AtomicUsize = AtomicUsize::new(0);
89
90 struct Foo(u8);
91 impl Default for Foo {
92 fn default() -> Self {
93 CALLED.fetch_add(1, SeqCst);
94 Foo(42)
95 }
96 }
97
98 let lazy: Lazy<std::sync::Mutex<Foo>> = <_>::default();
99
100 assert_eq!(CALLED.load(SeqCst), 0);
101
102 assert_eq!(lazy.lock().unwrap().0, 42);
103 assert_eq!(CALLED.load(SeqCst), 1);
104
105 lazy.lock().unwrap().0 = 21;
106
107 assert_eq!(lazy.lock().unwrap().0, 21);
108 assert_eq!(CALLED.load(SeqCst), 1);
109 }
110
111 #[test]
static_lazy()112 fn static_lazy() {
113 static XS: Lazy<Vec<i32>> = Lazy::new(|| {
114 let mut xs = Vec::new();
115 xs.push(1);
116 xs.push(2);
117 xs.push(3);
118 xs
119 });
120 scope(|s| {
121 s.spawn(|| {
122 assert_eq!(&*XS, &vec![1, 2, 3]);
123 });
124 });
125 assert_eq!(&*XS, &vec![1, 2, 3]);
126 }
127
128 #[test]
static_lazy_via_fn()129 fn static_lazy_via_fn() {
130 fn xs() -> &'static Vec<i32> {
131 static XS: OnceCell<Vec<i32>> = OnceCell::new();
132 XS.get_or_init(|| {
133 let mut xs = Vec::new();
134 xs.push(1);
135 xs.push(2);
136 xs.push(3);
137 xs
138 })
139 }
140 assert_eq!(xs(), &vec![1, 2, 3]);
141 }
142
143 #[test]
lazy_into_value()144 fn lazy_into_value() {
145 let l: Lazy<i32, _> = Lazy::new(|| panic!());
146 assert!(matches!(Lazy::into_value(l), Err(_)));
147 let l = Lazy::new(|| -> i32 { 92 });
148 Lazy::force(&l);
149 assert!(matches!(Lazy::into_value(l), Ok(92)));
150 }
151
152 #[test]
153 #[cfg(not(target_os = "android"))]
lazy_poisoning()154 fn lazy_poisoning() {
155 let x: Lazy<String> = Lazy::new(|| panic!("kaboom"));
156 for _ in 0..2 {
157 let res = std::panic::catch_unwind(|| x.len());
158 assert!(res.is_err());
159 }
160 }
161
162 #[test]
163 // https://github.com/rust-lang/rust/issues/34761#issuecomment-256320669
arrrrrrrrrrrrrrrrrrrrrr()164 fn arrrrrrrrrrrrrrrrrrrrrr() {
165 let lazy: Lazy<&String, _>;
166 {
167 let s = String::new();
168 lazy = Lazy::new(|| &s);
169 _ = *lazy;
170 }
171 }
172
173 #[test]
lazy_is_sync_send()174 fn lazy_is_sync_send() {
175 fn assert_traits<T: Send + Sync>() {}
176 assert_traits::<Lazy<String>>();
177 }
178