vendor/slab/tests/slab.rs

   1 extern crate slab;
   2
   3 use slab::*;
   4
   5 #[test]
   6 fn insert_get_remove_one() {
   7     let mut slab = Slab::new();
   8     assert!(slab.is_empty());
   9
  10     let key = slab.insert(10);
  11
  12     assert_eq!(slab[key], 10);
  13     assert_eq!(slab.get(key), Some(&10));
  14     assert!(!slab.is_empty());
  15     assert!(slab.contains(key));
  16
  17     assert_eq!(slab.remove(key), 10);
  18     assert!(!slab.contains(key));
  19     assert!(slab.get(key).is_none());
  20 }
  21
  22 #[test]
  23 fn insert_get_many() {
  24     let mut slab = Slab::with_capacity(10);
  25
  26     for i in 0..10 {
  27         let key = slab.insert(i + 10);
  28         assert_eq!(slab[key], i + 10);
  29     }
  30
  31     assert_eq!(slab.capacity(), 10);
  32
  33     // Storing another one grows the slab
  34     let key = slab.insert(20);
  35     assert_eq!(slab[key], 20);
  36
  37     // Capacity grows by 2x
  38     assert_eq!(slab.capacity(), 20);
  39 }
  40
  41 #[test]
  42 fn insert_get_remove_many() {
  43     let mut slab = Slab::with_capacity(10);
  44     let mut keys = vec![];
  45
  46     for i in 0..10 {
  47         for j in 0..10 {
  48             let val = (i * 10) + j;
  49
  50             let key = slab.insert(val);
  51             keys.push((key, val));
  52             assert_eq!(slab[key], val);
  53         }
  54
  55         for (key, val) in keys.drain(..) {
  56             assert_eq!(val, slab.remove(key));
  57         }
  58     }
  59
  60     assert_eq!(10, slab.capacity());
  61 }
  62
  63 #[test]
  64 fn insert_with_vacant_entry() {
  65     let mut slab = Slab::with_capacity(1);
  66     let key;
  67
  68     {
  69         let entry = slab.vacant_entry();
  70         key = entry.key();
  71         entry.insert(123);
  72     }
  73
  74     assert_eq!(123, slab[key]);
  75 }
  76
  77 #[test]
  78 fn get_vacant_entry_without_using() {
  79     let mut slab = Slab::<usize>::with_capacity(1);
  80     let key = slab.vacant_entry().key();
  81     assert_eq!(key, slab.vacant_entry().key());
  82 }
  83
  84 #[test]
  85 #[should_panic]
  86 fn invalid_get_panics() {
  87     let slab = Slab::<usize>::with_capacity(1);
  88     slab[0];
  89 }
  90
  91 #[test]
  92 #[should_panic]
  93 fn double_remove_panics() {
  94     let mut slab = Slab::<usize>::with_capacity(1);
  95     let key = slab.insert(123);
  96     slab.remove(key);
  97     slab.remove(key);
  98 }
  99
 100 #[test]
 101 #[should_panic]
 102 fn invalid_remove_panics() {
 103     let mut slab = Slab::<usize>::with_capacity(1);
 104     slab.remove(0);
 105 }
 106
 107 #[test]
 108 fn slab_get_mut() {
 109     let mut slab = Slab::new();
 110     let key = slab.insert(1);
 111
 112     slab[key] = 2;
 113     assert_eq!(slab[key], 2);
 114
 115     *slab.get_mut(key).unwrap() = 3;
 116     assert_eq!(slab[key], 3);
 117 }
 118
 119 #[test]
 120 fn reserve_does_not_allocate_if_available() {
 121     let mut slab = Slab::with_capacity(10);
 122     let mut keys = vec![];
 123
 124     for i in 0..6 {
 125         keys.push(slab.insert(i));
 126     }
 127
 128     for key in 0..4 {
 129         slab.remove(key);
 130     }
 131
 132     assert!(slab.capacity() - slab.len() == 8);
 133
 134     slab.reserve(8);
 135     assert_eq!(10, slab.capacity());
 136 }
 137
 138 #[test]
 139 fn reserve_exact_does_not_allocate_if_available() {
 140     let mut slab = Slab::with_capacity(10);
 141     let mut keys = vec![];
 142
 143     for i in 0..6 {
 144         keys.push(slab.insert(i));
 145     }
 146
 147     for key in 0..4 {
 148         slab.remove(key);
 149     }
 150
 151     assert!(slab.capacity() - slab.len() == 8);
 152
 153     slab.reserve(8);
 154     assert_eq!(10, slab.capacity());
 155 }
 156
 157 #[test]
 158 fn retain() {
 159     let mut slab = Slab::with_capacity(2);
 160
 161     let key1 = slab.insert(0);
 162     let key2 = slab.insert(1);
 163
 164     slab.retain(|key, x| {
 165         assert_eq!(key, *x);
 166         *x % 2 == 0
 167     });
 168
 169     assert_eq!(slab.len(), 1);
 170     assert_eq!(slab[key1], 0);
 171     assert!(!slab.contains(key2));
 172
 173     // Ensure consistency is retained
 174     let key = slab.insert(123);
 175     assert_eq!(key, key2);
 176
 177     assert_eq!(2, slab.len());
 178     assert_eq!(2, slab.capacity());
 179
 180     // Inserting another element grows
 181     let key = slab.insert(345);
 182     assert_eq!(key, 2);
 183
 184     assert_eq!(4, slab.capacity());
 185 }
 186
 187 #[test]
 188 fn iter() {
 189     let mut slab = Slab::new();
 190
 191     for i in 0..4 {
 192         slab.insert(i);
 193     }
 194
 195     let vals: Vec<_> = slab
 196         .iter()
 197         .enumerate()
 198         .map(|(i, (key, val))| {
 199             assert_eq!(i, key);
 200             *val
 201         })
 202         .collect();
 203     assert_eq!(vals, vec![0, 1, 2, 3]);
 204
 205     slab.remove(1);
 206
 207     let vals: Vec<_> = slab.iter().map(|(_, r)| *r).collect();
 208     assert_eq!(vals, vec![0, 2, 3]);
 209 }
 210
 211 #[test]
 212 fn iter_mut() {
 213     let mut slab = Slab::new();
 214
 215     for i in 0..4 {
 216         slab.insert(i);
 217     }
 218
 219     for (i, (key, e)) in slab.iter_mut().enumerate() {
 220         assert_eq!(i, key);
 221         *e = *e + 1;
 222     }
 223
 224     let vals: Vec<_> = slab.iter().map(|(_, r)| *r).collect();
 225     assert_eq!(vals, vec![1, 2, 3, 4]);
 226
 227     slab.remove(2);
 228
 229     for (_, e) in slab.iter_mut() {
 230         *e = *e + 1;
 231     }
 232
 233     let vals: Vec<_> = slab.iter().map(|(_, r)| *r).collect();
 234     assert_eq!(vals, vec![2, 3, 5]);
 235 }
 236
 237 #[test]
 238 fn clear() {
 239     let mut slab = Slab::new();
 240
 241     for i in 0..4 {
 242         slab.insert(i);
 243     }
 244
 245     // clear full
 246     slab.clear();
 247
 248     let vals: Vec<_> = slab.iter().map(|(_, r)| *r).collect();
 249     assert!(vals.is_empty());
 250
 251     assert_eq!(0, slab.len());
 252     assert_eq!(4, slab.capacity());
 253
 254     for i in 0..2 {
 255         slab.insert(i);
 256     }
 257
 258     let vals: Vec<_> = slab.iter().map(|(_, r)| *r).collect();
 259     assert_eq!(vals, vec![0, 1]);
 260
 261     // clear half-filled
 262     slab.clear();
 263
 264     let vals: Vec<_> = slab.iter().map(|(_, r)| *r).collect();
 265     assert!(vals.is_empty());
 266 }
 267
 268 #[test]
 269 fn fully_consumed_drain() {
 270     let mut slab = Slab::new();
 271
 272     for i in 0..3 {
 273         slab.insert(i);
 274     }
 275
 276     {
 277         let mut drain = slab.drain();
 278         assert_eq!(Some(0), drain.next());
 279         assert_eq!(Some(1), drain.next());
 280         assert_eq!(Some(2), drain.next());
 281         assert_eq!(None, drain.next());
 282     }
 283
 284     assert!(slab.is_empty());
 285 }
 286
 287 #[test]
 288 fn partially_consumed_drain() {
 289     let mut slab = Slab::new();
 290
 291     for i in 0..3 {
 292         slab.insert(i);
 293     }
 294
 295     {
 296         let mut drain = slab.drain();
 297         assert_eq!(Some(0), drain.next());
 298     }
 299
 300     assert!(slab.is_empty())
 301 }