]>
Commit | Line | Data |
---|---|---|
2c00a5a8 XL |
1 | extern crate arrayvec; |
2 | #[macro_use] extern crate matches; | |
3 | ||
4 | use arrayvec::ArrayVec; | |
5 | use arrayvec::ArrayString; | |
6 | use std::mem; | |
7 | use arrayvec::CapacityError; | |
8 | ||
9 | use std::collections::HashMap; | |
10 | ||
11 | ||
12 | #[test] | |
13 | fn test_simple() { | |
14 | use std::ops::Add; | |
15 | ||
16 | let mut vec: ArrayVec<[Vec<i32>; 3]> = ArrayVec::new(); | |
17 | ||
18 | vec.push(vec![1, 2, 3, 4]); | |
19 | vec.push(vec![10]); | |
20 | vec.push(vec![-1, 13, -2]); | |
21 | ||
22 | for elt in &vec { | |
23 | assert_eq!(elt.iter().fold(0, Add::add), 10); | |
24 | } | |
25 | ||
26 | let sum_len = vec.into_iter().map(|x| x.len()).fold(0, Add::add); | |
27 | assert_eq!(sum_len, 8); | |
28 | } | |
29 | ||
f035d41b XL |
30 | #[test] |
31 | fn test_capacity_left() { | |
32 | let mut vec: ArrayVec<[usize; 4]> = ArrayVec::new(); | |
33 | assert_eq!(vec.remaining_capacity(), 4); | |
34 | vec.push(1); | |
35 | assert_eq!(vec.remaining_capacity(), 3); | |
36 | vec.push(2); | |
37 | assert_eq!(vec.remaining_capacity(), 2); | |
38 | vec.push(3); | |
39 | assert_eq!(vec.remaining_capacity(), 1); | |
40 | vec.push(4); | |
41 | assert_eq!(vec.remaining_capacity(), 0); | |
42 | } | |
43 | ||
44 | #[test] | |
45 | fn test_extend_from_slice() { | |
46 | let mut vec: ArrayVec<[usize; 10]> = ArrayVec::new(); | |
47 | ||
48 | vec.try_extend_from_slice(&[1, 2, 3]).unwrap(); | |
49 | assert_eq!(vec.len(), 3); | |
50 | assert_eq!(&vec[..], &[1, 2, 3]); | |
51 | assert_eq!(vec.pop(), Some(3)); | |
52 | assert_eq!(&vec[..], &[1, 2]); | |
53 | } | |
54 | ||
55 | #[test] | |
56 | fn test_extend_from_slice_error() { | |
57 | let mut vec: ArrayVec<[usize; 10]> = ArrayVec::new(); | |
58 | ||
59 | vec.try_extend_from_slice(&[1, 2, 3]).unwrap(); | |
60 | let res = vec.try_extend_from_slice(&[0; 8]); | |
61 | assert_matches!(res, Err(_)); | |
62 | ||
63 | let mut vec: ArrayVec<[usize; 0]> = ArrayVec::new(); | |
64 | let res = vec.try_extend_from_slice(&[0; 1]); | |
65 | assert_matches!(res, Err(_)); | |
66 | } | |
67 | ||
2c00a5a8 XL |
68 | #[test] |
69 | fn test_u16_index() { | |
70 | const N: usize = 4096; | |
71 | let mut vec: ArrayVec<[_; N]> = ArrayVec::new(); | |
72 | for _ in 0..N { | |
73 | assert!(vec.try_push(1u8).is_ok()); | |
74 | } | |
75 | assert!(vec.try_push(0).is_err()); | |
76 | assert_eq!(vec.len(), N); | |
77 | } | |
78 | ||
79 | #[test] | |
80 | fn test_iter() { | |
81 | let mut iter = ArrayVec::from([1, 2, 3]).into_iter(); | |
82 | assert_eq!(iter.size_hint(), (3, Some(3))); | |
83 | assert_eq!(iter.next_back(), Some(3)); | |
84 | assert_eq!(iter.next(), Some(1)); | |
85 | assert_eq!(iter.next_back(), Some(2)); | |
86 | assert_eq!(iter.size_hint(), (0, Some(0))); | |
87 | assert_eq!(iter.next_back(), None); | |
88 | } | |
89 | ||
90 | #[test] | |
91 | fn test_drop() { | |
92 | use std::cell::Cell; | |
93 | ||
94 | let flag = &Cell::new(0); | |
95 | ||
f035d41b | 96 | #[derive(Clone)] |
2c00a5a8 XL |
97 | struct Bump<'a>(&'a Cell<i32>); |
98 | ||
99 | impl<'a> Drop for Bump<'a> { | |
100 | fn drop(&mut self) { | |
101 | let n = self.0.get(); | |
102 | self.0.set(n + 1); | |
103 | } | |
104 | } | |
105 | ||
106 | { | |
107 | let mut array = ArrayVec::<[Bump; 128]>::new(); | |
108 | array.push(Bump(flag)); | |
109 | array.push(Bump(flag)); | |
110 | } | |
111 | assert_eq!(flag.get(), 2); | |
112 | ||
113 | // test something with the nullable pointer optimization | |
114 | flag.set(0); | |
115 | ||
116 | { | |
117 | let mut array = ArrayVec::<[_; 3]>::new(); | |
118 | array.push(vec![Bump(flag)]); | |
119 | array.push(vec![Bump(flag), Bump(flag)]); | |
120 | array.push(vec![]); | |
121 | let push4 = array.try_push(vec![Bump(flag)]); | |
122 | assert_eq!(flag.get(), 0); | |
123 | drop(push4); | |
124 | assert_eq!(flag.get(), 1); | |
125 | drop(array.pop()); | |
126 | assert_eq!(flag.get(), 1); | |
127 | drop(array.pop()); | |
128 | assert_eq!(flag.get(), 3); | |
129 | } | |
130 | ||
131 | assert_eq!(flag.get(), 4); | |
132 | ||
133 | // test into_inner | |
134 | flag.set(0); | |
135 | { | |
136 | let mut array = ArrayVec::<[_; 3]>::new(); | |
137 | array.push(Bump(flag)); | |
138 | array.push(Bump(flag)); | |
139 | array.push(Bump(flag)); | |
140 | let inner = array.into_inner(); | |
141 | assert!(inner.is_ok()); | |
142 | assert_eq!(flag.get(), 0); | |
143 | drop(inner); | |
144 | assert_eq!(flag.get(), 3); | |
145 | } | |
146 | ||
f035d41b XL |
147 | // test cloning into_iter |
148 | flag.set(0); | |
149 | { | |
150 | let mut array = ArrayVec::<[_; 3]>::new(); | |
151 | array.push(Bump(flag)); | |
152 | array.push(Bump(flag)); | |
153 | array.push(Bump(flag)); | |
154 | let mut iter = array.into_iter(); | |
155 | assert_eq!(flag.get(), 0); | |
156 | iter.next(); | |
157 | assert_eq!(flag.get(), 1); | |
158 | let clone = iter.clone(); | |
159 | assert_eq!(flag.get(), 1); | |
160 | drop(clone); | |
161 | assert_eq!(flag.get(), 3); | |
162 | drop(iter); | |
163 | assert_eq!(flag.get(), 5); | |
164 | } | |
165 | } | |
166 | ||
167 | #[test] | |
168 | fn test_drop_panics() { | |
169 | use std::cell::Cell; | |
170 | use std::panic::catch_unwind; | |
171 | use std::panic::AssertUnwindSafe; | |
172 | ||
173 | let flag = &Cell::new(0); | |
174 | ||
175 | struct Bump<'a>(&'a Cell<i32>); | |
176 | ||
177 | // Panic in the first drop | |
178 | impl<'a> Drop for Bump<'a> { | |
179 | fn drop(&mut self) { | |
180 | let n = self.0.get(); | |
181 | self.0.set(n + 1); | |
182 | if n == 0 { | |
183 | panic!("Panic in Bump's drop"); | |
184 | } | |
185 | } | |
186 | } | |
187 | // check if rust is new enough | |
188 | flag.set(0); | |
189 | { | |
190 | let array = vec![Bump(flag), Bump(flag)]; | |
191 | let res = catch_unwind(AssertUnwindSafe(|| { | |
192 | drop(array); | |
193 | })); | |
194 | assert!(res.is_err()); | |
195 | } | |
196 | ||
197 | if flag.get() != 2 { | |
198 | println!("test_drop_panics: skip, this version of Rust doesn't continue in drop_in_place"); | |
199 | return; | |
200 | } | |
201 | ||
202 | flag.set(0); | |
203 | { | |
204 | let mut array = ArrayVec::<[Bump; 128]>::new(); | |
205 | array.push(Bump(flag)); | |
206 | array.push(Bump(flag)); | |
207 | array.push(Bump(flag)); | |
208 | ||
209 | let res = catch_unwind(AssertUnwindSafe(|| { | |
210 | drop(array); | |
211 | })); | |
212 | assert!(res.is_err()); | |
213 | } | |
214 | // Check that all the elements drop, even if the first drop panics. | |
215 | assert_eq!(flag.get(), 3); | |
216 | ||
217 | ||
218 | flag.set(0); | |
219 | { | |
220 | let mut array = ArrayVec::<[Bump; 16]>::new(); | |
221 | array.push(Bump(flag)); | |
222 | array.push(Bump(flag)); | |
223 | array.push(Bump(flag)); | |
224 | array.push(Bump(flag)); | |
225 | array.push(Bump(flag)); | |
226 | ||
227 | let i = 2; | |
228 | let tail_len = array.len() - i; | |
229 | ||
230 | let res = catch_unwind(AssertUnwindSafe(|| { | |
231 | array.truncate(i); | |
232 | })); | |
233 | assert!(res.is_err()); | |
234 | // Check that all the tail elements drop, even if the first drop panics. | |
235 | assert_eq!(flag.get(), tail_len as i32); | |
236 | } | |
237 | ||
238 | ||
2c00a5a8 XL |
239 | } |
240 | ||
241 | #[test] | |
242 | fn test_extend() { | |
243 | let mut range = 0..10; | |
244 | ||
245 | let mut array: ArrayVec<[_; 5]> = range.by_ref().collect(); | |
246 | assert_eq!(&array[..], &[0, 1, 2, 3, 4]); | |
247 | assert_eq!(range.next(), Some(5)); | |
248 | ||
249 | array.extend(range.by_ref()); | |
250 | assert_eq!(range.next(), Some(6)); | |
251 | ||
252 | let mut array: ArrayVec<[_; 10]> = (0..3).collect(); | |
253 | assert_eq!(&array[..], &[0, 1, 2]); | |
254 | array.extend(3..5); | |
255 | assert_eq!(&array[..], &[0, 1, 2, 3, 4]); | |
256 | } | |
257 | ||
258 | #[test] | |
259 | fn test_is_send_sync() { | |
260 | let data = ArrayVec::<[Vec<i32>; 5]>::new(); | |
f035d41b XL |
261 | &data as &dyn Send; |
262 | &data as &dyn Sync; | |
2c00a5a8 XL |
263 | } |
264 | ||
265 | #[test] | |
266 | fn test_compact_size() { | |
267 | // Future rust will kill these drop flags! | |
268 | // 4 elements size + 1 len + 1 enum tag + [1 drop flag] | |
269 | type ByteArray = ArrayVec<[u8; 4]>; | |
270 | println!("{}", mem::size_of::<ByteArray>()); | |
271 | assert!(mem::size_of::<ByteArray>() <= 8); | |
272 | ||
f035d41b XL |
273 | // 1 enum tag + 1 drop flag |
274 | type EmptyArray = ArrayVec<[u8; 0]>; | |
275 | println!("{}", mem::size_of::<EmptyArray>()); | |
276 | assert!(mem::size_of::<EmptyArray>() <= 2); | |
277 | ||
2c00a5a8 XL |
278 | // 12 element size + 1 enum tag + 3 padding + 1 len + 1 drop flag + 2 padding |
279 | type QuadArray = ArrayVec<[u32; 3]>; | |
280 | println!("{}", mem::size_of::<QuadArray>()); | |
281 | assert!(mem::size_of::<QuadArray>() <= 24); | |
282 | } | |
283 | ||
f035d41b XL |
284 | #[test] |
285 | fn test_still_works_with_option_arrayvec() { | |
286 | type RefArray = ArrayVec<[&'static i32; 2]>; | |
287 | let array = Some(RefArray::new()); | |
288 | assert!(array.is_some()); | |
289 | println!("{:?}", array); | |
290 | } | |
291 | ||
2c00a5a8 XL |
292 | #[test] |
293 | fn test_drain() { | |
294 | let mut v = ArrayVec::from([0; 8]); | |
295 | v.pop(); | |
296 | v.drain(0..7); | |
297 | assert_eq!(&v[..], &[]); | |
298 | ||
299 | v.extend(0..); | |
300 | v.drain(1..4); | |
301 | assert_eq!(&v[..], &[0, 4, 5, 6, 7]); | |
302 | let u: ArrayVec<[_; 3]> = v.drain(1..4).rev().collect(); | |
303 | assert_eq!(&u[..], &[6, 5, 4]); | |
304 | assert_eq!(&v[..], &[0, 7]); | |
305 | v.drain(..); | |
306 | assert_eq!(&v[..], &[]); | |
307 | } | |
308 | ||
f035d41b XL |
309 | #[test] |
310 | fn test_drain_range_inclusive() { | |
311 | let mut v = ArrayVec::from([0; 8]); | |
312 | v.drain(0..=7); | |
313 | assert_eq!(&v[..], &[]); | |
314 | ||
315 | v.extend(0..); | |
316 | v.drain(1..=4); | |
317 | assert_eq!(&v[..], &[0, 5, 6, 7]); | |
318 | let u: ArrayVec<[_; 3]> = v.drain(1..=2).rev().collect(); | |
319 | assert_eq!(&u[..], &[6, 5]); | |
320 | assert_eq!(&v[..], &[0, 7]); | |
321 | v.drain(..); | |
322 | assert_eq!(&v[..], &[]); | |
323 | } | |
324 | ||
325 | #[test] | |
326 | #[should_panic] | |
327 | fn test_drain_range_inclusive_oob() { | |
328 | let mut v = ArrayVec::from([0; 0]); | |
329 | v.drain(0..=0); | |
330 | } | |
331 | ||
2c00a5a8 XL |
332 | #[test] |
333 | fn test_retain() { | |
334 | let mut v = ArrayVec::from([0; 8]); | |
335 | for (i, elt) in v.iter_mut().enumerate() { | |
336 | *elt = i; | |
337 | } | |
338 | v.retain(|_| true); | |
339 | assert_eq!(&v[..], &[0, 1, 2, 3, 4, 5, 6, 7]); | |
340 | v.retain(|elt| { | |
341 | *elt /= 2; | |
342 | *elt % 2 == 0 | |
343 | }); | |
344 | assert_eq!(&v[..], &[0, 0, 2, 2]); | |
345 | v.retain(|_| false); | |
346 | assert_eq!(&v[..], &[]); | |
347 | } | |
348 | ||
349 | #[test] | |
350 | #[should_panic] | |
351 | fn test_drain_oob() { | |
352 | let mut v = ArrayVec::from([0; 8]); | |
353 | v.pop(); | |
354 | v.drain(0..8); | |
355 | } | |
356 | ||
357 | #[test] | |
358 | #[should_panic] | |
359 | fn test_drop_panic() { | |
360 | struct DropPanic; | |
361 | ||
362 | impl Drop for DropPanic { | |
363 | fn drop(&mut self) { | |
364 | panic!("drop"); | |
365 | } | |
366 | } | |
367 | ||
368 | let mut array = ArrayVec::<[DropPanic; 1]>::new(); | |
369 | array.push(DropPanic); | |
370 | } | |
371 | ||
372 | #[test] | |
373 | #[should_panic] | |
374 | fn test_drop_panic_into_iter() { | |
375 | struct DropPanic; | |
376 | ||
377 | impl Drop for DropPanic { | |
378 | fn drop(&mut self) { | |
379 | panic!("drop"); | |
380 | } | |
381 | } | |
382 | ||
383 | let mut array = ArrayVec::<[DropPanic; 1]>::new(); | |
384 | array.push(DropPanic); | |
385 | array.into_iter(); | |
386 | } | |
387 | ||
388 | #[test] | |
389 | fn test_insert() { | |
390 | let mut v = ArrayVec::from([]); | |
391 | assert_matches!(v.try_push(1), Err(_)); | |
392 | ||
393 | let mut v = ArrayVec::<[_; 3]>::new(); | |
394 | v.insert(0, 0); | |
395 | v.insert(1, 1); | |
396 | //let ret1 = v.try_insert(3, 3); | |
397 | //assert_matches!(ret1, Err(InsertError::OutOfBounds(_))); | |
398 | assert_eq!(&v[..], &[0, 1]); | |
399 | v.insert(2, 2); | |
400 | assert_eq!(&v[..], &[0, 1, 2]); | |
401 | ||
402 | let ret2 = v.try_insert(1, 9); | |
403 | assert_eq!(&v[..], &[0, 1, 2]); | |
404 | assert_matches!(ret2, Err(_)); | |
405 | ||
406 | let mut v = ArrayVec::from([2]); | |
407 | assert_matches!(v.try_insert(0, 1), Err(CapacityError { .. })); | |
408 | assert_matches!(v.try_insert(1, 1), Err(CapacityError { .. })); | |
409 | //assert_matches!(v.try_insert(2, 1), Err(CapacityError { .. })); | |
410 | } | |
411 | ||
412 | #[test] | |
413 | fn test_into_inner_1() { | |
414 | let mut v = ArrayVec::from([1, 2]); | |
415 | v.pop(); | |
416 | let u = v.clone(); | |
417 | assert_eq!(v.into_inner(), Err(u)); | |
418 | } | |
419 | ||
420 | #[test] | |
421 | fn test_into_inner_2() { | |
422 | let mut v = ArrayVec::<[String; 4]>::new(); | |
423 | v.push("a".into()); | |
424 | v.push("b".into()); | |
425 | v.push("c".into()); | |
426 | v.push("d".into()); | |
427 | assert_eq!(v.into_inner().unwrap(), ["a", "b", "c", "d"]); | |
428 | } | |
429 | ||
430 | #[test] | |
431 | fn test_into_inner_3_() { | |
432 | let mut v = ArrayVec::<[i32; 4]>::new(); | |
433 | v.extend(1..); | |
434 | assert_eq!(v.into_inner().unwrap(), [1, 2, 3, 4]); | |
435 | } | |
436 | ||
f035d41b | 437 | #[cfg(feature="std")] |
2c00a5a8 XL |
438 | #[test] |
439 | fn test_write() { | |
440 | use std::io::Write; | |
441 | let mut v = ArrayVec::<[_; 8]>::new(); | |
442 | write!(&mut v, "\x01\x02\x03").unwrap(); | |
443 | assert_eq!(&v[..], &[1, 2, 3]); | |
444 | let r = v.write(&[9; 16]).unwrap(); | |
445 | assert_eq!(r, 5); | |
446 | assert_eq!(&v[..], &[1, 2, 3, 9, 9, 9, 9, 9]); | |
447 | } | |
448 | ||
449 | #[test] | |
450 | fn array_clone_from() { | |
451 | let mut v = ArrayVec::<[_; 4]>::new(); | |
452 | v.push(vec![1, 2]); | |
453 | v.push(vec![3, 4, 5]); | |
454 | v.push(vec![6]); | |
455 | let reference = v.to_vec(); | |
456 | let mut u = ArrayVec::<[_; 4]>::new(); | |
457 | u.clone_from(&v); | |
458 | assert_eq!(&u, &reference[..]); | |
459 | ||
460 | let mut t = ArrayVec::<[_; 4]>::new(); | |
461 | t.push(vec![97]); | |
462 | t.push(vec![]); | |
463 | t.push(vec![5, 6, 2]); | |
464 | t.push(vec![2]); | |
465 | t.clone_from(&v); | |
466 | assert_eq!(&t, &reference[..]); | |
467 | t.clear(); | |
468 | t.clone_from(&v); | |
469 | assert_eq!(&t, &reference[..]); | |
470 | } | |
471 | ||
f035d41b | 472 | #[cfg(feature="std")] |
2c00a5a8 XL |
473 | #[test] |
474 | fn test_string() { | |
475 | use std::error::Error; | |
476 | ||
477 | let text = "hello world"; | |
478 | let mut s = ArrayString::<[_; 16]>::new(); | |
479 | s.try_push_str(text).unwrap(); | |
480 | assert_eq!(&s, text); | |
481 | assert_eq!(text, &s); | |
482 | ||
483 | // Make sure Hash / Eq / Borrow match up so we can use HashMap | |
484 | let mut map = HashMap::new(); | |
485 | map.insert(s, 1); | |
486 | assert_eq!(map[text], 1); | |
487 | ||
488 | let mut t = ArrayString::<[_; 2]>::new(); | |
489 | assert!(t.try_push_str(text).is_err()); | |
490 | assert_eq!(&t, ""); | |
491 | ||
492 | t.push_str("ab"); | |
493 | // DerefMut | |
494 | let tmut: &mut str = &mut t; | |
495 | assert_eq!(tmut, "ab"); | |
496 | ||
497 | // Test Error trait / try | |
f035d41b | 498 | let t = || -> Result<(), Box<dyn Error>> { |
2c00a5a8 | 499 | let mut t = ArrayString::<[_; 2]>::new(); |
f035d41b | 500 | t.try_push_str(text)?; |
2c00a5a8 XL |
501 | Ok(()) |
502 | }(); | |
503 | assert!(t.is_err()); | |
504 | } | |
505 | ||
506 | #[test] | |
507 | fn test_string_from() { | |
508 | let text = "hello world"; | |
509 | // Test `from` constructor | |
510 | let u = ArrayString::<[_; 11]>::from(text).unwrap(); | |
511 | assert_eq!(&u, text); | |
512 | assert_eq!(u.len(), text.len()); | |
513 | } | |
514 | ||
f035d41b XL |
515 | #[test] |
516 | fn test_string_parse_from_str() { | |
517 | let text = "hello world"; | |
518 | let u: ArrayString<[_; 11]> = text.parse().unwrap(); | |
519 | assert_eq!(&u, text); | |
520 | assert_eq!(u.len(), text.len()); | |
521 | } | |
522 | ||
2c00a5a8 XL |
523 | #[test] |
524 | fn test_string_from_bytes() { | |
525 | let text = "hello world"; | |
526 | let u = ArrayString::from_byte_string(b"hello world").unwrap(); | |
527 | assert_eq!(&u, text); | |
528 | assert_eq!(u.len(), text.len()); | |
529 | } | |
530 | ||
531 | #[test] | |
532 | fn test_string_clone() { | |
533 | let text = "hi"; | |
534 | let mut s = ArrayString::<[_; 4]>::new(); | |
535 | s.push_str("abcd"); | |
536 | let t = ArrayString::<[_; 4]>::from(text).unwrap(); | |
537 | s.clone_from(&t); | |
538 | assert_eq!(&t, &s); | |
539 | } | |
540 | ||
541 | #[test] | |
542 | fn test_string_push() { | |
543 | let text = "abcαβγ"; | |
544 | let mut s = ArrayString::<[_; 8]>::new(); | |
545 | for c in text.chars() { | |
546 | if let Err(_) = s.try_push(c) { | |
547 | break; | |
548 | } | |
549 | } | |
550 | assert_eq!("abcαβ", &s[..]); | |
551 | s.push('x'); | |
552 | assert_eq!("abcαβx", &s[..]); | |
553 | assert!(s.try_push('x').is_err()); | |
554 | } | |
555 | ||
556 | ||
557 | #[test] | |
558 | fn test_insert_at_length() { | |
559 | let mut v = ArrayVec::<[_; 8]>::new(); | |
560 | let result1 = v.try_insert(0, "a"); | |
561 | let result2 = v.try_insert(1, "b"); | |
562 | assert!(result1.is_ok() && result2.is_ok()); | |
563 | assert_eq!(&v[..], &["a", "b"]); | |
564 | } | |
565 | ||
566 | #[should_panic] | |
567 | #[test] | |
568 | fn test_insert_out_of_bounds() { | |
569 | let mut v = ArrayVec::<[_; 8]>::new(); | |
570 | let _ = v.try_insert(1, "test"); | |
571 | } | |
572 | ||
573 | /* | |
574 | * insert that pushes out the last | |
575 | let mut u = ArrayVec::from([1, 2, 3, 4]); | |
576 | let ret = u.try_insert(3, 99); | |
577 | assert_eq!(&u[..], &[1, 2, 3, 99]); | |
578 | assert_matches!(ret, Err(_)); | |
579 | let ret = u.try_insert(4, 77); | |
580 | assert_eq!(&u[..], &[1, 2, 3, 99]); | |
581 | assert_matches!(ret, Err(_)); | |
582 | */ | |
583 | ||
584 | #[test] | |
585 | fn test_drop_in_insert() { | |
586 | use std::cell::Cell; | |
587 | ||
588 | let flag = &Cell::new(0); | |
589 | ||
590 | struct Bump<'a>(&'a Cell<i32>); | |
591 | ||
592 | impl<'a> Drop for Bump<'a> { | |
593 | fn drop(&mut self) { | |
594 | let n = self.0.get(); | |
595 | self.0.set(n + 1); | |
596 | } | |
597 | } | |
598 | ||
599 | flag.set(0); | |
600 | ||
601 | { | |
602 | let mut array = ArrayVec::<[_; 2]>::new(); | |
603 | array.push(Bump(flag)); | |
604 | array.insert(0, Bump(flag)); | |
605 | assert_eq!(flag.get(), 0); | |
606 | let ret = array.try_insert(1, Bump(flag)); | |
607 | assert_eq!(flag.get(), 0); | |
608 | assert_matches!(ret, Err(_)); | |
609 | drop(ret); | |
610 | assert_eq!(flag.get(), 1); | |
611 | } | |
612 | assert_eq!(flag.get(), 3); | |
613 | } | |
614 | ||
615 | #[test] | |
616 | fn test_pop_at() { | |
617 | let mut v = ArrayVec::<[String; 4]>::new(); | |
618 | let s = String::from; | |
619 | v.push(s("a")); | |
620 | v.push(s("b")); | |
621 | v.push(s("c")); | |
622 | v.push(s("d")); | |
623 | ||
624 | assert_eq!(v.pop_at(4), None); | |
625 | assert_eq!(v.pop_at(1), Some(s("b"))); | |
626 | assert_eq!(v.pop_at(1), Some(s("c"))); | |
627 | assert_eq!(v.pop_at(2), None); | |
628 | assert_eq!(&v[..], &["a", "d"]); | |
629 | } | |
630 | ||
631 | #[test] | |
632 | fn test_sizes() { | |
633 | let v = ArrayVec::from([0u8; 1 << 16]); | |
634 | assert_eq!(vec![0u8; v.len()], &v[..]); | |
635 | } | |
636 | ||
637 | #[test] | |
638 | fn test_default() { | |
639 | use std::net; | |
640 | let s: ArrayString<[u8; 4]> = Default::default(); | |
641 | // Something without `Default` implementation. | |
642 | let v: ArrayVec<[net::TcpStream; 4]> = Default::default(); | |
643 | assert_eq!(s.len(), 0); | |
644 | assert_eq!(v.len(), 0); | |
645 | } | |
f035d41b XL |
646 | |
647 | #[cfg(feature="array-sizes-33-128")] | |
648 | #[test] | |
649 | fn test_sizes_33_128() { | |
650 | ArrayVec::from([0u8; 52]); | |
651 | ArrayVec::from([0u8; 127]); | |
652 | } | |
653 | ||
654 | #[cfg(feature="array-sizes-129-255")] | |
655 | #[test] | |
656 | fn test_sizes_129_255() { | |
657 | ArrayVec::from([0u8; 237]); | |
658 | ArrayVec::from([0u8; 255]); | |
659 | } | |
660 | ||
661 | #[test] | |
662 | fn test_extend_zst() { | |
663 | let mut range = 0..10; | |
664 | #[derive(Copy, Clone, PartialEq, Debug)] | |
665 | struct Z; // Zero sized type | |
666 | ||
667 | let mut array: ArrayVec<[_; 5]> = range.by_ref().map(|_| Z).collect(); | |
668 | assert_eq!(&array[..], &[Z; 5]); | |
669 | assert_eq!(range.next(), Some(5)); | |
670 | ||
671 | array.extend(range.by_ref().map(|_| Z)); | |
672 | assert_eq!(range.next(), Some(6)); | |
673 | ||
674 | let mut array: ArrayVec<[_; 10]> = (0..3).map(|_| Z).collect(); | |
675 | assert_eq!(&array[..], &[Z; 3]); | |
676 | array.extend((3..5).map(|_| Z)); | |
677 | assert_eq!(&array[..], &[Z; 5]); | |
678 | assert_eq!(array.len(), 5); | |
679 | } |