1 extern crate slab;
2
3 use slab::*;
4
5 #[test]
insert_get_remove_one()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]
insert_get_many()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]
insert_get_remove_many()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]
insert_with_vacant_entry()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]
get_vacant_entry_without_using()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]
invalid_get_panics()86 fn invalid_get_panics() {
87 let slab = Slab::<usize>::with_capacity(1);
88 slab[0];
89 }
90
91 #[test]
92 #[should_panic]
double_remove_panics()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]
invalid_remove_panics()102 fn invalid_remove_panics() {
103 let mut slab = Slab::<usize>::with_capacity(1);
104 slab.remove(0);
105 }
106
107 #[test]
slab_get_mut()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]
reserve_does_not_allocate_if_available()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]
reserve_exact_does_not_allocate_if_available()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]
retain()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]
iter()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]
iter_mut()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]
clear()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]
fully_consumed_drain()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]
partially_consumed_drain()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 }
302