2 use core::cmp::Ordering;
3 use core::result::Result::{Err, Ok};
7 let b = [1, 2, 3, 5, 5];
8 assert_eq!(b.iter().position(|&v| v == 9), None);
9 assert_eq!(b.iter().position(|&v| v == 5), Some(3));
10 assert_eq!(b.iter().position(|&v| v == 3), Some(2));
11 assert_eq!(b.iter().position(|&v| v == 0), None);
16 let b = [1, 2, 3, 5, 5];
17 assert_eq!(b.iter().rposition(|&v| v == 9), None);
18 assert_eq!(b.iter().rposition(|&v| v == 5), Some(4));
19 assert_eq!(b.iter().rposition(|&v| v == 3), Some(2));
20 assert_eq!(b.iter().rposition(|&v| v == 0), None);
24 fn test_binary_search() {
26 assert_eq!(b.binary_search(&5), Err(0));
29 assert_eq!(b.binary_search(&3), Err(0));
30 assert_eq!(b.binary_search(&4), Ok(0));
31 assert_eq!(b.binary_search(&5), Err(1));
33 let b = [1, 2, 4, 6, 8, 9];
34 assert_eq!(b.binary_search(&5), Err(3));
35 assert_eq!(b.binary_search(&6), Ok(3));
36 assert_eq!(b.binary_search(&7), Err(4));
37 assert_eq!(b.binary_search(&8), Ok(4));
39 let b = [1, 2, 4, 5, 6, 8];
40 assert_eq!(b.binary_search(&9), Err(6));
42 let b = [1, 2, 4, 6, 7, 8, 9];
43 assert_eq!(b.binary_search(&6), Ok(3));
44 assert_eq!(b.binary_search(&5), Err(3));
45 assert_eq!(b.binary_search(&8), Ok(5));
47 let b = [1, 2, 4, 5, 6, 8, 9];
48 assert_eq!(b.binary_search(&7), Err(5));
49 assert_eq!(b.binary_search(&0), Err(0));
51 let b = [1, 3, 3, 3, 7];
52 assert_eq!(b.binary_search(&0), Err(0));
53 assert_eq!(b.binary_search(&1), Ok(0));
54 assert_eq!(b.binary_search(&2), Err(1));
55 assert!(match b.binary_search(&3) {
59 assert!(match b.binary_search(&3) {
63 assert_eq!(b.binary_search(&4), Err(4));
64 assert_eq!(b.binary_search(&5), Err(4));
65 assert_eq!(b.binary_search(&6), Err(4));
66 assert_eq!(b.binary_search(&7), Ok(4));
67 assert_eq!(b.binary_search(&8), Err(5));
69 let b = [(); usize::MAX];
70 assert_eq!(b.binary_search(&()), Ok(usize::MAX / 2));
74 fn test_binary_search_by_overflow() {
75 let b = [(); usize::MAX];
76 assert_eq!(b.binary_search_by(|_| Ordering::Equal), Ok(usize::MAX / 2));
77 assert_eq!(b.binary_search_by(|_| Ordering::Greater), Err(0));
78 assert_eq!(b.binary_search_by(|_| Ordering::Less), Err(usize::MAX));
82 // Test implementation specific behavior when finding equivalent elements.
83 // It is ok to break this test but when you do a crater run is highly advisable.
84 fn test_binary_search_implementation_details() {
85 let b = [1, 1, 2, 2, 3, 3, 3];
86 assert_eq!(b.binary_search(&1), Ok(1));
87 assert_eq!(b.binary_search(&2), Ok(3));
88 assert_eq!(b.binary_search(&3), Ok(5));
89 let b = [1, 1, 1, 1, 1, 3, 3, 3, 3];
90 assert_eq!(b.binary_search(&1), Ok(4));
91 assert_eq!(b.binary_search(&3), Ok(7));
92 let b = [1, 1, 1, 1, 3, 3, 3, 3, 3];
93 assert_eq!(b.binary_search(&1), Ok(2));
94 assert_eq!(b.binary_search(&3), Ok(4));
98 fn test_partition_point() {
100 assert_eq!(b.partition_point(|&x| x < 5), 0);
103 assert_eq!(b.partition_point(|&x| x < 3), 0);
104 assert_eq!(b.partition_point(|&x| x < 4), 0);
105 assert_eq!(b.partition_point(|&x| x < 5), 1);
107 let b = [1, 2, 4, 6, 8, 9];
108 assert_eq!(b.partition_point(|&x| x < 5), 3);
109 assert_eq!(b.partition_point(|&x| x < 6), 3);
110 assert_eq!(b.partition_point(|&x| x < 7), 4);
111 assert_eq!(b.partition_point(|&x| x < 8), 4);
113 let b = [1, 2, 4, 5, 6, 8];
114 assert_eq!(b.partition_point(|&x| x < 9), 6);
116 let b = [1, 2, 4, 6, 7, 8, 9];
117 assert_eq!(b.partition_point(|&x| x < 6), 3);
118 assert_eq!(b.partition_point(|&x| x < 5), 3);
119 assert_eq!(b.partition_point(|&x| x < 8), 5);
121 let b = [1, 2, 4, 5, 6, 8, 9];
122 assert_eq!(b.partition_point(|&x| x < 7), 5);
123 assert_eq!(b.partition_point(|&x| x < 0), 0);
125 let b = [1, 3, 3, 3, 7];
126 assert_eq!(b.partition_point(|&x| x < 0), 0);
127 assert_eq!(b.partition_point(|&x| x < 1), 0);
128 assert_eq!(b.partition_point(|&x| x < 2), 1);
129 assert_eq!(b.partition_point(|&x| x < 3), 1);
130 assert_eq!(b.partition_point(|&x| x < 4), 4);
131 assert_eq!(b.partition_point(|&x| x < 5), 4);
132 assert_eq!(b.partition_point(|&x| x < 6), 4);
133 assert_eq!(b.partition_point(|&x| x < 7), 4);
134 assert_eq!(b.partition_point(|&x| x < 8), 5);
138 fn test_iterator_advance_by() {
139 let v = &[0, 1, 2, 3, 4];
141 for i in 0..=v.len() {
142 let mut iter = v.iter();
143 iter.advance_by(i).unwrap();
144 assert_eq!(iter.as_slice(), &v[i..]);
147 let mut iter = v.iter();
148 assert_eq!(iter.advance_by(v.len() + 1), Err(v.len()));
149 assert_eq!(iter.as_slice(), &[]);
151 let mut iter = v.iter();
152 iter.advance_by(3).unwrap();
153 assert_eq!(iter.as_slice(), &v[3..]);
154 iter.advance_by(2).unwrap();
155 assert_eq!(iter.as_slice(), &[]);
159 fn test_iterator_advance_back_by() {
160 let v = &[0, 1, 2, 3, 4];
162 for i in 0..=v.len() {
163 let mut iter = v.iter();
164 iter.advance_back_by(i).unwrap();
165 assert_eq!(iter.as_slice(), &v[..v.len() - i]);
168 let mut iter = v.iter();
169 assert_eq!(iter.advance_back_by(v.len() + 1), Err(v.len()));
170 assert_eq!(iter.as_slice(), &[]);
172 let mut iter = v.iter();
173 iter.advance_back_by(3).unwrap();
174 assert_eq!(iter.as_slice(), &v[..v.len() - 3]);
175 iter.advance_back_by(2).unwrap();
176 assert_eq!(iter.as_slice(), &[]);
180 fn test_iterator_nth() {
181 let v: &[_] = &[0, 1, 2, 3, 4];
182 for i in 0..v.len() {
183 assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
185 assert_eq!(v.iter().nth(v.len()), None);
187 let mut iter = v.iter();
188 assert_eq!(iter.nth(2).unwrap(), &v[2]);
189 assert_eq!(iter.nth(1).unwrap(), &v[4]);
193 fn test_iterator_nth_back() {
194 let v: &[_] = &[0, 1, 2, 3, 4];
195 for i in 0..v.len() {
196 assert_eq!(v.iter().nth_back(i).unwrap(), &v[v.len() - i - 1]);
198 assert_eq!(v.iter().nth_back(v.len()), None);
200 let mut iter = v.iter();
201 assert_eq!(iter.nth_back(2).unwrap(), &v[2]);
202 assert_eq!(iter.nth_back(1).unwrap(), &v[0]);
206 fn test_iterator_last() {
207 let v: &[_] = &[0, 1, 2, 3, 4];
208 assert_eq!(v.iter().last().unwrap(), &4);
209 assert_eq!(v[..1].iter().last().unwrap(), &0);
213 fn test_iterator_count() {
214 let v: &[_] = &[0, 1, 2, 3, 4];
215 assert_eq!(v.iter().count(), 5);
217 let mut iter2 = v.iter();
220 assert_eq!(iter2.count(), 3);
224 fn test_chunks_count() {
225 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
227 assert_eq!(c.count(), 2);
229 let v2: &[i32] = &[0, 1, 2, 3, 4];
230 let c2 = v2.chunks(2);
231 assert_eq!(c2.count(), 3);
233 let v3: &[i32] = &[];
234 let c3 = v3.chunks(2);
235 assert_eq!(c3.count(), 0);
239 fn test_chunks_nth() {
240 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
241 let mut c = v.chunks(2);
242 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
243 assert_eq!(c.next().unwrap(), &[4, 5]);
245 let v2: &[i32] = &[0, 1, 2, 3, 4];
246 let mut c2 = v2.chunks(3);
247 assert_eq!(c2.nth(1).unwrap(), &[3, 4]);
248 assert_eq!(c2.next(), None);
252 fn test_chunks_nth_back() {
253 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
254 let mut c = v.chunks(2);
255 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
256 assert_eq!(c.next().unwrap(), &[0, 1]);
257 assert_eq!(c.next(), None);
259 let v2: &[i32] = &[0, 1, 2, 3, 4];
260 let mut c2 = v2.chunks(3);
261 assert_eq!(c2.nth_back(1).unwrap(), &[0, 1, 2]);
262 assert_eq!(c2.next(), None);
263 assert_eq!(c2.next_back(), None);
265 let v3: &[i32] = &[0, 1, 2, 3, 4];
266 let mut c3 = v3.chunks(10);
267 assert_eq!(c3.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
268 assert_eq!(c3.next(), None);
270 let v4: &[i32] = &[0, 1, 2];
271 let mut c4 = v4.chunks(10);
272 assert_eq!(c4.nth_back(1_000_000_000usize), None);
276 fn test_chunks_last() {
277 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
279 assert_eq!(c.last().unwrap()[1], 5);
281 let v2: &[i32] = &[0, 1, 2, 3, 4];
282 let c2 = v2.chunks(2);
283 assert_eq!(c2.last().unwrap()[0], 4);
287 fn test_chunks_zip() {
288 let v1: &[i32] = &[0, 1, 2, 3, 4];
289 let v2: &[i32] = &[6, 7, 8, 9, 10];
294 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
295 .collect::<Vec<_>>();
296 assert_eq!(res, vec![14, 22, 14]);
300 fn test_chunks_mut_count() {
301 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
302 let c = v.chunks_mut(3);
303 assert_eq!(c.count(), 2);
305 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
306 let c2 = v2.chunks_mut(2);
307 assert_eq!(c2.count(), 3);
309 let v3: &mut [i32] = &mut [];
310 let c3 = v3.chunks_mut(2);
311 assert_eq!(c3.count(), 0);
315 fn test_chunks_mut_nth() {
316 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
317 let mut c = v.chunks_mut(2);
318 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
319 assert_eq!(c.next().unwrap(), &[4, 5]);
321 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
322 let mut c2 = v2.chunks_mut(3);
323 assert_eq!(c2.nth(1).unwrap(), &[3, 4]);
324 assert_eq!(c2.next(), None);
328 fn test_chunks_mut_nth_back() {
329 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
330 let mut c = v.chunks_mut(2);
331 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
332 assert_eq!(c.next().unwrap(), &[0, 1]);
334 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
335 let mut c1 = v1.chunks_mut(3);
336 assert_eq!(c1.nth_back(1).unwrap(), &[0, 1, 2]);
337 assert_eq!(c1.next(), None);
339 let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
340 let mut c3 = v3.chunks_mut(10);
341 assert_eq!(c3.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
342 assert_eq!(c3.next(), None);
344 let v4: &mut [i32] = &mut [0, 1, 2];
345 let mut c4 = v4.chunks_mut(10);
346 assert_eq!(c4.nth_back(1_000_000_000usize), None);
350 fn test_chunks_mut_last() {
351 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
352 let c = v.chunks_mut(2);
353 assert_eq!(c.last().unwrap(), &[4, 5]);
355 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
356 let c2 = v2.chunks_mut(2);
357 assert_eq!(c2.last().unwrap(), &[4]);
361 fn test_chunks_mut_zip() {
362 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
363 let v2: &[i32] = &[6, 7, 8, 9, 10];
365 for (a, b) in v1.chunks_mut(2).zip(v2.chunks(2)) {
366 let sum = b.iter().sum::<i32>();
371 assert_eq!(v1, [13, 14, 19, 20, 14]);
375 fn test_chunks_exact_count() {
376 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
377 let c = v.chunks_exact(3);
378 assert_eq!(c.count(), 2);
380 let v2: &[i32] = &[0, 1, 2, 3, 4];
381 let c2 = v2.chunks_exact(2);
382 assert_eq!(c2.count(), 2);
384 let v3: &[i32] = &[];
385 let c3 = v3.chunks_exact(2);
386 assert_eq!(c3.count(), 0);
390 fn test_chunks_exact_nth() {
391 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
392 let mut c = v.chunks_exact(2);
393 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
394 assert_eq!(c.next().unwrap(), &[4, 5]);
396 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
397 let mut c2 = v2.chunks_exact(3);
398 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
399 assert_eq!(c2.next(), None);
403 fn test_chunks_exact_nth_back() {
404 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
405 let mut c = v.chunks_exact(2);
406 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
407 assert_eq!(c.next().unwrap(), &[0, 1]);
408 assert_eq!(c.next(), None);
410 let v2: &[i32] = &[0, 1, 2, 3, 4];
411 let mut c2 = v2.chunks_exact(3);
412 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
413 assert_eq!(c2.next(), None);
414 assert_eq!(c2.next_back(), None);
416 let v3: &[i32] = &[0, 1, 2, 3, 4];
417 let mut c3 = v3.chunks_exact(10);
418 assert_eq!(c3.nth_back(0), None);
422 fn test_chunks_exact_last() {
423 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
424 let c = v.chunks_exact(2);
425 assert_eq!(c.last().unwrap(), &[4, 5]);
427 let v2: &[i32] = &[0, 1, 2, 3, 4];
428 let c2 = v2.chunks_exact(2);
429 assert_eq!(c2.last().unwrap(), &[2, 3]);
433 fn test_chunks_exact_remainder() {
434 let v: &[i32] = &[0, 1, 2, 3, 4];
435 let c = v.chunks_exact(2);
436 assert_eq!(c.remainder(), &[4]);
440 fn test_chunks_exact_zip() {
441 let v1: &[i32] = &[0, 1, 2, 3, 4];
442 let v2: &[i32] = &[6, 7, 8, 9, 10];
446 .zip(v2.chunks_exact(2))
447 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
448 .collect::<Vec<_>>();
449 assert_eq!(res, vec![14, 22]);
453 fn test_chunks_exact_mut_count() {
454 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
455 let c = v.chunks_exact_mut(3);
456 assert_eq!(c.count(), 2);
458 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
459 let c2 = v2.chunks_exact_mut(2);
460 assert_eq!(c2.count(), 2);
462 let v3: &mut [i32] = &mut [];
463 let c3 = v3.chunks_exact_mut(2);
464 assert_eq!(c3.count(), 0);
468 fn test_chunks_exact_mut_nth() {
469 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
470 let mut c = v.chunks_exact_mut(2);
471 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
472 assert_eq!(c.next().unwrap(), &[4, 5]);
474 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
475 let mut c2 = v2.chunks_exact_mut(3);
476 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
477 assert_eq!(c2.next(), None);
481 fn test_chunks_exact_mut_nth_back() {
482 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
483 let mut c = v.chunks_exact_mut(2);
484 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
485 assert_eq!(c.next().unwrap(), &[0, 1]);
486 assert_eq!(c.next(), None);
488 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
489 let mut c2 = v2.chunks_exact_mut(3);
490 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
491 assert_eq!(c2.next(), None);
492 assert_eq!(c2.next_back(), None);
494 let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
495 let mut c3 = v3.chunks_exact_mut(10);
496 assert_eq!(c3.nth_back(0), None);
500 fn test_chunks_exact_mut_last() {
501 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
502 let c = v.chunks_exact_mut(2);
503 assert_eq!(c.last().unwrap(), &[4, 5]);
505 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
506 let c2 = v2.chunks_exact_mut(2);
507 assert_eq!(c2.last().unwrap(), &[2, 3]);
511 fn test_chunks_exact_mut_remainder() {
512 let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
513 let c = v.chunks_exact_mut(2);
514 assert_eq!(c.into_remainder(), &[4]);
518 fn test_chunks_exact_mut_zip() {
519 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
520 let v2: &[i32] = &[6, 7, 8, 9, 10];
522 for (a, b) in v1.chunks_exact_mut(2).zip(v2.chunks_exact(2)) {
523 let sum = b.iter().sum::<i32>();
528 assert_eq!(v1, [13, 14, 19, 20, 4]);
532 fn test_array_chunks_infer() {
533 let v: &[i32] = &[0, 1, 2, 3, 4, -4];
534 let c = v.array_chunks();
535 for &[a, b, c] in c {
536 assert_eq!(a + b + c, 3);
539 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
540 let total = v2.array_chunks().map(|&[a, b]| a * b).sum::<i32>();
541 assert_eq!(total, 2 * 3 + 4 * 5);
545 fn test_array_chunks_count() {
546 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
547 let c = v.array_chunks::<3>();
548 assert_eq!(c.count(), 2);
550 let v2: &[i32] = &[0, 1, 2, 3, 4];
551 let c2 = v2.array_chunks::<2>();
552 assert_eq!(c2.count(), 2);
554 let v3: &[i32] = &[];
555 let c3 = v3.array_chunks::<2>();
556 assert_eq!(c3.count(), 0);
560 fn test_array_chunks_nth() {
561 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
562 let mut c = v.array_chunks::<2>();
563 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
564 assert_eq!(c.next().unwrap(), &[4, 5]);
566 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
567 let mut c2 = v2.array_chunks::<3>();
568 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
569 assert_eq!(c2.next(), None);
573 fn test_array_chunks_nth_back() {
574 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
575 let mut c = v.array_chunks::<2>();
576 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
577 assert_eq!(c.next().unwrap(), &[0, 1]);
578 assert_eq!(c.next(), None);
580 let v2: &[i32] = &[0, 1, 2, 3, 4];
581 let mut c2 = v2.array_chunks::<3>();
582 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
583 assert_eq!(c2.next(), None);
584 assert_eq!(c2.next_back(), None);
586 let v3: &[i32] = &[0, 1, 2, 3, 4];
587 let mut c3 = v3.array_chunks::<10>();
588 assert_eq!(c3.nth_back(0), None);
592 fn test_array_chunks_last() {
593 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
594 let c = v.array_chunks::<2>();
595 assert_eq!(c.last().unwrap(), &[4, 5]);
597 let v2: &[i32] = &[0, 1, 2, 3, 4];
598 let c2 = v2.array_chunks::<2>();
599 assert_eq!(c2.last().unwrap(), &[2, 3]);
603 fn test_array_chunks_remainder() {
604 let v: &[i32] = &[0, 1, 2, 3, 4];
605 let c = v.array_chunks::<2>();
606 assert_eq!(c.remainder(), &[4]);
610 fn test_array_chunks_zip() {
611 let v1: &[i32] = &[0, 1, 2, 3, 4];
612 let v2: &[i32] = &[6, 7, 8, 9, 10];
616 .zip(v2.array_chunks::<2>())
617 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
618 .collect::<Vec<_>>();
619 assert_eq!(res, vec![14, 22]);
623 fn test_array_chunks_mut_infer() {
624 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
625 for a in v.array_chunks_mut() {
626 let sum = a.iter().sum::<i32>();
629 assert_eq!(v, &[3, 3, 3, 12, 12, 12, 6]);
631 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
632 v2.array_chunks_mut().for_each(|[a, b]| core::mem::swap(a, b));
633 assert_eq!(v2, &[1, 0, 3, 2, 5, 4, 6]);
637 fn test_array_chunks_mut_count() {
638 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
639 let c = v.array_chunks_mut::<3>();
640 assert_eq!(c.count(), 2);
642 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
643 let c2 = v2.array_chunks_mut::<2>();
644 assert_eq!(c2.count(), 2);
646 let v3: &mut [i32] = &mut [];
647 let c3 = v3.array_chunks_mut::<2>();
648 assert_eq!(c3.count(), 0);
652 fn test_array_chunks_mut_nth() {
653 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
654 let mut c = v.array_chunks_mut::<2>();
655 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
656 assert_eq!(c.next().unwrap(), &[4, 5]);
658 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
659 let mut c2 = v2.array_chunks_mut::<3>();
660 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
661 assert_eq!(c2.next(), None);
665 fn test_array_chunks_mut_nth_back() {
666 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
667 let mut c = v.array_chunks_mut::<2>();
668 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
669 assert_eq!(c.next().unwrap(), &[0, 1]);
670 assert_eq!(c.next(), None);
672 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
673 let mut c2 = v2.array_chunks_mut::<3>();
674 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
675 assert_eq!(c2.next(), None);
676 assert_eq!(c2.next_back(), None);
678 let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
679 let mut c3 = v3.array_chunks_mut::<10>();
680 assert_eq!(c3.nth_back(0), None);
684 fn test_array_chunks_mut_last() {
685 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
686 let c = v.array_chunks_mut::<2>();
687 assert_eq!(c.last().unwrap(), &[4, 5]);
689 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
690 let c2 = v2.array_chunks_mut::<2>();
691 assert_eq!(c2.last().unwrap(), &[2, 3]);
695 fn test_array_chunks_mut_remainder() {
696 let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
697 let c = v.array_chunks_mut::<2>();
698 assert_eq!(c.into_remainder(), &[4]);
702 fn test_array_chunks_mut_zip() {
703 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
704 let v2: &[i32] = &[6, 7, 8, 9, 10];
706 for (a, b) in v1.array_chunks_mut::<2>().zip(v2.array_chunks::<2>()) {
707 let sum = b.iter().sum::<i32>();
712 assert_eq!(v1, [13, 14, 19, 20, 4]);
716 fn test_array_windows_infer() {
717 let v: &[i32] = &[0, 1, 0, 1];
718 assert_eq!(v.array_windows::<2>().count(), 3);
719 let c = v.array_windows();
721 assert_eq!(a + b, 1);
724 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
725 let total = v2.array_windows().map(|&[a, b, c]| a + b + c).sum::<i32>();
726 assert_eq!(total, 3 + 6 + 9 + 12 + 15);
730 fn test_array_windows_count() {
731 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
732 let c = v.array_windows::<3>();
733 assert_eq!(c.count(), 4);
735 let v2: &[i32] = &[0, 1, 2, 3, 4];
736 let c2 = v2.array_windows::<6>();
737 assert_eq!(c2.count(), 0);
739 let v3: &[i32] = &[];
740 let c3 = v3.array_windows::<2>();
741 assert_eq!(c3.count(), 0);
743 let v4: &[()] = &[(); usize::MAX];
744 let c4 = v4.array_windows::<1>();
745 assert_eq!(c4.count(), usize::MAX);
749 fn test_array_windows_nth() {
750 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
751 let snd = v.array_windows::<4>().nth(1);
752 assert_eq!(snd, Some(&[1, 2, 3, 4]));
753 let mut arr_windows = v.array_windows::<2>();
754 assert_ne!(arr_windows.nth(0), arr_windows.nth(0));
755 let last = v.array_windows::<3>().last();
756 assert_eq!(last, Some(&[3, 4, 5]));
760 fn test_array_windows_nth_back() {
761 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
762 let snd = v.array_windows::<4>().nth_back(1);
763 assert_eq!(snd, Some(&[1, 2, 3, 4]));
764 let mut arr_windows = v.array_windows::<2>();
765 assert_ne!(arr_windows.nth_back(0), arr_windows.nth_back(0));
769 fn test_rchunks_count() {
770 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
771 let c = v.rchunks(3);
772 assert_eq!(c.count(), 2);
774 let v2: &[i32] = &[0, 1, 2, 3, 4];
775 let c2 = v2.rchunks(2);
776 assert_eq!(c2.count(), 3);
778 let v3: &[i32] = &[];
779 let c3 = v3.rchunks(2);
780 assert_eq!(c3.count(), 0);
784 fn test_rchunks_nth() {
785 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
786 let mut c = v.rchunks(2);
787 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
788 assert_eq!(c.next().unwrap(), &[0, 1]);
790 let v2: &[i32] = &[0, 1, 2, 3, 4];
791 let mut c2 = v2.rchunks(3);
792 assert_eq!(c2.nth(1).unwrap(), &[0, 1]);
793 assert_eq!(c2.next(), None);
797 fn test_rchunks_nth_back() {
798 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
799 let mut c = v.rchunks(2);
800 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
801 assert_eq!(c.next_back().unwrap(), &[4, 5]);
803 let v2: &[i32] = &[0, 1, 2, 3, 4];
804 let mut c2 = v2.rchunks(3);
805 assert_eq!(c2.nth_back(1).unwrap(), &[2, 3, 4]);
806 assert_eq!(c2.next_back(), None);
810 fn test_rchunks_last() {
811 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
812 let c = v.rchunks(2);
813 assert_eq!(c.last().unwrap()[1], 1);
815 let v2: &[i32] = &[0, 1, 2, 3, 4];
816 let c2 = v2.rchunks(2);
817 assert_eq!(c2.last().unwrap()[0], 0);
821 fn test_rchunks_zip() {
822 let v1: &[i32] = &[0, 1, 2, 3, 4];
823 let v2: &[i32] = &[6, 7, 8, 9, 10];
828 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
829 .collect::<Vec<_>>();
830 assert_eq!(res, vec![26, 18, 6]);
834 fn test_rchunks_mut_count() {
835 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
836 let c = v.rchunks_mut(3);
837 assert_eq!(c.count(), 2);
839 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
840 let c2 = v2.rchunks_mut(2);
841 assert_eq!(c2.count(), 3);
843 let v3: &mut [i32] = &mut [];
844 let c3 = v3.rchunks_mut(2);
845 assert_eq!(c3.count(), 0);
849 fn test_rchunks_mut_nth() {
850 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
851 let mut c = v.rchunks_mut(2);
852 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
853 assert_eq!(c.next().unwrap(), &[0, 1]);
855 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
856 let mut c2 = v2.rchunks_mut(3);
857 assert_eq!(c2.nth(1).unwrap(), &[0, 1]);
858 assert_eq!(c2.next(), None);
862 fn test_rchunks_mut_nth_back() {
863 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
864 let mut c = v.rchunks_mut(2);
865 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
866 assert_eq!(c.next_back().unwrap(), &[4, 5]);
868 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
869 let mut c2 = v2.rchunks_mut(3);
870 assert_eq!(c2.nth_back(1).unwrap(), &[2, 3, 4]);
871 assert_eq!(c2.next_back(), None);
875 fn test_rchunks_mut_last() {
876 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
877 let c = v.rchunks_mut(2);
878 assert_eq!(c.last().unwrap(), &[0, 1]);
880 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
881 let c2 = v2.rchunks_mut(2);
882 assert_eq!(c2.last().unwrap(), &[0]);
886 fn test_rchunks_mut_zip() {
887 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
888 let v2: &[i32] = &[6, 7, 8, 9, 10];
890 for (a, b) in v1.rchunks_mut(2).zip(v2.rchunks(2)) {
891 let sum = b.iter().sum::<i32>();
896 assert_eq!(v1, [6, 16, 17, 22, 23]);
900 fn test_rchunks_exact_count() {
901 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
902 let c = v.rchunks_exact(3);
903 assert_eq!(c.count(), 2);
905 let v2: &[i32] = &[0, 1, 2, 3, 4];
906 let c2 = v2.rchunks_exact(2);
907 assert_eq!(c2.count(), 2);
909 let v3: &[i32] = &[];
910 let c3 = v3.rchunks_exact(2);
911 assert_eq!(c3.count(), 0);
915 fn test_rchunks_exact_nth() {
916 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
917 let mut c = v.rchunks_exact(2);
918 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
919 assert_eq!(c.next().unwrap(), &[0, 1]);
921 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
922 let mut c2 = v2.rchunks_exact(3);
923 assert_eq!(c2.nth(1).unwrap(), &[1, 2, 3]);
924 assert_eq!(c2.next(), None);
928 fn test_rchunks_exact_nth_back() {
929 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
930 let mut c = v.rchunks_exact(2);
931 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
932 assert_eq!(c.next_back().unwrap(), &[4, 5]);
934 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
935 let mut c2 = v2.rchunks_exact(3);
936 assert_eq!(c2.nth_back(1).unwrap(), &[4, 5, 6]);
937 assert_eq!(c2.next(), None);
941 fn test_rchunks_exact_last() {
942 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
943 let c = v.rchunks_exact(2);
944 assert_eq!(c.last().unwrap(), &[0, 1]);
946 let v2: &[i32] = &[0, 1, 2, 3, 4];
947 let c2 = v2.rchunks_exact(2);
948 assert_eq!(c2.last().unwrap(), &[1, 2]);
952 fn test_rchunks_exact_remainder() {
953 let v: &[i32] = &[0, 1, 2, 3, 4];
954 let c = v.rchunks_exact(2);
955 assert_eq!(c.remainder(), &[0]);
959 fn test_rchunks_exact_zip() {
960 let v1: &[i32] = &[0, 1, 2, 3, 4];
961 let v2: &[i32] = &[6, 7, 8, 9, 10];
965 .zip(v2.rchunks_exact(2))
966 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
967 .collect::<Vec<_>>();
968 assert_eq!(res, vec![26, 18]);
972 fn test_rchunks_exact_mut_count() {
973 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
974 let c = v.rchunks_exact_mut(3);
975 assert_eq!(c.count(), 2);
977 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
978 let c2 = v2.rchunks_exact_mut(2);
979 assert_eq!(c2.count(), 2);
981 let v3: &mut [i32] = &mut [];
982 let c3 = v3.rchunks_exact_mut(2);
983 assert_eq!(c3.count(), 0);
987 fn test_rchunks_exact_mut_nth() {
988 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
989 let mut c = v.rchunks_exact_mut(2);
990 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
991 assert_eq!(c.next().unwrap(), &[0, 1]);
993 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
994 let mut c2 = v2.rchunks_exact_mut(3);
995 assert_eq!(c2.nth(1).unwrap(), &[1, 2, 3]);
996 assert_eq!(c2.next(), None);
1000 fn test_rchunks_exact_mut_nth_back() {
1001 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1002 let mut c = v.rchunks_exact_mut(2);
1003 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
1004 assert_eq!(c.next_back().unwrap(), &[4, 5]);
1006 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
1007 let mut c2 = v2.rchunks_exact_mut(3);
1008 assert_eq!(c2.nth_back(1).unwrap(), &[4, 5, 6]);
1009 assert_eq!(c2.next(), None);
1013 fn test_rchunks_exact_mut_last() {
1014 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1015 let c = v.rchunks_exact_mut(2);
1016 assert_eq!(c.last().unwrap(), &[0, 1]);
1018 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
1019 let c2 = v2.rchunks_exact_mut(2);
1020 assert_eq!(c2.last().unwrap(), &[1, 2]);
1024 fn test_rchunks_exact_mut_remainder() {
1025 let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
1026 let c = v.rchunks_exact_mut(2);
1027 assert_eq!(c.into_remainder(), &[0]);
1031 fn test_rchunks_exact_mut_zip() {
1032 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
1033 let v2: &[i32] = &[6, 7, 8, 9, 10];
1035 for (a, b) in v1.rchunks_exact_mut(2).zip(v2.rchunks_exact(2)) {
1036 let sum = b.iter().sum::<i32>();
1041 assert_eq!(v1, [0, 16, 17, 22, 23]);
1045 fn test_windows_count() {
1046 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1047 let c = v.windows(3);
1048 assert_eq!(c.count(), 4);
1050 let v2: &[i32] = &[0, 1, 2, 3, 4];
1051 let c2 = v2.windows(6);
1052 assert_eq!(c2.count(), 0);
1054 let v3: &[i32] = &[];
1055 let c3 = v3.windows(2);
1056 assert_eq!(c3.count(), 0);
1058 let v4 = &[(); usize::MAX];
1059 let c4 = v4.windows(1);
1060 assert_eq!(c4.count(), usize::MAX);
1064 fn test_windows_nth() {
1065 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1066 let mut c = v.windows(2);
1067 assert_eq!(c.nth(2).unwrap()[1], 3);
1068 assert_eq!(c.next().unwrap()[0], 3);
1070 let v2: &[i32] = &[0, 1, 2, 3, 4];
1071 let mut c2 = v2.windows(4);
1072 assert_eq!(c2.nth(1).unwrap()[1], 2);
1073 assert_eq!(c2.next(), None);
1077 fn test_windows_nth_back() {
1078 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1079 let mut c = v.windows(2);
1080 assert_eq!(c.nth_back(2).unwrap()[0], 2);
1081 assert_eq!(c.next_back().unwrap()[1], 2);
1083 let v2: &[i32] = &[0, 1, 2, 3, 4];
1084 let mut c2 = v2.windows(4);
1085 assert_eq!(c2.nth_back(1).unwrap()[1], 1);
1086 assert_eq!(c2.next_back(), None);
1090 fn test_windows_last() {
1091 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1092 let c = v.windows(2);
1093 assert_eq!(c.last().unwrap()[1], 5);
1095 let v2: &[i32] = &[0, 1, 2, 3, 4];
1096 let c2 = v2.windows(2);
1097 assert_eq!(c2.last().unwrap()[0], 3);
1101 fn test_windows_zip() {
1102 let v1: &[i32] = &[0, 1, 2, 3, 4];
1103 let v2: &[i32] = &[6, 7, 8, 9, 10];
1108 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
1109 .collect::<Vec<_>>();
1111 assert_eq!(res, [14, 18, 22, 26]);
1116 fn test_iter_ref_consistency() {
1117 use std::fmt::Debug;
1119 fn test<T: Copy + Debug + PartialEq>(x: T) {
1120 let v: &[T] = &[x, x, x];
1121 let v_ptrs: [*const T; 3] = match v {
1122 [ref v1, ref v2, ref v3] => [v1 as *const _, v2 as *const _, v3 as *const _],
1123 _ => unreachable!(),
1129 assert_eq!(&v[i] as *const _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1130 let nth = v.iter().nth(i).unwrap();
1131 assert_eq!(nth as *const _, v_ptrs[i]);
1133 assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1135 // stepping through with nth(0)
1137 let mut it = v.iter();
1139 let next = it.nth(0).unwrap();
1140 assert_eq!(next as *const _, v_ptrs[i]);
1142 assert_eq!(it.nth(0), None);
1147 let mut it = v.iter();
1149 let remaining = len - i;
1150 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1152 let next = it.next().unwrap();
1153 assert_eq!(next as *const _, v_ptrs[i]);
1155 assert_eq!(it.size_hint(), (0, Some(0)));
1156 assert_eq!(it.next(), None, "The final call to next() should return None");
1161 let mut it = v.iter();
1163 let remaining = len - i;
1164 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1166 let prev = it.next_back().unwrap();
1167 assert_eq!(prev as *const _, v_ptrs[remaining - 1]);
1169 assert_eq!(it.size_hint(), (0, Some(0)));
1170 assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1174 fn test_mut<T: Copy + Debug + PartialEq>(x: T) {
1175 let v: &mut [T] = &mut [x, x, x];
1176 let v_ptrs: [*mut T; 3] = match v {
1177 [ref v1, ref v2, ref v3] => {
1178 [v1 as *const _ as *mut _, v2 as *const _ as *mut _, v3 as *const _ as *mut _]
1180 _ => unreachable!(),
1186 assert_eq!(&mut v[i] as *mut _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1187 let nth = v.iter_mut().nth(i).unwrap();
1188 assert_eq!(nth as *mut _, v_ptrs[i]);
1190 assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1192 // stepping through with nth(0)
1194 let mut it = v.iter();
1196 let next = it.nth(0).unwrap();
1197 assert_eq!(next as *const _, v_ptrs[i]);
1199 assert_eq!(it.nth(0), None);
1204 let mut it = v.iter_mut();
1206 let remaining = len - i;
1207 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1209 let next = it.next().unwrap();
1210 assert_eq!(next as *mut _, v_ptrs[i]);
1212 assert_eq!(it.size_hint(), (0, Some(0)));
1213 assert_eq!(it.next(), None, "The final call to next() should return None");
1218 let mut it = v.iter_mut();
1220 let remaining = len - i;
1221 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1223 let prev = it.next_back().unwrap();
1224 assert_eq!(prev as *mut _, v_ptrs[remaining - 1]);
1226 assert_eq!(it.size_hint(), (0, Some(0)));
1227 assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1231 // Make sure iterators and slice patterns yield consistent addresses for various types,
1235 test([0u32; 0]); // ZST with alignment > 0
1238 test_mut([0u32; 0]); // ZST with alignment > 0
1241 // The current implementation of SliceIndex fails to handle methods
1242 // orthogonally from range types; therefore, it is worth testing
1243 // all of the indexing operations on each input.
1245 // This checks all six indexing methods, given an input range that
1246 // should succeed. (it is NOT suitable for testing invalid inputs)
1247 macro_rules! assert_range_eq {
1248 ($arr:expr, $range:expr, $expected:expr) => {
1250 let mut expected = $expected;
1253 let expected: &[_] = &expected;
1255 assert_eq!(&s[$range], expected, "(in assertion for: index)");
1256 assert_eq!(s.get($range), Some(expected), "(in assertion for: get)");
1259 s.get_unchecked($range),
1261 "(in assertion for: get_unchecked)",
1266 let s: &mut [_] = &mut arr;
1267 let expected: &mut [_] = &mut expected;
1269 assert_eq!(&mut s[$range], expected, "(in assertion for: index_mut)",);
1272 Some(&mut expected[..]),
1273 "(in assertion for: get_mut)",
1277 s.get_unchecked_mut($range),
1279 "(in assertion for: get_unchecked_mut)",
1286 // Make sure the macro can actually detect bugs,
1287 // because if it can't, then what are we even doing here?
1289 // (Be aware this only demonstrates the ability to detect bugs
1290 // in the FIRST method that panics, as the macro is not designed
1291 // to be used in `should_panic`)
1293 #[should_panic(expected = "out of range")]
1294 fn assert_range_eq_can_fail_by_panic() {
1295 assert_range_eq!([0, 1, 2], 0..5, [0, 1, 2]);
1298 // (Be aware this only demonstrates the ability to detect bugs
1299 // in the FIRST method it calls, as the macro is not designed
1300 // to be used in `should_panic`)
1302 #[should_panic(expected = "==")]
1303 fn assert_range_eq_can_fail_by_inequality() {
1304 assert_range_eq!([0, 1, 2], 0..2, [0, 1, 2]);
1307 // Test cases for bad index operations.
1309 // This generates `should_panic` test cases for Index/IndexMut
1310 // and `None` test cases for get/get_mut.
1311 macro_rules! panic_cases {
1313 // each test case needs a unique name to namespace the tests
1314 in mod $case_name:ident {
1319 // one or more similar inputs for which data[input] succeeds,
1320 // and the corresponding output as an array. This helps validate
1321 // "critical points" where an input range straddles the boundary
1322 // between valid and invalid.
1323 // (such as the input `len..len`, which is just barely valid)
1325 good: data[$good:expr] == $output:expr;
1328 bad: data[$bad:expr];
1329 message: $expect_msg:expr;
1333 #[allow(unused_imports)]
1334 use core::ops::Bound;
1340 $( assert_range_eq!($data, $good, $output); )*
1344 assert_eq!(v.get($bad), None, "(in None assertion for get)");
1348 let v: &mut [_] = &mut v;
1349 assert_eq!(v.get_mut($bad), None, "(in None assertion for get_mut)");
1354 #[should_panic(expected = $expect_msg)]
1362 #[should_panic(expected = $expect_msg)]
1363 fn index_mut_fail() {
1365 let v: &mut [_] = &mut v;
1366 let _v = &mut v[$bad];
1374 let v = [0, 1, 2, 3, 4, 5];
1376 assert_range_eq!(v, .., [0, 1, 2, 3, 4, 5]);
1377 assert_range_eq!(v, ..2, [0, 1]);
1378 assert_range_eq!(v, ..=1, [0, 1]);
1379 assert_range_eq!(v, 2.., [2, 3, 4, 5]);
1380 assert_range_eq!(v, 1..4, [1, 2, 3]);
1381 assert_range_eq!(v, 1..=3, [1, 2, 3]);
1385 in mod rangefrom_len {
1386 data: [0, 1, 2, 3, 4, 5];
1388 good: data[6..] == [];
1390 message: "out of range";
1393 in mod rangeto_len {
1394 data: [0, 1, 2, 3, 4, 5];
1396 good: data[..6] == [0, 1, 2, 3, 4, 5];
1398 message: "out of range";
1401 in mod rangetoinclusive_len {
1402 data: [0, 1, 2, 3, 4, 5];
1404 good: data[..=5] == [0, 1, 2, 3, 4, 5];
1406 message: "out of range";
1409 in mod rangeinclusive_len {
1410 data: [0, 1, 2, 3, 4, 5];
1412 good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1414 message: "out of range";
1417 in mod range_len_len {
1418 data: [0, 1, 2, 3, 4, 5];
1420 good: data[6..6] == [];
1422 message: "out of range";
1425 in mod rangeinclusive_len_len {
1426 data: [0, 1, 2, 3, 4, 5];
1428 good: data[6..=5] == [];
1430 message: "out of range";
1433 in mod boundpair_len {
1434 data: [0, 1, 2, 3, 4, 5];
1436 good: data[(Bound::Included(6), Bound::Unbounded)] == [];
1437 good: data[(Bound::Unbounded, Bound::Included(5))] == [0, 1, 2, 3, 4, 5];
1438 good: data[(Bound::Unbounded, Bound::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1439 good: data[(Bound::Included(0), Bound::Included(5))] == [0, 1, 2, 3, 4, 5];
1440 good: data[(Bound::Included(0), Bound::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1441 good: data[(Bound::Included(2), Bound::Excluded(4))] == [2, 3];
1442 good: data[(Bound::Excluded(1), Bound::Included(4))] == [2, 3, 4];
1443 good: data[(Bound::Excluded(5), Bound::Excluded(6))] == [];
1444 good: data[(Bound::Included(6), Bound::Excluded(6))] == [];
1445 good: data[(Bound::Excluded(5), Bound::Included(5))] == [];
1446 good: data[(Bound::Included(6), Bound::Included(5))] == [];
1447 bad: data[(Bound::Unbounded, Bound::Included(6))];
1448 message: "out of range";
1453 in mod rangeinclusive_exhausted {
1454 data: [0, 1, 2, 3, 4, 5];
1456 good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1458 let mut iter = 0..=5;
1459 iter.by_ref().count(); // exhaust it
1463 // 0..=6 is out of range before exhaustion, so it
1464 // stands to reason that it still would be after.
1466 let mut iter = 0..=6;
1467 iter.by_ref().count(); // exhaust it
1470 message: "out of range";
1475 in mod range_neg_width {
1476 data: [0, 1, 2, 3, 4, 5];
1478 good: data[4..4] == [];
1480 message: "but ends at";
1483 in mod rangeinclusive_neg_width {
1484 data: [0, 1, 2, 3, 4, 5];
1486 good: data[4..=3] == [];
1488 message: "but ends at";
1491 in mod boundpair_neg_width {
1492 data: [0, 1, 2, 3, 4, 5];
1494 good: data[(Bound::Included(4), Bound::Excluded(4))] == [];
1495 bad: data[(Bound::Included(4), Bound::Excluded(3))];
1496 message: "but ends at";
1501 in mod rangeinclusive_overflow {
1504 // note: using 0 specifically ensures that the result of overflowing is 0..0,
1505 // so that `get` doesn't simply return None for the wrong reason.
1506 bad: data[0 ..= usize::MAX];
1507 message: "maximum usize";
1510 in mod rangetoinclusive_overflow {
1513 bad: data[..= usize::MAX];
1514 message: "maximum usize";
1517 in mod boundpair_overflow_end {
1520 bad: data[(Bound::Unbounded, Bound::Included(usize::MAX))];
1521 message: "maximum usize";
1524 in mod boundpair_overflow_start {
1527 bad: data[(Bound::Excluded(usize::MAX), Bound::Unbounded)];
1528 message: "maximum usize";
1534 fn test_find_rfind() {
1535 let v = [0, 1, 2, 3, 4, 5];
1536 let mut iter = v.iter();
1537 let mut i = v.len();
1538 while let Some(&elt) = iter.rfind(|_| true) {
1540 assert_eq!(elt, v[i]);
1543 assert_eq!(v.iter().rfind(|&&x| x <= 3), Some(&3));
1547 fn test_iter_folds() {
1548 let a = [1, 2, 3, 4, 5]; // len>4 so the unroll is used
1549 assert_eq!(a.iter().fold(0, |acc, &x| 2 * acc + x), 57);
1550 assert_eq!(a.iter().rfold(0, |acc, &x| 2 * acc + x), 129);
1551 let fold = |acc: i32, &x| acc.checked_mul(2)?.checked_add(x);
1552 assert_eq!(a.iter().try_fold(0, &fold), Some(57));
1553 assert_eq!(a.iter().try_rfold(0, &fold), Some(129));
1555 // short-circuiting try_fold, through other methods
1556 let a = [0, 1, 2, 3, 5, 5, 5, 7, 8, 9];
1557 let mut iter = a.iter();
1558 assert_eq!(iter.position(|&x| x == 3), Some(3));
1559 assert_eq!(iter.rfind(|&&x| x == 5), Some(&5));
1560 assert_eq!(iter.len(), 2);
1564 fn test_rotate_left() {
1565 const N: usize = 600;
1566 let a: &mut [_] = &mut [0; N];
1575 assert_eq!(a[(i + k) % N], i);
1580 fn test_rotate_right() {
1581 const N: usize = 600;
1582 let a: &mut [_] = &mut [0; N];
1590 assert_eq!(a[(i + 42) % N], i);
1595 #[cfg_attr(miri, ignore)] // Miri is too slow
1596 fn brute_force_rotate_test_0() {
1597 // In case of edge cases involving multiple algorithms
1601 let mut v = Vec::with_capacity(len);
1605 v[..].rotate_right(s);
1606 for i in 0..v.len() {
1607 assert_eq!(v[i], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1614 fn brute_force_rotate_test_1() {
1615 // `ptr_rotate` covers so many kinds of pointer usage, that this is just a good test for
1616 // pointers in general. This uses a `[usize; 4]` to hit all algorithms without overwhelming miri
1620 let mut v: Vec<[usize; 4]> = Vec::with_capacity(len);
1622 v.push([i, 0, 0, 0]);
1624 v[..].rotate_right(s);
1625 for i in 0..v.len() {
1626 assert_eq!(v[i][0], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1633 #[cfg(not(target_arch = "wasm32"))]
1634 fn sort_unstable() {
1635 use core::cmp::Ordering::{Equal, Greater, Less};
1636 use core::slice::heapsort;
1637 use rand::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng};
1639 // Miri is too slow (but still need to `chain` to make the types match)
1640 let lens = if cfg!(miri) { (2..20).chain(0..0) } else { (2..25).chain(500..510) };
1641 let rounds = if cfg!(miri) { 1 } else { 100 };
1643 let mut v = [0; 600];
1644 let mut tmp = [0; 600];
1645 let mut rng = StdRng::from_entropy();
1648 let v = &mut v[0..len];
1649 let tmp = &mut tmp[0..len];
1651 for &modulus in &[5, 10, 100, 1000] {
1652 for _ in 0..rounds {
1654 v[i] = rng.gen::<i32>() % modulus;
1657 // Sort in default order.
1658 tmp.copy_from_slice(v);
1659 tmp.sort_unstable();
1660 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1662 // Sort in ascending order.
1663 tmp.copy_from_slice(v);
1664 tmp.sort_unstable_by(|a, b| a.cmp(b));
1665 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1667 // Sort in descending order.
1668 tmp.copy_from_slice(v);
1669 tmp.sort_unstable_by(|a, b| b.cmp(a));
1670 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1672 // Test heapsort using `<` operator.
1673 tmp.copy_from_slice(v);
1674 heapsort(tmp, |a, b| a < b);
1675 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1677 // Test heapsort using `>` operator.
1678 tmp.copy_from_slice(v);
1679 heapsort(tmp, |a, b| a > b);
1680 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1685 // Sort using a completely random comparison function.
1686 // This will reorder the elements *somehow*, but won't panic.
1687 for i in 0..v.len() {
1690 v.sort_unstable_by(|_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1692 for i in 0..v.len() {
1693 assert_eq!(v[i], i as i32);
1696 // Should not panic.
1697 [0i32; 0].sort_unstable();
1698 [(); 10].sort_unstable();
1699 [(); 100].sort_unstable();
1701 let mut v = [0xDEADBEEFu64];
1703 assert!(v == [0xDEADBEEF]);
1707 #[cfg(not(target_arch = "wasm32"))]
1708 #[cfg_attr(miri, ignore)] // Miri is too slow
1709 fn select_nth_unstable() {
1710 use core::cmp::Ordering::{Equal, Greater, Less};
1711 use rand::rngs::StdRng;
1712 use rand::seq::SliceRandom;
1713 use rand::{Rng, SeedableRng};
1715 let mut rng = StdRng::from_entropy();
1717 for len in (2..21).chain(500..501) {
1718 let mut orig = vec![0; len];
1720 for &modulus in &[5, 10, 1000] {
1723 orig[i] = rng.gen::<i32>() % modulus;
1727 let mut v = orig.clone();
1732 // Sort in default order.
1733 for pivot in 0..len {
1734 let mut v = orig.clone();
1735 v.select_nth_unstable(pivot);
1737 assert_eq!(v_sorted[pivot], v[pivot]);
1739 for j in pivot..len {
1740 assert!(v[i] <= v[j]);
1745 // Sort in ascending order.
1746 for pivot in 0..len {
1747 let mut v = orig.clone();
1748 let (left, pivot, right) = v.select_nth_unstable_by(pivot, |a, b| a.cmp(b));
1750 assert_eq!(left.len() + right.len(), len - 1);
1753 assert!(l <= pivot);
1754 for r in right.iter_mut() {
1756 assert!(pivot <= r);
1761 // Sort in descending order.
1762 let sort_descending_comparator = |a: &i32, b: &i32| b.cmp(a);
1763 let v_sorted_descending = {
1764 let mut v = orig.clone();
1765 v.sort_by(sort_descending_comparator);
1769 for pivot in 0..len {
1770 let mut v = orig.clone();
1771 v.select_nth_unstable_by(pivot, sort_descending_comparator);
1773 assert_eq!(v_sorted_descending[pivot], v[pivot]);
1775 for j in pivot..len {
1776 assert!(v[j] <= v[i]);
1784 // Sort at index using a completely random comparison function.
1785 // This will reorder the elements *somehow*, but won't panic.
1786 let mut v = [0; 500];
1787 for i in 0..v.len() {
1791 for pivot in 0..v.len() {
1792 v.select_nth_unstable_by(pivot, |_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1794 for i in 0..v.len() {
1795 assert_eq!(v[i], i as i32);
1799 // Should not panic.
1800 [(); 10].select_nth_unstable(0);
1801 [(); 10].select_nth_unstable(5);
1802 [(); 10].select_nth_unstable(9);
1803 [(); 100].select_nth_unstable(0);
1804 [(); 100].select_nth_unstable(50);
1805 [(); 100].select_nth_unstable(99);
1807 let mut v = [0xDEADBEEFu64];
1808 v.select_nth_unstable(0);
1809 assert!(v == [0xDEADBEEF]);
1813 #[should_panic(expected = "index 0 greater than length of slice")]
1814 fn select_nth_unstable_zero_length() {
1815 [0i32; 0].select_nth_unstable(0);
1819 #[should_panic(expected = "index 20 greater than length of slice")]
1820 fn select_nth_unstable_past_length() {
1821 [0i32; 10].select_nth_unstable(20);
1825 use core::slice::memchr::{memchr, memrchr};
1827 // test fallback implementations on all platforms
1830 assert_eq!(Some(0), memchr(b'a', b"a"));
1834 fn matches_begin() {
1835 assert_eq!(Some(0), memchr(b'a', b"aaaa"));
1840 assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
1845 assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
1849 fn matches_past_nul() {
1850 assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
1854 fn no_match_empty() {
1855 assert_eq!(None, memchr(b'a', b""));
1860 assert_eq!(None, memchr(b'a', b"xyz"));
1864 fn matches_one_reversed() {
1865 assert_eq!(Some(0), memrchr(b'a', b"a"));
1869 fn matches_begin_reversed() {
1870 assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
1874 fn matches_end_reversed() {
1875 assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
1879 fn matches_nul_reversed() {
1880 assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
1884 fn matches_past_nul_reversed() {
1885 assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
1889 fn no_match_empty_reversed() {
1890 assert_eq!(None, memrchr(b'a', b""));
1894 fn no_match_reversed() {
1895 assert_eq!(None, memrchr(b'a', b"xyz"));
1899 fn each_alignment_reversed() {
1900 let mut data = [1u8; 64];
1904 for start in 0..16 {
1905 assert_eq!(Some(pos - start), memrchr(needle, &data[start..]));
1911 fn test_align_to_simple() {
1912 let bytes = [1u8, 2, 3, 4, 5, 6, 7];
1913 let (prefix, aligned, suffix) = unsafe { bytes.align_to::<u16>() };
1914 assert_eq!(aligned.len(), 3);
1915 assert!(prefix == [1] || suffix == [7]);
1916 let expect1 = [1 << 8 | 2, 3 << 8 | 4, 5 << 8 | 6];
1917 let expect2 = [1 | 2 << 8, 3 | 4 << 8, 5 | 6 << 8];
1918 let expect3 = [2 << 8 | 3, 4 << 8 | 5, 6 << 8 | 7];
1919 let expect4 = [2 | 3 << 8, 4 | 5 << 8, 6 | 7 << 8];
1921 aligned == expect1 || aligned == expect2 || aligned == expect3 || aligned == expect4,
1922 "aligned={:?} expected={:?} || {:?} || {:?} || {:?}",
1932 fn test_align_to_zst() {
1933 let bytes = [1, 2, 3, 4, 5, 6, 7];
1934 let (prefix, aligned, suffix) = unsafe { bytes.align_to::<()>() };
1935 assert_eq!(aligned.len(), 0);
1936 assert!(prefix == [1, 2, 3, 4, 5, 6, 7] || suffix == [1, 2, 3, 4, 5, 6, 7]);
1940 fn test_align_to_non_trivial() {
1942 struct U64(u64, u64);
1944 struct U64U64U32(u64, u64, u32);
1955 let (prefix, aligned, suffix) = unsafe { data.align_to::<U64U64U32>() };
1956 assert_eq!(aligned.len(), 4);
1957 assert_eq!(prefix.len() + suffix.len(), 2);
1961 fn test_align_to_empty_mid() {
1964 // Make sure that we do not create empty unaligned slices for the mid part, even when the
1965 // overall slice is too short to contain an aligned address.
1966 let bytes = [1, 2, 3, 4, 5, 6, 7];
1968 for offset in 0..4 {
1969 let (_, mid, _) = unsafe { bytes[offset..offset + 1].align_to::<Chunk>() };
1970 assert_eq!(mid.as_ptr() as usize % mem::align_of::<Chunk>(), 0);
1975 fn test_align_to_mut_aliasing() {
1976 let mut val = [1u8, 2, 3, 4, 5];
1977 // `align_to_mut` used to create `mid` in a way that there was some intermediate
1978 // incorrect aliasing, invalidating the resulting `mid` slice.
1979 let (begin, mid, end) = unsafe { val.align_to_mut::<[u8; 2]>() };
1980 assert!(begin.len() == 0);
1981 assert!(end.len() == 1);
1983 assert_eq!(val, [3, 4, 3, 4, 5])
1987 fn test_slice_partition_dedup_by() {
1988 let mut slice: [i32; 9] = [1, -1, 2, 3, 1, -5, 5, -2, 2];
1990 let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.abs() == b.abs());
1992 assert_eq!(dedup, [1, 2, 3, 1, -5, -2]);
1993 assert_eq!(duplicates, [5, -1, 2]);
1997 fn test_slice_partition_dedup_empty() {
1998 let mut slice: [i32; 0] = [];
2000 let (dedup, duplicates) = slice.partition_dedup();
2002 assert_eq!(dedup, []);
2003 assert_eq!(duplicates, []);
2007 fn test_slice_partition_dedup_one() {
2008 let mut slice = [12];
2010 let (dedup, duplicates) = slice.partition_dedup();
2012 assert_eq!(dedup, [12]);
2013 assert_eq!(duplicates, []);
2017 fn test_slice_partition_dedup_multiple_ident() {
2018 let mut slice = [12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11];
2020 let (dedup, duplicates) = slice.partition_dedup();
2022 assert_eq!(dedup, [12, 11]);
2023 assert_eq!(duplicates, [12, 12, 12, 12, 11, 11, 11, 11, 11]);
2027 fn test_slice_partition_dedup_partialeq() {
2029 struct Foo(i32, i32);
2031 impl PartialEq for Foo {
2032 fn eq(&self, other: &Foo) -> bool {
2037 let mut slice = [Foo(0, 1), Foo(0, 5), Foo(1, 7), Foo(1, 9)];
2039 let (dedup, duplicates) = slice.partition_dedup();
2041 assert_eq!(dedup, [Foo(0, 1), Foo(1, 7)]);
2042 assert_eq!(duplicates, [Foo(0, 5), Foo(1, 9)]);
2046 fn test_copy_within() {
2047 // Start to end, with a RangeTo.
2048 let mut bytes = *b"Hello, World!";
2049 bytes.copy_within(..3, 10);
2050 assert_eq!(&bytes, b"Hello, WorHel");
2052 // End to start, with a RangeFrom.
2053 let mut bytes = *b"Hello, World!";
2054 bytes.copy_within(10.., 0);
2055 assert_eq!(&bytes, b"ld!lo, World!");
2057 // Overlapping, with a RangeInclusive.
2058 let mut bytes = *b"Hello, World!";
2059 bytes.copy_within(0..=11, 1);
2060 assert_eq!(&bytes, b"HHello, World");
2062 // Whole slice, with a RangeFull.
2063 let mut bytes = *b"Hello, World!";
2064 bytes.copy_within(.., 0);
2065 assert_eq!(&bytes, b"Hello, World!");
2067 // Ensure that copying at the end of slice won't cause UB.
2068 let mut bytes = *b"Hello, World!";
2069 bytes.copy_within(13..13, 5);
2070 assert_eq!(&bytes, b"Hello, World!");
2071 bytes.copy_within(5..5, 13);
2072 assert_eq!(&bytes, b"Hello, World!");
2076 #[should_panic(expected = "range end index 14 out of range for slice of length 13")]
2077 fn test_copy_within_panics_src_too_long() {
2078 let mut bytes = *b"Hello, World!";
2079 // The length is only 13, so 14 is out of bounds.
2080 bytes.copy_within(10..14, 0);
2084 #[should_panic(expected = "dest is out of bounds")]
2085 fn test_copy_within_panics_dest_too_long() {
2086 let mut bytes = *b"Hello, World!";
2087 // The length is only 13, so a slice of length 4 starting at index 10 is out of bounds.
2088 bytes.copy_within(0..4, 10);
2092 #[should_panic(expected = "slice index starts at 2 but ends at 1")]
2093 fn test_copy_within_panics_src_inverted() {
2094 let mut bytes = *b"Hello, World!";
2095 // 2 is greater than 1, so this range is invalid.
2096 bytes.copy_within(2..1, 0);
2099 #[should_panic(expected = "attempted to index slice up to maximum usize")]
2100 fn test_copy_within_panics_src_out_of_bounds() {
2101 let mut bytes = *b"Hello, World!";
2102 // an inclusive range ending at usize::MAX would make src_end overflow
2103 bytes.copy_within(usize::MAX..=usize::MAX, 0);
2107 fn test_is_sorted() {
2108 let empty: [i32; 0] = [];
2110 assert!([1, 2, 2, 9].is_sorted());
2111 assert!(![1, 3, 2].is_sorted());
2112 assert!([0].is_sorted());
2113 assert!(empty.is_sorted());
2114 assert!(![0.0, 1.0, f32::NAN].is_sorted());
2115 assert!([-2, -1, 0, 3].is_sorted());
2116 assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
2117 assert!(!["c", "bb", "aaa"].is_sorted());
2118 assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
2122 fn test_slice_run_destructors() {
2123 // Make sure that destructors get run on slice literals
2128 impl<'a> Drop for Foo<'a> {
2129 fn drop(&mut self) {
2130 self.x.set(self.x.get() + 1);
2134 fn foo(x: &Cell<isize>) -> Foo<'_> {
2138 let x = &Cell::new(0);
2142 assert_eq!(l[0].x.get(), 0);
2145 assert_eq!(x.get(), 1);