2 use core::cmp::Ordering;
3 use core::mem::MaybeUninit;
4 use core::result::Result::{Err, Ok};
8 let b = [1, 2, 3, 5, 5];
9 assert_eq!(b.iter().position(|&v| v == 9), None);
10 assert_eq!(b.iter().position(|&v| v == 5), Some(3));
11 assert_eq!(b.iter().position(|&v| v == 3), Some(2));
12 assert_eq!(b.iter().position(|&v| v == 0), None);
17 let b = [1, 2, 3, 5, 5];
18 assert_eq!(b.iter().rposition(|&v| v == 9), None);
19 assert_eq!(b.iter().rposition(|&v| v == 5), Some(4));
20 assert_eq!(b.iter().rposition(|&v| v == 3), Some(2));
21 assert_eq!(b.iter().rposition(|&v| v == 0), None);
25 fn test_binary_search() {
27 assert_eq!(b.binary_search(&5), Err(0));
30 assert_eq!(b.binary_search(&3), Err(0));
31 assert_eq!(b.binary_search(&4), Ok(0));
32 assert_eq!(b.binary_search(&5), Err(1));
34 let b = [1, 2, 4, 6, 8, 9];
35 assert_eq!(b.binary_search(&5), Err(3));
36 assert_eq!(b.binary_search(&6), Ok(3));
37 assert_eq!(b.binary_search(&7), Err(4));
38 assert_eq!(b.binary_search(&8), Ok(4));
40 let b = [1, 2, 4, 5, 6, 8];
41 assert_eq!(b.binary_search(&9), Err(6));
43 let b = [1, 2, 4, 6, 7, 8, 9];
44 assert_eq!(b.binary_search(&6), Ok(3));
45 assert_eq!(b.binary_search(&5), Err(3));
46 assert_eq!(b.binary_search(&8), Ok(5));
48 let b = [1, 2, 4, 5, 6, 8, 9];
49 assert_eq!(b.binary_search(&7), Err(5));
50 assert_eq!(b.binary_search(&0), Err(0));
52 let b = [1, 3, 3, 3, 7];
53 assert_eq!(b.binary_search(&0), Err(0));
54 assert_eq!(b.binary_search(&1), Ok(0));
55 assert_eq!(b.binary_search(&2), Err(1));
56 assert!(match b.binary_search(&3) {
60 assert!(match b.binary_search(&3) {
64 assert_eq!(b.binary_search(&4), Err(4));
65 assert_eq!(b.binary_search(&5), Err(4));
66 assert_eq!(b.binary_search(&6), Err(4));
67 assert_eq!(b.binary_search(&7), Ok(4));
68 assert_eq!(b.binary_search(&8), Err(5));
70 let b = [(); usize::MAX];
71 assert_eq!(b.binary_search(&()), Ok(usize::MAX / 2));
75 fn test_binary_search_by_overflow() {
76 let b = [(); usize::MAX];
77 assert_eq!(b.binary_search_by(|_| Ordering::Equal), Ok(usize::MAX / 2));
78 assert_eq!(b.binary_search_by(|_| Ordering::Greater), Err(0));
79 assert_eq!(b.binary_search_by(|_| Ordering::Less), Err(usize::MAX));
83 // Test implementation specific behavior when finding equivalent elements.
84 // It is ok to break this test but when you do a crater run is highly advisable.
85 fn test_binary_search_implementation_details() {
86 let b = [1, 1, 2, 2, 3, 3, 3];
87 assert_eq!(b.binary_search(&1), Ok(1));
88 assert_eq!(b.binary_search(&2), Ok(3));
89 assert_eq!(b.binary_search(&3), Ok(5));
90 let b = [1, 1, 1, 1, 1, 3, 3, 3, 3];
91 assert_eq!(b.binary_search(&1), Ok(4));
92 assert_eq!(b.binary_search(&3), Ok(7));
93 let b = [1, 1, 1, 1, 3, 3, 3, 3, 3];
94 assert_eq!(b.binary_search(&1), Ok(2));
95 assert_eq!(b.binary_search(&3), Ok(4));
99 fn test_partition_point() {
100 let b: [i32; 0] = [];
101 assert_eq!(b.partition_point(|&x| x < 5), 0);
104 assert_eq!(b.partition_point(|&x| x < 3), 0);
105 assert_eq!(b.partition_point(|&x| x < 4), 0);
106 assert_eq!(b.partition_point(|&x| x < 5), 1);
108 let b = [1, 2, 4, 6, 8, 9];
109 assert_eq!(b.partition_point(|&x| x < 5), 3);
110 assert_eq!(b.partition_point(|&x| x < 6), 3);
111 assert_eq!(b.partition_point(|&x| x < 7), 4);
112 assert_eq!(b.partition_point(|&x| x < 8), 4);
114 let b = [1, 2, 4, 5, 6, 8];
115 assert_eq!(b.partition_point(|&x| x < 9), 6);
117 let b = [1, 2, 4, 6, 7, 8, 9];
118 assert_eq!(b.partition_point(|&x| x < 6), 3);
119 assert_eq!(b.partition_point(|&x| x < 5), 3);
120 assert_eq!(b.partition_point(|&x| x < 8), 5);
122 let b = [1, 2, 4, 5, 6, 8, 9];
123 assert_eq!(b.partition_point(|&x| x < 7), 5);
124 assert_eq!(b.partition_point(|&x| x < 0), 0);
126 let b = [1, 3, 3, 3, 7];
127 assert_eq!(b.partition_point(|&x| x < 0), 0);
128 assert_eq!(b.partition_point(|&x| x < 1), 0);
129 assert_eq!(b.partition_point(|&x| x < 2), 1);
130 assert_eq!(b.partition_point(|&x| x < 3), 1);
131 assert_eq!(b.partition_point(|&x| x < 4), 4);
132 assert_eq!(b.partition_point(|&x| x < 5), 4);
133 assert_eq!(b.partition_point(|&x| x < 6), 4);
134 assert_eq!(b.partition_point(|&x| x < 7), 4);
135 assert_eq!(b.partition_point(|&x| x < 8), 5);
139 fn test_iterator_advance_by() {
140 let v = &[0, 1, 2, 3, 4];
142 for i in 0..=v.len() {
143 let mut iter = v.iter();
144 iter.advance_by(i).unwrap();
145 assert_eq!(iter.as_slice(), &v[i..]);
148 let mut iter = v.iter();
149 assert_eq!(iter.advance_by(v.len() + 1), Err(v.len()));
150 assert_eq!(iter.as_slice(), &[]);
152 let mut iter = v.iter();
153 iter.advance_by(3).unwrap();
154 assert_eq!(iter.as_slice(), &v[3..]);
155 iter.advance_by(2).unwrap();
156 assert_eq!(iter.as_slice(), &[]);
160 fn test_iterator_advance_back_by() {
161 let v = &[0, 1, 2, 3, 4];
163 for i in 0..=v.len() {
164 let mut iter = v.iter();
165 iter.advance_back_by(i).unwrap();
166 assert_eq!(iter.as_slice(), &v[..v.len() - i]);
169 let mut iter = v.iter();
170 assert_eq!(iter.advance_back_by(v.len() + 1), Err(v.len()));
171 assert_eq!(iter.as_slice(), &[]);
173 let mut iter = v.iter();
174 iter.advance_back_by(3).unwrap();
175 assert_eq!(iter.as_slice(), &v[..v.len() - 3]);
176 iter.advance_back_by(2).unwrap();
177 assert_eq!(iter.as_slice(), &[]);
181 fn test_iterator_nth() {
182 let v: &[_] = &[0, 1, 2, 3, 4];
183 for i in 0..v.len() {
184 assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
186 assert_eq!(v.iter().nth(v.len()), None);
188 let mut iter = v.iter();
189 assert_eq!(iter.nth(2).unwrap(), &v[2]);
190 assert_eq!(iter.nth(1).unwrap(), &v[4]);
194 fn test_iterator_nth_back() {
195 let v: &[_] = &[0, 1, 2, 3, 4];
196 for i in 0..v.len() {
197 assert_eq!(v.iter().nth_back(i).unwrap(), &v[v.len() - i - 1]);
199 assert_eq!(v.iter().nth_back(v.len()), None);
201 let mut iter = v.iter();
202 assert_eq!(iter.nth_back(2).unwrap(), &v[2]);
203 assert_eq!(iter.nth_back(1).unwrap(), &v[0]);
207 fn test_iterator_last() {
208 let v: &[_] = &[0, 1, 2, 3, 4];
209 assert_eq!(v.iter().last().unwrap(), &4);
210 assert_eq!(v[..1].iter().last().unwrap(), &0);
214 fn test_iterator_count() {
215 let v: &[_] = &[0, 1, 2, 3, 4];
216 assert_eq!(v.iter().count(), 5);
218 let mut iter2 = v.iter();
221 assert_eq!(iter2.count(), 3);
225 fn test_chunks_count() {
226 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
228 assert_eq!(c.count(), 2);
230 let v2: &[i32] = &[0, 1, 2, 3, 4];
231 let c2 = v2.chunks(2);
232 assert_eq!(c2.count(), 3);
234 let v3: &[i32] = &[];
235 let c3 = v3.chunks(2);
236 assert_eq!(c3.count(), 0);
240 fn test_chunks_nth() {
241 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
242 let mut c = v.chunks(2);
243 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
244 assert_eq!(c.next().unwrap(), &[4, 5]);
246 let v2: &[i32] = &[0, 1, 2, 3, 4];
247 let mut c2 = v2.chunks(3);
248 assert_eq!(c2.nth(1).unwrap(), &[3, 4]);
249 assert_eq!(c2.next(), None);
253 fn test_chunks_nth_back() {
254 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
255 let mut c = v.chunks(2);
256 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
257 assert_eq!(c.next().unwrap(), &[0, 1]);
258 assert_eq!(c.next(), None);
260 let v2: &[i32] = &[0, 1, 2, 3, 4];
261 let mut c2 = v2.chunks(3);
262 assert_eq!(c2.nth_back(1).unwrap(), &[0, 1, 2]);
263 assert_eq!(c2.next(), None);
264 assert_eq!(c2.next_back(), None);
266 let v3: &[i32] = &[0, 1, 2, 3, 4];
267 let mut c3 = v3.chunks(10);
268 assert_eq!(c3.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
269 assert_eq!(c3.next(), None);
271 let v4: &[i32] = &[0, 1, 2];
272 let mut c4 = v4.chunks(10);
273 assert_eq!(c4.nth_back(1_000_000_000usize), None);
277 fn test_chunks_last() {
278 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
280 assert_eq!(c.last().unwrap()[1], 5);
282 let v2: &[i32] = &[0, 1, 2, 3, 4];
283 let c2 = v2.chunks(2);
284 assert_eq!(c2.last().unwrap()[0], 4);
288 fn test_chunks_zip() {
289 let v1: &[i32] = &[0, 1, 2, 3, 4];
290 let v2: &[i32] = &[6, 7, 8, 9, 10];
295 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
296 .collect::<Vec<_>>();
297 assert_eq!(res, vec![14, 22, 14]);
301 fn test_chunks_mut_count() {
302 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
303 let c = v.chunks_mut(3);
304 assert_eq!(c.count(), 2);
306 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
307 let c2 = v2.chunks_mut(2);
308 assert_eq!(c2.count(), 3);
310 let v3: &mut [i32] = &mut [];
311 let c3 = v3.chunks_mut(2);
312 assert_eq!(c3.count(), 0);
316 fn test_chunks_mut_nth() {
317 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
318 let mut c = v.chunks_mut(2);
319 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
320 assert_eq!(c.next().unwrap(), &[4, 5]);
322 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
323 let mut c2 = v2.chunks_mut(3);
324 assert_eq!(c2.nth(1).unwrap(), &[3, 4]);
325 assert_eq!(c2.next(), None);
329 fn test_chunks_mut_nth_back() {
330 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
331 let mut c = v.chunks_mut(2);
332 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
333 assert_eq!(c.next().unwrap(), &[0, 1]);
335 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
336 let mut c1 = v1.chunks_mut(3);
337 assert_eq!(c1.nth_back(1).unwrap(), &[0, 1, 2]);
338 assert_eq!(c1.next(), None);
340 let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
341 let mut c3 = v3.chunks_mut(10);
342 assert_eq!(c3.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
343 assert_eq!(c3.next(), None);
345 let v4: &mut [i32] = &mut [0, 1, 2];
346 let mut c4 = v4.chunks_mut(10);
347 assert_eq!(c4.nth_back(1_000_000_000usize), None);
351 fn test_chunks_mut_last() {
352 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
353 let c = v.chunks_mut(2);
354 assert_eq!(c.last().unwrap(), &[4, 5]);
356 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
357 let c2 = v2.chunks_mut(2);
358 assert_eq!(c2.last().unwrap(), &[4]);
362 fn test_chunks_mut_zip() {
363 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
364 let v2: &[i32] = &[6, 7, 8, 9, 10];
366 for (a, b) in v1.chunks_mut(2).zip(v2.chunks(2)) {
367 let sum = b.iter().sum::<i32>();
372 assert_eq!(v1, [13, 14, 19, 20, 14]);
376 fn test_chunks_exact_count() {
377 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
378 let c = v.chunks_exact(3);
379 assert_eq!(c.count(), 2);
381 let v2: &[i32] = &[0, 1, 2, 3, 4];
382 let c2 = v2.chunks_exact(2);
383 assert_eq!(c2.count(), 2);
385 let v3: &[i32] = &[];
386 let c3 = v3.chunks_exact(2);
387 assert_eq!(c3.count(), 0);
391 fn test_chunks_exact_nth() {
392 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
393 let mut c = v.chunks_exact(2);
394 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
395 assert_eq!(c.next().unwrap(), &[4, 5]);
397 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
398 let mut c2 = v2.chunks_exact(3);
399 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
400 assert_eq!(c2.next(), None);
404 fn test_chunks_exact_nth_back() {
405 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
406 let mut c = v.chunks_exact(2);
407 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
408 assert_eq!(c.next().unwrap(), &[0, 1]);
409 assert_eq!(c.next(), None);
411 let v2: &[i32] = &[0, 1, 2, 3, 4];
412 let mut c2 = v2.chunks_exact(3);
413 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
414 assert_eq!(c2.next(), None);
415 assert_eq!(c2.next_back(), None);
417 let v3: &[i32] = &[0, 1, 2, 3, 4];
418 let mut c3 = v3.chunks_exact(10);
419 assert_eq!(c3.nth_back(0), None);
423 fn test_chunks_exact_last() {
424 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
425 let c = v.chunks_exact(2);
426 assert_eq!(c.last().unwrap(), &[4, 5]);
428 let v2: &[i32] = &[0, 1, 2, 3, 4];
429 let c2 = v2.chunks_exact(2);
430 assert_eq!(c2.last().unwrap(), &[2, 3]);
434 fn test_chunks_exact_remainder() {
435 let v: &[i32] = &[0, 1, 2, 3, 4];
436 let c = v.chunks_exact(2);
437 assert_eq!(c.remainder(), &[4]);
441 fn test_chunks_exact_zip() {
442 let v1: &[i32] = &[0, 1, 2, 3, 4];
443 let v2: &[i32] = &[6, 7, 8, 9, 10];
447 .zip(v2.chunks_exact(2))
448 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
449 .collect::<Vec<_>>();
450 assert_eq!(res, vec![14, 22]);
454 fn test_chunks_exact_mut_count() {
455 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
456 let c = v.chunks_exact_mut(3);
457 assert_eq!(c.count(), 2);
459 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
460 let c2 = v2.chunks_exact_mut(2);
461 assert_eq!(c2.count(), 2);
463 let v3: &mut [i32] = &mut [];
464 let c3 = v3.chunks_exact_mut(2);
465 assert_eq!(c3.count(), 0);
469 fn test_chunks_exact_mut_nth() {
470 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
471 let mut c = v.chunks_exact_mut(2);
472 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
473 assert_eq!(c.next().unwrap(), &[4, 5]);
475 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
476 let mut c2 = v2.chunks_exact_mut(3);
477 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
478 assert_eq!(c2.next(), None);
482 fn test_chunks_exact_mut_nth_back() {
483 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
484 let mut c = v.chunks_exact_mut(2);
485 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
486 assert_eq!(c.next().unwrap(), &[0, 1]);
487 assert_eq!(c.next(), None);
489 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
490 let mut c2 = v2.chunks_exact_mut(3);
491 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
492 assert_eq!(c2.next(), None);
493 assert_eq!(c2.next_back(), None);
495 let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
496 let mut c3 = v3.chunks_exact_mut(10);
497 assert_eq!(c3.nth_back(0), None);
501 fn test_chunks_exact_mut_last() {
502 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
503 let c = v.chunks_exact_mut(2);
504 assert_eq!(c.last().unwrap(), &[4, 5]);
506 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
507 let c2 = v2.chunks_exact_mut(2);
508 assert_eq!(c2.last().unwrap(), &[2, 3]);
512 fn test_chunks_exact_mut_remainder() {
513 let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
514 let c = v.chunks_exact_mut(2);
515 assert_eq!(c.into_remainder(), &[4]);
519 fn test_chunks_exact_mut_zip() {
520 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
521 let v2: &[i32] = &[6, 7, 8, 9, 10];
523 for (a, b) in v1.chunks_exact_mut(2).zip(v2.chunks_exact(2)) {
524 let sum = b.iter().sum::<i32>();
529 assert_eq!(v1, [13, 14, 19, 20, 4]);
533 fn test_array_chunks_infer() {
534 let v: &[i32] = &[0, 1, 2, 3, 4, -4];
535 let c = v.array_chunks();
536 for &[a, b, c] in c {
537 assert_eq!(a + b + c, 3);
540 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
541 let total = v2.array_chunks().map(|&[a, b]| a * b).sum::<i32>();
542 assert_eq!(total, 2 * 3 + 4 * 5);
546 fn test_array_chunks_count() {
547 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
548 let c = v.array_chunks::<3>();
549 assert_eq!(c.count(), 2);
551 let v2: &[i32] = &[0, 1, 2, 3, 4];
552 let c2 = v2.array_chunks::<2>();
553 assert_eq!(c2.count(), 2);
555 let v3: &[i32] = &[];
556 let c3 = v3.array_chunks::<2>();
557 assert_eq!(c3.count(), 0);
561 fn test_array_chunks_nth() {
562 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
563 let mut c = v.array_chunks::<2>();
564 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
565 assert_eq!(c.next().unwrap(), &[4, 5]);
567 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
568 let mut c2 = v2.array_chunks::<3>();
569 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
570 assert_eq!(c2.next(), None);
574 fn test_array_chunks_nth_back() {
575 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
576 let mut c = v.array_chunks::<2>();
577 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
578 assert_eq!(c.next().unwrap(), &[0, 1]);
579 assert_eq!(c.next(), None);
581 let v2: &[i32] = &[0, 1, 2, 3, 4];
582 let mut c2 = v2.array_chunks::<3>();
583 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
584 assert_eq!(c2.next(), None);
585 assert_eq!(c2.next_back(), None);
587 let v3: &[i32] = &[0, 1, 2, 3, 4];
588 let mut c3 = v3.array_chunks::<10>();
589 assert_eq!(c3.nth_back(0), None);
593 fn test_array_chunks_last() {
594 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
595 let c = v.array_chunks::<2>();
596 assert_eq!(c.last().unwrap(), &[4, 5]);
598 let v2: &[i32] = &[0, 1, 2, 3, 4];
599 let c2 = v2.array_chunks::<2>();
600 assert_eq!(c2.last().unwrap(), &[2, 3]);
604 fn test_array_chunks_remainder() {
605 let v: &[i32] = &[0, 1, 2, 3, 4];
606 let c = v.array_chunks::<2>();
607 assert_eq!(c.remainder(), &[4]);
611 fn test_array_chunks_zip() {
612 let v1: &[i32] = &[0, 1, 2, 3, 4];
613 let v2: &[i32] = &[6, 7, 8, 9, 10];
617 .zip(v2.array_chunks::<2>())
618 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
619 .collect::<Vec<_>>();
620 assert_eq!(res, vec![14, 22]);
624 fn test_array_chunks_mut_infer() {
625 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
626 for a in v.array_chunks_mut() {
627 let sum = a.iter().sum::<i32>();
630 assert_eq!(v, &[3, 3, 3, 12, 12, 12, 6]);
632 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
633 v2.array_chunks_mut().for_each(|[a, b]| core::mem::swap(a, b));
634 assert_eq!(v2, &[1, 0, 3, 2, 5, 4, 6]);
638 fn test_array_chunks_mut_count() {
639 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
640 let c = v.array_chunks_mut::<3>();
641 assert_eq!(c.count(), 2);
643 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
644 let c2 = v2.array_chunks_mut::<2>();
645 assert_eq!(c2.count(), 2);
647 let v3: &mut [i32] = &mut [];
648 let c3 = v3.array_chunks_mut::<2>();
649 assert_eq!(c3.count(), 0);
653 fn test_array_chunks_mut_nth() {
654 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
655 let mut c = v.array_chunks_mut::<2>();
656 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
657 assert_eq!(c.next().unwrap(), &[4, 5]);
659 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
660 let mut c2 = v2.array_chunks_mut::<3>();
661 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
662 assert_eq!(c2.next(), None);
666 fn test_array_chunks_mut_nth_back() {
667 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
668 let mut c = v.array_chunks_mut::<2>();
669 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
670 assert_eq!(c.next().unwrap(), &[0, 1]);
671 assert_eq!(c.next(), None);
673 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
674 let mut c2 = v2.array_chunks_mut::<3>();
675 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
676 assert_eq!(c2.next(), None);
677 assert_eq!(c2.next_back(), None);
679 let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
680 let mut c3 = v3.array_chunks_mut::<10>();
681 assert_eq!(c3.nth_back(0), None);
685 fn test_array_chunks_mut_last() {
686 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
687 let c = v.array_chunks_mut::<2>();
688 assert_eq!(c.last().unwrap(), &[4, 5]);
690 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
691 let c2 = v2.array_chunks_mut::<2>();
692 assert_eq!(c2.last().unwrap(), &[2, 3]);
696 fn test_array_chunks_mut_remainder() {
697 let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
698 let c = v.array_chunks_mut::<2>();
699 assert_eq!(c.into_remainder(), &[4]);
703 fn test_array_chunks_mut_zip() {
704 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
705 let v2: &[i32] = &[6, 7, 8, 9, 10];
707 for (a, b) in v1.array_chunks_mut::<2>().zip(v2.array_chunks::<2>()) {
708 let sum = b.iter().sum::<i32>();
713 assert_eq!(v1, [13, 14, 19, 20, 4]);
717 fn test_array_windows_infer() {
718 let v: &[i32] = &[0, 1, 0, 1];
719 assert_eq!(v.array_windows::<2>().count(), 3);
720 let c = v.array_windows();
722 assert_eq!(a + b, 1);
725 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
726 let total = v2.array_windows().map(|&[a, b, c]| a + b + c).sum::<i32>();
727 assert_eq!(total, 3 + 6 + 9 + 12 + 15);
731 fn test_array_windows_count() {
732 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
733 let c = v.array_windows::<3>();
734 assert_eq!(c.count(), 4);
736 let v2: &[i32] = &[0, 1, 2, 3, 4];
737 let c2 = v2.array_windows::<6>();
738 assert_eq!(c2.count(), 0);
740 let v3: &[i32] = &[];
741 let c3 = v3.array_windows::<2>();
742 assert_eq!(c3.count(), 0);
744 let v4: &[()] = &[(); usize::MAX];
745 let c4 = v4.array_windows::<1>();
746 assert_eq!(c4.count(), usize::MAX);
750 fn test_array_windows_nth() {
751 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
752 let snd = v.array_windows::<4>().nth(1);
753 assert_eq!(snd, Some(&[1, 2, 3, 4]));
754 let mut arr_windows = v.array_windows::<2>();
755 assert_ne!(arr_windows.nth(0), arr_windows.nth(0));
756 let last = v.array_windows::<3>().last();
757 assert_eq!(last, Some(&[3, 4, 5]));
761 fn test_array_windows_nth_back() {
762 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
763 let snd = v.array_windows::<4>().nth_back(1);
764 assert_eq!(snd, Some(&[1, 2, 3, 4]));
765 let mut arr_windows = v.array_windows::<2>();
766 assert_ne!(arr_windows.nth_back(0), arr_windows.nth_back(0));
770 fn test_rchunks_count() {
771 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
772 let c = v.rchunks(3);
773 assert_eq!(c.count(), 2);
775 let v2: &[i32] = &[0, 1, 2, 3, 4];
776 let c2 = v2.rchunks(2);
777 assert_eq!(c2.count(), 3);
779 let v3: &[i32] = &[];
780 let c3 = v3.rchunks(2);
781 assert_eq!(c3.count(), 0);
785 fn test_rchunks_nth() {
786 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
787 let mut c = v.rchunks(2);
788 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
789 assert_eq!(c.next().unwrap(), &[0, 1]);
791 let v2: &[i32] = &[0, 1, 2, 3, 4];
792 let mut c2 = v2.rchunks(3);
793 assert_eq!(c2.nth(1).unwrap(), &[0, 1]);
794 assert_eq!(c2.next(), None);
798 fn test_rchunks_nth_back() {
799 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
800 let mut c = v.rchunks(2);
801 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
802 assert_eq!(c.next_back().unwrap(), &[4, 5]);
804 let v2: &[i32] = &[0, 1, 2, 3, 4];
805 let mut c2 = v2.rchunks(3);
806 assert_eq!(c2.nth_back(1).unwrap(), &[2, 3, 4]);
807 assert_eq!(c2.next_back(), None);
811 fn test_rchunks_last() {
812 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
813 let c = v.rchunks(2);
814 assert_eq!(c.last().unwrap()[1], 1);
816 let v2: &[i32] = &[0, 1, 2, 3, 4];
817 let c2 = v2.rchunks(2);
818 assert_eq!(c2.last().unwrap()[0], 0);
822 fn test_rchunks_zip() {
823 let v1: &[i32] = &[0, 1, 2, 3, 4];
824 let v2: &[i32] = &[6, 7, 8, 9, 10];
829 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
830 .collect::<Vec<_>>();
831 assert_eq!(res, vec![26, 18, 6]);
835 fn test_rchunks_mut_count() {
836 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
837 let c = v.rchunks_mut(3);
838 assert_eq!(c.count(), 2);
840 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
841 let c2 = v2.rchunks_mut(2);
842 assert_eq!(c2.count(), 3);
844 let v3: &mut [i32] = &mut [];
845 let c3 = v3.rchunks_mut(2);
846 assert_eq!(c3.count(), 0);
850 fn test_rchunks_mut_nth() {
851 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
852 let mut c = v.rchunks_mut(2);
853 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
854 assert_eq!(c.next().unwrap(), &[0, 1]);
856 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
857 let mut c2 = v2.rchunks_mut(3);
858 assert_eq!(c2.nth(1).unwrap(), &[0, 1]);
859 assert_eq!(c2.next(), None);
863 fn test_rchunks_mut_nth_back() {
864 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
865 let mut c = v.rchunks_mut(2);
866 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
867 assert_eq!(c.next_back().unwrap(), &[4, 5]);
869 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
870 let mut c2 = v2.rchunks_mut(3);
871 assert_eq!(c2.nth_back(1).unwrap(), &[2, 3, 4]);
872 assert_eq!(c2.next_back(), None);
876 fn test_rchunks_mut_last() {
877 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
878 let c = v.rchunks_mut(2);
879 assert_eq!(c.last().unwrap(), &[0, 1]);
881 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
882 let c2 = v2.rchunks_mut(2);
883 assert_eq!(c2.last().unwrap(), &[0]);
887 fn test_rchunks_mut_zip() {
888 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
889 let v2: &[i32] = &[6, 7, 8, 9, 10];
891 for (a, b) in v1.rchunks_mut(2).zip(v2.rchunks(2)) {
892 let sum = b.iter().sum::<i32>();
897 assert_eq!(v1, [6, 16, 17, 22, 23]);
901 fn test_rchunks_exact_count() {
902 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
903 let c = v.rchunks_exact(3);
904 assert_eq!(c.count(), 2);
906 let v2: &[i32] = &[0, 1, 2, 3, 4];
907 let c2 = v2.rchunks_exact(2);
908 assert_eq!(c2.count(), 2);
910 let v3: &[i32] = &[];
911 let c3 = v3.rchunks_exact(2);
912 assert_eq!(c3.count(), 0);
916 fn test_rchunks_exact_nth() {
917 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
918 let mut c = v.rchunks_exact(2);
919 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
920 assert_eq!(c.next().unwrap(), &[0, 1]);
922 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
923 let mut c2 = v2.rchunks_exact(3);
924 assert_eq!(c2.nth(1).unwrap(), &[1, 2, 3]);
925 assert_eq!(c2.next(), None);
929 fn test_rchunks_exact_nth_back() {
930 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
931 let mut c = v.rchunks_exact(2);
932 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
933 assert_eq!(c.next_back().unwrap(), &[4, 5]);
935 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
936 let mut c2 = v2.rchunks_exact(3);
937 assert_eq!(c2.nth_back(1).unwrap(), &[4, 5, 6]);
938 assert_eq!(c2.next(), None);
942 fn test_rchunks_exact_last() {
943 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
944 let c = v.rchunks_exact(2);
945 assert_eq!(c.last().unwrap(), &[0, 1]);
947 let v2: &[i32] = &[0, 1, 2, 3, 4];
948 let c2 = v2.rchunks_exact(2);
949 assert_eq!(c2.last().unwrap(), &[1, 2]);
953 fn test_rchunks_exact_remainder() {
954 let v: &[i32] = &[0, 1, 2, 3, 4];
955 let c = v.rchunks_exact(2);
956 assert_eq!(c.remainder(), &[0]);
960 fn test_rchunks_exact_zip() {
961 let v1: &[i32] = &[0, 1, 2, 3, 4];
962 let v2: &[i32] = &[6, 7, 8, 9, 10];
966 .zip(v2.rchunks_exact(2))
967 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
968 .collect::<Vec<_>>();
969 assert_eq!(res, vec![26, 18]);
973 fn test_rchunks_exact_mut_count() {
974 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
975 let c = v.rchunks_exact_mut(3);
976 assert_eq!(c.count(), 2);
978 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
979 let c2 = v2.rchunks_exact_mut(2);
980 assert_eq!(c2.count(), 2);
982 let v3: &mut [i32] = &mut [];
983 let c3 = v3.rchunks_exact_mut(2);
984 assert_eq!(c3.count(), 0);
988 fn test_rchunks_exact_mut_nth() {
989 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
990 let mut c = v.rchunks_exact_mut(2);
991 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
992 assert_eq!(c.next().unwrap(), &[0, 1]);
994 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
995 let mut c2 = v2.rchunks_exact_mut(3);
996 assert_eq!(c2.nth(1).unwrap(), &[1, 2, 3]);
997 assert_eq!(c2.next(), None);
1001 fn test_rchunks_exact_mut_nth_back() {
1002 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1003 let mut c = v.rchunks_exact_mut(2);
1004 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
1005 assert_eq!(c.next_back().unwrap(), &[4, 5]);
1007 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
1008 let mut c2 = v2.rchunks_exact_mut(3);
1009 assert_eq!(c2.nth_back(1).unwrap(), &[4, 5, 6]);
1010 assert_eq!(c2.next(), None);
1014 fn test_rchunks_exact_mut_last() {
1015 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1016 let c = v.rchunks_exact_mut(2);
1017 assert_eq!(c.last().unwrap(), &[0, 1]);
1019 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
1020 let c2 = v2.rchunks_exact_mut(2);
1021 assert_eq!(c2.last().unwrap(), &[1, 2]);
1025 fn test_rchunks_exact_mut_remainder() {
1026 let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
1027 let c = v.rchunks_exact_mut(2);
1028 assert_eq!(c.into_remainder(), &[0]);
1032 fn test_rchunks_exact_mut_zip() {
1033 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
1034 let v2: &[i32] = &[6, 7, 8, 9, 10];
1036 for (a, b) in v1.rchunks_exact_mut(2).zip(v2.rchunks_exact(2)) {
1037 let sum = b.iter().sum::<i32>();
1042 assert_eq!(v1, [0, 16, 17, 22, 23]);
1046 fn test_windows_count() {
1047 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1048 let c = v.windows(3);
1049 assert_eq!(c.count(), 4);
1051 let v2: &[i32] = &[0, 1, 2, 3, 4];
1052 let c2 = v2.windows(6);
1053 assert_eq!(c2.count(), 0);
1055 let v3: &[i32] = &[];
1056 let c3 = v3.windows(2);
1057 assert_eq!(c3.count(), 0);
1059 let v4 = &[(); usize::MAX];
1060 let c4 = v4.windows(1);
1061 assert_eq!(c4.count(), usize::MAX);
1065 fn test_windows_nth() {
1066 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1067 let mut c = v.windows(2);
1068 assert_eq!(c.nth(2).unwrap()[1], 3);
1069 assert_eq!(c.next().unwrap()[0], 3);
1071 let v2: &[i32] = &[0, 1, 2, 3, 4];
1072 let mut c2 = v2.windows(4);
1073 assert_eq!(c2.nth(1).unwrap()[1], 2);
1074 assert_eq!(c2.next(), None);
1078 fn test_windows_nth_back() {
1079 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1080 let mut c = v.windows(2);
1081 assert_eq!(c.nth_back(2).unwrap()[0], 2);
1082 assert_eq!(c.next_back().unwrap()[1], 2);
1084 let v2: &[i32] = &[0, 1, 2, 3, 4];
1085 let mut c2 = v2.windows(4);
1086 assert_eq!(c2.nth_back(1).unwrap()[1], 1);
1087 assert_eq!(c2.next_back(), None);
1091 fn test_windows_last() {
1092 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1093 let c = v.windows(2);
1094 assert_eq!(c.last().unwrap()[1], 5);
1096 let v2: &[i32] = &[0, 1, 2, 3, 4];
1097 let c2 = v2.windows(2);
1098 assert_eq!(c2.last().unwrap()[0], 3);
1102 fn test_windows_zip() {
1103 let v1: &[i32] = &[0, 1, 2, 3, 4];
1104 let v2: &[i32] = &[6, 7, 8, 9, 10];
1109 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
1110 .collect::<Vec<_>>();
1112 assert_eq!(res, [14, 18, 22, 26]);
1117 fn test_iter_ref_consistency() {
1118 use std::fmt::Debug;
1120 fn test<T: Copy + Debug + PartialEq>(x: T) {
1121 let v: &[T] = &[x, x, x];
1122 let v_ptrs: [*const T; 3] = match v {
1123 [ref v1, ref v2, ref v3] => [v1 as *const _, v2 as *const _, v3 as *const _],
1124 _ => unreachable!(),
1130 assert_eq!(&v[i] as *const _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1131 let nth = v.iter().nth(i).unwrap();
1132 assert_eq!(nth as *const _, v_ptrs[i]);
1134 assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1136 // stepping through with nth(0)
1138 let mut it = v.iter();
1140 let next = it.nth(0).unwrap();
1141 assert_eq!(next as *const _, v_ptrs[i]);
1143 assert_eq!(it.nth(0), None);
1148 let mut it = v.iter();
1150 let remaining = len - i;
1151 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1153 let next = it.next().unwrap();
1154 assert_eq!(next as *const _, v_ptrs[i]);
1156 assert_eq!(it.size_hint(), (0, Some(0)));
1157 assert_eq!(it.next(), None, "The final call to next() should return None");
1162 let mut it = v.iter();
1164 let remaining = len - i;
1165 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1167 let prev = it.next_back().unwrap();
1168 assert_eq!(prev as *const _, v_ptrs[remaining - 1]);
1170 assert_eq!(it.size_hint(), (0, Some(0)));
1171 assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1175 fn test_mut<T: Copy + Debug + PartialEq>(x: T) {
1176 let v: &mut [T] = &mut [x, x, x];
1177 let v_ptrs: [*mut T; 3] = match v {
1178 [ref v1, ref v2, ref v3] => {
1179 [v1 as *const _ as *mut _, v2 as *const _ as *mut _, v3 as *const _ as *mut _]
1181 _ => unreachable!(),
1187 assert_eq!(&mut v[i] as *mut _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1188 let nth = v.iter_mut().nth(i).unwrap();
1189 assert_eq!(nth as *mut _, v_ptrs[i]);
1191 assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1193 // stepping through with nth(0)
1195 let mut it = v.iter();
1197 let next = it.nth(0).unwrap();
1198 assert_eq!(next as *const _, v_ptrs[i]);
1200 assert_eq!(it.nth(0), None);
1205 let mut it = v.iter_mut();
1207 let remaining = len - i;
1208 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1210 let next = it.next().unwrap();
1211 assert_eq!(next as *mut _, v_ptrs[i]);
1213 assert_eq!(it.size_hint(), (0, Some(0)));
1214 assert_eq!(it.next(), None, "The final call to next() should return None");
1219 let mut it = v.iter_mut();
1221 let remaining = len - i;
1222 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1224 let prev = it.next_back().unwrap();
1225 assert_eq!(prev as *mut _, v_ptrs[remaining - 1]);
1227 assert_eq!(it.size_hint(), (0, Some(0)));
1228 assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1232 // Make sure iterators and slice patterns yield consistent addresses for various types,
1236 test([0u32; 0]); // ZST with alignment > 0
1239 test_mut([0u32; 0]); // ZST with alignment > 0
1242 // The current implementation of SliceIndex fails to handle methods
1243 // orthogonally from range types; therefore, it is worth testing
1244 // all of the indexing operations on each input.
1246 // This checks all six indexing methods, given an input range that
1247 // should succeed. (it is NOT suitable for testing invalid inputs)
1248 macro_rules! assert_range_eq {
1249 ($arr:expr, $range:expr, $expected:expr) => {
1251 let mut expected = $expected;
1254 let expected: &[_] = &expected;
1256 assert_eq!(&s[$range], expected, "(in assertion for: index)");
1257 assert_eq!(s.get($range), Some(expected), "(in assertion for: get)");
1260 s.get_unchecked($range),
1262 "(in assertion for: get_unchecked)",
1267 let s: &mut [_] = &mut arr;
1268 let expected: &mut [_] = &mut expected;
1270 assert_eq!(&mut s[$range], expected, "(in assertion for: index_mut)",);
1273 Some(&mut expected[..]),
1274 "(in assertion for: get_mut)",
1278 s.get_unchecked_mut($range),
1280 "(in assertion for: get_unchecked_mut)",
1287 // Make sure the macro can actually detect bugs,
1288 // because if it can't, then what are we even doing here?
1290 // (Be aware this only demonstrates the ability to detect bugs
1291 // in the FIRST method that panics, as the macro is not designed
1292 // to be used in `should_panic`)
1294 #[should_panic(expected = "out of range")]
1295 fn assert_range_eq_can_fail_by_panic() {
1296 assert_range_eq!([0, 1, 2], 0..5, [0, 1, 2]);
1299 // (Be aware this only demonstrates the ability to detect bugs
1300 // in the FIRST method it calls, as the macro is not designed
1301 // to be used in `should_panic`)
1303 #[should_panic(expected = "==")]
1304 fn assert_range_eq_can_fail_by_inequality() {
1305 assert_range_eq!([0, 1, 2], 0..2, [0, 1, 2]);
1308 // Test cases for bad index operations.
1310 // This generates `should_panic` test cases for Index/IndexMut
1311 // and `None` test cases for get/get_mut.
1312 macro_rules! panic_cases {
1314 // each test case needs a unique name to namespace the tests
1315 in mod $case_name:ident {
1320 // one or more similar inputs for which data[input] succeeds,
1321 // and the corresponding output as an array. This helps validate
1322 // "critical points" where an input range straddles the boundary
1323 // between valid and invalid.
1324 // (such as the input `len..len`, which is just barely valid)
1326 good: data[$good:expr] == $output:expr;
1329 bad: data[$bad:expr];
1330 message: $expect_msg:expr;
1334 #[allow(unused_imports)]
1335 use core::ops::Bound;
1341 $( assert_range_eq!($data, $good, $output); )*
1345 assert_eq!(v.get($bad), None, "(in None assertion for get)");
1349 let v: &mut [_] = &mut v;
1350 assert_eq!(v.get_mut($bad), None, "(in None assertion for get_mut)");
1355 #[should_panic(expected = $expect_msg)]
1363 #[should_panic(expected = $expect_msg)]
1364 fn index_mut_fail() {
1366 let v: &mut [_] = &mut v;
1367 let _v = &mut v[$bad];
1375 let v = [0, 1, 2, 3, 4, 5];
1377 assert_range_eq!(v, .., [0, 1, 2, 3, 4, 5]);
1378 assert_range_eq!(v, ..2, [0, 1]);
1379 assert_range_eq!(v, ..=1, [0, 1]);
1380 assert_range_eq!(v, 2.., [2, 3, 4, 5]);
1381 assert_range_eq!(v, 1..4, [1, 2, 3]);
1382 assert_range_eq!(v, 1..=3, [1, 2, 3]);
1386 in mod rangefrom_len {
1387 data: [0, 1, 2, 3, 4, 5];
1389 good: data[6..] == [];
1391 message: "out of range";
1394 in mod rangeto_len {
1395 data: [0, 1, 2, 3, 4, 5];
1397 good: data[..6] == [0, 1, 2, 3, 4, 5];
1399 message: "out of range";
1402 in mod rangetoinclusive_len {
1403 data: [0, 1, 2, 3, 4, 5];
1405 good: data[..=5] == [0, 1, 2, 3, 4, 5];
1407 message: "out of range";
1410 in mod rangeinclusive_len {
1411 data: [0, 1, 2, 3, 4, 5];
1413 good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1415 message: "out of range";
1418 in mod range_len_len {
1419 data: [0, 1, 2, 3, 4, 5];
1421 good: data[6..6] == [];
1423 message: "out of range";
1426 in mod rangeinclusive_len_len {
1427 data: [0, 1, 2, 3, 4, 5];
1429 good: data[6..=5] == [];
1431 message: "out of range";
1434 in mod boundpair_len {
1435 data: [0, 1, 2, 3, 4, 5];
1437 good: data[(Bound::Included(6), Bound::Unbounded)] == [];
1438 good: data[(Bound::Unbounded, Bound::Included(5))] == [0, 1, 2, 3, 4, 5];
1439 good: data[(Bound::Unbounded, Bound::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1440 good: data[(Bound::Included(0), Bound::Included(5))] == [0, 1, 2, 3, 4, 5];
1441 good: data[(Bound::Included(0), Bound::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1442 good: data[(Bound::Included(2), Bound::Excluded(4))] == [2, 3];
1443 good: data[(Bound::Excluded(1), Bound::Included(4))] == [2, 3, 4];
1444 good: data[(Bound::Excluded(5), Bound::Excluded(6))] == [];
1445 good: data[(Bound::Included(6), Bound::Excluded(6))] == [];
1446 good: data[(Bound::Excluded(5), Bound::Included(5))] == [];
1447 good: data[(Bound::Included(6), Bound::Included(5))] == [];
1448 bad: data[(Bound::Unbounded, Bound::Included(6))];
1449 message: "out of range";
1454 in mod rangeinclusive_exhausted {
1455 data: [0, 1, 2, 3, 4, 5];
1457 good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1459 let mut iter = 0..=5;
1460 iter.by_ref().count(); // exhaust it
1464 // 0..=6 is out of range before exhaustion, so it
1465 // stands to reason that it still would be after.
1467 let mut iter = 0..=6;
1468 iter.by_ref().count(); // exhaust it
1471 message: "out of range";
1476 in mod range_neg_width {
1477 data: [0, 1, 2, 3, 4, 5];
1479 good: data[4..4] == [];
1481 message: "but ends at";
1484 in mod rangeinclusive_neg_width {
1485 data: [0, 1, 2, 3, 4, 5];
1487 good: data[4..=3] == [];
1489 message: "but ends at";
1492 in mod boundpair_neg_width {
1493 data: [0, 1, 2, 3, 4, 5];
1495 good: data[(Bound::Included(4), Bound::Excluded(4))] == [];
1496 bad: data[(Bound::Included(4), Bound::Excluded(3))];
1497 message: "but ends at";
1502 in mod rangeinclusive_overflow {
1505 // note: using 0 specifically ensures that the result of overflowing is 0..0,
1506 // so that `get` doesn't simply return None for the wrong reason.
1507 bad: data[0 ..= usize::MAX];
1508 message: "maximum usize";
1511 in mod rangetoinclusive_overflow {
1514 bad: data[..= usize::MAX];
1515 message: "maximum usize";
1518 in mod boundpair_overflow_end {
1521 bad: data[(Bound::Unbounded, Bound::Included(usize::MAX))];
1522 message: "maximum usize";
1525 in mod boundpair_overflow_start {
1528 bad: data[(Bound::Excluded(usize::MAX), Bound::Unbounded)];
1529 message: "maximum usize";
1535 fn test_find_rfind() {
1536 let v = [0, 1, 2, 3, 4, 5];
1537 let mut iter = v.iter();
1538 let mut i = v.len();
1539 while let Some(&elt) = iter.rfind(|_| true) {
1541 assert_eq!(elt, v[i]);
1544 assert_eq!(v.iter().rfind(|&&x| x <= 3), Some(&3));
1548 fn test_iter_folds() {
1549 let a = [1, 2, 3, 4, 5]; // len>4 so the unroll is used
1550 assert_eq!(a.iter().fold(0, |acc, &x| 2 * acc + x), 57);
1551 assert_eq!(a.iter().rfold(0, |acc, &x| 2 * acc + x), 129);
1552 let fold = |acc: i32, &x| acc.checked_mul(2)?.checked_add(x);
1553 assert_eq!(a.iter().try_fold(0, &fold), Some(57));
1554 assert_eq!(a.iter().try_rfold(0, &fold), Some(129));
1556 // short-circuiting try_fold, through other methods
1557 let a = [0, 1, 2, 3, 5, 5, 5, 7, 8, 9];
1558 let mut iter = a.iter();
1559 assert_eq!(iter.position(|&x| x == 3), Some(3));
1560 assert_eq!(iter.rfind(|&&x| x == 5), Some(&5));
1561 assert_eq!(iter.len(), 2);
1565 fn test_rotate_left() {
1566 const N: usize = 600;
1567 let a: &mut [_] = &mut [0; N];
1576 assert_eq!(a[(i + k) % N], i);
1581 fn test_rotate_right() {
1582 const N: usize = 600;
1583 let a: &mut [_] = &mut [0; N];
1591 assert_eq!(a[(i + 42) % N], i);
1596 #[cfg_attr(miri, ignore)] // Miri is too slow
1597 fn brute_force_rotate_test_0() {
1598 // In case of edge cases involving multiple algorithms
1602 let mut v = Vec::with_capacity(len);
1606 v[..].rotate_right(s);
1607 for i in 0..v.len() {
1608 assert_eq!(v[i], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1615 fn brute_force_rotate_test_1() {
1616 // `ptr_rotate` covers so many kinds of pointer usage, that this is just a good test for
1617 // pointers in general. This uses a `[usize; 4]` to hit all algorithms without overwhelming miri
1621 let mut v: Vec<[usize; 4]> = Vec::with_capacity(len);
1623 v.push([i, 0, 0, 0]);
1625 v[..].rotate_right(s);
1626 for i in 0..v.len() {
1627 assert_eq!(v[i][0], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1634 #[cfg(not(target_arch = "wasm32"))]
1635 fn sort_unstable() {
1636 use core::cmp::Ordering::{Equal, Greater, Less};
1637 use core::slice::heapsort;
1638 use rand::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng};
1640 // Miri is too slow (but still need to `chain` to make the types match)
1641 let lens = if cfg!(miri) { (2..20).chain(0..0) } else { (2..25).chain(500..510) };
1642 let rounds = if cfg!(miri) { 1 } else { 100 };
1644 let mut v = [0; 600];
1645 let mut tmp = [0; 600];
1646 let mut rng = StdRng::from_entropy();
1649 let v = &mut v[0..len];
1650 let tmp = &mut tmp[0..len];
1652 for &modulus in &[5, 10, 100, 1000] {
1653 for _ in 0..rounds {
1655 v[i] = rng.gen::<i32>() % modulus;
1658 // Sort in default order.
1659 tmp.copy_from_slice(v);
1660 tmp.sort_unstable();
1661 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1663 // Sort in ascending order.
1664 tmp.copy_from_slice(v);
1665 tmp.sort_unstable_by(|a, b| a.cmp(b));
1666 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1668 // Sort in descending order.
1669 tmp.copy_from_slice(v);
1670 tmp.sort_unstable_by(|a, b| b.cmp(a));
1671 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1673 // Test heapsort using `<` operator.
1674 tmp.copy_from_slice(v);
1675 heapsort(tmp, |a, b| a < b);
1676 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1678 // Test heapsort using `>` operator.
1679 tmp.copy_from_slice(v);
1680 heapsort(tmp, |a, b| a > b);
1681 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1686 // Sort using a completely random comparison function.
1687 // This will reorder the elements *somehow*, but won't panic.
1688 for i in 0..v.len() {
1691 v.sort_unstable_by(|_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1693 for i in 0..v.len() {
1694 assert_eq!(v[i], i as i32);
1697 // Should not panic.
1698 [0i32; 0].sort_unstable();
1699 [(); 10].sort_unstable();
1700 [(); 100].sort_unstable();
1702 let mut v = [0xDEADBEEFu64];
1704 assert!(v == [0xDEADBEEF]);
1708 #[cfg(not(target_arch = "wasm32"))]
1709 #[cfg_attr(miri, ignore)] // Miri is too slow
1710 fn select_nth_unstable() {
1711 use core::cmp::Ordering::{Equal, Greater, Less};
1712 use rand::rngs::StdRng;
1713 use rand::seq::SliceRandom;
1714 use rand::{Rng, SeedableRng};
1716 let mut rng = StdRng::from_entropy();
1718 for len in (2..21).chain(500..501) {
1719 let mut orig = vec![0; len];
1721 for &modulus in &[5, 10, 1000] {
1724 orig[i] = rng.gen::<i32>() % modulus;
1728 let mut v = orig.clone();
1733 // Sort in default order.
1734 for pivot in 0..len {
1735 let mut v = orig.clone();
1736 v.select_nth_unstable(pivot);
1738 assert_eq!(v_sorted[pivot], v[pivot]);
1740 for j in pivot..len {
1741 assert!(v[i] <= v[j]);
1746 // Sort in ascending order.
1747 for pivot in 0..len {
1748 let mut v = orig.clone();
1749 let (left, pivot, right) = v.select_nth_unstable_by(pivot, |a, b| a.cmp(b));
1751 assert_eq!(left.len() + right.len(), len - 1);
1754 assert!(l <= pivot);
1755 for r in right.iter_mut() {
1757 assert!(pivot <= r);
1762 // Sort in descending order.
1763 let sort_descending_comparator = |a: &i32, b: &i32| b.cmp(a);
1764 let v_sorted_descending = {
1765 let mut v = orig.clone();
1766 v.sort_by(sort_descending_comparator);
1770 for pivot in 0..len {
1771 let mut v = orig.clone();
1772 v.select_nth_unstable_by(pivot, sort_descending_comparator);
1774 assert_eq!(v_sorted_descending[pivot], v[pivot]);
1776 for j in pivot..len {
1777 assert!(v[j] <= v[i]);
1785 // Sort at index using a completely random comparison function.
1786 // This will reorder the elements *somehow*, but won't panic.
1787 let mut v = [0; 500];
1788 for i in 0..v.len() {
1792 for pivot in 0..v.len() {
1793 v.select_nth_unstable_by(pivot, |_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1795 for i in 0..v.len() {
1796 assert_eq!(v[i], i as i32);
1800 // Should not panic.
1801 [(); 10].select_nth_unstable(0);
1802 [(); 10].select_nth_unstable(5);
1803 [(); 10].select_nth_unstable(9);
1804 [(); 100].select_nth_unstable(0);
1805 [(); 100].select_nth_unstable(50);
1806 [(); 100].select_nth_unstable(99);
1808 let mut v = [0xDEADBEEFu64];
1809 v.select_nth_unstable(0);
1810 assert!(v == [0xDEADBEEF]);
1814 #[should_panic(expected = "index 0 greater than length of slice")]
1815 fn select_nth_unstable_zero_length() {
1816 [0i32; 0].select_nth_unstable(0);
1820 #[should_panic(expected = "index 20 greater than length of slice")]
1821 fn select_nth_unstable_past_length() {
1822 [0i32; 10].select_nth_unstable(20);
1826 use core::slice::memchr::{memchr, memrchr};
1828 // test fallback implementations on all platforms
1831 assert_eq!(Some(0), memchr(b'a', b"a"));
1835 fn matches_begin() {
1836 assert_eq!(Some(0), memchr(b'a', b"aaaa"));
1841 assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
1846 assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
1850 fn matches_past_nul() {
1851 assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
1855 fn no_match_empty() {
1856 assert_eq!(None, memchr(b'a', b""));
1861 assert_eq!(None, memchr(b'a', b"xyz"));
1865 fn matches_one_reversed() {
1866 assert_eq!(Some(0), memrchr(b'a', b"a"));
1870 fn matches_begin_reversed() {
1871 assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
1875 fn matches_end_reversed() {
1876 assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
1880 fn matches_nul_reversed() {
1881 assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
1885 fn matches_past_nul_reversed() {
1886 assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
1890 fn no_match_empty_reversed() {
1891 assert_eq!(None, memrchr(b'a', b""));
1895 fn no_match_reversed() {
1896 assert_eq!(None, memrchr(b'a', b"xyz"));
1900 fn each_alignment_reversed() {
1901 let mut data = [1u8; 64];
1905 for start in 0..16 {
1906 assert_eq!(Some(pos - start), memrchr(needle, &data[start..]));
1912 fn test_align_to_simple() {
1913 let bytes = [1u8, 2, 3, 4, 5, 6, 7];
1914 let (prefix, aligned, suffix) = unsafe { bytes.align_to::<u16>() };
1915 assert_eq!(aligned.len(), 3);
1916 assert!(prefix == [1] || suffix == [7]);
1917 let expect1 = [1 << 8 | 2, 3 << 8 | 4, 5 << 8 | 6];
1918 let expect2 = [1 | 2 << 8, 3 | 4 << 8, 5 | 6 << 8];
1919 let expect3 = [2 << 8 | 3, 4 << 8 | 5, 6 << 8 | 7];
1920 let expect4 = [2 | 3 << 8, 4 | 5 << 8, 6 | 7 << 8];
1922 aligned == expect1 || aligned == expect2 || aligned == expect3 || aligned == expect4,
1923 "aligned={:?} expected={:?} || {:?} || {:?} || {:?}",
1933 fn test_align_to_zst() {
1934 let bytes = [1, 2, 3, 4, 5, 6, 7];
1935 let (prefix, aligned, suffix) = unsafe { bytes.align_to::<()>() };
1936 assert_eq!(aligned.len(), 0);
1937 assert!(prefix == [1, 2, 3, 4, 5, 6, 7] || suffix == [1, 2, 3, 4, 5, 6, 7]);
1941 fn test_align_to_non_trivial() {
1943 struct U64(u64, u64);
1945 struct U64U64U32(u64, u64, u32);
1956 let (prefix, aligned, suffix) = unsafe { data.align_to::<U64U64U32>() };
1957 assert_eq!(aligned.len(), 4);
1958 assert_eq!(prefix.len() + suffix.len(), 2);
1962 fn test_align_to_empty_mid() {
1965 // Make sure that we do not create empty unaligned slices for the mid part, even when the
1966 // overall slice is too short to contain an aligned address.
1967 let bytes = [1, 2, 3, 4, 5, 6, 7];
1969 for offset in 0..4 {
1970 let (_, mid, _) = unsafe { bytes[offset..offset + 1].align_to::<Chunk>() };
1971 assert_eq!(mid.as_ptr() as usize % mem::align_of::<Chunk>(), 0);
1976 fn test_align_to_mut_aliasing() {
1977 let mut val = [1u8, 2, 3, 4, 5];
1978 // `align_to_mut` used to create `mid` in a way that there was some intermediate
1979 // incorrect aliasing, invalidating the resulting `mid` slice.
1980 let (begin, mid, end) = unsafe { val.align_to_mut::<[u8; 2]>() };
1981 assert!(begin.len() == 0);
1982 assert!(end.len() == 1);
1984 assert_eq!(val, [3, 4, 3, 4, 5])
1988 fn test_slice_partition_dedup_by() {
1989 let mut slice: [i32; 9] = [1, -1, 2, 3, 1, -5, 5, -2, 2];
1991 let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.abs() == b.abs());
1993 assert_eq!(dedup, [1, 2, 3, 1, -5, -2]);
1994 assert_eq!(duplicates, [5, -1, 2]);
1998 fn test_slice_partition_dedup_empty() {
1999 let mut slice: [i32; 0] = [];
2001 let (dedup, duplicates) = slice.partition_dedup();
2003 assert_eq!(dedup, []);
2004 assert_eq!(duplicates, []);
2008 fn test_slice_partition_dedup_one() {
2009 let mut slice = [12];
2011 let (dedup, duplicates) = slice.partition_dedup();
2013 assert_eq!(dedup, [12]);
2014 assert_eq!(duplicates, []);
2018 fn test_slice_partition_dedup_multiple_ident() {
2019 let mut slice = [12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11];
2021 let (dedup, duplicates) = slice.partition_dedup();
2023 assert_eq!(dedup, [12, 11]);
2024 assert_eq!(duplicates, [12, 12, 12, 12, 11, 11, 11, 11, 11]);
2028 fn test_slice_partition_dedup_partialeq() {
2030 struct Foo(i32, i32);
2032 impl PartialEq for Foo {
2033 fn eq(&self, other: &Foo) -> bool {
2038 let mut slice = [Foo(0, 1), Foo(0, 5), Foo(1, 7), Foo(1, 9)];
2040 let (dedup, duplicates) = slice.partition_dedup();
2042 assert_eq!(dedup, [Foo(0, 1), Foo(1, 7)]);
2043 assert_eq!(duplicates, [Foo(0, 5), Foo(1, 9)]);
2047 fn test_copy_within() {
2048 // Start to end, with a RangeTo.
2049 let mut bytes = *b"Hello, World!";
2050 bytes.copy_within(..3, 10);
2051 assert_eq!(&bytes, b"Hello, WorHel");
2053 // End to start, with a RangeFrom.
2054 let mut bytes = *b"Hello, World!";
2055 bytes.copy_within(10.., 0);
2056 assert_eq!(&bytes, b"ld!lo, World!");
2058 // Overlapping, with a RangeInclusive.
2059 let mut bytes = *b"Hello, World!";
2060 bytes.copy_within(0..=11, 1);
2061 assert_eq!(&bytes, b"HHello, World");
2063 // Whole slice, with a RangeFull.
2064 let mut bytes = *b"Hello, World!";
2065 bytes.copy_within(.., 0);
2066 assert_eq!(&bytes, b"Hello, World!");
2068 // Ensure that copying at the end of slice won't cause UB.
2069 let mut bytes = *b"Hello, World!";
2070 bytes.copy_within(13..13, 5);
2071 assert_eq!(&bytes, b"Hello, World!");
2072 bytes.copy_within(5..5, 13);
2073 assert_eq!(&bytes, b"Hello, World!");
2077 #[should_panic(expected = "range end index 14 out of range for slice of length 13")]
2078 fn test_copy_within_panics_src_too_long() {
2079 let mut bytes = *b"Hello, World!";
2080 // The length is only 13, so 14 is out of bounds.
2081 bytes.copy_within(10..14, 0);
2085 #[should_panic(expected = "dest is out of bounds")]
2086 fn test_copy_within_panics_dest_too_long() {
2087 let mut bytes = *b"Hello, World!";
2088 // The length is only 13, so a slice of length 4 starting at index 10 is out of bounds.
2089 bytes.copy_within(0..4, 10);
2093 #[should_panic(expected = "slice index starts at 2 but ends at 1")]
2094 fn test_copy_within_panics_src_inverted() {
2095 let mut bytes = *b"Hello, World!";
2096 // 2 is greater than 1, so this range is invalid.
2097 bytes.copy_within(2..1, 0);
2100 #[should_panic(expected = "attempted to index slice up to maximum usize")]
2101 fn test_copy_within_panics_src_out_of_bounds() {
2102 let mut bytes = *b"Hello, World!";
2103 // an inclusive range ending at usize::MAX would make src_end overflow
2104 bytes.copy_within(usize::MAX..=usize::MAX, 0);
2108 fn test_is_sorted() {
2109 let empty: [i32; 0] = [];
2111 assert!([1, 2, 2, 9].is_sorted());
2112 assert!(![1, 3, 2].is_sorted());
2113 assert!([0].is_sorted());
2114 assert!(empty.is_sorted());
2115 assert!(![0.0, 1.0, f32::NAN].is_sorted());
2116 assert!([-2, -1, 0, 3].is_sorted());
2117 assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
2118 assert!(!["c", "bb", "aaa"].is_sorted());
2119 assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
2123 fn test_slice_run_destructors() {
2124 // Make sure that destructors get run on slice literals
2129 impl<'a> Drop for Foo<'a> {
2130 fn drop(&mut self) {
2131 self.x.set(self.x.get() + 1);
2135 fn foo(x: &Cell<isize>) -> Foo<'_> {
2139 let x = &Cell::new(0);
2143 assert_eq!(l[0].x.get(), 0);
2146 assert_eq!(x.get(), 1);
2150 fn test_slice_fill_with_uninit() {
2151 // This should not UB. See #87891
2152 let mut a = [MaybeUninit::<u8>::uninit(); 10];
2153 a.fill(MaybeUninit::uninit());