vendor/tinyvec/tests/tinyvec.rs

   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]
  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]
  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]
  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]
  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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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 }