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 #[cfg(feature = "rustc_1_57")]
308 #[test]
TinyVec_try_reserve()309 fn TinyVec_try_reserve() {
310 let mut tv: TinyVec<[i32; 4]> = Default::default();
311 assert_eq!(tv.capacity(), 4);
312 tv.extend_from_slice(&[1, 2]);
313 assert_eq!(tv.capacity(), 4);
314 assert!(tv.try_reserve(2).is_ok());
315 assert_eq!(tv.capacity(), 4);
316 assert!(tv.try_reserve(4).is_ok());
317 assert!(tv.capacity() >= 6);
318 tv.extend_from_slice(&[3, 4, 5, 6]);
319 assert!(tv.try_reserve(4).is_ok());
320 assert!(tv.capacity() >= 10);
321 }
322
323 #[test]
TinyVec_reserve_exact()324 fn TinyVec_reserve_exact() {
325 let mut tv: TinyVec<[i32; 4]> = Default::default();
326 assert_eq!(tv.capacity(), 4);
327
328 tv.extend_from_slice(&[1, 2]);
329 assert_eq!(tv.capacity(), 4);
330 tv.reserve_exact(2);
331 assert_eq!(tv.capacity(), 4);
332 tv.reserve_exact(4);
333 assert!(tv.capacity() >= 6);
334 tv.extend_from_slice(&[3, 4, 5, 6]);
335 tv.reserve_exact(4);
336 assert!(tv.capacity() >= 10);
337 }
338
339 #[cfg(feature = "rustc_1_57")]
340 #[test]
TinyVec_try_reserve_exact()341 fn TinyVec_try_reserve_exact() {
342 let mut tv: TinyVec<[i32; 4]> = Default::default();
343 assert_eq!(tv.capacity(), 4);
344
345 tv.extend_from_slice(&[1, 2]);
346 assert_eq!(tv.capacity(), 4);
347 assert!(tv.try_reserve_exact(2).is_ok());
348 assert_eq!(tv.capacity(), 4);
349 assert!(tv.try_reserve_exact(4).is_ok());
350 assert!(tv.capacity() >= 6);
351 tv.extend_from_slice(&[3, 4, 5, 6]);
352 assert!(tv.try_reserve_exact(4).is_ok());
353 assert!(tv.capacity() >= 10);
354 }
355
356 #[test]
TinyVec_move_to_heap_and_shrink()357 fn TinyVec_move_to_heap_and_shrink() {
358 let mut tv: TinyVec<[i32; 4]> = Default::default();
359 assert!(tv.is_inline());
360 tv.move_to_the_heap();
361 assert!(tv.is_heap());
362 assert_eq!(tv.capacity(), 0);
363
364 tv.push(1);
365 tv.shrink_to_fit();
366 assert!(tv.is_inline());
367 assert_eq!(tv.capacity(), 4);
368
369 tv.move_to_the_heap_and_reserve(3);
370 assert!(tv.is_heap());
371 assert_eq!(tv.capacity(), 4);
372 tv.extend(2..=4);
373 assert_eq!(tv.capacity(), 4);
374 assert_eq!(tv.as_slice(), [1, 2, 3, 4]);
375 }
376
377 #[cfg(feature = "rustc_1_57")]
378 #[test]
TinyVec_try_move_to_heap_and_shrink()379 fn TinyVec_try_move_to_heap_and_shrink() {
380 let mut tv: TinyVec<[i32; 4]> = Default::default();
381 assert!(tv.is_inline());
382 assert!(tv.try_move_to_the_heap().is_ok());
383 assert!(tv.is_heap());
384 assert_eq!(tv.capacity(), 0);
385
386 assert!(tv.try_reserve_exact(1).is_ok());
387 assert_eq!(tv.capacity(), 1);
388 tv.push(1);
389 tv.shrink_to_fit();
390 assert!(tv.is_inline());
391 assert_eq!(tv.capacity(), 4);
392
393 assert!(tv.try_move_to_the_heap_and_reserve(3).is_ok());
394 assert!(tv.is_heap());
395 assert_eq!(tv.capacity(), 4);
396 tv.extend(2..=4);
397 assert_eq!(tv.capacity(), 4);
398 assert_eq!(tv.as_slice(), [1, 2, 3, 4]);
399 }
400
401 #[cfg(feature = "serde")]
402 #[test]
TinyVec_ser_de_empty()403 fn TinyVec_ser_de_empty() {
404 let tv: TinyVec<[i32; 0]> = tiny_vec![];
405
406 assert_tokens(&tv, &[Token::Seq { len: Some(0) }, Token::SeqEnd]);
407 }
408
409 #[cfg(feature = "serde")]
410 #[test]
TinyVec_ser_de()411 fn TinyVec_ser_de() {
412 let tv: TinyVec<[i32; 4]> = tiny_vec![1, 2, 3, 4];
413
414 assert_tokens(
415 &tv,
416 &[
417 Token::Seq { len: Some(4) },
418 Token::I32(1),
419 Token::I32(2),
420 Token::I32(3),
421 Token::I32(4),
422 Token::SeqEnd,
423 ],
424 );
425 }
426
427 #[cfg(feature = "serde")]
428 #[test]
TinyVec_ser_de_heap()429 fn TinyVec_ser_de_heap() {
430 let mut tv: TinyVec<[i32; 4]> = tiny_vec![1, 2, 3, 4];
431 tv.move_to_the_heap();
432
433 assert_tokens(
434 &tv,
435 &[
436 Token::Seq { len: Some(4) },
437 Token::I32(1),
438 Token::I32(2),
439 Token::I32(3),
440 Token::I32(4),
441 Token::SeqEnd,
442 ],
443 );
444 }
445
446 #[test]
TinyVec_pretty_debug()447 fn TinyVec_pretty_debug() {
448 let tv: TinyVec<[i32; 6]> = tiny_vec![1, 2, 3];
449 let s = format!("{:#?}", tv);
450 let expected = format!("{:#?}", tv.as_slice());
451
452 assert_eq!(s, expected);
453 }
454
455 #[cfg(feature = "std")]
456 #[test]
TinyVec_std_io_write()457 fn TinyVec_std_io_write() {
458 use std::io::Write;
459 let mut tv: TinyVec<[u8; 3]> = TinyVec::new();
460
461 tv.write_all(b"foo").ok();
462 assert!(tv.is_inline());
463 assert_eq!(tv, tiny_vec![b'f', b'o', b'o']);
464
465 tv.write_all(b"bar").ok();
466 assert!(tv.is_heap());
467 assert_eq!(tv, tiny_vec![b'f', b'o', b'o', b'b', b'a', b'r']);
468 }
469