1 use crate::{smallvec, SmallVec};
2
3 use std::iter::FromIterator;
4
5 use alloc::borrow::ToOwned;
6 use alloc::boxed::Box;
7 use alloc::rc::Rc;
8 use alloc::{vec, vec::Vec};
9
10 #[test]
test_zero()11 pub fn test_zero() {
12 let mut v = SmallVec::<[_; 0]>::new();
13 assert!(!v.spilled());
14 v.push(0usize);
15 assert!(v.spilled());
16 assert_eq!(&*v, &[0]);
17 }
18
19 // We heap allocate all these strings so that double frees will show up under valgrind.
20
21 #[test]
test_inline()22 pub fn test_inline() {
23 let mut v = SmallVec::<[_; 16]>::new();
24 v.push("hello".to_owned());
25 v.push("there".to_owned());
26 assert_eq!(&*v, &["hello".to_owned(), "there".to_owned(),][..]);
27 }
28
29 #[test]
test_spill()30 pub fn test_spill() {
31 let mut v = SmallVec::<[_; 2]>::new();
32 v.push("hello".to_owned());
33 assert_eq!(v[0], "hello");
34 v.push("there".to_owned());
35 v.push("burma".to_owned());
36 assert_eq!(v[0], "hello");
37 v.push("shave".to_owned());
38 assert_eq!(
39 &*v,
40 &[
41 "hello".to_owned(),
42 "there".to_owned(),
43 "burma".to_owned(),
44 "shave".to_owned(),
45 ][..]
46 );
47 }
48
49 #[test]
test_double_spill()50 pub fn test_double_spill() {
51 let mut v = SmallVec::<[_; 2]>::new();
52 v.push("hello".to_owned());
53 v.push("there".to_owned());
54 v.push("burma".to_owned());
55 v.push("shave".to_owned());
56 v.push("hello".to_owned());
57 v.push("there".to_owned());
58 v.push("burma".to_owned());
59 v.push("shave".to_owned());
60 assert_eq!(
61 &*v,
62 &[
63 "hello".to_owned(),
64 "there".to_owned(),
65 "burma".to_owned(),
66 "shave".to_owned(),
67 "hello".to_owned(),
68 "there".to_owned(),
69 "burma".to_owned(),
70 "shave".to_owned(),
71 ][..]
72 );
73 }
74
75 /// https://github.com/servo/rust-smallvec/issues/4
76 #[test]
issue_4()77 fn issue_4() {
78 SmallVec::<[Box<u32>; 2]>::new();
79 }
80
81 /// https://github.com/servo/rust-smallvec/issues/5
82 #[test]
issue_5()83 fn issue_5() {
84 assert!(Some(SmallVec::<[&u32; 2]>::new()).is_some());
85 }
86
87 #[test]
test_with_capacity()88 fn test_with_capacity() {
89 let v: SmallVec<[u8; 3]> = SmallVec::with_capacity(1);
90 assert!(v.is_empty());
91 assert!(!v.spilled());
92 assert_eq!(v.capacity(), 3);
93
94 let v: SmallVec<[u8; 3]> = SmallVec::with_capacity(10);
95 assert!(v.is_empty());
96 assert!(v.spilled());
97 assert_eq!(v.capacity(), 10);
98 }
99
100 #[test]
drain()101 fn drain() {
102 let mut v: SmallVec<[u8; 2]> = SmallVec::new();
103 v.push(3);
104 assert_eq!(v.drain(..).collect::<Vec<_>>(), &[3]);
105
106 // spilling the vec
107 v.push(3);
108 v.push(4);
109 v.push(5);
110 let old_capacity = v.capacity();
111 assert_eq!(v.drain(1..).collect::<Vec<_>>(), &[4, 5]);
112 // drain should not change the capacity
113 assert_eq!(v.capacity(), old_capacity);
114 }
115
116 #[test]
drain_rev()117 fn drain_rev() {
118 let mut v: SmallVec<[u8; 2]> = SmallVec::new();
119 v.push(3);
120 assert_eq!(v.drain(..).rev().collect::<Vec<_>>(), &[3]);
121
122 // spilling the vec
123 v.push(3);
124 v.push(4);
125 v.push(5);
126 assert_eq!(v.drain(..).rev().collect::<Vec<_>>(), &[5, 4, 3]);
127 }
128
129 #[test]
drain_forget()130 fn drain_forget() {
131 let mut v: SmallVec<[u8; 1]> = smallvec![0, 1, 2, 3, 4, 5, 6, 7];
132 std::mem::forget(v.drain(2..5));
133 assert_eq!(v.len(), 2);
134 }
135
136 #[test]
into_iter()137 fn into_iter() {
138 let mut v: SmallVec<[u8; 2]> = SmallVec::new();
139 v.push(3);
140 assert_eq!(v.into_iter().collect::<Vec<_>>(), &[3]);
141
142 // spilling the vec
143 let mut v: SmallVec<[u8; 2]> = SmallVec::new();
144 v.push(3);
145 v.push(4);
146 v.push(5);
147 assert_eq!(v.into_iter().collect::<Vec<_>>(), &[3, 4, 5]);
148 }
149
150 #[test]
into_iter_rev()151 fn into_iter_rev() {
152 let mut v: SmallVec<[u8; 2]> = SmallVec::new();
153 v.push(3);
154 assert_eq!(v.into_iter().rev().collect::<Vec<_>>(), &[3]);
155
156 // spilling the vec
157 let mut v: SmallVec<[u8; 2]> = SmallVec::new();
158 v.push(3);
159 v.push(4);
160 v.push(5);
161 assert_eq!(v.into_iter().rev().collect::<Vec<_>>(), &[5, 4, 3]);
162 }
163
164 #[test]
into_iter_drop()165 fn into_iter_drop() {
166 use std::cell::Cell;
167
168 struct DropCounter<'a>(&'a Cell<i32>);
169
170 impl<'a> Drop for DropCounter<'a> {
171 fn drop(&mut self) {
172 self.0.set(self.0.get() + 1);
173 }
174 }
175
176 {
177 let cell = Cell::new(0);
178 let mut v: SmallVec<[DropCounter<'_>; 2]> = SmallVec::new();
179 v.push(DropCounter(&cell));
180 v.into_iter();
181 assert_eq!(cell.get(), 1);
182 }
183
184 {
185 let cell = Cell::new(0);
186 let mut v: SmallVec<[DropCounter<'_>; 2]> = SmallVec::new();
187 v.push(DropCounter(&cell));
188 v.push(DropCounter(&cell));
189 assert!(v.into_iter().next().is_some());
190 assert_eq!(cell.get(), 2);
191 }
192
193 {
194 let cell = Cell::new(0);
195 let mut v: SmallVec<[DropCounter<'_>; 2]> = SmallVec::new();
196 v.push(DropCounter(&cell));
197 v.push(DropCounter(&cell));
198 v.push(DropCounter(&cell));
199 assert!(v.into_iter().next().is_some());
200 assert_eq!(cell.get(), 3);
201 }
202 {
203 let cell = Cell::new(0);
204 let mut v: SmallVec<[DropCounter<'_>; 2]> = SmallVec::new();
205 v.push(DropCounter(&cell));
206 v.push(DropCounter(&cell));
207 v.push(DropCounter(&cell));
208 {
209 let mut it = v.into_iter();
210 assert!(it.next().is_some());
211 assert!(it.next_back().is_some());
212 }
213 assert_eq!(cell.get(), 3);
214 }
215 }
216
217 #[test]
test_capacity()218 fn test_capacity() {
219 let mut v: SmallVec<[u8; 2]> = SmallVec::new();
220 v.reserve(1);
221 assert_eq!(v.capacity(), 2);
222 assert!(!v.spilled());
223
224 v.reserve_exact(0x100);
225 assert!(v.capacity() >= 0x100);
226
227 v.push(0);
228 v.push(1);
229 v.push(2);
230 v.push(3);
231
232 v.shrink_to_fit();
233 assert!(v.capacity() < 0x100);
234 }
235
236 #[test]
test_truncate()237 fn test_truncate() {
238 let mut v: SmallVec<[Box<u8>; 8]> = SmallVec::new();
239
240 for x in 0..8 {
241 v.push(Box::new(x));
242 }
243 v.truncate(4);
244
245 assert_eq!(v.len(), 4);
246 assert!(!v.spilled());
247
248 assert_eq!(*v.swap_remove(1), 1);
249 assert_eq!(*v.remove(1), 3);
250 v.insert(1, Box::new(3));
251
252 assert_eq!(&v.iter().map(|v| **v).collect::<Vec<_>>(), &[0, 3, 2]);
253 }
254
255 #[test]
test_insert_many()256 fn test_insert_many() {
257 let mut v: SmallVec<[u8; 8]> = SmallVec::new();
258 for x in 0..4 {
259 v.push(x);
260 }
261 assert_eq!(v.len(), 4);
262 v.insert_many(1, [5, 6].iter().cloned());
263 assert_eq!(
264 &v.iter().map(|v| *v).collect::<Vec<_>>(),
265 &[0, 5, 6, 1, 2, 3]
266 );
267 }
268
269 struct MockHintIter<T: Iterator> {
270 x: T,
271 hint: usize,
272 }
273 impl<T: Iterator> Iterator for MockHintIter<T> {
274 type Item = T::Item;
next(&mut self) -> Option<Self::Item>275 fn next(&mut self) -> Option<Self::Item> {
276 self.x.next()
277 }
size_hint(&self) -> (usize, Option<usize>)278 fn size_hint(&self) -> (usize, Option<usize>) {
279 (self.hint, None)
280 }
281 }
282
283 #[test]
test_insert_many_short_hint()284 fn test_insert_many_short_hint() {
285 let mut v: SmallVec<[u8; 8]> = SmallVec::new();
286 for x in 0..4 {
287 v.push(x);
288 }
289 assert_eq!(v.len(), 4);
290 v.insert_many(
291 1,
292 MockHintIter {
293 x: [5, 6].iter().cloned(),
294 hint: 5,
295 },
296 );
297 assert_eq!(
298 &v.iter().map(|v| *v).collect::<Vec<_>>(),
299 &[0, 5, 6, 1, 2, 3]
300 );
301 }
302
303 #[test]
test_insert_many_long_hint()304 fn test_insert_many_long_hint() {
305 let mut v: SmallVec<[u8; 8]> = SmallVec::new();
306 for x in 0..4 {
307 v.push(x);
308 }
309 assert_eq!(v.len(), 4);
310 v.insert_many(
311 1,
312 MockHintIter {
313 x: [5, 6].iter().cloned(),
314 hint: 1,
315 },
316 );
317 assert_eq!(
318 &v.iter().map(|v| *v).collect::<Vec<_>>(),
319 &[0, 5, 6, 1, 2, 3]
320 );
321 }
322
323 // https://github.com/servo/rust-smallvec/issues/96
324 mod insert_many_panic {
325 use crate::{smallvec, SmallVec};
326 use alloc::boxed::Box;
327
328 struct PanicOnDoubleDrop {
329 dropped: Box<bool>,
330 }
331
332 impl PanicOnDoubleDrop {
new() -> Self333 fn new() -> Self {
334 Self {
335 dropped: Box::new(false),
336 }
337 }
338 }
339
340 impl Drop for PanicOnDoubleDrop {
drop(&mut self)341 fn drop(&mut self) {
342 assert!(!*self.dropped, "already dropped");
343 *self.dropped = true;
344 }
345 }
346
347 /// Claims to yield `hint` items, but actually yields `count`, then panics.
348 struct BadIter {
349 hint: usize,
350 count: usize,
351 }
352
353 impl Iterator for BadIter {
354 type Item = PanicOnDoubleDrop;
size_hint(&self) -> (usize, Option<usize>)355 fn size_hint(&self) -> (usize, Option<usize>) {
356 (self.hint, None)
357 }
next(&mut self) -> Option<Self::Item>358 fn next(&mut self) -> Option<Self::Item> {
359 if self.count == 0 {
360 panic!()
361 }
362 self.count -= 1;
363 Some(PanicOnDoubleDrop::new())
364 }
365 }
366
367 #[test]
panic_early_at_start()368 fn panic_early_at_start() {
369 let mut vec: SmallVec<[PanicOnDoubleDrop; 0]> =
370 smallvec![PanicOnDoubleDrop::new(), PanicOnDoubleDrop::new(),];
371 let result = ::std::panic::catch_unwind(move || {
372 vec.insert_many(0, BadIter { hint: 1, count: 0 });
373 });
374 assert!(result.is_err());
375 }
376
377 #[test]
panic_early_in_middle()378 fn panic_early_in_middle() {
379 let mut vec: SmallVec<[PanicOnDoubleDrop; 0]> =
380 smallvec![PanicOnDoubleDrop::new(), PanicOnDoubleDrop::new(),];
381 let result = ::std::panic::catch_unwind(move || {
382 vec.insert_many(1, BadIter { hint: 4, count: 2 });
383 });
384 assert!(result.is_err());
385 }
386
387 #[test]
panic_early_at_end()388 fn panic_early_at_end() {
389 let mut vec: SmallVec<[PanicOnDoubleDrop; 0]> =
390 smallvec![PanicOnDoubleDrop::new(), PanicOnDoubleDrop::new(),];
391 let result = ::std::panic::catch_unwind(move || {
392 vec.insert_many(2, BadIter { hint: 3, count: 1 });
393 });
394 assert!(result.is_err());
395 }
396
397 #[test]
panic_late_at_start()398 fn panic_late_at_start() {
399 let mut vec: SmallVec<[PanicOnDoubleDrop; 0]> =
400 smallvec![PanicOnDoubleDrop::new(), PanicOnDoubleDrop::new(),];
401 let result = ::std::panic::catch_unwind(move || {
402 vec.insert_many(0, BadIter { hint: 3, count: 5 });
403 });
404 assert!(result.is_err());
405 }
406
407 #[test]
panic_late_at_end()408 fn panic_late_at_end() {
409 let mut vec: SmallVec<[PanicOnDoubleDrop; 0]> =
410 smallvec![PanicOnDoubleDrop::new(), PanicOnDoubleDrop::new(),];
411 let result = ::std::panic::catch_unwind(move || {
412 vec.insert_many(2, BadIter { hint: 3, count: 5 });
413 });
414 assert!(result.is_err());
415 }
416 }
417
418 #[test]
419 #[should_panic]
test_invalid_grow()420 fn test_invalid_grow() {
421 let mut v: SmallVec<[u8; 8]> = SmallVec::new();
422 v.extend(0..8);
423 v.grow(5);
424 }
425
426 #[test]
test_insert_from_slice()427 fn test_insert_from_slice() {
428 let mut v: SmallVec<[u8; 8]> = SmallVec::new();
429 for x in 0..4 {
430 v.push(x);
431 }
432 assert_eq!(v.len(), 4);
433 v.insert_from_slice(1, &[5, 6]);
434 assert_eq!(
435 &v.iter().map(|v| *v).collect::<Vec<_>>(),
436 &[0, 5, 6, 1, 2, 3]
437 );
438 }
439
440 #[test]
test_extend_from_slice()441 fn test_extend_from_slice() {
442 let mut v: SmallVec<[u8; 8]> = SmallVec::new();
443 for x in 0..4 {
444 v.push(x);
445 }
446 assert_eq!(v.len(), 4);
447 v.extend_from_slice(&[5, 6]);
448 assert_eq!(
449 &v.iter().map(|v| *v).collect::<Vec<_>>(),
450 &[0, 1, 2, 3, 5, 6]
451 );
452 }
453
454 #[test]
455 #[should_panic]
test_drop_panic_smallvec()456 fn test_drop_panic_smallvec() {
457 // This test should only panic once, and not double panic,
458 // which would mean a double drop
459 struct DropPanic;
460
461 impl Drop for DropPanic {
462 fn drop(&mut self) {
463 panic!("drop");
464 }
465 }
466
467 let mut v = SmallVec::<[_; 1]>::new();
468 v.push(DropPanic);
469 }
470
471 #[test]
test_eq()472 fn test_eq() {
473 let mut a: SmallVec<[u32; 2]> = SmallVec::new();
474 let mut b: SmallVec<[u32; 2]> = SmallVec::new();
475 let mut c: SmallVec<[u32; 2]> = SmallVec::new();
476 // a = [1, 2]
477 a.push(1);
478 a.push(2);
479 // b = [1, 2]
480 b.push(1);
481 b.push(2);
482 // c = [3, 4]
483 c.push(3);
484 c.push(4);
485
486 assert!(a == b);
487 assert!(a != c);
488 }
489
490 #[test]
test_ord()491 fn test_ord() {
492 let mut a: SmallVec<[u32; 2]> = SmallVec::new();
493 let mut b: SmallVec<[u32; 2]> = SmallVec::new();
494 let mut c: SmallVec<[u32; 2]> = SmallVec::new();
495 // a = [1]
496 a.push(1);
497 // b = [1, 1]
498 b.push(1);
499 b.push(1);
500 // c = [1, 2]
501 c.push(1);
502 c.push(2);
503
504 assert!(a < b);
505 assert!(b > a);
506 assert!(b < c);
507 assert!(c > b);
508 }
509
510 #[test]
test_hash()511 fn test_hash() {
512 use std::collections::hash_map::DefaultHasher;
513 use std::hash::Hash;
514
515 {
516 let mut a: SmallVec<[u32; 2]> = SmallVec::new();
517 let b = [1, 2];
518 a.extend(b.iter().cloned());
519 let mut hasher = DefaultHasher::new();
520 assert_eq!(a.hash(&mut hasher), b.hash(&mut hasher));
521 }
522 {
523 let mut a: SmallVec<[u32; 2]> = SmallVec::new();
524 let b = [1, 2, 11, 12];
525 a.extend(b.iter().cloned());
526 let mut hasher = DefaultHasher::new();
527 assert_eq!(a.hash(&mut hasher), b.hash(&mut hasher));
528 }
529 }
530
531 #[test]
test_as_ref()532 fn test_as_ref() {
533 let mut a: SmallVec<[u32; 2]> = SmallVec::new();
534 a.push(1);
535 assert_eq!(a.as_ref(), [1]);
536 a.push(2);
537 assert_eq!(a.as_ref(), [1, 2]);
538 a.push(3);
539 assert_eq!(a.as_ref(), [1, 2, 3]);
540 }
541
542 #[test]
test_as_mut()543 fn test_as_mut() {
544 let mut a: SmallVec<[u32; 2]> = SmallVec::new();
545 a.push(1);
546 assert_eq!(a.as_mut(), [1]);
547 a.push(2);
548 assert_eq!(a.as_mut(), [1, 2]);
549 a.push(3);
550 assert_eq!(a.as_mut(), [1, 2, 3]);
551 a.as_mut()[1] = 4;
552 assert_eq!(a.as_mut(), [1, 4, 3]);
553 }
554
555 #[test]
test_borrow()556 fn test_borrow() {
557 use std::borrow::Borrow;
558
559 let mut a: SmallVec<[u32; 2]> = SmallVec::new();
560 a.push(1);
561 assert_eq!(a.borrow(), [1]);
562 a.push(2);
563 assert_eq!(a.borrow(), [1, 2]);
564 a.push(3);
565 assert_eq!(a.borrow(), [1, 2, 3]);
566 }
567
568 #[test]
test_borrow_mut()569 fn test_borrow_mut() {
570 use std::borrow::BorrowMut;
571
572 let mut a: SmallVec<[u32; 2]> = SmallVec::new();
573 a.push(1);
574 assert_eq!(a.borrow_mut(), [1]);
575 a.push(2);
576 assert_eq!(a.borrow_mut(), [1, 2]);
577 a.push(3);
578 assert_eq!(a.borrow_mut(), [1, 2, 3]);
579 BorrowMut::<[u32]>::borrow_mut(&mut a)[1] = 4;
580 assert_eq!(a.borrow_mut(), [1, 4, 3]);
581 }
582
583 #[test]
test_from()584 fn test_from() {
585 assert_eq!(&SmallVec::<[u32; 2]>::from(&[1][..])[..], [1]);
586 assert_eq!(&SmallVec::<[u32; 2]>::from(&[1, 2, 3][..])[..], [1, 2, 3]);
587
588 let vec = vec![];
589 let small_vec: SmallVec<[u8; 3]> = SmallVec::from(vec);
590 assert_eq!(&*small_vec, &[]);
591 drop(small_vec);
592
593 let vec = vec![1, 2, 3, 4, 5];
594 let small_vec: SmallVec<[u8; 3]> = SmallVec::from(vec);
595 assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);
596 drop(small_vec);
597
598 let vec = vec![1, 2, 3, 4, 5];
599 let small_vec: SmallVec<[u8; 1]> = SmallVec::from(vec);
600 assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);
601 drop(small_vec);
602
603 let array = [1];
604 let small_vec: SmallVec<[u8; 1]> = SmallVec::from(array);
605 assert_eq!(&*small_vec, &[1]);
606 drop(small_vec);
607
608 let array = [99; 128];
609 let small_vec: SmallVec<[u8; 128]> = SmallVec::from(array);
610 assert_eq!(&*small_vec, vec![99u8; 128].as_slice());
611 drop(small_vec);
612 }
613
614 #[test]
test_from_slice()615 fn test_from_slice() {
616 assert_eq!(&SmallVec::<[u32; 2]>::from_slice(&[1][..])[..], [1]);
617 assert_eq!(
618 &SmallVec::<[u32; 2]>::from_slice(&[1, 2, 3][..])[..],
619 [1, 2, 3]
620 );
621 }
622
623 #[test]
test_exact_size_iterator()624 fn test_exact_size_iterator() {
625 let mut vec = SmallVec::<[u32; 2]>::from(&[1, 2, 3][..]);
626 assert_eq!(vec.clone().into_iter().len(), 3);
627 assert_eq!(vec.drain(..2).len(), 2);
628 assert_eq!(vec.into_iter().len(), 1);
629 }
630
631 #[test]
test_into_iter_as_slice()632 fn test_into_iter_as_slice() {
633 let vec = SmallVec::<[u32; 2]>::from(&[1, 2, 3][..]);
634 let mut iter = vec.clone().into_iter();
635 assert_eq!(iter.as_slice(), &[1, 2, 3]);
636 assert_eq!(iter.as_mut_slice(), &[1, 2, 3]);
637 iter.next();
638 assert_eq!(iter.as_slice(), &[2, 3]);
639 assert_eq!(iter.as_mut_slice(), &[2, 3]);
640 iter.next_back();
641 assert_eq!(iter.as_slice(), &[2]);
642 assert_eq!(iter.as_mut_slice(), &[2]);
643 }
644
645 #[test]
test_into_iter_clone()646 fn test_into_iter_clone() {
647 // Test that the cloned iterator yields identical elements and that it owns its own copy
648 // (i.e. no use after move errors).
649 let mut iter = SmallVec::<[u8; 2]>::from_iter(0..3).into_iter();
650 let mut clone_iter = iter.clone();
651 while let Some(x) = iter.next() {
652 assert_eq!(x, clone_iter.next().unwrap());
653 }
654 assert_eq!(clone_iter.next(), None);
655 }
656
657 #[test]
test_into_iter_clone_partially_consumed_iterator()658 fn test_into_iter_clone_partially_consumed_iterator() {
659 // Test that the cloned iterator only contains the remaining elements of the original iterator.
660 let mut iter = SmallVec::<[u8; 2]>::from_iter(0..3).into_iter().skip(1);
661 let mut clone_iter = iter.clone();
662 while let Some(x) = iter.next() {
663 assert_eq!(x, clone_iter.next().unwrap());
664 }
665 assert_eq!(clone_iter.next(), None);
666 }
667
668 #[test]
test_into_iter_clone_empty_smallvec()669 fn test_into_iter_clone_empty_smallvec() {
670 let mut iter = SmallVec::<[u8; 2]>::new().into_iter();
671 let mut clone_iter = iter.clone();
672 assert_eq!(iter.next(), None);
673 assert_eq!(clone_iter.next(), None);
674 }
675
676 #[test]
shrink_to_fit_unspill()677 fn shrink_to_fit_unspill() {
678 let mut vec = SmallVec::<[u8; 2]>::from_iter(0..3);
679 vec.pop();
680 assert!(vec.spilled());
681 vec.shrink_to_fit();
682 assert!(!vec.spilled(), "shrink_to_fit will un-spill if possible");
683 }
684
685 #[test]
test_into_vec()686 fn test_into_vec() {
687 let vec = SmallVec::<[u8; 2]>::from_iter(0..2);
688 assert_eq!(vec.into_vec(), vec![0, 1]);
689
690 let vec = SmallVec::<[u8; 2]>::from_iter(0..3);
691 assert_eq!(vec.into_vec(), vec![0, 1, 2]);
692 }
693
694 #[test]
test_into_inner()695 fn test_into_inner() {
696 let vec = SmallVec::<[u8; 2]>::from_iter(0..2);
697 assert_eq!(vec.into_inner(), Ok([0, 1]));
698
699 let vec = SmallVec::<[u8; 2]>::from_iter(0..1);
700 assert_eq!(vec.clone().into_inner(), Err(vec));
701
702 let vec = SmallVec::<[u8; 2]>::from_iter(0..3);
703 assert_eq!(vec.clone().into_inner(), Err(vec));
704 }
705
706 #[test]
test_from_vec()707 fn test_from_vec() {
708 let vec = vec![];
709 let small_vec: SmallVec<[u8; 3]> = SmallVec::from_vec(vec);
710 assert_eq!(&*small_vec, &[]);
711 drop(small_vec);
712
713 let vec = vec![];
714 let small_vec: SmallVec<[u8; 1]> = SmallVec::from_vec(vec);
715 assert_eq!(&*small_vec, &[]);
716 drop(small_vec);
717
718 let vec = vec![1];
719 let small_vec: SmallVec<[u8; 3]> = SmallVec::from_vec(vec);
720 assert_eq!(&*small_vec, &[1]);
721 drop(small_vec);
722
723 let vec = vec![1, 2, 3];
724 let small_vec: SmallVec<[u8; 3]> = SmallVec::from_vec(vec);
725 assert_eq!(&*small_vec, &[1, 2, 3]);
726 drop(small_vec);
727
728 let vec = vec![1, 2, 3, 4, 5];
729 let small_vec: SmallVec<[u8; 3]> = SmallVec::from_vec(vec);
730 assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);
731 drop(small_vec);
732
733 let vec = vec![1, 2, 3, 4, 5];
734 let small_vec: SmallVec<[u8; 1]> = SmallVec::from_vec(vec);
735 assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);
736 drop(small_vec);
737 }
738
739 #[test]
test_retain()740 fn test_retain() {
741 // Test inline data storate
742 let mut sv: SmallVec<[i32; 5]> = SmallVec::from_slice(&[1, 2, 3, 3, 4]);
743 sv.retain(|&mut i| i != 3);
744 assert_eq!(sv.pop(), Some(4));
745 assert_eq!(sv.pop(), Some(2));
746 assert_eq!(sv.pop(), Some(1));
747 assert_eq!(sv.pop(), None);
748
749 // Test spilled data storage
750 let mut sv: SmallVec<[i32; 3]> = SmallVec::from_slice(&[1, 2, 3, 3, 4]);
751 sv.retain(|&mut i| i != 3);
752 assert_eq!(sv.pop(), Some(4));
753 assert_eq!(sv.pop(), Some(2));
754 assert_eq!(sv.pop(), Some(1));
755 assert_eq!(sv.pop(), None);
756
757 // Test that drop implementations are called for inline.
758 let one = Rc::new(1);
759 let mut sv: SmallVec<[Rc<i32>; 3]> = SmallVec::new();
760 sv.push(Rc::clone(&one));
761 assert_eq!(Rc::strong_count(&one), 2);
762 sv.retain(|_| false);
763 assert_eq!(Rc::strong_count(&one), 1);
764
765 // Test that drop implementations are called for spilled data.
766 let mut sv: SmallVec<[Rc<i32>; 1]> = SmallVec::new();
767 sv.push(Rc::clone(&one));
768 sv.push(Rc::new(2));
769 assert_eq!(Rc::strong_count(&one), 2);
770 sv.retain(|_| false);
771 assert_eq!(Rc::strong_count(&one), 1);
772 }
773
774 #[test]
test_dedup()775 fn test_dedup() {
776 let mut dupes: SmallVec<[i32; 5]> = SmallVec::from_slice(&[1, 1, 2, 3, 3]);
777 dupes.dedup();
778 assert_eq!(&*dupes, &[1, 2, 3]);
779
780 let mut empty: SmallVec<[i32; 5]> = SmallVec::new();
781 empty.dedup();
782 assert!(empty.is_empty());
783
784 let mut all_ones: SmallVec<[i32; 5]> = SmallVec::from_slice(&[1, 1, 1, 1, 1]);
785 all_ones.dedup();
786 assert_eq!(all_ones.len(), 1);
787
788 let mut no_dupes: SmallVec<[i32; 5]> = SmallVec::from_slice(&[1, 2, 3, 4, 5]);
789 no_dupes.dedup();
790 assert_eq!(no_dupes.len(), 5);
791 }
792
793 #[test]
test_resize()794 fn test_resize() {
795 let mut v: SmallVec<[i32; 8]> = SmallVec::new();
796 v.push(1);
797 v.resize(5, 0);
798 assert_eq!(v[..], [1, 0, 0, 0, 0][..]);
799
800 v.resize(2, -1);
801 assert_eq!(v[..], [1, 0][..]);
802 }
803
804 #[cfg(feature = "write")]
805 #[test]
test_write()806 fn test_write() {
807 use std::io::Write;
808
809 let data = [1, 2, 3, 4, 5];
810
811 let mut small_vec: SmallVec<[u8; 2]> = SmallVec::new();
812 let len = small_vec.write(&data[..]).unwrap();
813 assert_eq!(len, 5);
814 assert_eq!(small_vec.as_ref(), data.as_ref());
815
816 let mut small_vec: SmallVec<[u8; 2]> = SmallVec::new();
817 small_vec.write_all(&data[..]).unwrap();
818 assert_eq!(small_vec.as_ref(), data.as_ref());
819 }
820
821 #[cfg(feature = "serde")]
822 extern crate bincode;
823
824 #[cfg(feature = "serde")]
825 #[test]
test_serde()826 fn test_serde() {
827 use self::bincode::{config, deserialize};
828 let mut small_vec: SmallVec<[i32; 2]> = SmallVec::new();
829 small_vec.push(1);
830 let encoded = config().limit(100).serialize(&small_vec).unwrap();
831 let decoded: SmallVec<[i32; 2]> = deserialize(&encoded).unwrap();
832 assert_eq!(small_vec, decoded);
833 small_vec.push(2);
834 // Spill the vec
835 small_vec.push(3);
836 small_vec.push(4);
837 // Check again after spilling.
838 let encoded = config().limit(100).serialize(&small_vec).unwrap();
839 let decoded: SmallVec<[i32; 2]> = deserialize(&encoded).unwrap();
840 assert_eq!(small_vec, decoded);
841 }
842
843 #[test]
grow_to_shrink()844 fn grow_to_shrink() {
845 let mut v: SmallVec<[u8; 2]> = SmallVec::new();
846 v.push(1);
847 v.push(2);
848 v.push(3);
849 assert!(v.spilled());
850 v.clear();
851 // Shrink to inline.
852 v.grow(2);
853 assert!(!v.spilled());
854 assert_eq!(v.capacity(), 2);
855 assert_eq!(v.len(), 0);
856 v.push(4);
857 assert_eq!(v[..], [4]);
858 }
859
860 #[test]
resumable_extend()861 fn resumable_extend() {
862 let s = "a b c";
863 // This iterator yields: (Some('a'), None, Some('b'), None, Some('c')), None
864 let it = s
865 .chars()
866 .scan(0, |_, ch| if ch.is_whitespace() { None } else { Some(ch) });
867 let mut v: SmallVec<[char; 4]> = SmallVec::new();
868 v.extend(it);
869 assert_eq!(v[..], ['a']);
870 }
871
872 // #139
873 #[test]
uninhabited()874 fn uninhabited() {
875 enum Void {}
876 let _sv = SmallVec::<[Void; 8]>::new();
877 }
878
879 #[test]
grow_spilled_same_size()880 fn grow_spilled_same_size() {
881 let mut v: SmallVec<[u8; 2]> = SmallVec::new();
882 v.push(0);
883 v.push(1);
884 v.push(2);
885 assert!(v.spilled());
886 assert_eq!(v.capacity(), 4);
887 // grow with the same capacity
888 v.grow(4);
889 assert_eq!(v.capacity(), 4);
890 assert_eq!(v[..], [0, 1, 2]);
891 }
892
893 #[cfg(feature = "const_generics")]
894 #[test]
const_generics()895 fn const_generics() {
896 let _v = SmallVec::<[i32; 987]>::default();
897 }
898
899 #[test]
empty_macro()900 fn empty_macro() {
901 let _v: SmallVec<[u8; 1]> = smallvec![];
902 }
903
904 #[test]
zero_size_items()905 fn zero_size_items() {
906 SmallVec::<[(); 0]>::new().push(());
907 }
908