1use std::{
2 cell::Cell,
3 sync::atomic::{AtomicUsize, Ordering::SeqCst},
4 thread::scope,
5};
6
7use once_cell::sync::{Lazy, OnceCell};
8
9#[test]
10fn 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]
33fn 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]
52fn 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]
68fn 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]
87fn 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]
112fn 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]
129fn 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]
144fn 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]
153fn lazy_poisoning() {
154 let x: Lazy<String> = Lazy::new(|| panic!("kaboom"));
155 for _ in 0..2 {
156 let res = std::panic::catch_unwind(|| x.len());
157 assert!(res.is_err());
158 }
159}
160
161#[test]
162// https://github.com/rust-lang/rust/issues/34761#issuecomment-256320669
163fn arrrrrrrrrrrrrrrrrrrrrr() {
164 let lazy: Lazy<&String, _>;
165 {
166 let s = String::new();
167 lazy = Lazy::new(|| &s);
168 _ = *lazy;
169 }
170}
171
172#[test]
173fn lazy_is_sync_send() {
174 fn assert_traits<T: Send + Sync>() {}
175 assert_traits::<Lazy<String>>();
176}
177