]>
Commit | Line | Data |
---|---|---|
416331ca XL |
1 | use super::*; |
2 | ||
3 | use std::boxed::Box; | |
4 | use std::clone::Clone; | |
5 | use std::sync::mpsc::channel; | |
6 | use std::mem::drop; | |
7 | use std::ops::Drop; | |
8 | use std::option::Option::{self, None, Some}; | |
9 | use std::sync::atomic::{self, Ordering::{Acquire, SeqCst}}; | |
10 | use std::thread; | |
11 | use std::sync::Mutex; | |
12 | use std::convert::{From, TryInto}; | |
13 | ||
14 | use crate::vec::Vec; | |
15 | ||
16 | struct Canary(*mut atomic::AtomicUsize); | |
17 | ||
18 | impl Drop for Canary { | |
19 | fn drop(&mut self) { | |
20 | unsafe { | |
21 | match *self { | |
22 | Canary(c) => { | |
23 | (*c).fetch_add(1, SeqCst); | |
24 | } | |
25 | } | |
26 | } | |
27 | } | |
28 | } | |
29 | ||
30 | #[test] | |
31 | #[cfg_attr(target_os = "emscripten", ignore)] | |
60c5eb7d | 32 | #[cfg_attr(miri, ignore)] // Miri does not support threads |
416331ca XL |
33 | fn manually_share_arc() { |
34 | let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; | |
35 | let arc_v = Arc::new(v); | |
36 | ||
37 | let (tx, rx) = channel(); | |
38 | ||
39 | let _t = thread::spawn(move || { | |
40 | let arc_v: Arc<Vec<i32>> = rx.recv().unwrap(); | |
41 | assert_eq!((*arc_v)[3], 4); | |
42 | }); | |
43 | ||
44 | tx.send(arc_v.clone()).unwrap(); | |
45 | ||
46 | assert_eq!((*arc_v)[2], 3); | |
47 | assert_eq!((*arc_v)[4], 5); | |
48 | } | |
49 | ||
50 | #[test] | |
51 | fn test_arc_get_mut() { | |
52 | let mut x = Arc::new(3); | |
53 | *Arc::get_mut(&mut x).unwrap() = 4; | |
54 | assert_eq!(*x, 4); | |
55 | let y = x.clone(); | |
56 | assert!(Arc::get_mut(&mut x).is_none()); | |
57 | drop(y); | |
58 | assert!(Arc::get_mut(&mut x).is_some()); | |
59 | let _w = Arc::downgrade(&x); | |
60 | assert!(Arc::get_mut(&mut x).is_none()); | |
61 | } | |
62 | ||
63 | #[test] | |
64 | fn weak_counts() { | |
60c5eb7d | 65 | assert_eq!(Weak::weak_count(&Weak::<u64>::new()), 0); |
416331ca XL |
66 | assert_eq!(Weak::strong_count(&Weak::<u64>::new()), 0); |
67 | ||
68 | let a = Arc::new(0); | |
69 | let w = Arc::downgrade(&a); | |
70 | assert_eq!(Weak::strong_count(&w), 1); | |
60c5eb7d | 71 | assert_eq!(Weak::weak_count(&w), 1); |
416331ca XL |
72 | let w2 = w.clone(); |
73 | assert_eq!(Weak::strong_count(&w), 1); | |
60c5eb7d | 74 | assert_eq!(Weak::weak_count(&w), 2); |
416331ca | 75 | assert_eq!(Weak::strong_count(&w2), 1); |
60c5eb7d | 76 | assert_eq!(Weak::weak_count(&w2), 2); |
416331ca XL |
77 | drop(w); |
78 | assert_eq!(Weak::strong_count(&w2), 1); | |
60c5eb7d | 79 | assert_eq!(Weak::weak_count(&w2), 1); |
416331ca XL |
80 | let a2 = a.clone(); |
81 | assert_eq!(Weak::strong_count(&w2), 2); | |
60c5eb7d | 82 | assert_eq!(Weak::weak_count(&w2), 1); |
416331ca XL |
83 | drop(a2); |
84 | drop(a); | |
85 | assert_eq!(Weak::strong_count(&w2), 0); | |
60c5eb7d | 86 | assert_eq!(Weak::weak_count(&w2), 0); |
416331ca XL |
87 | drop(w2); |
88 | } | |
89 | ||
90 | #[test] | |
91 | fn try_unwrap() { | |
92 | let x = Arc::new(3); | |
93 | assert_eq!(Arc::try_unwrap(x), Ok(3)); | |
94 | let x = Arc::new(4); | |
95 | let _y = x.clone(); | |
96 | assert_eq!(Arc::try_unwrap(x), Err(Arc::new(4))); | |
97 | let x = Arc::new(5); | |
98 | let _w = Arc::downgrade(&x); | |
99 | assert_eq!(Arc::try_unwrap(x), Ok(5)); | |
100 | } | |
101 | ||
102 | #[test] | |
103 | fn into_from_raw() { | |
104 | let x = Arc::new(box "hello"); | |
105 | let y = x.clone(); | |
106 | ||
107 | let x_ptr = Arc::into_raw(x); | |
108 | drop(y); | |
109 | unsafe { | |
110 | assert_eq!(**x_ptr, "hello"); | |
111 | ||
112 | let x = Arc::from_raw(x_ptr); | |
113 | assert_eq!(**x, "hello"); | |
114 | ||
115 | assert_eq!(Arc::try_unwrap(x).map(|x| *x), Ok("hello")); | |
116 | } | |
117 | } | |
118 | ||
119 | #[test] | |
120 | fn test_into_from_raw_unsized() { | |
121 | use std::fmt::Display; | |
122 | use std::string::ToString; | |
123 | ||
124 | let arc: Arc<str> = Arc::from("foo"); | |
125 | ||
126 | let ptr = Arc::into_raw(arc.clone()); | |
127 | let arc2 = unsafe { Arc::from_raw(ptr) }; | |
128 | ||
129 | assert_eq!(unsafe { &*ptr }, "foo"); | |
130 | assert_eq!(arc, arc2); | |
131 | ||
132 | let arc: Arc<dyn Display> = Arc::new(123); | |
133 | ||
134 | let ptr = Arc::into_raw(arc.clone()); | |
135 | let arc2 = unsafe { Arc::from_raw(ptr) }; | |
136 | ||
137 | assert_eq!(unsafe { &*ptr }.to_string(), "123"); | |
138 | assert_eq!(arc2.to_string(), "123"); | |
139 | } | |
140 | ||
141 | #[test] | |
142 | fn test_cowarc_clone_make_mut() { | |
143 | let mut cow0 = Arc::new(75); | |
144 | let mut cow1 = cow0.clone(); | |
145 | let mut cow2 = cow1.clone(); | |
146 | ||
147 | assert!(75 == *Arc::make_mut(&mut cow0)); | |
148 | assert!(75 == *Arc::make_mut(&mut cow1)); | |
149 | assert!(75 == *Arc::make_mut(&mut cow2)); | |
150 | ||
151 | *Arc::make_mut(&mut cow0) += 1; | |
152 | *Arc::make_mut(&mut cow1) += 2; | |
153 | *Arc::make_mut(&mut cow2) += 3; | |
154 | ||
155 | assert!(76 == *cow0); | |
156 | assert!(77 == *cow1); | |
157 | assert!(78 == *cow2); | |
158 | ||
159 | // none should point to the same backing memory | |
160 | assert!(*cow0 != *cow1); | |
161 | assert!(*cow0 != *cow2); | |
162 | assert!(*cow1 != *cow2); | |
163 | } | |
164 | ||
165 | #[test] | |
166 | fn test_cowarc_clone_unique2() { | |
167 | let mut cow0 = Arc::new(75); | |
168 | let cow1 = cow0.clone(); | |
169 | let cow2 = cow1.clone(); | |
170 | ||
171 | assert!(75 == *cow0); | |
172 | assert!(75 == *cow1); | |
173 | assert!(75 == *cow2); | |
174 | ||
175 | *Arc::make_mut(&mut cow0) += 1; | |
176 | assert!(76 == *cow0); | |
177 | assert!(75 == *cow1); | |
178 | assert!(75 == *cow2); | |
179 | ||
180 | // cow1 and cow2 should share the same contents | |
181 | // cow0 should have a unique reference | |
182 | assert!(*cow0 != *cow1); | |
183 | assert!(*cow0 != *cow2); | |
184 | assert!(*cow1 == *cow2); | |
185 | } | |
186 | ||
187 | #[test] | |
188 | fn test_cowarc_clone_weak() { | |
189 | let mut cow0 = Arc::new(75); | |
190 | let cow1_weak = Arc::downgrade(&cow0); | |
191 | ||
192 | assert!(75 == *cow0); | |
193 | assert!(75 == *cow1_weak.upgrade().unwrap()); | |
194 | ||
195 | *Arc::make_mut(&mut cow0) += 1; | |
196 | ||
197 | assert!(76 == *cow0); | |
198 | assert!(cow1_weak.upgrade().is_none()); | |
199 | } | |
200 | ||
201 | #[test] | |
202 | fn test_live() { | |
203 | let x = Arc::new(5); | |
204 | let y = Arc::downgrade(&x); | |
205 | assert!(y.upgrade().is_some()); | |
206 | } | |
207 | ||
208 | #[test] | |
209 | fn test_dead() { | |
210 | let x = Arc::new(5); | |
211 | let y = Arc::downgrade(&x); | |
212 | drop(x); | |
213 | assert!(y.upgrade().is_none()); | |
214 | } | |
215 | ||
216 | #[test] | |
217 | fn weak_self_cyclic() { | |
218 | struct Cycle { | |
219 | x: Mutex<Option<Weak<Cycle>>>, | |
220 | } | |
221 | ||
222 | let a = Arc::new(Cycle { x: Mutex::new(None) }); | |
223 | let b = Arc::downgrade(&a.clone()); | |
224 | *a.x.lock().unwrap() = Some(b); | |
225 | ||
226 | // hopefully we don't double-free (or leak)... | |
227 | } | |
228 | ||
229 | #[test] | |
230 | fn drop_arc() { | |
231 | let mut canary = atomic::AtomicUsize::new(0); | |
232 | let x = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize)); | |
233 | drop(x); | |
234 | assert!(canary.load(Acquire) == 1); | |
235 | } | |
236 | ||
237 | #[test] | |
238 | fn drop_arc_weak() { | |
239 | let mut canary = atomic::AtomicUsize::new(0); | |
240 | let arc = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize)); | |
241 | let arc_weak = Arc::downgrade(&arc); | |
242 | assert!(canary.load(Acquire) == 0); | |
243 | drop(arc); | |
244 | assert!(canary.load(Acquire) == 1); | |
245 | drop(arc_weak); | |
246 | } | |
247 | ||
248 | #[test] | |
249 | fn test_strong_count() { | |
250 | let a = Arc::new(0); | |
251 | assert!(Arc::strong_count(&a) == 1); | |
252 | let w = Arc::downgrade(&a); | |
253 | assert!(Arc::strong_count(&a) == 1); | |
254 | let b = w.upgrade().expect(""); | |
255 | assert!(Arc::strong_count(&b) == 2); | |
256 | assert!(Arc::strong_count(&a) == 2); | |
257 | drop(w); | |
258 | drop(a); | |
259 | assert!(Arc::strong_count(&b) == 1); | |
260 | let c = b.clone(); | |
261 | assert!(Arc::strong_count(&b) == 2); | |
262 | assert!(Arc::strong_count(&c) == 2); | |
263 | } | |
264 | ||
265 | #[test] | |
266 | fn test_weak_count() { | |
267 | let a = Arc::new(0); | |
268 | assert!(Arc::strong_count(&a) == 1); | |
269 | assert!(Arc::weak_count(&a) == 0); | |
270 | let w = Arc::downgrade(&a); | |
271 | assert!(Arc::strong_count(&a) == 1); | |
272 | assert!(Arc::weak_count(&a) == 1); | |
273 | let x = w.clone(); | |
274 | assert!(Arc::weak_count(&a) == 2); | |
275 | drop(w); | |
276 | drop(x); | |
277 | assert!(Arc::strong_count(&a) == 1); | |
278 | assert!(Arc::weak_count(&a) == 0); | |
279 | let c = a.clone(); | |
280 | assert!(Arc::strong_count(&a) == 2); | |
281 | assert!(Arc::weak_count(&a) == 0); | |
282 | let d = Arc::downgrade(&c); | |
283 | assert!(Arc::weak_count(&c) == 1); | |
284 | assert!(Arc::strong_count(&c) == 2); | |
285 | ||
286 | drop(a); | |
287 | drop(c); | |
288 | drop(d); | |
289 | } | |
290 | ||
291 | #[test] | |
292 | fn show_arc() { | |
293 | let a = Arc::new(5); | |
294 | assert_eq!(format!("{:?}", a), "5"); | |
295 | } | |
296 | ||
297 | // Make sure deriving works with Arc<T> | |
298 | #[derive(Eq, Ord, PartialEq, PartialOrd, Clone, Debug, Default)] | |
299 | struct Foo { | |
300 | inner: Arc<i32>, | |
301 | } | |
302 | ||
303 | #[test] | |
304 | fn test_unsized() { | |
305 | let x: Arc<[i32]> = Arc::new([1, 2, 3]); | |
306 | assert_eq!(format!("{:?}", x), "[1, 2, 3]"); | |
307 | let y = Arc::downgrade(&x.clone()); | |
308 | drop(x); | |
309 | assert!(y.upgrade().is_none()); | |
310 | } | |
311 | ||
312 | #[test] | |
313 | fn test_from_owned() { | |
314 | let foo = 123; | |
315 | let foo_arc = Arc::from(foo); | |
316 | assert!(123 == *foo_arc); | |
317 | } | |
318 | ||
319 | #[test] | |
320 | fn test_new_weak() { | |
321 | let foo: Weak<usize> = Weak::new(); | |
322 | assert!(foo.upgrade().is_none()); | |
323 | } | |
324 | ||
325 | #[test] | |
326 | fn test_ptr_eq() { | |
327 | let five = Arc::new(5); | |
328 | let same_five = five.clone(); | |
329 | let other_five = Arc::new(5); | |
330 | ||
331 | assert!(Arc::ptr_eq(&five, &same_five)); | |
332 | assert!(!Arc::ptr_eq(&five, &other_five)); | |
333 | } | |
334 | ||
335 | #[test] | |
336 | #[cfg_attr(target_os = "emscripten", ignore)] | |
60c5eb7d | 337 | #[cfg_attr(miri, ignore)] // Miri does not support threads |
416331ca XL |
338 | fn test_weak_count_locked() { |
339 | let mut a = Arc::new(atomic::AtomicBool::new(false)); | |
340 | let a2 = a.clone(); | |
341 | let t = thread::spawn(move || { | |
342 | for _i in 0..1000000 { | |
343 | Arc::get_mut(&mut a); | |
344 | } | |
345 | a.store(true, SeqCst); | |
346 | }); | |
347 | ||
348 | while !a2.load(SeqCst) { | |
349 | let n = Arc::weak_count(&a2); | |
350 | assert!(n < 2, "bad weak count: {}", n); | |
351 | } | |
352 | t.join().unwrap(); | |
353 | } | |
354 | ||
355 | #[test] | |
356 | fn test_from_str() { | |
357 | let r: Arc<str> = Arc::from("foo"); | |
358 | ||
359 | assert_eq!(&r[..], "foo"); | |
360 | } | |
361 | ||
362 | #[test] | |
363 | fn test_copy_from_slice() { | |
364 | let s: &[u32] = &[1, 2, 3]; | |
365 | let r: Arc<[u32]> = Arc::from(s); | |
366 | ||
367 | assert_eq!(&r[..], [1, 2, 3]); | |
368 | } | |
369 | ||
370 | #[test] | |
371 | fn test_clone_from_slice() { | |
372 | #[derive(Clone, Debug, Eq, PartialEq)] | |
373 | struct X(u32); | |
374 | ||
375 | let s: &[X] = &[X(1), X(2), X(3)]; | |
376 | let r: Arc<[X]> = Arc::from(s); | |
377 | ||
378 | assert_eq!(&r[..], s); | |
379 | } | |
380 | ||
381 | #[test] | |
382 | #[should_panic] | |
383 | fn test_clone_from_slice_panic() { | |
384 | use std::string::{String, ToString}; | |
385 | ||
386 | struct Fail(u32, String); | |
387 | ||
388 | impl Clone for Fail { | |
389 | fn clone(&self) -> Fail { | |
390 | if self.0 == 2 { | |
391 | panic!(); | |
392 | } | |
393 | Fail(self.0, self.1.clone()) | |
394 | } | |
395 | } | |
396 | ||
397 | let s: &[Fail] = &[ | |
398 | Fail(0, "foo".to_string()), | |
399 | Fail(1, "bar".to_string()), | |
400 | Fail(2, "baz".to_string()), | |
401 | ]; | |
402 | ||
403 | // Should panic, but not cause memory corruption | |
404 | let _r: Arc<[Fail]> = Arc::from(s); | |
405 | } | |
406 | ||
407 | #[test] | |
408 | fn test_from_box() { | |
409 | let b: Box<u32> = box 123; | |
410 | let r: Arc<u32> = Arc::from(b); | |
411 | ||
412 | assert_eq!(*r, 123); | |
413 | } | |
414 | ||
415 | #[test] | |
416 | fn test_from_box_str() { | |
417 | use std::string::String; | |
418 | ||
419 | let s = String::from("foo").into_boxed_str(); | |
420 | let r: Arc<str> = Arc::from(s); | |
421 | ||
422 | assert_eq!(&r[..], "foo"); | |
423 | } | |
424 | ||
425 | #[test] | |
426 | fn test_from_box_slice() { | |
427 | let s = vec![1, 2, 3].into_boxed_slice(); | |
428 | let r: Arc<[u32]> = Arc::from(s); | |
429 | ||
430 | assert_eq!(&r[..], [1, 2, 3]); | |
431 | } | |
432 | ||
433 | #[test] | |
434 | fn test_from_box_trait() { | |
435 | use std::fmt::Display; | |
436 | use std::string::ToString; | |
437 | ||
438 | let b: Box<dyn Display> = box 123; | |
439 | let r: Arc<dyn Display> = Arc::from(b); | |
440 | ||
441 | assert_eq!(r.to_string(), "123"); | |
442 | } | |
443 | ||
444 | #[test] | |
445 | fn test_from_box_trait_zero_sized() { | |
446 | use std::fmt::Debug; | |
447 | ||
448 | let b: Box<dyn Debug> = box (); | |
449 | let r: Arc<dyn Debug> = Arc::from(b); | |
450 | ||
451 | assert_eq!(format!("{:?}", r), "()"); | |
452 | } | |
453 | ||
454 | #[test] | |
455 | fn test_from_vec() { | |
456 | let v = vec![1, 2, 3]; | |
457 | let r: Arc<[u32]> = Arc::from(v); | |
458 | ||
459 | assert_eq!(&r[..], [1, 2, 3]); | |
460 | } | |
461 | ||
462 | #[test] | |
463 | fn test_downcast() { | |
464 | use std::any::Any; | |
465 | ||
466 | let r1: Arc<dyn Any + Send + Sync> = Arc::new(i32::max_value()); | |
467 | let r2: Arc<dyn Any + Send + Sync> = Arc::new("abc"); | |
468 | ||
469 | assert!(r1.clone().downcast::<u32>().is_err()); | |
470 | ||
471 | let r1i32 = r1.downcast::<i32>(); | |
472 | assert!(r1i32.is_ok()); | |
473 | assert_eq!(r1i32.unwrap(), Arc::new(i32::max_value())); | |
474 | ||
475 | assert!(r2.clone().downcast::<i32>().is_err()); | |
476 | ||
477 | let r2str = r2.downcast::<&'static str>(); | |
478 | assert!(r2str.is_ok()); | |
479 | assert_eq!(r2str.unwrap(), Arc::new("abc")); | |
480 | } | |
481 | ||
482 | #[test] | |
483 | fn test_array_from_slice() { | |
484 | let v = vec![1, 2, 3]; | |
485 | let r: Arc<[u32]> = Arc::from(v); | |
486 | ||
487 | let a: Result<Arc<[u32; 3]>, _> = r.clone().try_into(); | |
488 | assert!(a.is_ok()); | |
489 | ||
490 | let a: Result<Arc<[u32; 2]>, _> = r.clone().try_into(); | |
491 | assert!(a.is_err()); | |
492 | } |