-#![allow(bad_style)]
-#![allow(clippy::redundant_clone)]
-
-use std::iter::FromIterator;
-use tinyvec::*;
-
-#[test]
-fn TinyVec_swap_remove() {
- let mut tv: TinyVec<[i32; 10]> = Default::default();
- tv.push(1);
- tv.push(2);
- tv.push(3);
- tv.push(4);
- assert_eq!(tv.swap_remove(3), 4);
- assert_eq!(&tv[..], &[1, 2, 3][..]);
- assert_eq!(tv.swap_remove(0), 1);
- assert_eq!(&tv[..], &[3, 2][..]);
- assert_eq!(tv.swap_remove(0), 3);
- assert_eq!(&tv[..], &[2][..]);
- assert_eq!(tv.swap_remove(0), 2);
- assert_eq!(&tv[..], &[][..]);
-}
-
-#[test]
-fn TinyVec_capacity() {
- let mut tv: TinyVec<[i32; 1]> = Default::default();
- assert_eq!(tv.capacity(), 1);
- tv.move_to_the_heap();
- tv.extend_from_slice(&[1, 2, 3, 4]);
- assert_eq!(tv.capacity(), 4);
-}
-
-#[test]
-fn TinyVec_drain() {
- let mut tv: TinyVec<[i32; 10]> = Default::default();
- tv.push(1);
- tv.push(2);
- tv.push(3);
-
- assert_eq!(Vec::from_iter(tv.clone().drain(..)), vec![1, 2, 3]);
-
- assert_eq!(Vec::from_iter(tv.clone().drain(..2)), vec![1, 2]);
- assert_eq!(Vec::from_iter(tv.clone().drain(..3)), vec![1, 2, 3]);
-
- assert_eq!(Vec::from_iter(tv.clone().drain(..=1)), vec![1, 2]);
- assert_eq!(Vec::from_iter(tv.clone().drain(..=2)), vec![1, 2, 3]);
-
- assert_eq!(Vec::from_iter(tv.clone().drain(0..)), vec![1, 2, 3]);
- assert_eq!(Vec::from_iter(tv.clone().drain(1..)), vec![2, 3]);
-
- assert_eq!(Vec::from_iter(tv.clone().drain(0..2)), vec![1, 2]);
- assert_eq!(Vec::from_iter(tv.clone().drain(0..3)), vec![1, 2, 3]);
- assert_eq!(Vec::from_iter(tv.clone().drain(1..2)), vec![2]);
- assert_eq!(Vec::from_iter(tv.clone().drain(1..3)), vec![2, 3]);
-
- assert_eq!(Vec::from_iter(tv.clone().drain(0..=1)), vec![1, 2]);
- assert_eq!(Vec::from_iter(tv.clone().drain(0..=2)), vec![1, 2, 3]);
- assert_eq!(Vec::from_iter(tv.clone().drain(1..=1)), vec![2]);
- assert_eq!(Vec::from_iter(tv.clone().drain(1..=2)), vec![2, 3]);
-}
-
-#[test]
-fn TinyVec_resize() {
- let mut tv: TinyVec<[i32; 10]> = Default::default();
- tv.resize(20, 5);
- assert_eq!(&tv[..], &[5; 20]);
-}
-
-#[test]
-fn TinyVec_from_slice_impl() {
- let bigger_slice: [u8; 11] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
- let tinyvec: TinyVec<[u8; 10]> = TinyVec::Heap((&bigger_slice[..]).into());
- assert_eq!(TinyVec::from(&bigger_slice[..]), tinyvec);
-
- let smaller_slice: [u8; 5] = [0, 1, 2, 3, 4];
- let tinyvec: TinyVec<[u8; 10]> = TinyVec::Inline(ArrayVec::from_array_len(
- [0, 1, 2, 3, 4, 0, 0, 0, 0, 0],
- 5,
- ));
- assert_eq!(TinyVec::from(&smaller_slice[..]), tinyvec);
-
- let same_size: [u8; 4] = [0, 1, 2, 3];
- let tinyvec: TinyVec<[u8; 4]> =
- TinyVec::Inline(ArrayVec::from_array_len(same_size, 4));
- assert_eq!(TinyVec::from(&same_size[..]), tinyvec);
-}
-
-#[test]
-fn TinyVec_from_array() {
- let array = [9, 8, 7, 6, 5, 4, 3, 2, 1];
- let tv = TinyVec::from(array);
- assert_eq!(&array, &tv[..]);
-}
+#![cfg(feature = "alloc")]\r
+#![allow(bad_style)]\r
+#![allow(clippy::redundant_clone)]\r
+\r
+#[cfg(feature = "serde")]\r
+use serde_test::{assert_tokens, Token};\r
+use std::iter::FromIterator;\r
+use tinyvec::*;\r
+\r
+#[test]\r
+fn TinyVec_swap_remove() {\r
+ let mut tv: TinyVec<[i32; 10]> = Default::default();\r
+ tv.push(1);\r
+ tv.push(2);\r
+ tv.push(3);\r
+ tv.push(4);\r
+ assert_eq!(tv.swap_remove(3), 4);\r
+ assert_eq!(&tv[..], &[1, 2, 3][..]);\r
+ assert_eq!(tv.swap_remove(0), 1);\r
+ assert_eq!(&tv[..], &[3, 2][..]);\r
+ assert_eq!(tv.swap_remove(0), 3);\r
+ assert_eq!(&tv[..], &[2][..]);\r
+ assert_eq!(tv.swap_remove(0), 2);\r
+ assert_eq!(&tv[..], &[][..]);\r
+}\r
+\r
+#[test]\r
+fn TinyVec_capacity() {\r
+ let mut tv: TinyVec<[i32; 1]> = Default::default();\r
+ assert_eq!(tv.capacity(), 1);\r
+ tv.move_to_the_heap();\r
+ tv.extend_from_slice(&[1, 2, 3, 4]);\r
+ assert_eq!(tv.capacity(), 4);\r
+}\r
+\r
+#[test]\r
+fn TinyVec_drain() {\r
+ let mut tv: TinyVec<[i32; 10]> = Default::default();\r
+ tv.push(1);\r
+ tv.push(2);\r
+ tv.push(3);\r
+\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(..)), vec![1, 2, 3]);\r
+\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(..2)), vec![1, 2]);\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(..3)), vec![1, 2, 3]);\r
+\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(..=1)), vec![1, 2]);\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(..=2)), vec![1, 2, 3]);\r
+\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(0..)), vec![1, 2, 3]);\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(1..)), vec![2, 3]);\r
+\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(0..2)), vec![1, 2]);\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(0..3)), vec![1, 2, 3]);\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(1..2)), vec![2]);\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(1..3)), vec![2, 3]);\r
+\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(0..=1)), vec![1, 2]);\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(0..=2)), vec![1, 2, 3]);\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(1..=1)), vec![2]);\r
+ assert_eq!(Vec::from_iter(tv.clone().drain(1..=2)), vec![2, 3]);\r
+}\r
+\r
+#[test]\r
+fn TinyVec_splice() {\r
+ let mut tv: TinyVec<[i32; 10]> = Default::default();\r
+ tv.push(1);\r
+ tv.push(2);\r
+ tv.push(3);\r
+\r
+ // splice returns the same things as drain\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(.., None)), vec![1, 2, 3]);\r
+\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(..2, None)), vec![1, 2]);\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(..3, None)), vec![1, 2, 3]);\r
+\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(..=1, None)), vec![1, 2]);\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(..=2, None)), vec![1, 2, 3]);\r
+\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(0.., None)), vec![1, 2, 3]);\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(1.., None)), vec![2, 3]);\r
+\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(0..2, None)), vec![1, 2]);\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(0..3, None)), vec![1, 2, 3]);\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(1..2, None)), vec![2]);\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(1..3, None)), vec![2, 3]);\r
+\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(0..=1, None)), vec![1, 2]);\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(0..=2, None)), vec![1, 2, 3]);\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(1..=1, None)), vec![2]);\r
+ assert_eq!(Vec::from_iter(tv.clone().splice(1..=2, None)), vec![2, 3]);\r
+\r
+ // splice removes the same things as drain\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(.., None);\r
+ assert_eq!(tv2, tiny_vec![]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(..2, None);\r
+ assert_eq!(tv2, tiny_vec![3]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(..3, None);\r
+ assert_eq!(tv2, tiny_vec![]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(..=1, None);\r
+ assert_eq!(tv2, tiny_vec![3]);\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(..=2, None);\r
+ assert_eq!(tv2, tiny_vec![]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(0.., None);\r
+ assert_eq!(tv2, tiny_vec![]);\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(1.., None);\r
+ assert_eq!(tv2, tiny_vec![1]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(0..2, None);\r
+ assert_eq!(tv2, tiny_vec![3]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(0..3, None);\r
+ assert_eq!(tv2, tiny_vec![]);\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(1..2, None);\r
+ assert_eq!(tv2, tiny_vec![1, 3]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(1..3, None);\r
+ assert_eq!(tv2, tiny_vec![1]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(0..=1, None);\r
+ assert_eq!(tv2, tiny_vec![3]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(0..=2, None);\r
+ assert_eq!(tv2, tiny_vec![]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(1..=1, None);\r
+ assert_eq!(tv2, tiny_vec![1, 3]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(1..=2, None);\r
+ assert_eq!(tv2, tiny_vec![1]);\r
+\r
+ // splice adds the elements correctly\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(.., 4..=6);\r
+ assert_eq!(tv2, tiny_vec![4, 5, 6]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(..2, 4..=6);\r
+ assert_eq!(tv2, tiny_vec![4, 5, 6, 3]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(..3, 4..=6);\r
+ assert_eq!(tv2, tiny_vec![4, 5, 6]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(..=1, 4..=6);\r
+ assert_eq!(tv2, tiny_vec![4, 5, 6, 3]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(..=2, 4..=6);\r
+ assert_eq!(tv2, tiny_vec![4, 5, 6]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(0.., 4..=6);\r
+ assert_eq!(tv2, tiny_vec![4, 5, 6]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(1.., 4..=6);\r
+ assert_eq!(tv2, tiny_vec![1, 4, 5, 6]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(0..2, 4..=6);\r
+ assert_eq!(tv2, tiny_vec![4, 5, 6, 3]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(0..3, 4..=6);\r
+ assert_eq!(tv2, tiny_vec![4, 5, 6]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(1..2, 4..=6);\r
+ assert_eq!(tv2, tiny_vec![1, 4, 5, 6, 3]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(1..3, 4..=6);\r
+ assert_eq!(tv2, tiny_vec![1, 4, 5, 6]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(0..=1, 4..=6);\r
+ assert_eq!(tv2, tiny_vec![4, 5, 6, 3]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(0..=2, 4..=6);\r
+ assert_eq!(tv2, tiny_vec![4, 5, 6]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(1..=1, 4..=6);\r
+ assert_eq!(tv2, tiny_vec![1, 4, 5, 6, 3]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(1..=2, 4..=6);\r
+ assert_eq!(tv2, tiny_vec![1, 4, 5, 6]);\r
+\r
+ // splice adds the elements correctly when the replacement is smaller\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(.., Some(4));\r
+ assert_eq!(tv2, tiny_vec![4]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(..2, Some(4));\r
+ assert_eq!(tv2, tiny_vec![4, 3]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(1.., Some(4));\r
+ assert_eq!(tv2, tiny_vec![1, 4]);\r
+\r
+ let mut tv2 = tv.clone();\r
+ tv2.splice(1..=1, Some(4));\r
+ assert_eq!(tv2, tiny_vec![1, 4, 3]);\r
+}\r
+\r
+#[test]\r
+fn TinyVec_resize() {\r
+ let mut tv: TinyVec<[i32; 10]> = Default::default();\r
+ tv.resize(20, 5);\r
+ assert_eq!(&tv[..], &[5; 20]);\r
+}\r
+\r
+#[test]\r
+fn TinyVec_from_slice_impl() {\r
+ let bigger_slice: [u8; 11] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\r
+ let tinyvec: TinyVec<[u8; 10]> = TinyVec::Heap((&bigger_slice[..]).into());\r
+ assert_eq!(TinyVec::from(&bigger_slice[..]), tinyvec);\r
+\r
+ let smaller_slice: [u8; 5] = [0, 1, 2, 3, 4];\r
+ let tinyvec: TinyVec<[u8; 10]> = TinyVec::Inline(ArrayVec::from_array_len(\r
+ [0, 1, 2, 3, 4, 0, 0, 0, 0, 0],\r
+ 5,\r
+ ));\r
+ assert_eq!(TinyVec::from(&smaller_slice[..]), tinyvec);\r
+\r
+ let same_size: [u8; 4] = [0, 1, 2, 3];\r
+ let tinyvec: TinyVec<[u8; 4]> =\r
+ TinyVec::Inline(ArrayVec::from_array_len(same_size, 4));\r
+ assert_eq!(TinyVec::from(&same_size[..]), tinyvec);\r
+}\r
+\r
+#[test]\r
+fn TinyVec_from_array() {\r
+ let array = [9, 8, 7, 6, 5, 4, 3, 2, 1];\r
+ let tv = TinyVec::from(array);\r
+ assert_eq!(&array, &tv[..]);\r
+}\r
+\r
+#[test]\r
+fn TinyVec_macro() {\r
+ let mut expected: TinyVec<[i32; 4]> = Default::default();\r
+ expected.push(1);\r
+ expected.push(2);\r
+ expected.push(3);\r
+\r
+ let actual = tiny_vec!(1, 2, 3);\r
+\r
+ assert_eq!(expected, actual);\r
+\r
+ assert_eq!(tiny_vec![0u8; 4], tiny_vec!(0u8, 0u8, 0u8, 0u8));\r
+ assert_eq!(tiny_vec![0u8; 4], tiny_vec!([u8; 4] => 0, 0, 0, 0));\r
+ assert_eq!(tiny_vec![0; 4], tiny_vec!(0, 0, 0, 0));\r
+ assert_eq!(tiny_vec![0; 4], tiny_vec!([u8; 4] => 0, 0, 0, 0));\r
+\r
+ let expected2 = tiny_vec![1.1; 3];\r
+ let actual2 = tiny_vec!([f32; 3] => 1.1, 1.1, 1.1);\r
+ assert_eq!(expected2, actual2);\r
+}\r
+\r
+#[test]\r
+fn TinyVec_macro_non_copy() {\r
+ // must use a variable here to avoid macro shenanigans\r
+ let s = String::new();\r
+ let _: TinyVec<[String; 10]> = tiny_vec!([String; 10] => s);\r
+}\r
+\r
+#[test]\r
+fn TinyVec_reserve() {\r
+ let mut tv: TinyVec<[i32; 4]> = Default::default();\r
+ assert_eq!(tv.capacity(), 4);\r
+ tv.extend_from_slice(&[1, 2]);\r
+ assert_eq!(tv.capacity(), 4);\r
+ tv.reserve(2);\r
+ assert_eq!(tv.capacity(), 4);\r
+ tv.reserve(4);\r
+ assert!(tv.capacity() >= 6);\r
+ tv.extend_from_slice(&[3, 4, 5, 6]);\r
+ tv.reserve(4);\r
+ assert!(tv.capacity() >= 10);\r
+}\r
+\r
+#[test]\r
+fn TinyVec_reserve_exact() {\r
+ let mut tv: TinyVec<[i32; 4]> = Default::default();\r
+ assert_eq!(tv.capacity(), 4);\r
+\r
+ tv.extend_from_slice(&[1, 2]);\r
+ assert_eq!(tv.capacity(), 4);\r
+ tv.reserve_exact(2);\r
+ assert_eq!(tv.capacity(), 4);\r
+ tv.reserve_exact(4);\r
+ assert!(tv.capacity() >= 6);\r
+ tv.extend_from_slice(&[3, 4, 5, 6]);\r
+ tv.reserve_exact(4);\r
+ assert!(tv.capacity() >= 10);\r
+}\r
+\r
+#[test]\r
+fn TinyVec_move_to_heap_and_shrink() {\r
+ let mut tv: TinyVec<[i32; 4]> = Default::default();\r
+ assert!(tv.is_inline());\r
+ tv.move_to_the_heap();\r
+ assert!(tv.is_heap());\r
+ assert_eq!(tv.capacity(), 0);\r
+\r
+ tv.push(1);\r
+ tv.shrink_to_fit();\r
+ assert!(tv.is_inline());\r
+ assert_eq!(tv.capacity(), 4);\r
+\r
+ tv.move_to_the_heap_and_reserve(3);\r
+ assert!(tv.is_heap());\r
+ assert_eq!(tv.capacity(), 4);\r
+ tv.extend(2..=4);\r
+ assert_eq!(tv.capacity(), 4);\r
+ assert_eq!(tv.as_slice(), [1, 2, 3, 4]);\r
+}\r
+\r
+#[cfg(feature = "serde")]\r
+#[test]\r
+fn TinyVec_ser_de_empty() {\r
+ let tv: TinyVec<[i32; 0]> = tiny_vec![];\r
+\r
+ assert_tokens(&tv, &[Token::Seq { len: Some(0) }, Token::SeqEnd]);\r
+}\r
+\r
+#[cfg(feature = "serde")]\r
+#[test]\r
+fn TinyVec_ser_de() {\r
+ let tv: TinyVec<[i32; 4]> = tiny_vec![1, 2, 3, 4];\r
+\r
+ assert_tokens(\r
+ &tv,\r
+ &[\r
+ Token::Seq { len: Some(4) },\r
+ Token::I32(1),\r
+ Token::I32(2),\r
+ Token::I32(3),\r
+ Token::I32(4),\r
+ Token::SeqEnd,\r
+ ],\r
+ );\r
+}\r
+\r
+#[cfg(feature = "serde")]\r
+#[test]\r
+fn TinyVec_ser_de_heap() {\r
+ let mut tv: TinyVec<[i32; 4]> = tiny_vec![1, 2, 3, 4];\r
+ tv.move_to_the_heap();\r
+\r
+ assert_tokens(\r
+ &tv,\r
+ &[\r
+ Token::Seq { len: Some(4) },\r
+ Token::I32(1),\r
+ Token::I32(2),\r
+ Token::I32(3),\r
+ Token::I32(4),\r
+ Token::SeqEnd,\r
+ ],\r
+ );\r
+}\r
projects / rustc.git / blobdiff