1 use std::cmp::Ordering::{Equal, Greater, Less};
2 use std::convert::identity;
3 use std::fmt;
4 use std::mem;
5 use std::panic;
6 use std::rc::Rc;
7
square(n: usize) -> usize8 fn square(n: usize) -> usize {
9 n * n
10 }
11
is_odd(n: &usize) -> bool12 fn is_odd(n: &usize) -> bool {
13 *n % 2 == 1
14 }
15
16 #[test]
test_from_fn()17 fn test_from_fn() {
18 // Test on-stack from_fn.
19 let mut v: Vec<_> = (0..3).map(square).collect();
20 {
21 let v = v;
22 assert_eq!(v.len(), 3);
23 assert_eq!(v[0], 0);
24 assert_eq!(v[1], 1);
25 assert_eq!(v[2], 4);
26 }
27
28 // Test on-heap from_fn.
29 v = (0..5).map(square).collect();
30 {
31 let v = v;
32 assert_eq!(v.len(), 5);
33 assert_eq!(v[0], 0);
34 assert_eq!(v[1], 1);
35 assert_eq!(v[2], 4);
36 assert_eq!(v[3], 9);
37 assert_eq!(v[4], 16);
38 }
39 }
40
41 #[test]
test_from_elem()42 fn test_from_elem() {
43 // Test on-stack from_elem.
44 let mut v = vec![10, 10];
45 {
46 let v = v;
47 assert_eq!(v.len(), 2);
48 assert_eq!(v[0], 10);
49 assert_eq!(v[1], 10);
50 }
51
52 // Test on-heap from_elem.
53 v = vec![20; 6];
54 {
55 let v = &v[..];
56 assert_eq!(v[0], 20);
57 assert_eq!(v[1], 20);
58 assert_eq!(v[2], 20);
59 assert_eq!(v[3], 20);
60 assert_eq!(v[4], 20);
61 assert_eq!(v[5], 20);
62 }
63 }
64
65 #[test]
test_is_empty()66 fn test_is_empty() {
67 let xs: [i32; 0] = [];
68 assert!(xs.is_empty());
69 assert!(![0].is_empty());
70 }
71
72 #[test]
test_len_divzero()73 fn test_len_divzero() {
74 type Z = [i8; 0];
75 let v0: &[Z] = &[];
76 let v1: &[Z] = &[[]];
77 let v2: &[Z] = &[[], []];
78 assert_eq!(mem::size_of::<Z>(), 0);
79 assert_eq!(v0.len(), 0);
80 assert_eq!(v1.len(), 1);
81 assert_eq!(v2.len(), 2);
82 }
83
84 #[test]
test_get()85 fn test_get() {
86 let mut a = vec![11];
87 assert_eq!(a.get(1), None);
88 a = vec![11, 12];
89 assert_eq!(a.get(1).unwrap(), &12);
90 a = vec![11, 12, 13];
91 assert_eq!(a.get(1).unwrap(), &12);
92 }
93
94 #[test]
test_first()95 fn test_first() {
96 let mut a = vec![];
97 assert_eq!(a.first(), None);
98 a = vec![11];
99 assert_eq!(a.first().unwrap(), &11);
100 a = vec![11, 12];
101 assert_eq!(a.first().unwrap(), &11);
102 }
103
104 #[test]
test_first_mut()105 fn test_first_mut() {
106 let mut a = vec![];
107 assert_eq!(a.first_mut(), None);
108 a = vec![11];
109 assert_eq!(*a.first_mut().unwrap(), 11);
110 a = vec![11, 12];
111 assert_eq!(*a.first_mut().unwrap(), 11);
112 }
113
114 #[test]
test_split_first()115 fn test_split_first() {
116 let mut a = vec![11];
117 let b: &[i32] = &[];
118 assert!(b.split_first().is_none());
119 assert_eq!(a.split_first(), Some((&11, b)));
120 a = vec![11, 12];
121 let b: &[i32] = &[12];
122 assert_eq!(a.split_first(), Some((&11, b)));
123 }
124
125 #[test]
test_split_first_mut()126 fn test_split_first_mut() {
127 let mut a = vec![11];
128 let b: &mut [i32] = &mut [];
129 assert!(b.split_first_mut().is_none());
130 assert!(a.split_first_mut() == Some((&mut 11, b)));
131 a = vec![11, 12];
132 let b: &mut [_] = &mut [12];
133 assert!(a.split_first_mut() == Some((&mut 11, b)));
134 }
135
136 #[test]
test_split_last()137 fn test_split_last() {
138 let mut a = vec![11];
139 let b: &[i32] = &[];
140 assert!(b.split_last().is_none());
141 assert_eq!(a.split_last(), Some((&11, b)));
142 a = vec![11, 12];
143 let b: &[_] = &[11];
144 assert_eq!(a.split_last(), Some((&12, b)));
145 }
146
147 #[test]
test_split_last_mut()148 fn test_split_last_mut() {
149 let mut a = vec![11];
150 let b: &mut [i32] = &mut [];
151 assert!(b.split_last_mut().is_none());
152 assert!(a.split_last_mut() == Some((&mut 11, b)));
153
154 a = vec![11, 12];
155 let b: &mut [_] = &mut [11];
156 assert!(a.split_last_mut() == Some((&mut 12, b)));
157 }
158
159 #[test]
test_last()160 fn test_last() {
161 let mut a = vec![];
162 assert_eq!(a.last(), None);
163 a = vec![11];
164 assert_eq!(a.last().unwrap(), &11);
165 a = vec![11, 12];
166 assert_eq!(a.last().unwrap(), &12);
167 }
168
169 #[test]
test_last_mut()170 fn test_last_mut() {
171 let mut a = vec![];
172 assert_eq!(a.last_mut(), None);
173 a = vec![11];
174 assert_eq!(*a.last_mut().unwrap(), 11);
175 a = vec![11, 12];
176 assert_eq!(*a.last_mut().unwrap(), 12);
177 }
178
179 #[test]
test_slice()180 fn test_slice() {
181 // Test fixed length vector.
182 let vec_fixed = [1, 2, 3, 4];
183 let v_a = vec_fixed[1..vec_fixed.len()].to_vec();
184 assert_eq!(v_a.len(), 3);
185
186 assert_eq!(v_a[0], 2);
187 assert_eq!(v_a[1], 3);
188 assert_eq!(v_a[2], 4);
189
190 // Test on stack.
191 let vec_stack: &[_] = &[1, 2, 3];
192 let v_b = vec_stack[1..3].to_vec();
193 assert_eq!(v_b.len(), 2);
194
195 assert_eq!(v_b[0], 2);
196 assert_eq!(v_b[1], 3);
197
198 // Test `Box<[T]>`
199 let vec_unique = vec![1, 2, 3, 4, 5, 6];
200 let v_d = vec_unique[1..6].to_vec();
201 assert_eq!(v_d.len(), 5);
202
203 assert_eq!(v_d[0], 2);
204 assert_eq!(v_d[1], 3);
205 assert_eq!(v_d[2], 4);
206 assert_eq!(v_d[3], 5);
207 assert_eq!(v_d[4], 6);
208 }
209
210 #[test]
test_slice_from()211 fn test_slice_from() {
212 let vec: &[_] = &[1, 2, 3, 4];
213 assert_eq!(&vec[..], vec);
214 let b: &[_] = &[3, 4];
215 assert_eq!(&vec[2..], b);
216 let b: &[_] = &[];
217 assert_eq!(&vec[4..], b);
218 }
219
220 #[test]
test_slice_to()221 fn test_slice_to() {
222 let vec: &[_] = &[1, 2, 3, 4];
223 assert_eq!(&vec[..4], vec);
224 let b: &[_] = &[1, 2];
225 assert_eq!(&vec[..2], b);
226 let b: &[_] = &[];
227 assert_eq!(&vec[..0], b);
228 }
229
230 #[test]
test_pop()231 fn test_pop() {
232 let mut v = vec![5];
233 let e = v.pop();
234 assert_eq!(v.len(), 0);
235 assert_eq!(e, Some(5));
236 let f = v.pop();
237 assert_eq!(f, None);
238 let g = v.pop();
239 assert_eq!(g, None);
240 }
241
242 #[test]
test_swap_remove()243 fn test_swap_remove() {
244 let mut v = vec![1, 2, 3, 4, 5];
245 let mut e = v.swap_remove(0);
246 assert_eq!(e, 1);
247 assert_eq!(v, [5, 2, 3, 4]);
248 e = v.swap_remove(3);
249 assert_eq!(e, 4);
250 assert_eq!(v, [5, 2, 3]);
251 }
252
253 #[test]
254 #[should_panic]
test_swap_remove_fail()255 fn test_swap_remove_fail() {
256 let mut v = vec![1];
257 let _ = v.swap_remove(0);
258 let _ = v.swap_remove(0);
259 }
260
261 #[test]
test_swap_remove_noncopyable()262 fn test_swap_remove_noncopyable() {
263 // Tests that we don't accidentally run destructors twice.
264 let mut v: Vec<Box<_>> = Vec::new();
265 v.push(Box::new(0));
266 v.push(Box::new(0));
267 v.push(Box::new(0));
268 let mut _e = v.swap_remove(0);
269 assert_eq!(v.len(), 2);
270 _e = v.swap_remove(1);
271 assert_eq!(v.len(), 1);
272 _e = v.swap_remove(0);
273 assert_eq!(v.len(), 0);
274 }
275
276 #[test]
test_push()277 fn test_push() {
278 // Test on-stack push().
279 let mut v = vec![];
280 v.push(1);
281 assert_eq!(v.len(), 1);
282 assert_eq!(v[0], 1);
283
284 // Test on-heap push().
285 v.push(2);
286 assert_eq!(v.len(), 2);
287 assert_eq!(v[0], 1);
288 assert_eq!(v[1], 2);
289 }
290
291 #[test]
test_truncate()292 fn test_truncate() {
293 let mut v: Vec<Box<_>> = vec![Box::new(6), Box::new(5), Box::new(4)];
294 v.truncate(1);
295 let v = v;
296 assert_eq!(v.len(), 1);
297 assert_eq!(*(v[0]), 6);
298 // If the unsafe block didn't drop things properly, we blow up here.
299 }
300
301 #[test]
test_clear()302 fn test_clear() {
303 let mut v: Vec<Box<_>> = vec![Box::new(6), Box::new(5), Box::new(4)];
304 v.clear();
305 assert_eq!(v.len(), 0);
306 // If the unsafe block didn't drop things properly, we blow up here.
307 }
308
309 #[test]
test_retain()310 fn test_retain() {
311 let mut v = vec![1, 2, 3, 4, 5];
312 v.retain(is_odd);
313 assert_eq!(v, [1, 3, 5]);
314 }
315
316 #[test]
test_binary_search()317 fn test_binary_search() {
318 assert_eq!([1, 2, 3, 4, 5].binary_search(&5).ok(), Some(4));
319 assert_eq!([1, 2, 3, 4, 5].binary_search(&4).ok(), Some(3));
320 assert_eq!([1, 2, 3, 4, 5].binary_search(&3).ok(), Some(2));
321 assert_eq!([1, 2, 3, 4, 5].binary_search(&2).ok(), Some(1));
322 assert_eq!([1, 2, 3, 4, 5].binary_search(&1).ok(), Some(0));
323
324 assert_eq!([2, 4, 6, 8, 10].binary_search(&1).ok(), None);
325 assert_eq!([2, 4, 6, 8, 10].binary_search(&5).ok(), None);
326 assert_eq!([2, 4, 6, 8, 10].binary_search(&4).ok(), Some(1));
327 assert_eq!([2, 4, 6, 8, 10].binary_search(&10).ok(), Some(4));
328
329 assert_eq!([2, 4, 6, 8].binary_search(&1).ok(), None);
330 assert_eq!([2, 4, 6, 8].binary_search(&5).ok(), None);
331 assert_eq!([2, 4, 6, 8].binary_search(&4).ok(), Some(1));
332 assert_eq!([2, 4, 6, 8].binary_search(&8).ok(), Some(3));
333
334 assert_eq!([2, 4, 6].binary_search(&1).ok(), None);
335 assert_eq!([2, 4, 6].binary_search(&5).ok(), None);
336 assert_eq!([2, 4, 6].binary_search(&4).ok(), Some(1));
337 assert_eq!([2, 4, 6].binary_search(&6).ok(), Some(2));
338
339 assert_eq!([2, 4].binary_search(&1).ok(), None);
340 assert_eq!([2, 4].binary_search(&5).ok(), None);
341 assert_eq!([2, 4].binary_search(&2).ok(), Some(0));
342 assert_eq!([2, 4].binary_search(&4).ok(), Some(1));
343
344 assert_eq!([2].binary_search(&1).ok(), None);
345 assert_eq!([2].binary_search(&5).ok(), None);
346 assert_eq!([2].binary_search(&2).ok(), Some(0));
347
348 assert_eq!([].binary_search(&1).ok(), None);
349 assert_eq!([].binary_search(&5).ok(), None);
350
351 assert!([1, 1, 1, 1, 1].binary_search(&1).ok() != None);
352 assert!([1, 1, 1, 1, 2].binary_search(&1).ok() != None);
353 assert!([1, 1, 1, 2, 2].binary_search(&1).ok() != None);
354 assert!([1, 1, 2, 2, 2].binary_search(&1).ok() != None);
355 assert_eq!([1, 2, 2, 2, 2].binary_search(&1).ok(), Some(0));
356
357 assert_eq!([1, 2, 3, 4, 5].binary_search(&6).ok(), None);
358 assert_eq!([1, 2, 3, 4, 5].binary_search(&0).ok(), None);
359 }
360
361 #[test]
test_reverse()362 fn test_reverse() {
363 let mut v = vec![10, 20];
364 assert_eq!(v[0], 10);
365 assert_eq!(v[1], 20);
366 v.reverse();
367 assert_eq!(v[0], 20);
368 assert_eq!(v[1], 10);
369
370 let mut v3 = Vec::<i32>::new();
371 v3.reverse();
372 assert!(v3.is_empty());
373
374 // check the 1-byte-types path
375 let mut v = (-50..51i8).collect::<Vec<_>>();
376 v.reverse();
377 assert_eq!(v, (-50..51i8).rev().collect::<Vec<_>>());
378
379 // check the 2-byte-types path
380 let mut v = (-50..51i16).collect::<Vec<_>>();
381 v.reverse();
382 assert_eq!(v, (-50..51i16).rev().collect::<Vec<_>>());
383 }
384
385 #[test]
test_rotate_left()386 fn test_rotate_left() {
387 let expected: Vec<_> = (0..13).collect();
388 let mut v = Vec::new();
389
390 // no-ops
391 v.clone_from(&expected);
392 v.rotate_left(0);
393 assert_eq!(v, expected);
394 v.rotate_left(expected.len());
395 assert_eq!(v, expected);
396 let mut zst_array = [(), (), ()];
397 zst_array.rotate_left(2);
398
399 // happy path
400 v = (5..13).chain(0..5).collect();
401 v.rotate_left(8);
402 assert_eq!(v, expected);
403
404 let expected: Vec<_> = (0..1000).collect();
405
406 // small rotations in large slice, uses ptr::copy
407 v = (2..1000).chain(0..2).collect();
408 v.rotate_left(998);
409 assert_eq!(v, expected);
410 v = (998..1000).chain(0..998).collect();
411 v.rotate_left(2);
412 assert_eq!(v, expected);
413
414 // non-small prime rotation, has a few rounds of swapping
415 v = (389..1000).chain(0..389).collect();
416 v.rotate_left(1000 - 389);
417 assert_eq!(v, expected);
418 }
419
420 #[test]
test_rotate_right()421 fn test_rotate_right() {
422 let expected: Vec<_> = (0..13).collect();
423 let mut v = Vec::new();
424
425 // no-ops
426 v.clone_from(&expected);
427 v.rotate_right(0);
428 assert_eq!(v, expected);
429 v.rotate_right(expected.len());
430 assert_eq!(v, expected);
431 let mut zst_array = [(), (), ()];
432 zst_array.rotate_right(2);
433
434 // happy path
435 v = (5..13).chain(0..5).collect();
436 v.rotate_right(5);
437 assert_eq!(v, expected);
438
439 let expected: Vec<_> = (0..1000).collect();
440
441 // small rotations in large slice, uses ptr::copy
442 v = (2..1000).chain(0..2).collect();
443 v.rotate_right(2);
444 assert_eq!(v, expected);
445 v = (998..1000).chain(0..998).collect();
446 v.rotate_right(998);
447 assert_eq!(v, expected);
448
449 // non-small prime rotation, has a few rounds of swapping
450 v = (389..1000).chain(0..389).collect();
451 v.rotate_right(389);
452 assert_eq!(v, expected);
453 }
454
455 #[test]
test_concat()456 fn test_concat() {
457 let v: [Vec<i32>; 0] = [];
458 let c = v.concat();
459 assert_eq!(c, []);
460 let d = [vec![1], vec![2, 3]].concat();
461 assert_eq!(d, [1, 2, 3]);
462
463 let v: &[&[_]] = &[&[1], &[2, 3]];
464 assert_eq!(v.join(&0), [1, 0, 2, 3]);
465 let v: &[&[_]] = &[&[1], &[2], &[3]];
466 assert_eq!(v.join(&0), [1, 0, 2, 0, 3]);
467 }
468
469 #[test]
test_join()470 fn test_join() {
471 let v: [Vec<i32>; 0] = [];
472 assert_eq!(v.join(&0), []);
473 assert_eq!([vec![1], vec![2, 3]].join(&0), [1, 0, 2, 3]);
474 assert_eq!([vec![1], vec![2], vec![3]].join(&0), [1, 0, 2, 0, 3]);
475
476 let v: [&[_]; 2] = [&[1], &[2, 3]];
477 assert_eq!(v.join(&0), [1, 0, 2, 3]);
478 let v: [&[_]; 3] = [&[1], &[2], &[3]];
479 assert_eq!(v.join(&0), [1, 0, 2, 0, 3]);
480 }
481
482 #[test]
test_join_nocopy()483 fn test_join_nocopy() {
484 let v: [String; 0] = [];
485 assert_eq!(v.join(","), "");
486 assert_eq!(["a".to_string(), "ab".into()].join(","), "a,ab");
487 assert_eq!(["a".to_string(), "ab".into(), "abc".into()].join(","), "a,ab,abc");
488 assert_eq!(["a".to_string(), "ab".into(), "".into()].join(","), "a,ab,");
489 }
490
491 #[test]
test_insert()492 fn test_insert() {
493 let mut a = vec![1, 2, 4];
494 a.insert(2, 3);
495 assert_eq!(a, [1, 2, 3, 4]);
496
497 let mut a = vec![1, 2, 3];
498 a.insert(0, 0);
499 assert_eq!(a, [0, 1, 2, 3]);
500
501 let mut a = vec![1, 2, 3];
502 a.insert(3, 4);
503 assert_eq!(a, [1, 2, 3, 4]);
504
505 let mut a = vec![];
506 a.insert(0, 1);
507 assert_eq!(a, [1]);
508 }
509
510 #[test]
511 #[should_panic]
test_insert_oob()512 fn test_insert_oob() {
513 let mut a = vec![1, 2, 3];
514 a.insert(4, 5);
515 }
516
517 #[test]
test_remove()518 fn test_remove() {
519 let mut a = vec![1, 2, 3, 4];
520
521 assert_eq!(a.remove(2), 3);
522 assert_eq!(a, [1, 2, 4]);
523
524 assert_eq!(a.remove(2), 4);
525 assert_eq!(a, [1, 2]);
526
527 assert_eq!(a.remove(0), 1);
528 assert_eq!(a, [2]);
529
530 assert_eq!(a.remove(0), 2);
531 assert_eq!(a, []);
532 }
533
534 #[test]
535 #[should_panic]
test_remove_fail()536 fn test_remove_fail() {
537 let mut a = vec![1];
538 let _ = a.remove(0);
539 let _ = a.remove(0);
540 }
541
542 #[test]
test_capacity()543 fn test_capacity() {
544 let mut v = vec![0];
545 v.reserve_exact(10);
546 assert!(v.capacity() >= 11);
547 }
548
549 #[test]
test_slice_2()550 fn test_slice_2() {
551 let v = vec![1, 2, 3, 4, 5];
552 let v = &v[1..3];
553 assert_eq!(v.len(), 2);
554 assert_eq!(v[0], 2);
555 assert_eq!(v[1], 3);
556 }
557
558 macro_rules! assert_order {
559 (Greater, $a:expr, $b:expr) => {
560 assert_eq!($a.cmp($b), Greater);
561 assert!($a > $b);
562 };
563 (Less, $a:expr, $b:expr) => {
564 assert_eq!($a.cmp($b), Less);
565 assert!($a < $b);
566 };
567 (Equal, $a:expr, $b:expr) => {
568 assert_eq!($a.cmp($b), Equal);
569 assert_eq!($a, $b);
570 };
571 }
572
573 #[test]
test_total_ord_u8()574 fn test_total_ord_u8() {
575 let c = &[1u8, 2, 3];
576 assert_order!(Greater, &[1u8, 2, 3, 4][..], &c[..]);
577 let c = &[1u8, 2, 3, 4];
578 assert_order!(Less, &[1u8, 2, 3][..], &c[..]);
579 let c = &[1u8, 2, 3, 6];
580 assert_order!(Equal, &[1u8, 2, 3, 6][..], &c[..]);
581 let c = &[1u8, 2, 3, 4, 5, 6];
582 assert_order!(Less, &[1u8, 2, 3, 4, 5, 5, 5, 5][..], &c[..]);
583 let c = &[1u8, 2, 3, 4];
584 assert_order!(Greater, &[2u8, 2][..], &c[..]);
585 }
586
587 #[test]
test_total_ord_i32()588 fn test_total_ord_i32() {
589 let c = &[1, 2, 3];
590 assert_order!(Greater, &[1, 2, 3, 4][..], &c[..]);
591 let c = &[1, 2, 3, 4];
592 assert_order!(Less, &[1, 2, 3][..], &c[..]);
593 let c = &[1, 2, 3, 6];
594 assert_order!(Equal, &[1, 2, 3, 6][..], &c[..]);
595 let c = &[1, 2, 3, 4, 5, 6];
596 assert_order!(Less, &[1, 2, 3, 4, 5, 5, 5, 5][..], &c[..]);
597 let c = &[1, 2, 3, 4];
598 assert_order!(Greater, &[2, 2][..], &c[..]);
599 }
600
601 #[test]
test_iterator()602 fn test_iterator() {
603 let xs = [1, 2, 5, 10, 11];
604 let mut it = xs.iter();
605 assert_eq!(it.size_hint(), (5, Some(5)));
606 assert_eq!(it.next().unwrap(), &1);
607 assert_eq!(it.size_hint(), (4, Some(4)));
608 assert_eq!(it.next().unwrap(), &2);
609 assert_eq!(it.size_hint(), (3, Some(3)));
610 assert_eq!(it.next().unwrap(), &5);
611 assert_eq!(it.size_hint(), (2, Some(2)));
612 assert_eq!(it.next().unwrap(), &10);
613 assert_eq!(it.size_hint(), (1, Some(1)));
614 assert_eq!(it.next().unwrap(), &11);
615 assert_eq!(it.size_hint(), (0, Some(0)));
616 assert!(it.next().is_none());
617 }
618
619 #[test]
test_iter_size_hints()620 fn test_iter_size_hints() {
621 let mut xs = [1, 2, 5, 10, 11];
622 assert_eq!(xs.iter().size_hint(), (5, Some(5)));
623 assert_eq!(xs.iter_mut().size_hint(), (5, Some(5)));
624 }
625
626 #[test]
test_iter_as_slice()627 fn test_iter_as_slice() {
628 let xs = [1, 2, 5, 10, 11];
629 let mut iter = xs.iter();
630 assert_eq!(iter.as_slice(), &[1, 2, 5, 10, 11]);
631 iter.next();
632 assert_eq!(iter.as_slice(), &[2, 5, 10, 11]);
633 }
634
635 #[test]
test_iter_as_ref()636 fn test_iter_as_ref() {
637 let xs = [1, 2, 5, 10, 11];
638 let mut iter = xs.iter();
639 assert_eq!(iter.as_ref(), &[1, 2, 5, 10, 11]);
640 iter.next();
641 assert_eq!(iter.as_ref(), &[2, 5, 10, 11]);
642 }
643
644 #[test]
test_iter_clone()645 fn test_iter_clone() {
646 let xs = [1, 2, 5];
647 let mut it = xs.iter();
648 it.next();
649 let mut jt = it.clone();
650 assert_eq!(it.next(), jt.next());
651 assert_eq!(it.next(), jt.next());
652 assert_eq!(it.next(), jt.next());
653 }
654
655 #[test]
test_iter_is_empty()656 fn test_iter_is_empty() {
657 let xs = [1, 2, 5, 10, 11];
658 for i in 0..xs.len() {
659 for j in i..xs.len() {
660 assert_eq!(xs[i..j].iter().is_empty(), xs[i..j].is_empty());
661 }
662 }
663 }
664
665 #[test]
test_mut_iterator()666 fn test_mut_iterator() {
667 let mut xs = [1, 2, 3, 4, 5];
668 for x in &mut xs {
669 *x += 1;
670 }
671 assert!(xs == [2, 3, 4, 5, 6])
672 }
673
674 #[test]
test_rev_iterator()675 fn test_rev_iterator() {
676 let xs = [1, 2, 5, 10, 11];
677 let ys = [11, 10, 5, 2, 1];
678 let mut i = 0;
679 for &x in xs.iter().rev() {
680 assert_eq!(x, ys[i]);
681 i += 1;
682 }
683 assert_eq!(i, 5);
684 }
685
686 #[test]
test_mut_rev_iterator()687 fn test_mut_rev_iterator() {
688 let mut xs = [1, 2, 3, 4, 5];
689 for (i, x) in xs.iter_mut().rev().enumerate() {
690 *x += i;
691 }
692 assert!(xs == [5, 5, 5, 5, 5])
693 }
694
695 #[test]
test_move_iterator()696 fn test_move_iterator() {
697 let xs = vec![1, 2, 3, 4, 5];
698 assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10 * a + b), 12345);
699 }
700
701 #[test]
test_move_rev_iterator()702 fn test_move_rev_iterator() {
703 let xs = vec![1, 2, 3, 4, 5];
704 assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10 * a + b), 54321);
705 }
706
707 #[test]
test_split_iterator()708 fn test_split_iterator() {
709 let xs = &[1, 2, 3, 4, 5];
710
711 let splits: &[&[_]] = &[&[1], &[3], &[5]];
712 assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(), splits);
713 let splits: &[&[_]] = &[&[], &[2, 3, 4, 5]];
714 assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(), splits);
715 let splits: &[&[_]] = &[&[1, 2, 3, 4], &[]];
716 assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(), splits);
717 let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
718 assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(), splits);
719 let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]];
720 assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(), splits);
721
722 let xs: &[i32] = &[];
723 let splits: &[&[i32]] = &[&[]];
724 assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
725 }
726
727 #[test]
test_split_iterator_inclusive()728 fn test_split_iterator_inclusive() {
729 let xs = &[1, 2, 3, 4, 5];
730
731 let splits: &[&[_]] = &[&[1, 2], &[3, 4], &[5]];
732 assert_eq!(xs.split_inclusive(|x| *x % 2 == 0).collect::<Vec<_>>(), splits);
733 let splits: &[&[_]] = &[&[1], &[2, 3, 4, 5]];
734 assert_eq!(xs.split_inclusive(|x| *x == 1).collect::<Vec<_>>(), splits);
735 let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
736 assert_eq!(xs.split_inclusive(|x| *x == 5).collect::<Vec<_>>(), splits);
737 let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
738 assert_eq!(xs.split_inclusive(|x| *x == 10).collect::<Vec<_>>(), splits);
739 let splits: &[&[_]] = &[&[1], &[2], &[3], &[4], &[5]];
740 assert_eq!(xs.split_inclusive(|_| true).collect::<Vec<&[i32]>>(), splits);
741
742 let xs: &[i32] = &[];
743 let splits: &[&[i32]] = &[];
744 assert_eq!(xs.split_inclusive(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
745 }
746
747 #[test]
test_split_iterator_inclusive_reverse()748 fn test_split_iterator_inclusive_reverse() {
749 let xs = &[1, 2, 3, 4, 5];
750
751 let splits: &[&[_]] = &[&[5], &[3, 4], &[1, 2]];
752 assert_eq!(xs.split_inclusive(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits);
753 let splits: &[&[_]] = &[&[2, 3, 4, 5], &[1]];
754 assert_eq!(xs.split_inclusive(|x| *x == 1).rev().collect::<Vec<_>>(), splits);
755 let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
756 assert_eq!(xs.split_inclusive(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
757 let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
758 assert_eq!(xs.split_inclusive(|x| *x == 10).rev().collect::<Vec<_>>(), splits);
759 let splits: &[&[_]] = &[&[5], &[4], &[3], &[2], &[1]];
760 assert_eq!(xs.split_inclusive(|_| true).rev().collect::<Vec<_>>(), splits);
761
762 let xs: &[i32] = &[];
763 let splits: &[&[i32]] = &[];
764 assert_eq!(xs.split_inclusive(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
765 }
766
767 #[test]
test_split_iterator_mut_inclusive()768 fn test_split_iterator_mut_inclusive() {
769 let xs = &mut [1, 2, 3, 4, 5];
770
771 let splits: &[&[_]] = &[&[1, 2], &[3, 4], &[5]];
772 assert_eq!(xs.split_inclusive_mut(|x| *x % 2 == 0).collect::<Vec<_>>(), splits);
773 let splits: &[&[_]] = &[&[1], &[2, 3, 4, 5]];
774 assert_eq!(xs.split_inclusive_mut(|x| *x == 1).collect::<Vec<_>>(), splits);
775 let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
776 assert_eq!(xs.split_inclusive_mut(|x| *x == 5).collect::<Vec<_>>(), splits);
777 let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
778 assert_eq!(xs.split_inclusive_mut(|x| *x == 10).collect::<Vec<_>>(), splits);
779 let splits: &[&[_]] = &[&[1], &[2], &[3], &[4], &[5]];
780 assert_eq!(xs.split_inclusive_mut(|_| true).collect::<Vec<_>>(), splits);
781
782 let xs: &mut [i32] = &mut [];
783 let splits: &[&[i32]] = &[];
784 assert_eq!(xs.split_inclusive_mut(|x| *x == 5).collect::<Vec<_>>(), splits);
785 }
786
787 #[test]
test_split_iterator_mut_inclusive_reverse()788 fn test_split_iterator_mut_inclusive_reverse() {
789 let xs = &mut [1, 2, 3, 4, 5];
790
791 let splits: &[&[_]] = &[&[5], &[3, 4], &[1, 2]];
792 assert_eq!(xs.split_inclusive_mut(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits);
793 let splits: &[&[_]] = &[&[2, 3, 4, 5], &[1]];
794 assert_eq!(xs.split_inclusive_mut(|x| *x == 1).rev().collect::<Vec<_>>(), splits);
795 let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
796 assert_eq!(xs.split_inclusive_mut(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
797 let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
798 assert_eq!(xs.split_inclusive_mut(|x| *x == 10).rev().collect::<Vec<_>>(), splits);
799 let splits: &[&[_]] = &[&[5], &[4], &[3], &[2], &[1]];
800 assert_eq!(xs.split_inclusive_mut(|_| true).rev().collect::<Vec<_>>(), splits);
801
802 let xs: &mut [i32] = &mut [];
803 let splits: &[&[i32]] = &[];
804 assert_eq!(xs.split_inclusive_mut(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
805 }
806
807 #[test]
test_splitn_iterator()808 fn test_splitn_iterator() {
809 let xs = &[1, 2, 3, 4, 5];
810
811 let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
812 assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
813 let splits: &[&[_]] = &[&[1], &[3, 4, 5]];
814 assert_eq!(xs.splitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
815 let splits: &[&[_]] = &[&[], &[], &[], &[4, 5]];
816 assert_eq!(xs.splitn(4, |_| true).collect::<Vec<_>>(), splits);
817
818 let xs: &[i32] = &[];
819 let splits: &[&[i32]] = &[&[]];
820 assert_eq!(xs.splitn(2, |x| *x == 5).collect::<Vec<_>>(), splits);
821 }
822
823 #[test]
test_splitn_iterator_mut()824 fn test_splitn_iterator_mut() {
825 let xs = &mut [1, 2, 3, 4, 5];
826
827 let splits: &[&mut [_]] = &[&mut [1, 2, 3, 4, 5]];
828 assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
829 let splits: &[&mut [_]] = &[&mut [1], &mut [3, 4, 5]];
830 assert_eq!(xs.splitn_mut(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
831 let splits: &[&mut [_]] = &[&mut [], &mut [], &mut [], &mut [4, 5]];
832 assert_eq!(xs.splitn_mut(4, |_| true).collect::<Vec<_>>(), splits);
833
834 let xs: &mut [i32] = &mut [];
835 let splits: &[&mut [i32]] = &[&mut []];
836 assert_eq!(xs.splitn_mut(2, |x| *x == 5).collect::<Vec<_>>(), splits);
837 }
838
839 #[test]
test_rsplit_iterator()840 fn test_rsplit_iterator() {
841 let xs = &[1, 2, 3, 4, 5];
842
843 let splits: &[&[_]] = &[&[5], &[3], &[1]];
844 assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits);
845 let splits: &[&[_]] = &[&[2, 3, 4, 5], &[]];
846 assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(), splits);
847 let splits: &[&[_]] = &[&[], &[1, 2, 3, 4]];
848 assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
849 let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
850 assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(), splits);
851
852 let xs: &[i32] = &[];
853 let splits: &[&[i32]] = &[&[]];
854 assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
855 }
856
857 #[test]
test_rsplitn_iterator()858 fn test_rsplitn_iterator() {
859 let xs = &[1, 2, 3, 4, 5];
860
861 let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
862 assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
863 let splits: &[&[_]] = &[&[5], &[1, 2, 3]];
864 assert_eq!(xs.rsplitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
865 let splits: &[&[_]] = &[&[], &[], &[], &[1, 2]];
866 assert_eq!(xs.rsplitn(4, |_| true).collect::<Vec<_>>(), splits);
867
868 let xs: &[i32] = &[];
869 let splits: &[&[i32]] = &[&[]];
870 assert_eq!(xs.rsplitn(2, |x| *x == 5).collect::<Vec<&[i32]>>(), splits);
871 assert!(xs.rsplitn(0, |x| *x % 2 == 0).next().is_none());
872 }
873
874 #[test]
test_split_iterators_size_hint()875 fn test_split_iterators_size_hint() {
876 #[derive(Copy, Clone)]
877 enum Bounds {
878 Lower,
879 Upper,
880 }
881 fn assert_tight_size_hints(mut it: impl Iterator, which: Bounds, ctx: impl fmt::Display) {
882 match which {
883 Bounds::Lower => {
884 let mut lower_bounds = vec![it.size_hint().0];
885 while let Some(_) = it.next() {
886 lower_bounds.push(it.size_hint().0);
887 }
888 let target: Vec<_> = (0..lower_bounds.len()).rev().collect();
889 assert_eq!(lower_bounds, target, "lower bounds incorrect or not tight: {}", ctx);
890 }
891 Bounds::Upper => {
892 let mut upper_bounds = vec![it.size_hint().1];
893 while let Some(_) = it.next() {
894 upper_bounds.push(it.size_hint().1);
895 }
896 let target: Vec<_> = (0..upper_bounds.len()).map(Some).rev().collect();
897 assert_eq!(upper_bounds, target, "upper bounds incorrect or not tight: {}", ctx);
898 }
899 }
900 }
901
902 for len in 0..=2 {
903 let mut v: Vec<u8> = (0..len).collect();
904
905 // p: predicate, b: bound selection
906 for (p, b) in [
907 // with a predicate always returning false, the split*-iterators
908 // become maximally short, so the size_hint lower bounds are tight
909 ((|_| false) as fn(&_) -> _, Bounds::Lower),
910 // with a predicate always returning true, the split*-iterators
911 // become maximally long, so the size_hint upper bounds are tight
912 ((|_| true) as fn(&_) -> _, Bounds::Upper),
913 ] {
914 use assert_tight_size_hints as a;
915 use format_args as f;
916
917 a(v.split(p), b, "split");
918 a(v.split_mut(p), b, "split_mut");
919 a(v.split_inclusive(p), b, "split_inclusive");
920 a(v.split_inclusive_mut(p), b, "split_inclusive_mut");
921 a(v.rsplit(p), b, "rsplit");
922 a(v.rsplit_mut(p), b, "rsplit_mut");
923
924 for n in 0..=3 {
925 a(v.splitn(n, p), b, f!("splitn, n = {n}"));
926 a(v.splitn_mut(n, p), b, f!("splitn_mut, n = {n}"));
927 a(v.rsplitn(n, p), b, f!("rsplitn, n = {n}"));
928 a(v.rsplitn_mut(n, p), b, f!("rsplitn_mut, n = {n}"));
929 }
930 }
931 }
932 }
933
934 #[test]
test_windows_iterator()935 fn test_windows_iterator() {
936 let v = &[1, 2, 3, 4];
937
938 let wins: &[&[_]] = &[&[1, 2], &[2, 3], &[3, 4]];
939 assert_eq!(v.windows(2).collect::<Vec<_>>(), wins);
940
941 let wins: &[&[_]] = &[&[1, 2, 3], &[2, 3, 4]];
942 assert_eq!(v.windows(3).collect::<Vec<_>>(), wins);
943 assert!(v.windows(6).next().is_none());
944
945 let wins: &[&[_]] = &[&[3, 4], &[2, 3], &[1, 2]];
946 assert_eq!(v.windows(2).rev().collect::<Vec<&[_]>>(), wins);
947 }
948
949 #[test]
950 #[should_panic]
test_windows_iterator_0()951 fn test_windows_iterator_0() {
952 let v = &[1, 2, 3, 4];
953 let _it = v.windows(0);
954 }
955
956 #[test]
test_chunks_iterator()957 fn test_chunks_iterator() {
958 let v = &[1, 2, 3, 4, 5];
959
960 assert_eq!(v.chunks(2).len(), 3);
961
962 let chunks: &[&[_]] = &[&[1, 2], &[3, 4], &[5]];
963 assert_eq!(v.chunks(2).collect::<Vec<_>>(), chunks);
964 let chunks: &[&[_]] = &[&[1, 2, 3], &[4, 5]];
965 assert_eq!(v.chunks(3).collect::<Vec<_>>(), chunks);
966 let chunks: &[&[_]] = &[&[1, 2, 3, 4, 5]];
967 assert_eq!(v.chunks(6).collect::<Vec<_>>(), chunks);
968
969 let chunks: &[&[_]] = &[&[5], &[3, 4], &[1, 2]];
970 assert_eq!(v.chunks(2).rev().collect::<Vec<_>>(), chunks);
971 }
972
973 #[test]
974 #[should_panic]
test_chunks_iterator_0()975 fn test_chunks_iterator_0() {
976 let v = &[1, 2, 3, 4];
977 let _it = v.chunks(0);
978 }
979
980 #[test]
test_chunks_exact_iterator()981 fn test_chunks_exact_iterator() {
982 let v = &[1, 2, 3, 4, 5];
983
984 assert_eq!(v.chunks_exact(2).len(), 2);
985
986 let chunks: &[&[_]] = &[&[1, 2], &[3, 4]];
987 assert_eq!(v.chunks_exact(2).collect::<Vec<_>>(), chunks);
988 let chunks: &[&[_]] = &[&[1, 2, 3]];
989 assert_eq!(v.chunks_exact(3).collect::<Vec<_>>(), chunks);
990 let chunks: &[&[_]] = &[];
991 assert_eq!(v.chunks_exact(6).collect::<Vec<_>>(), chunks);
992
993 let chunks: &[&[_]] = &[&[3, 4], &[1, 2]];
994 assert_eq!(v.chunks_exact(2).rev().collect::<Vec<_>>(), chunks);
995 }
996
997 #[test]
998 #[should_panic]
test_chunks_exact_iterator_0()999 fn test_chunks_exact_iterator_0() {
1000 let v = &[1, 2, 3, 4];
1001 let _it = v.chunks_exact(0);
1002 }
1003
1004 #[test]
test_rchunks_iterator()1005 fn test_rchunks_iterator() {
1006 let v = &[1, 2, 3, 4, 5];
1007
1008 assert_eq!(v.rchunks(2).len(), 3);
1009
1010 let chunks: &[&[_]] = &[&[4, 5], &[2, 3], &[1]];
1011 assert_eq!(v.rchunks(2).collect::<Vec<_>>(), chunks);
1012 let chunks: &[&[_]] = &[&[3, 4, 5], &[1, 2]];
1013 assert_eq!(v.rchunks(3).collect::<Vec<_>>(), chunks);
1014 let chunks: &[&[_]] = &[&[1, 2, 3, 4, 5]];
1015 assert_eq!(v.rchunks(6).collect::<Vec<_>>(), chunks);
1016
1017 let chunks: &[&[_]] = &[&[1], &[2, 3], &[4, 5]];
1018 assert_eq!(v.rchunks(2).rev().collect::<Vec<_>>(), chunks);
1019 }
1020
1021 #[test]
1022 #[should_panic]
test_rchunks_iterator_0()1023 fn test_rchunks_iterator_0() {
1024 let v = &[1, 2, 3, 4];
1025 let _it = v.rchunks(0);
1026 }
1027
1028 #[test]
test_rchunks_exact_iterator()1029 fn test_rchunks_exact_iterator() {
1030 let v = &[1, 2, 3, 4, 5];
1031
1032 assert_eq!(v.rchunks_exact(2).len(), 2);
1033
1034 let chunks: &[&[_]] = &[&[4, 5], &[2, 3]];
1035 assert_eq!(v.rchunks_exact(2).collect::<Vec<_>>(), chunks);
1036 let chunks: &[&[_]] = &[&[3, 4, 5]];
1037 assert_eq!(v.rchunks_exact(3).collect::<Vec<_>>(), chunks);
1038 let chunks: &[&[_]] = &[];
1039 assert_eq!(v.rchunks_exact(6).collect::<Vec<_>>(), chunks);
1040
1041 let chunks: &[&[_]] = &[&[2, 3], &[4, 5]];
1042 assert_eq!(v.rchunks_exact(2).rev().collect::<Vec<_>>(), chunks);
1043 }
1044
1045 #[test]
1046 #[should_panic]
test_rchunks_exact_iterator_0()1047 fn test_rchunks_exact_iterator_0() {
1048 let v = &[1, 2, 3, 4];
1049 let _it = v.rchunks_exact(0);
1050 }
1051
1052 #[test]
test_reverse_part()1053 fn test_reverse_part() {
1054 let mut values = [1, 2, 3, 4, 5];
1055 values[1..4].reverse();
1056 assert!(values == [1, 4, 3, 2, 5]);
1057 }
1058
1059 #[test]
test_show()1060 fn test_show() {
1061 macro_rules! test_show_vec {
1062 ($x:expr, $x_str:expr) => {{
1063 let (x, x_str) = ($x, $x_str);
1064 assert_eq!(format!("{x:?}"), x_str);
1065 assert_eq!(format!("{x:?}"), x_str);
1066 }};
1067 }
1068 let empty = Vec::<i32>::new();
1069 test_show_vec!(empty, "[]");
1070 test_show_vec!(vec![1], "[1]");
1071 test_show_vec!(vec![1, 2, 3], "[1, 2, 3]");
1072 test_show_vec!(vec![vec![], vec![1], vec![1, 1]], "[[], [1], [1, 1]]");
1073
1074 let empty_mut: &mut [i32] = &mut [];
1075 test_show_vec!(empty_mut, "[]");
1076 let v = &mut [1];
1077 test_show_vec!(v, "[1]");
1078 let v = &mut [1, 2, 3];
1079 test_show_vec!(v, "[1, 2, 3]");
1080 let v: &mut [&mut [_]] = &mut [&mut [], &mut [1], &mut [1, 1]];
1081 test_show_vec!(v, "[[], [1], [1, 1]]");
1082 }
1083
1084 #[test]
test_vec_default()1085 fn test_vec_default() {
1086 macro_rules! t {
1087 ($ty:ty) => {{
1088 let v: $ty = Default::default();
1089 assert!(v.is_empty());
1090 }};
1091 }
1092
1093 t!(&[i32]);
1094 t!(Vec<i32>);
1095 }
1096
1097 #[test]
1098 #[should_panic]
test_overflow_does_not_cause_segfault()1099 fn test_overflow_does_not_cause_segfault() {
1100 let mut v = vec![];
1101 v.reserve_exact(!0);
1102 v.push(1);
1103 v.push(2);
1104 }
1105
1106 #[test]
1107 #[should_panic]
test_overflow_does_not_cause_segfault_managed()1108 fn test_overflow_does_not_cause_segfault_managed() {
1109 let mut v = vec![Rc::new(1)];
1110 v.reserve_exact(!0);
1111 v.push(Rc::new(2));
1112 }
1113
1114 #[test]
test_mut_split_at()1115 fn test_mut_split_at() {
1116 let mut values = [1, 2, 3, 4, 5];
1117 {
1118 let (left, right) = values.split_at_mut(2);
1119 {
1120 let left: &[_] = left;
1121 assert!(left[..left.len()] == [1, 2]);
1122 }
1123 for p in left {
1124 *p += 1;
1125 }
1126
1127 {
1128 let right: &[_] = right;
1129 assert!(right[..right.len()] == [3, 4, 5]);
1130 }
1131 for p in right {
1132 *p += 2;
1133 }
1134 }
1135
1136 assert!(values == [2, 3, 5, 6, 7]);
1137 }
1138
1139 #[derive(Clone, PartialEq)]
1140 struct Foo;
1141
1142 #[test]
test_iter_zero_sized()1143 fn test_iter_zero_sized() {
1144 let mut v = vec![Foo, Foo, Foo];
1145 assert_eq!(v.len(), 3);
1146 let mut cnt = 0;
1147
1148 for f in &v {
1149 assert!(*f == Foo);
1150 cnt += 1;
1151 }
1152 assert_eq!(cnt, 3);
1153
1154 for f in &v[1..3] {
1155 assert!(*f == Foo);
1156 cnt += 1;
1157 }
1158 assert_eq!(cnt, 5);
1159
1160 for f in &mut v {
1161 assert!(*f == Foo);
1162 cnt += 1;
1163 }
1164 assert_eq!(cnt, 8);
1165
1166 for f in v {
1167 assert!(f == Foo);
1168 cnt += 1;
1169 }
1170 assert_eq!(cnt, 11);
1171
1172 let xs: [Foo; 3] = [Foo, Foo, Foo];
1173 cnt = 0;
1174 for f in &xs {
1175 assert!(*f == Foo);
1176 cnt += 1;
1177 }
1178 assert!(cnt == 3);
1179 }
1180
1181 #[test]
test_shrink_to_fit()1182 fn test_shrink_to_fit() {
1183 let mut xs = vec![0, 1, 2, 3];
1184 for i in 4..100 {
1185 xs.push(i)
1186 }
1187 assert_eq!(xs.capacity(), 128);
1188 xs.shrink_to_fit();
1189 assert_eq!(xs.capacity(), 100);
1190 assert_eq!(xs, (0..100).collect::<Vec<_>>());
1191 }
1192
1193 #[test]
test_starts_with()1194 fn test_starts_with() {
1195 assert!(b"foobar".starts_with(b"foo"));
1196 assert!(!b"foobar".starts_with(b"oob"));
1197 assert!(!b"foobar".starts_with(b"bar"));
1198 assert!(!b"foo".starts_with(b"foobar"));
1199 assert!(!b"bar".starts_with(b"foobar"));
1200 assert!(b"foobar".starts_with(b"foobar"));
1201 let empty: &[u8] = &[];
1202 assert!(empty.starts_with(empty));
1203 assert!(!empty.starts_with(b"foo"));
1204 assert!(b"foobar".starts_with(empty));
1205 }
1206
1207 #[test]
test_ends_with()1208 fn test_ends_with() {
1209 assert!(b"foobar".ends_with(b"bar"));
1210 assert!(!b"foobar".ends_with(b"oba"));
1211 assert!(!b"foobar".ends_with(b"foo"));
1212 assert!(!b"foo".ends_with(b"foobar"));
1213 assert!(!b"bar".ends_with(b"foobar"));
1214 assert!(b"foobar".ends_with(b"foobar"));
1215 let empty: &[u8] = &[];
1216 assert!(empty.ends_with(empty));
1217 assert!(!empty.ends_with(b"foo"));
1218 assert!(b"foobar".ends_with(empty));
1219 }
1220
1221 #[test]
test_mut_split_iterator()1222 fn test_mut_split_iterator() {
1223 let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0];
1224 assert_eq!(xs.split_mut(|x| *x == 0).count(), 6);
1225 for slice in xs.split_mut(|x| *x == 0) {
1226 slice.reverse();
1227 }
1228 assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0]);
1229
1230 let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0, 6, 7];
1231 for slice in xs.split_mut(|x| *x == 0).take(5) {
1232 slice.reverse();
1233 }
1234 assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0, 6, 7]);
1235 }
1236
1237 #[test]
test_mut_split_iterator_rev()1238 fn test_mut_split_iterator_rev() {
1239 let mut xs = [1, 2, 0, 3, 4, 0, 0, 5, 6, 0];
1240 for slice in xs.split_mut(|x| *x == 0).rev().take(4) {
1241 slice.reverse();
1242 }
1243 assert!(xs == [1, 2, 0, 4, 3, 0, 0, 6, 5, 0]);
1244 }
1245
1246 #[test]
test_get_mut()1247 fn test_get_mut() {
1248 let mut v = [0, 1, 2];
1249 assert_eq!(v.get_mut(3), None);
1250 v.get_mut(1).map(|e| *e = 7);
1251 assert_eq!(v[1], 7);
1252 let mut x = 2;
1253 assert_eq!(v.get_mut(2), Some(&mut x));
1254 }
1255
1256 #[test]
test_mut_chunks()1257 fn test_mut_chunks() {
1258 let mut v = [0, 1, 2, 3, 4, 5, 6];
1259 assert_eq!(v.chunks_mut(3).len(), 3);
1260 for (i, chunk) in v.chunks_mut(3).enumerate() {
1261 for x in chunk {
1262 *x = i as u8;
1263 }
1264 }
1265 let result = [0, 0, 0, 1, 1, 1, 2];
1266 assert_eq!(v, result);
1267 }
1268
1269 #[test]
test_mut_chunks_rev()1270 fn test_mut_chunks_rev() {
1271 let mut v = [0, 1, 2, 3, 4, 5, 6];
1272 for (i, chunk) in v.chunks_mut(3).rev().enumerate() {
1273 for x in chunk {
1274 *x = i as u8;
1275 }
1276 }
1277 let result = [2, 2, 2, 1, 1, 1, 0];
1278 assert_eq!(v, result);
1279 }
1280
1281 #[test]
1282 #[should_panic]
test_mut_chunks_0()1283 fn test_mut_chunks_0() {
1284 let mut v = [1, 2, 3, 4];
1285 let _it = v.chunks_mut(0);
1286 }
1287
1288 #[test]
test_mut_chunks_exact()1289 fn test_mut_chunks_exact() {
1290 let mut v = [0, 1, 2, 3, 4, 5, 6];
1291 assert_eq!(v.chunks_exact_mut(3).len(), 2);
1292 for (i, chunk) in v.chunks_exact_mut(3).enumerate() {
1293 for x in chunk {
1294 *x = i as u8;
1295 }
1296 }
1297 let result = [0, 0, 0, 1, 1, 1, 6];
1298 assert_eq!(v, result);
1299 }
1300
1301 #[test]
test_mut_chunks_exact_rev()1302 fn test_mut_chunks_exact_rev() {
1303 let mut v = [0, 1, 2, 3, 4, 5, 6];
1304 for (i, chunk) in v.chunks_exact_mut(3).rev().enumerate() {
1305 for x in chunk {
1306 *x = i as u8;
1307 }
1308 }
1309 let result = [1, 1, 1, 0, 0, 0, 6];
1310 assert_eq!(v, result);
1311 }
1312
1313 #[test]
1314 #[should_panic]
test_mut_chunks_exact_0()1315 fn test_mut_chunks_exact_0() {
1316 let mut v = [1, 2, 3, 4];
1317 let _it = v.chunks_exact_mut(0);
1318 }
1319
1320 #[test]
test_mut_rchunks()1321 fn test_mut_rchunks() {
1322 let mut v = [0, 1, 2, 3, 4, 5, 6];
1323 assert_eq!(v.rchunks_mut(3).len(), 3);
1324 for (i, chunk) in v.rchunks_mut(3).enumerate() {
1325 for x in chunk {
1326 *x = i as u8;
1327 }
1328 }
1329 let result = [2, 1, 1, 1, 0, 0, 0];
1330 assert_eq!(v, result);
1331 }
1332
1333 #[test]
test_mut_rchunks_rev()1334 fn test_mut_rchunks_rev() {
1335 let mut v = [0, 1, 2, 3, 4, 5, 6];
1336 for (i, chunk) in v.rchunks_mut(3).rev().enumerate() {
1337 for x in chunk {
1338 *x = i as u8;
1339 }
1340 }
1341 let result = [0, 1, 1, 1, 2, 2, 2];
1342 assert_eq!(v, result);
1343 }
1344
1345 #[test]
1346 #[should_panic]
test_mut_rchunks_0()1347 fn test_mut_rchunks_0() {
1348 let mut v = [1, 2, 3, 4];
1349 let _it = v.rchunks_mut(0);
1350 }
1351
1352 #[test]
test_mut_rchunks_exact()1353 fn test_mut_rchunks_exact() {
1354 let mut v = [0, 1, 2, 3, 4, 5, 6];
1355 assert_eq!(v.rchunks_exact_mut(3).len(), 2);
1356 for (i, chunk) in v.rchunks_exact_mut(3).enumerate() {
1357 for x in chunk {
1358 *x = i as u8;
1359 }
1360 }
1361 let result = [0, 1, 1, 1, 0, 0, 0];
1362 assert_eq!(v, result);
1363 }
1364
1365 #[test]
test_mut_rchunks_exact_rev()1366 fn test_mut_rchunks_exact_rev() {
1367 let mut v = [0, 1, 2, 3, 4, 5, 6];
1368 for (i, chunk) in v.rchunks_exact_mut(3).rev().enumerate() {
1369 for x in chunk {
1370 *x = i as u8;
1371 }
1372 }
1373 let result = [0, 0, 0, 0, 1, 1, 1];
1374 assert_eq!(v, result);
1375 }
1376
1377 #[test]
1378 #[should_panic]
test_mut_rchunks_exact_0()1379 fn test_mut_rchunks_exact_0() {
1380 let mut v = [1, 2, 3, 4];
1381 let _it = v.rchunks_exact_mut(0);
1382 }
1383
1384 #[test]
test_mut_last()1385 fn test_mut_last() {
1386 let mut x = [1, 2, 3, 4, 5];
1387 let h = x.last_mut();
1388 assert_eq!(*h.unwrap(), 5);
1389
1390 let y: &mut [i32] = &mut [];
1391 assert!(y.last_mut().is_none());
1392 }
1393
1394 #[test]
test_to_vec()1395 fn test_to_vec() {
1396 let xs: Box<_> = Box::new([1, 2, 3]);
1397 let ys = xs.to_vec();
1398 assert_eq!(ys, [1, 2, 3]);
1399 }
1400
1401 #[test]
test_in_place_iterator_specialization()1402 fn test_in_place_iterator_specialization() {
1403 let src: Box<[usize]> = Box::new([1, 2, 3]);
1404 let src_ptr = src.as_ptr();
1405 let sink: Box<_> = src.into_vec().into_iter().map(std::convert::identity).collect();
1406 let sink_ptr = sink.as_ptr();
1407 assert_eq!(src_ptr, sink_ptr);
1408 }
1409
1410 #[test]
test_box_slice_clone()1411 fn test_box_slice_clone() {
1412 let data = vec![vec![0, 1], vec![0], vec![1]];
1413 let data2 = data.clone().into_boxed_slice().clone().to_vec();
1414
1415 assert_eq!(data, data2);
1416 }
1417
1418 #[test]
1419 #[allow(unused_must_use)] // here, we care about the side effects of `.clone()`
1420 #[cfg_attr(target_os = "emscripten", ignore)]
1421 #[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
test_box_slice_clone_panics()1422 fn test_box_slice_clone_panics() {
1423 use std::sync::atomic::{AtomicUsize, Ordering};
1424 use std::sync::Arc;
1425
1426 struct Canary {
1427 count: Arc<AtomicUsize>,
1428 panics: bool,
1429 }
1430
1431 impl Drop for Canary {
1432 fn drop(&mut self) {
1433 self.count.fetch_add(1, Ordering::SeqCst);
1434 }
1435 }
1436
1437 impl Clone for Canary {
1438 fn clone(&self) -> Self {
1439 if self.panics {
1440 panic!()
1441 }
1442
1443 Canary { count: self.count.clone(), panics: self.panics }
1444 }
1445 }
1446
1447 let drop_count = Arc::new(AtomicUsize::new(0));
1448 let canary = Canary { count: drop_count.clone(), panics: false };
1449 let panic = Canary { count: drop_count.clone(), panics: true };
1450
1451 std::panic::catch_unwind(move || {
1452 // When xs is dropped, +5.
1453 let xs =
1454 vec![canary.clone(), canary.clone(), canary.clone(), panic, canary].into_boxed_slice();
1455
1456 // When panic is cloned, +3.
1457 xs.clone();
1458 })
1459 .unwrap_err();
1460
1461 // Total = 8
1462 assert_eq!(drop_count.load(Ordering::SeqCst), 8);
1463 }
1464
1465 #[test]
test_copy_from_slice()1466 fn test_copy_from_slice() {
1467 let src = [0, 1, 2, 3, 4, 5];
1468 let mut dst = [0; 6];
1469 dst.copy_from_slice(&src);
1470 assert_eq!(src, dst)
1471 }
1472
1473 #[test]
1474 #[should_panic(expected = "source slice length (4) does not match destination slice length (5)")]
test_copy_from_slice_dst_longer()1475 fn test_copy_from_slice_dst_longer() {
1476 let src = [0, 1, 2, 3];
1477 let mut dst = [0; 5];
1478 dst.copy_from_slice(&src);
1479 }
1480
1481 #[test]
1482 #[should_panic(expected = "source slice length (4) does not match destination slice length (3)")]
test_copy_from_slice_dst_shorter()1483 fn test_copy_from_slice_dst_shorter() {
1484 let src = [0, 1, 2, 3];
1485 let mut dst = [0; 3];
1486 dst.copy_from_slice(&src);
1487 }
1488
1489 #[test]
repeat_generic_slice()1490 fn repeat_generic_slice() {
1491 assert_eq!([1, 2].repeat(2), vec![1, 2, 1, 2]);
1492 assert_eq!([1, 2, 3, 4].repeat(0), vec![]);
1493 assert_eq!([1, 2, 3, 4].repeat(1), vec![1, 2, 3, 4]);
1494 assert_eq!([1, 2, 3, 4].repeat(3), vec![1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]);
1495 }
1496
1497 #[test]
1498 #[allow(unreachable_patterns)]
subslice_patterns()1499 fn subslice_patterns() {
1500 // This test comprehensively checks the passing static and dynamic semantics
1501 // of subslice patterns `..`, `x @ ..`, `ref x @ ..`, and `ref mut @ ..`
1502 // in slice patterns `[$($pat), $(,)?]` .
1503
1504 #[derive(PartialEq, Debug, Clone)]
1505 struct N(u8);
1506
1507 macro_rules! n {
1508 ($($e:expr),* $(,)?) => {
1509 [$(N($e)),*]
1510 }
1511 }
1512
1513 macro_rules! c {
1514 ($inp:expr, $typ:ty, $out:expr $(,)?) => {
1515 assert_eq!($out, identity::<$typ>($inp))
1516 };
1517 }
1518
1519 macro_rules! m {
1520 ($e:expr, $p:pat => $b:expr) => {
1521 match $e {
1522 $p => $b,
1523 _ => panic!(),
1524 }
1525 };
1526 }
1527
1528 // == Slices ==
1529
1530 // Matching slices using `ref` patterns:
1531 let mut v = vec![N(0), N(1), N(2), N(3), N(4)];
1532 let mut vc = (0..=4).collect::<Vec<u8>>();
1533
1534 let [..] = v[..]; // Always matches.
1535 m!(v[..], [N(0), ref sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3]));
1536 m!(v[..], [N(0), ref sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4]));
1537 m!(v[..], [ref sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3]));
1538 m!(v[..], [ref sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N]));
1539 m!(v[..], [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N], &n![] as &[N]));
1540 m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
1541
1542 // Matching slices using `ref mut` patterns:
1543 let [..] = v[..]; // Always matches.
1544 m!(v[..], [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3]));
1545 m!(v[..], [N(0), ref mut sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4]));
1546 m!(v[..], [ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3]));
1547 m!(v[..], [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N]));
1548 m!(v[..], [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N]));
1549 m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
1550
1551 // Matching slices using default binding modes (&):
1552 let [..] = &v[..]; // Always matches.
1553 m!(&v[..], [N(0), sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3]));
1554 m!(&v[..], [N(0), sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4]));
1555 m!(&v[..], [sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3]));
1556 m!(&v[..], [sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N]));
1557 m!(&v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &[N], &n![] as &[N]));
1558 m!(&vc[..], [x, .., y] => c!((x, y), (&u8, &u8), (&0, &4)));
1559
1560 // Matching slices using default binding modes (&mut):
1561 let [..] = &mut v[..]; // Always matches.
1562 m!(&mut v[..], [N(0), sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3]));
1563 m!(&mut v[..], [N(0), sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4]));
1564 m!(&mut v[..], [sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3]));
1565 m!(&mut v[..], [sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N]));
1566 m!(&mut v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N]));
1567 m!(&mut vc[..], [x, .., y] => c!((x, y), (&mut u8, &mut u8), (&mut 0, &mut 4)));
1568
1569 // == Arrays ==
1570 let mut v = n![0, 1, 2, 3, 4];
1571 let vc = [0, 1, 2, 3, 4];
1572
1573 // Matching arrays by value:
1574 m!(v.clone(), [N(0), sub @ .., N(4)] => c!(sub, [N; 3], n![1, 2, 3]));
1575 m!(v.clone(), [N(0), sub @ ..] => c!(sub, [N; 4], n![1, 2, 3, 4]));
1576 m!(v.clone(), [sub @ .., N(4)] => c!(sub, [N; 4], n![0, 1, 2, 3]));
1577 m!(v.clone(), [sub @ .., _, _, _, _, _] => c!(sub, [N; 0], n![] as [N; 0]));
1578 m!(v.clone(), [_, _, _, _, _, sub @ ..] => c!(sub, [N; 0], n![] as [N; 0]));
1579 m!(v.clone(), [x, .., y] => c!((x, y), (N, N), (N(0), N(4))));
1580 m!(v.clone(), [..] => ());
1581
1582 // Matching arrays by ref patterns:
1583 m!(v, [N(0), ref sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3]));
1584 m!(v, [N(0), ref sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4]));
1585 m!(v, [ref sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3]));
1586 m!(v, [ref sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0]));
1587 m!(v, [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0]));
1588 m!(vc, [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
1589
1590 // Matching arrays by ref mut patterns:
1591 m!(v, [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3]));
1592 m!(v, [N(0), ref mut sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4]));
1593 m!(v, [ref mut sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3]));
1594 m!(v, [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0]));
1595 m!(v, [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0]));
1596
1597 // Matching arrays by default binding modes (&):
1598 m!(&v, [N(0), sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3]));
1599 m!(&v, [N(0), sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4]));
1600 m!(&v, [sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3]));
1601 m!(&v, [sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0]));
1602 m!(&v, [_, _, _, _, _, sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0]));
1603 m!(&v, [..] => ());
1604 m!(&v, [x, .., y] => c!((x, y), (&N, &N), (&N(0), &N(4))));
1605
1606 // Matching arrays by default binding modes (&mut):
1607 m!(&mut v, [N(0), sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3]));
1608 m!(&mut v, [N(0), sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4]));
1609 m!(&mut v, [sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3]));
1610 m!(&mut v, [sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0]));
1611 m!(&mut v, [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0]));
1612 m!(&mut v, [..] => ());
1613 m!(&mut v, [x, .., y] => c!((x, y), (&mut N, &mut N), (&mut N(0), &mut N(4))));
1614 }
1615
1616 #[test]
test_group_by()1617 fn test_group_by() {
1618 let slice = &[1, 1, 1, 3, 3, 2, 2, 2, 1, 0];
1619
1620 let mut iter = slice.group_by(|a, b| a == b);
1621 assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
1622 assert_eq!(iter.next(), Some(&[3, 3][..]));
1623 assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
1624 assert_eq!(iter.next(), Some(&[1][..]));
1625 assert_eq!(iter.next(), Some(&[0][..]));
1626 assert_eq!(iter.next(), None);
1627
1628 let mut iter = slice.group_by(|a, b| a == b);
1629 assert_eq!(iter.next_back(), Some(&[0][..]));
1630 assert_eq!(iter.next_back(), Some(&[1][..]));
1631 assert_eq!(iter.next_back(), Some(&[2, 2, 2][..]));
1632 assert_eq!(iter.next_back(), Some(&[3, 3][..]));
1633 assert_eq!(iter.next_back(), Some(&[1, 1, 1][..]));
1634 assert_eq!(iter.next_back(), None);
1635
1636 let mut iter = slice.group_by(|a, b| a == b);
1637 assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
1638 assert_eq!(iter.next_back(), Some(&[0][..]));
1639 assert_eq!(iter.next(), Some(&[3, 3][..]));
1640 assert_eq!(iter.next_back(), Some(&[1][..]));
1641 assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
1642 assert_eq!(iter.next_back(), None);
1643 }
1644
1645 #[test]
test_group_by_mut()1646 fn test_group_by_mut() {
1647 let slice = &mut [1, 1, 1, 3, 3, 2, 2, 2, 1, 0];
1648
1649 let mut iter = slice.group_by_mut(|a, b| a == b);
1650 assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
1651 assert_eq!(iter.next(), Some(&mut [3, 3][..]));
1652 assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
1653 assert_eq!(iter.next(), Some(&mut [1][..]));
1654 assert_eq!(iter.next(), Some(&mut [0][..]));
1655 assert_eq!(iter.next(), None);
1656
1657 let mut iter = slice.group_by_mut(|a, b| a == b);
1658 assert_eq!(iter.next_back(), Some(&mut [0][..]));
1659 assert_eq!(iter.next_back(), Some(&mut [1][..]));
1660 assert_eq!(iter.next_back(), Some(&mut [2, 2, 2][..]));
1661 assert_eq!(iter.next_back(), Some(&mut [3, 3][..]));
1662 assert_eq!(iter.next_back(), Some(&mut [1, 1, 1][..]));
1663 assert_eq!(iter.next_back(), None);
1664
1665 let mut iter = slice.group_by_mut(|a, b| a == b);
1666 assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
1667 assert_eq!(iter.next_back(), Some(&mut [0][..]));
1668 assert_eq!(iter.next(), Some(&mut [3, 3][..]));
1669 assert_eq!(iter.next_back(), Some(&mut [1][..]));
1670 assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
1671 assert_eq!(iter.next_back(), None);
1672 }
1673