1 //! Test for `boxed` mod.
2
3 use core::any::Any;
4 use core::clone::Clone;
5 use core::convert::TryInto;
6 use core::ops::Deref;
7
8 use std::boxed::Box;
9
10 #[test]
test_owned_clone()11 fn test_owned_clone() {
12 let a = Box::new(5);
13 let b: Box<i32> = a.clone();
14 assert!(a == b);
15 }
16
17 #[derive(Debug, PartialEq, Eq)]
18 struct Test;
19
20 #[test]
any_move()21 fn any_move() {
22 let a = Box::new(8) as Box<dyn Any>;
23 let b = Box::new(Test) as Box<dyn Any>;
24
25 let a: Box<i32> = a.downcast::<i32>().unwrap();
26 assert_eq!(*a, 8);
27
28 let b: Box<Test> = b.downcast::<Test>().unwrap();
29 assert_eq!(*b, Test);
30
31 let a = Box::new(8) as Box<dyn Any>;
32 let b = Box::new(Test) as Box<dyn Any>;
33
34 assert!(a.downcast::<Box<i32>>().is_err());
35 assert!(b.downcast::<Box<Test>>().is_err());
36 }
37
38 #[test]
test_show()39 fn test_show() {
40 let a = Box::new(8) as Box<dyn Any>;
41 let b = Box::new(Test) as Box<dyn Any>;
42 let a_str = format!("{a:?}");
43 let b_str = format!("{b:?}");
44 assert_eq!(a_str, "Any { .. }");
45 assert_eq!(b_str, "Any { .. }");
46
47 static EIGHT: usize = 8;
48 static TEST: Test = Test;
49 let a = &EIGHT as &dyn Any;
50 let b = &TEST as &dyn Any;
51 let s = format!("{a:?}");
52 assert_eq!(s, "Any { .. }");
53 let s = format!("{b:?}");
54 assert_eq!(s, "Any { .. }");
55 }
56
57 #[test]
deref()58 fn deref() {
59 fn homura<T: Deref<Target = i32>>(_: T) {}
60 homura(Box::new(765));
61 }
62
63 #[test]
raw_sized()64 fn raw_sized() {
65 let x = Box::new(17);
66 let p = Box::into_raw(x);
67 unsafe {
68 assert_eq!(17, *p);
69 *p = 19;
70 let y = Box::from_raw(p);
71 assert_eq!(19, *y);
72 }
73 }
74
75 #[test]
raw_trait()76 fn raw_trait() {
77 trait Foo {
78 fn get(&self) -> u32;
79 fn set(&mut self, value: u32);
80 }
81
82 struct Bar(u32);
83
84 impl Foo for Bar {
85 fn get(&self) -> u32 {
86 self.0
87 }
88
89 fn set(&mut self, value: u32) {
90 self.0 = value;
91 }
92 }
93
94 let x: Box<dyn Foo> = Box::new(Bar(17));
95 let p = Box::into_raw(x);
96 unsafe {
97 assert_eq!(17, (*p).get());
98 (*p).set(19);
99 let y: Box<dyn Foo> = Box::from_raw(p);
100 assert_eq!(19, y.get());
101 }
102 }
103
104 #[test]
f64_slice()105 fn f64_slice() {
106 let slice: &[f64] = &[-1.0, 0.0, 1.0, f64::INFINITY];
107 let boxed: Box<[f64]> = Box::from(slice);
108 assert_eq!(&*boxed, slice)
109 }
110
111 #[test]
i64_slice()112 fn i64_slice() {
113 let slice: &[i64] = &[i64::MIN, -2, -1, 0, 1, 2, i64::MAX];
114 let boxed: Box<[i64]> = Box::from(slice);
115 assert_eq!(&*boxed, slice)
116 }
117
118 #[test]
str_slice()119 fn str_slice() {
120 let s = "Hello, world!";
121 let boxed: Box<str> = Box::from(s);
122 assert_eq!(&*boxed, s)
123 }
124
125 #[test]
boxed_slice_from_iter()126 fn boxed_slice_from_iter() {
127 let iter = 0..100;
128 let boxed: Box<[u32]> = iter.collect();
129 assert_eq!(boxed.len(), 100);
130 assert_eq!(boxed[7], 7);
131 }
132
133 #[test]
test_array_from_slice()134 fn test_array_from_slice() {
135 let v = vec![1, 2, 3];
136 let r: Box<[u32]> = v.into_boxed_slice();
137
138 let a: Result<Box<[u32; 3]>, _> = r.clone().try_into();
139 assert!(a.is_ok());
140
141 let a: Result<Box<[u32; 2]>, _> = r.clone().try_into();
142 assert!(a.is_err());
143 }
144