1 #![cfg(feature = "alloc")]
2 #![allow(bad_style)]
3 #![allow(clippy::redundant_clone)]
4
5 #[cfg(feature = "serde")]
6 use serde_test::{assert_tokens, Token};
7 use std::iter::FromIterator;
8 use tinyvec::*;
9
10 #[test]
TinyVec_swap_remove()11 fn TinyVec_swap_remove() {
12 let mut tv: TinyVec<[i32; 10]> = Default::default();
13 tv.push(1);
14 tv.push(2);
15 tv.push(3);
16 tv.push(4);
17 assert_eq!(tv.swap_remove(3), 4);
18 assert_eq!(&tv[..], &[1, 2, 3][..]);
19 assert_eq!(tv.swap_remove(0), 1);
20 assert_eq!(&tv[..], &[3, 2][..]);
21 assert_eq!(tv.swap_remove(0), 3);
22 assert_eq!(&tv[..], &[2][..]);
23 assert_eq!(tv.swap_remove(0), 2);
24 assert_eq!(&tv[..], &[][..]);
25 }
26
27 #[test]
TinyVec_capacity()28 fn TinyVec_capacity() {
29 let mut tv: TinyVec<[i32; 1]> = Default::default();
30 assert_eq!(tv.capacity(), 1);
31 tv.move_to_the_heap();
32 tv.extend_from_slice(&[1, 2, 3, 4]);
33 assert_eq!(tv.capacity(), 4);
34 }
35
36 #[test]
TinyVec_drain()37 fn TinyVec_drain() {
38 let mut tv: TinyVec<[i32; 10]> = Default::default();
39 tv.push(1);
40 tv.push(2);
41 tv.push(3);
42
43 assert_eq!(Vec::from_iter(tv.clone().drain(..)), vec![1, 2, 3]);
44
45 assert_eq!(Vec::from_iter(tv.clone().drain(..2)), vec![1, 2]);
46 assert_eq!(Vec::from_iter(tv.clone().drain(..3)), vec![1, 2, 3]);
47
48 assert_eq!(Vec::from_iter(tv.clone().drain(..=1)), vec![1, 2]);
49 assert_eq!(Vec::from_iter(tv.clone().drain(..=2)), vec![1, 2, 3]);
50
51 assert_eq!(Vec::from_iter(tv.clone().drain(0..)), vec![1, 2, 3]);
52 assert_eq!(Vec::from_iter(tv.clone().drain(1..)), vec![2, 3]);
53
54 assert_eq!(Vec::from_iter(tv.clone().drain(0..2)), vec![1, 2]);
55 assert_eq!(Vec::from_iter(tv.clone().drain(0..3)), vec![1, 2, 3]);
56 assert_eq!(Vec::from_iter(tv.clone().drain(1..2)), vec![2]);
57 assert_eq!(Vec::from_iter(tv.clone().drain(1..3)), vec![2, 3]);
58
59 assert_eq!(Vec::from_iter(tv.clone().drain(0..=1)), vec![1, 2]);
60 assert_eq!(Vec::from_iter(tv.clone().drain(0..=2)), vec![1, 2, 3]);
61 assert_eq!(Vec::from_iter(tv.clone().drain(1..=1)), vec![2]);
62 assert_eq!(Vec::from_iter(tv.clone().drain(1..=2)), vec![2, 3]);
63 }
64
65 #[test]
TinyVec_splice()66 fn TinyVec_splice() {
67 let mut tv: TinyVec<[i32; 10]> = Default::default();
68 tv.push(1);
69 tv.push(2);
70 tv.push(3);
71
72 // splice returns the same things as drain
73 assert_eq!(Vec::from_iter(tv.clone().splice(.., None)), vec![1, 2, 3]);
74
75 assert_eq!(Vec::from_iter(tv.clone().splice(..2, None)), vec![1, 2]);
76 assert_eq!(Vec::from_iter(tv.clone().splice(..3, None)), vec![1, 2, 3]);
77
78 assert_eq!(Vec::from_iter(tv.clone().splice(..=1, None)), vec![1, 2]);
79 assert_eq!(Vec::from_iter(tv.clone().splice(..=2, None)), vec![1, 2, 3]);
80
81 assert_eq!(Vec::from_iter(tv.clone().splice(0.., None)), vec![1, 2, 3]);
82 assert_eq!(Vec::from_iter(tv.clone().splice(1.., None)), vec![2, 3]);
83
84 assert_eq!(Vec::from_iter(tv.clone().splice(0..2, None)), vec![1, 2]);
85 assert_eq!(Vec::from_iter(tv.clone().splice(0..3, None)), vec![1, 2, 3]);
86 assert_eq!(Vec::from_iter(tv.clone().splice(1..2, None)), vec![2]);
87 assert_eq!(Vec::from_iter(tv.clone().splice(1..3, None)), vec![2, 3]);
88
89 assert_eq!(Vec::from_iter(tv.clone().splice(0..=1, None)), vec![1, 2]);
90 assert_eq!(Vec::from_iter(tv.clone().splice(0..=2, None)), vec![1, 2, 3]);
91 assert_eq!(Vec::from_iter(tv.clone().splice(1..=1, None)), vec![2]);
92 assert_eq!(Vec::from_iter(tv.clone().splice(1..=2, None)), vec![2, 3]);
93
94 // splice removes the same things as drain
95 let mut tv2 = tv.clone();
96 tv2.splice(.., None);
97 assert_eq!(tv2, tiny_vec![]);
98
99 let mut tv2 = tv.clone();
100 tv2.splice(..2, None);
101 assert_eq!(tv2, tiny_vec![3]);
102
103 let mut tv2 = tv.clone();
104 tv2.splice(..3, None);
105 assert_eq!(tv2, tiny_vec![]);
106
107 let mut tv2 = tv.clone();
108 tv2.splice(..=1, None);
109 assert_eq!(tv2, tiny_vec![3]);
110 let mut tv2 = tv.clone();
111 tv2.splice(..=2, None);
112 assert_eq!(tv2, tiny_vec![]);
113
114 let mut tv2 = tv.clone();
115 tv2.splice(0.., None);
116 assert_eq!(tv2, tiny_vec![]);
117 let mut tv2 = tv.clone();
118 tv2.splice(1.., None);
119 assert_eq!(tv2, tiny_vec![1]);
120
121 let mut tv2 = tv.clone();
122 tv2.splice(0..2, None);
123 assert_eq!(tv2, tiny_vec![3]);
124
125 let mut tv2 = tv.clone();
126 tv2.splice(0..3, None);
127 assert_eq!(tv2, tiny_vec![]);
128 let mut tv2 = tv.clone();
129 tv2.splice(1..2, None);
130 assert_eq!(tv2, tiny_vec![1, 3]);
131
132 let mut tv2 = tv.clone();
133 tv2.splice(1..3, None);
134 assert_eq!(tv2, tiny_vec![1]);
135
136 let mut tv2 = tv.clone();
137 tv2.splice(0..=1, None);
138 assert_eq!(tv2, tiny_vec![3]);
139
140 let mut tv2 = tv.clone();
141 tv2.splice(0..=2, None);
142 assert_eq!(tv2, tiny_vec![]);
143
144 let mut tv2 = tv.clone();
145 tv2.splice(1..=1, None);
146 assert_eq!(tv2, tiny_vec![1, 3]);
147
148 let mut tv2 = tv.clone();
149 tv2.splice(1..=2, None);
150 assert_eq!(tv2, tiny_vec![1]);
151
152 // splice adds the elements correctly
153 let mut tv2 = tv.clone();
154 tv2.splice(.., 4..=6);
155 assert_eq!(tv2, tiny_vec![4, 5, 6]);
156
157 let mut tv2 = tv.clone();
158 tv2.splice(..2, 4..=6);
159 assert_eq!(tv2, tiny_vec![4, 5, 6, 3]);
160
161 let mut tv2 = tv.clone();
162 tv2.splice(..3, 4..=6);
163 assert_eq!(tv2, tiny_vec![4, 5, 6]);
164
165 let mut tv2 = tv.clone();
166 tv2.splice(..=1, 4..=6);
167 assert_eq!(tv2, tiny_vec![4, 5, 6, 3]);
168
169 let mut tv2 = tv.clone();
170 tv2.splice(..=2, 4..=6);
171 assert_eq!(tv2, tiny_vec![4, 5, 6]);
172
173 let mut tv2 = tv.clone();
174 tv2.splice(0.., 4..=6);
175 assert_eq!(tv2, tiny_vec![4, 5, 6]);
176
177 let mut tv2 = tv.clone();
178 tv2.splice(1.., 4..=6);
179 assert_eq!(tv2, tiny_vec![1, 4, 5, 6]);
180
181 let mut tv2 = tv.clone();
182 tv2.splice(0..2, 4..=6);
183 assert_eq!(tv2, tiny_vec![4, 5, 6, 3]);
184
185 let mut tv2 = tv.clone();
186 tv2.splice(0..3, 4..=6);
187 assert_eq!(tv2, tiny_vec![4, 5, 6]);
188
189 let mut tv2 = tv.clone();
190 tv2.splice(1..2, 4..=6);
191 assert_eq!(tv2, tiny_vec![1, 4, 5, 6, 3]);
192
193 let mut tv2 = tv.clone();
194 tv2.splice(1..3, 4..=6);
195 assert_eq!(tv2, tiny_vec![1, 4, 5, 6]);
196
197 let mut tv2 = tv.clone();
198 tv2.splice(0..=1, 4..=6);
199 assert_eq!(tv2, tiny_vec![4, 5, 6, 3]);
200
201 let mut tv2 = tv.clone();
202 tv2.splice(0..=2, 4..=6);
203 assert_eq!(tv2, tiny_vec![4, 5, 6]);
204
205 let mut tv2 = tv.clone();
206 tv2.splice(1..=1, 4..=6);
207 assert_eq!(tv2, tiny_vec![1, 4, 5, 6, 3]);
208
209 let mut tv2 = tv.clone();
210 tv2.splice(1..=2, 4..=6);
211 assert_eq!(tv2, tiny_vec![1, 4, 5, 6]);
212
213 // splice adds the elements correctly when the replacement is smaller
214 let mut tv2 = tv.clone();
215 tv2.splice(.., Some(4));
216 assert_eq!(tv2, tiny_vec![4]);
217
218 let mut tv2 = tv.clone();
219 tv2.splice(..2, Some(4));
220 assert_eq!(tv2, tiny_vec![4, 3]);
221
222 let mut tv2 = tv.clone();
223 tv2.splice(1.., Some(4));
224 assert_eq!(tv2, tiny_vec![1, 4]);
225
226 let mut tv2 = tv.clone();
227 tv2.splice(1..=1, Some(4));
228 assert_eq!(tv2, tiny_vec![1, 4, 3]);
229 }
230
231 #[test]
TinyVec_resize()232 fn TinyVec_resize() {
233 let mut tv: TinyVec<[i32; 10]> = Default::default();
234 tv.resize(20, 5);
235 assert_eq!(&tv[..], &[5; 20]);
236 }
237
238 #[test]
TinyVec_from_slice_impl()239 fn TinyVec_from_slice_impl() {
240 let bigger_slice: [u8; 11] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
241 let tinyvec: TinyVec<[u8; 10]> = TinyVec::Heap((&bigger_slice[..]).into());
242 assert_eq!(TinyVec::from(&bigger_slice[..]), tinyvec);
243
244 let smaller_slice: [u8; 5] = [0, 1, 2, 3, 4];
245 let tinyvec: TinyVec<[u8; 10]> = TinyVec::Inline(ArrayVec::from_array_len(
246 [0, 1, 2, 3, 4, 0, 0, 0, 0, 0],
247 5,
248 ));
249 assert_eq!(TinyVec::from(&smaller_slice[..]), tinyvec);
250
251 let same_size: [u8; 4] = [0, 1, 2, 3];
252 let tinyvec: TinyVec<[u8; 4]> =
253 TinyVec::Inline(ArrayVec::from_array_len(same_size, 4));
254 assert_eq!(TinyVec::from(&same_size[..]), tinyvec);
255 }
256
257 #[test]
TinyVec_from_array()258 fn TinyVec_from_array() {
259 let array = [9, 8, 7, 6, 5, 4, 3, 2, 1];
260 let tv = TinyVec::from(array);
261 assert_eq!(&array, &tv[..]);
262 }
263
264 #[test]
TinyVec_macro()265 fn TinyVec_macro() {
266 let mut expected: TinyVec<[i32; 4]> = Default::default();
267 expected.push(1);
268 expected.push(2);
269 expected.push(3);
270
271 let actual = tiny_vec!(1, 2, 3);
272
273 assert_eq!(expected, actual);
274
275 assert_eq!(tiny_vec![0u8; 4], tiny_vec!(0u8, 0u8, 0u8, 0u8));
276 assert_eq!(tiny_vec![0u8; 4], tiny_vec!([u8; 4] => 0, 0, 0, 0));
277 assert_eq!(tiny_vec![0; 4], tiny_vec!(0, 0, 0, 0));
278 assert_eq!(tiny_vec![0; 4], tiny_vec!([u8; 4] => 0, 0, 0, 0));
279
280 let expected2 = tiny_vec![1.1; 3];
281 let actual2 = tiny_vec!([f32; 3] => 1.1, 1.1, 1.1);
282 assert_eq!(expected2, actual2);
283 }
284
285 #[test]
TinyVec_macro_non_copy()286 fn TinyVec_macro_non_copy() {
287 // must use a variable here to avoid macro shenanigans
288 let s = String::new();
289 let _: TinyVec<[String; 10]> = tiny_vec!([String; 10] => s);
290 }
291
292 #[test]
TinyVec_reserve()293 fn TinyVec_reserve() {
294 let mut tv: TinyVec<[i32; 4]> = Default::default();
295 assert_eq!(tv.capacity(), 4);
296 tv.extend_from_slice(&[1, 2]);
297 assert_eq!(tv.capacity(), 4);
298 tv.reserve(2);
299 assert_eq!(tv.capacity(), 4);
300 tv.reserve(4);
301 assert!(tv.capacity() >= 6);
302 tv.extend_from_slice(&[3, 4, 5, 6]);
303 tv.reserve(4);
304 assert!(tv.capacity() >= 10);
305 }
306
307 #[test]
TinyVec_reserve_exact()308 fn TinyVec_reserve_exact() {
309 let mut tv: TinyVec<[i32; 4]> = Default::default();
310 assert_eq!(tv.capacity(), 4);
311
312 tv.extend_from_slice(&[1, 2]);
313 assert_eq!(tv.capacity(), 4);
314 tv.reserve_exact(2);
315 assert_eq!(tv.capacity(), 4);
316 tv.reserve_exact(4);
317 assert!(tv.capacity() >= 6);
318 tv.extend_from_slice(&[3, 4, 5, 6]);
319 tv.reserve_exact(4);
320 assert!(tv.capacity() >= 10);
321 }
322
323 #[test]
TinyVec_move_to_heap_and_shrink()324 fn TinyVec_move_to_heap_and_shrink() {
325 let mut tv: TinyVec<[i32; 4]> = Default::default();
326 assert!(tv.is_inline());
327 tv.move_to_the_heap();
328 assert!(tv.is_heap());
329 assert_eq!(tv.capacity(), 0);
330
331 tv.push(1);
332 tv.shrink_to_fit();
333 assert!(tv.is_inline());
334 assert_eq!(tv.capacity(), 4);
335
336 tv.move_to_the_heap_and_reserve(3);
337 assert!(tv.is_heap());
338 assert_eq!(tv.capacity(), 4);
339 tv.extend(2..=4);
340 assert_eq!(tv.capacity(), 4);
341 assert_eq!(tv.as_slice(), [1, 2, 3, 4]);
342 }
343
344 #[cfg(feature = "serde")]
345 #[test]
TinyVec_ser_de_empty()346 fn TinyVec_ser_de_empty() {
347 let tv: TinyVec<[i32; 0]> = tiny_vec![];
348
349 assert_tokens(&tv, &[Token::Seq { len: Some(0) }, Token::SeqEnd]);
350 }
351
352 #[cfg(feature = "serde")]
353 #[test]
TinyVec_ser_de()354 fn TinyVec_ser_de() {
355 let tv: TinyVec<[i32; 4]> = tiny_vec![1, 2, 3, 4];
356
357 assert_tokens(
358 &tv,
359 &[
360 Token::Seq { len: Some(4) },
361 Token::I32(1),
362 Token::I32(2),
363 Token::I32(3),
364 Token::I32(4),
365 Token::SeqEnd,
366 ],
367 );
368 }
369
370 #[cfg(feature = "serde")]
371 #[test]
TinyVec_ser_de_heap()372 fn TinyVec_ser_de_heap() {
373 let mut tv: TinyVec<[i32; 4]> = tiny_vec![1, 2, 3, 4];
374 tv.move_to_the_heap();
375
376 assert_tokens(
377 &tv,
378 &[
379 Token::Seq { len: Some(4) },
380 Token::I32(1),
381 Token::I32(2),
382 Token::I32(3),
383 Token::I32(4),
384 Token::SeqEnd,
385 ],
386 );
387 }
388
389 #[test]
TinyVec_pretty_debug()390 fn TinyVec_pretty_debug() {
391 let tv: TinyVec<[i32; 6]> = tiny_vec![1, 2, 3];
392 let s = format!("{:#?}", tv);
393 let expected = format!("{:#?}", tv.as_slice());
394
395 assert_eq!(s, expected);
396 }
397