2 use core::cmp::Ordering;
3 use core::mem::MaybeUninit;
4 use core::result::Result::{Err, Ok};
9 let b = [1, 2, 3, 5, 5];
10 assert_eq!(b.iter().position(|&v| v == 9), None);
11 assert_eq!(b.iter().position(|&v| v == 5), Some(3));
12 assert_eq!(b.iter().position(|&v| v == 3), Some(2));
13 assert_eq!(b.iter().position(|&v| v == 0), None);
18 let b = [1, 2, 3, 5, 5];
19 assert_eq!(b.iter().rposition(|&v| v == 9), None);
20 assert_eq!(b.iter().rposition(|&v| v == 5), Some(4));
21 assert_eq!(b.iter().rposition(|&v| v == 3), Some(2));
22 assert_eq!(b.iter().rposition(|&v| v == 0), None);
26 fn test_binary_search() {
28 assert_eq!(b.binary_search(&5), Err(0));
31 assert_eq!(b.binary_search(&3), Err(0));
32 assert_eq!(b.binary_search(&4), Ok(0));
33 assert_eq!(b.binary_search(&5), Err(1));
35 let b = [1, 2, 4, 6, 8, 9];
36 assert_eq!(b.binary_search(&5), Err(3));
37 assert_eq!(b.binary_search(&6), Ok(3));
38 assert_eq!(b.binary_search(&7), Err(4));
39 assert_eq!(b.binary_search(&8), Ok(4));
41 let b = [1, 2, 4, 5, 6, 8];
42 assert_eq!(b.binary_search(&9), Err(6));
44 let b = [1, 2, 4, 6, 7, 8, 9];
45 assert_eq!(b.binary_search(&6), Ok(3));
46 assert_eq!(b.binary_search(&5), Err(3));
47 assert_eq!(b.binary_search(&8), Ok(5));
49 let b = [1, 2, 4, 5, 6, 8, 9];
50 assert_eq!(b.binary_search(&7), Err(5));
51 assert_eq!(b.binary_search(&0), Err(0));
53 let b = [1, 3, 3, 3, 7];
54 assert_eq!(b.binary_search(&0), Err(0));
55 assert_eq!(b.binary_search(&1), Ok(0));
56 assert_eq!(b.binary_search(&2), Err(1));
57 assert!(match b.binary_search(&3) {
61 assert!(match b.binary_search(&3) {
65 assert_eq!(b.binary_search(&4), Err(4));
66 assert_eq!(b.binary_search(&5), Err(4));
67 assert_eq!(b.binary_search(&6), Err(4));
68 assert_eq!(b.binary_search(&7), Ok(4));
69 assert_eq!(b.binary_search(&8), Err(5));
71 let b = [(); usize::MAX];
72 assert_eq!(b.binary_search(&()), Ok(usize::MAX / 2));
76 fn test_binary_search_by_overflow() {
77 let b = [(); usize::MAX];
78 assert_eq!(b.binary_search_by(|_| Ordering::Equal), Ok(usize::MAX / 2));
79 assert_eq!(b.binary_search_by(|_| Ordering::Greater), Err(0));
80 assert_eq!(b.binary_search_by(|_| Ordering::Less), Err(usize::MAX));
84 // Test implementation specific behavior when finding equivalent elements.
85 // It is ok to break this test but when you do a crater run is highly advisable.
86 fn test_binary_search_implementation_details() {
87 let b = [1, 1, 2, 2, 3, 3, 3];
88 assert_eq!(b.binary_search(&1), Ok(1));
89 assert_eq!(b.binary_search(&2), Ok(3));
90 assert_eq!(b.binary_search(&3), Ok(5));
91 let b = [1, 1, 1, 1, 1, 3, 3, 3, 3];
92 assert_eq!(b.binary_search(&1), Ok(4));
93 assert_eq!(b.binary_search(&3), Ok(7));
94 let b = [1, 1, 1, 1, 3, 3, 3, 3, 3];
95 assert_eq!(b.binary_search(&1), Ok(2));
96 assert_eq!(b.binary_search(&3), Ok(4));
100 fn test_partition_point() {
101 let b: [i32; 0] = [];
102 assert_eq!(b.partition_point(|&x| x < 5), 0);
105 assert_eq!(b.partition_point(|&x| x < 3), 0);
106 assert_eq!(b.partition_point(|&x| x < 4), 0);
107 assert_eq!(b.partition_point(|&x| x < 5), 1);
109 let b = [1, 2, 4, 6, 8, 9];
110 assert_eq!(b.partition_point(|&x| x < 5), 3);
111 assert_eq!(b.partition_point(|&x| x < 6), 3);
112 assert_eq!(b.partition_point(|&x| x < 7), 4);
113 assert_eq!(b.partition_point(|&x| x < 8), 4);
115 let b = [1, 2, 4, 5, 6, 8];
116 assert_eq!(b.partition_point(|&x| x < 9), 6);
118 let b = [1, 2, 4, 6, 7, 8, 9];
119 assert_eq!(b.partition_point(|&x| x < 6), 3);
120 assert_eq!(b.partition_point(|&x| x < 5), 3);
121 assert_eq!(b.partition_point(|&x| x < 8), 5);
123 let b = [1, 2, 4, 5, 6, 8, 9];
124 assert_eq!(b.partition_point(|&x| x < 7), 5);
125 assert_eq!(b.partition_point(|&x| x < 0), 0);
127 let b = [1, 3, 3, 3, 7];
128 assert_eq!(b.partition_point(|&x| x < 0), 0);
129 assert_eq!(b.partition_point(|&x| x < 1), 0);
130 assert_eq!(b.partition_point(|&x| x < 2), 1);
131 assert_eq!(b.partition_point(|&x| x < 3), 1);
132 assert_eq!(b.partition_point(|&x| x < 4), 4);
133 assert_eq!(b.partition_point(|&x| x < 5), 4);
134 assert_eq!(b.partition_point(|&x| x < 6), 4);
135 assert_eq!(b.partition_point(|&x| x < 7), 4);
136 assert_eq!(b.partition_point(|&x| x < 8), 5);
140 fn test_iterator_advance_by() {
141 let v = &[0, 1, 2, 3, 4];
143 for i in 0..=v.len() {
144 let mut iter = v.iter();
145 iter.advance_by(i).unwrap();
146 assert_eq!(iter.as_slice(), &v[i..]);
149 let mut iter = v.iter();
150 assert_eq!(iter.advance_by(v.len() + 1), Err(v.len()));
151 assert_eq!(iter.as_slice(), &[]);
153 let mut iter = v.iter();
154 iter.advance_by(3).unwrap();
155 assert_eq!(iter.as_slice(), &v[3..]);
156 iter.advance_by(2).unwrap();
157 assert_eq!(iter.as_slice(), &[]);
158 iter.advance_by(0).unwrap();
162 fn test_iterator_advance_back_by() {
163 let v = &[0, 1, 2, 3, 4];
165 for i in 0..=v.len() {
166 let mut iter = v.iter();
167 iter.advance_back_by(i).unwrap();
168 assert_eq!(iter.as_slice(), &v[..v.len() - i]);
171 let mut iter = v.iter();
172 assert_eq!(iter.advance_back_by(v.len() + 1), Err(v.len()));
173 assert_eq!(iter.as_slice(), &[]);
175 let mut iter = v.iter();
176 iter.advance_back_by(3).unwrap();
177 assert_eq!(iter.as_slice(), &v[..v.len() - 3]);
178 iter.advance_back_by(2).unwrap();
179 assert_eq!(iter.as_slice(), &[]);
180 iter.advance_back_by(0).unwrap();
184 fn test_iterator_nth() {
185 let v: &[_] = &[0, 1, 2, 3, 4];
186 for i in 0..v.len() {
187 assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
189 assert_eq!(v.iter().nth(v.len()), None);
191 let mut iter = v.iter();
192 assert_eq!(iter.nth(2).unwrap(), &v[2]);
193 assert_eq!(iter.nth(1).unwrap(), &v[4]);
197 fn test_iterator_nth_back() {
198 let v: &[_] = &[0, 1, 2, 3, 4];
199 for i in 0..v.len() {
200 assert_eq!(v.iter().nth_back(i).unwrap(), &v[v.len() - i - 1]);
202 assert_eq!(v.iter().nth_back(v.len()), None);
204 let mut iter = v.iter();
205 assert_eq!(iter.nth_back(2).unwrap(), &v[2]);
206 assert_eq!(iter.nth_back(1).unwrap(), &v[0]);
210 fn test_iterator_last() {
211 let v: &[_] = &[0, 1, 2, 3, 4];
212 assert_eq!(v.iter().last().unwrap(), &4);
213 assert_eq!(v[..1].iter().last().unwrap(), &0);
217 fn test_iterator_count() {
218 let v: &[_] = &[0, 1, 2, 3, 4];
219 assert_eq!(v.iter().count(), 5);
221 let mut iter2 = v.iter();
224 assert_eq!(iter2.count(), 3);
228 fn test_chunks_count() {
229 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
231 assert_eq!(c.count(), 2);
233 let v2: &[i32] = &[0, 1, 2, 3, 4];
234 let c2 = v2.chunks(2);
235 assert_eq!(c2.count(), 3);
237 let v3: &[i32] = &[];
238 let c3 = v3.chunks(2);
239 assert_eq!(c3.count(), 0);
243 fn test_chunks_nth() {
244 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
245 let mut c = v.chunks(2);
246 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
247 assert_eq!(c.next().unwrap(), &[4, 5]);
249 let v2: &[i32] = &[0, 1, 2, 3, 4];
250 let mut c2 = v2.chunks(3);
251 assert_eq!(c2.nth(1).unwrap(), &[3, 4]);
252 assert_eq!(c2.next(), None);
256 fn test_chunks_next() {
257 let v = [0, 1, 2, 3, 4, 5];
258 let mut c = v.chunks(2);
259 assert_eq!(c.next().unwrap(), &[0, 1]);
260 assert_eq!(c.next().unwrap(), &[2, 3]);
261 assert_eq!(c.next().unwrap(), &[4, 5]);
262 assert_eq!(c.next(), None);
264 let v = [0, 1, 2, 3, 4, 5, 6, 7];
265 let mut c = v.chunks(3);
266 assert_eq!(c.next().unwrap(), &[0, 1, 2]);
267 assert_eq!(c.next().unwrap(), &[3, 4, 5]);
268 assert_eq!(c.next().unwrap(), &[6, 7]);
269 assert_eq!(c.next(), None);
273 fn test_chunks_next_back() {
274 let v = [0, 1, 2, 3, 4, 5];
275 let mut c = v.chunks(2);
276 assert_eq!(c.next_back().unwrap(), &[4, 5]);
277 assert_eq!(c.next_back().unwrap(), &[2, 3]);
278 assert_eq!(c.next_back().unwrap(), &[0, 1]);
279 assert_eq!(c.next_back(), None);
281 let v = [0, 1, 2, 3, 4, 5, 6, 7];
282 let mut c = v.chunks(3);
283 assert_eq!(c.next_back().unwrap(), &[6, 7]);
284 assert_eq!(c.next_back().unwrap(), &[3, 4, 5]);
285 assert_eq!(c.next_back().unwrap(), &[0, 1, 2]);
286 assert_eq!(c.next_back(), None);
290 fn test_chunks_nth_back() {
291 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
292 let mut c = v.chunks(2);
293 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
294 assert_eq!(c.next().unwrap(), &[0, 1]);
295 assert_eq!(c.next(), None);
297 let v2: &[i32] = &[0, 1, 2, 3, 4];
298 let mut c2 = v2.chunks(3);
299 assert_eq!(c2.nth_back(1).unwrap(), &[0, 1, 2]);
300 assert_eq!(c2.next(), None);
301 assert_eq!(c2.next_back(), None);
303 let v3: &[i32] = &[0, 1, 2, 3, 4];
304 let mut c3 = v3.chunks(10);
305 assert_eq!(c3.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
306 assert_eq!(c3.next(), None);
308 let v4: &[i32] = &[0, 1, 2];
309 let mut c4 = v4.chunks(10);
310 assert_eq!(c4.nth_back(1_000_000_000usize), None);
314 fn test_chunks_last() {
315 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
317 assert_eq!(c.last().unwrap()[1], 5);
319 let v2: &[i32] = &[0, 1, 2, 3, 4];
320 let c2 = v2.chunks(2);
321 assert_eq!(c2.last().unwrap()[0], 4);
325 fn test_chunks_zip() {
326 let v1: &[i32] = &[0, 1, 2, 3, 4];
327 let v2: &[i32] = &[6, 7, 8, 9, 10];
332 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
333 .collect::<Vec<_>>();
334 assert_eq!(res, vec![14, 22, 14]);
338 fn test_chunks_mut_count() {
339 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
340 let c = v.chunks_mut(3);
341 assert_eq!(c.count(), 2);
343 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
344 let c2 = v2.chunks_mut(2);
345 assert_eq!(c2.count(), 3);
347 let v3: &mut [i32] = &mut [];
348 let c3 = v3.chunks_mut(2);
349 assert_eq!(c3.count(), 0);
353 fn test_chunks_mut_nth() {
354 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
355 let mut c = v.chunks_mut(2);
356 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
357 assert_eq!(c.next().unwrap(), &[4, 5]);
359 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
360 let mut c2 = v2.chunks_mut(3);
361 assert_eq!(c2.nth(1).unwrap(), &[3, 4]);
362 assert_eq!(c2.next(), None);
366 fn test_chunks_mut_nth_back() {
367 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
368 let mut c = v.chunks_mut(2);
369 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
370 assert_eq!(c.next().unwrap(), &[0, 1]);
372 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
373 let mut c1 = v1.chunks_mut(3);
374 assert_eq!(c1.nth_back(1).unwrap(), &[0, 1, 2]);
375 assert_eq!(c1.next(), None);
377 let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
378 let mut c3 = v3.chunks_mut(10);
379 assert_eq!(c3.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
380 assert_eq!(c3.next(), None);
382 let v4: &mut [i32] = &mut [0, 1, 2];
383 let mut c4 = v4.chunks_mut(10);
384 assert_eq!(c4.nth_back(1_000_000_000usize), None);
388 fn test_chunks_mut_last() {
389 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
390 let c = v.chunks_mut(2);
391 assert_eq!(c.last().unwrap(), &[4, 5]);
393 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
394 let c2 = v2.chunks_mut(2);
395 assert_eq!(c2.last().unwrap(), &[4]);
399 fn test_chunks_mut_zip() {
400 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
401 let v2: &[i32] = &[6, 7, 8, 9, 10];
403 for (a, b) in v1.chunks_mut(2).zip(v2.chunks(2)) {
404 let sum = b.iter().sum::<i32>();
409 assert_eq!(v1, [13, 14, 19, 20, 14]);
413 fn test_chunks_mut_zip_aliasing() {
414 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
415 let v2: &[i32] = &[6, 7, 8, 9, 10];
417 let mut it = v1.chunks_mut(2).zip(v2.chunks(2));
418 let first = it.next().unwrap();
419 let _ = it.next().unwrap();
420 assert_eq!(first, (&mut [0, 1][..], &[6, 7][..]));
424 fn test_chunks_exact_mut_zip_aliasing() {
425 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
426 let v2: &[i32] = &[6, 7, 8, 9, 10];
428 let mut it = v1.chunks_exact_mut(2).zip(v2.chunks(2));
429 let first = it.next().unwrap();
430 let _ = it.next().unwrap();
431 assert_eq!(first, (&mut [0, 1][..], &[6, 7][..]));
435 fn test_rchunks_mut_zip_aliasing() {
436 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
437 let v2: &[i32] = &[6, 7, 8, 9, 10];
439 let mut it = v1.rchunks_mut(2).zip(v2.chunks(2));
440 let first = it.next().unwrap();
441 let _ = it.next().unwrap();
442 assert_eq!(first, (&mut [3, 4][..], &[6, 7][..]));
446 fn test_rchunks_exact_mut_zip_aliasing() {
447 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
448 let v2: &[i32] = &[6, 7, 8, 9, 10];
450 let mut it = v1.rchunks_exact_mut(2).zip(v2.chunks(2));
451 let first = it.next().unwrap();
452 let _ = it.next().unwrap();
453 assert_eq!(first, (&mut [3, 4][..], &[6, 7][..]));
457 fn test_chunks_exact_count() {
458 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
459 let c = v.chunks_exact(3);
460 assert_eq!(c.count(), 2);
462 let v2: &[i32] = &[0, 1, 2, 3, 4];
463 let c2 = v2.chunks_exact(2);
464 assert_eq!(c2.count(), 2);
466 let v3: &[i32] = &[];
467 let c3 = v3.chunks_exact(2);
468 assert_eq!(c3.count(), 0);
472 fn test_chunks_exact_nth() {
473 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
474 let mut c = v.chunks_exact(2);
475 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
476 assert_eq!(c.next().unwrap(), &[4, 5]);
478 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
479 let mut c2 = v2.chunks_exact(3);
480 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
481 assert_eq!(c2.next(), None);
485 fn test_chunks_exact_nth_back() {
486 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
487 let mut c = v.chunks_exact(2);
488 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
489 assert_eq!(c.next().unwrap(), &[0, 1]);
490 assert_eq!(c.next(), None);
492 let v2: &[i32] = &[0, 1, 2, 3, 4];
493 let mut c2 = v2.chunks_exact(3);
494 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
495 assert_eq!(c2.next(), None);
496 assert_eq!(c2.next_back(), None);
498 let v3: &[i32] = &[0, 1, 2, 3, 4];
499 let mut c3 = v3.chunks_exact(10);
500 assert_eq!(c3.nth_back(0), None);
504 fn test_chunks_exact_last() {
505 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
506 let c = v.chunks_exact(2);
507 assert_eq!(c.last().unwrap(), &[4, 5]);
509 let v2: &[i32] = &[0, 1, 2, 3, 4];
510 let c2 = v2.chunks_exact(2);
511 assert_eq!(c2.last().unwrap(), &[2, 3]);
515 fn test_chunks_exact_remainder() {
516 let v: &[i32] = &[0, 1, 2, 3, 4];
517 let c = v.chunks_exact(2);
518 assert_eq!(c.remainder(), &[4]);
522 fn test_chunks_exact_zip() {
523 let v1: &[i32] = &[0, 1, 2, 3, 4];
524 let v2: &[i32] = &[6, 7, 8, 9, 10];
528 .zip(v2.chunks_exact(2))
529 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
530 .collect::<Vec<_>>();
531 assert_eq!(res, vec![14, 22]);
535 fn test_chunks_exact_mut_count() {
536 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
537 let c = v.chunks_exact_mut(3);
538 assert_eq!(c.count(), 2);
540 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
541 let c2 = v2.chunks_exact_mut(2);
542 assert_eq!(c2.count(), 2);
544 let v3: &mut [i32] = &mut [];
545 let c3 = v3.chunks_exact_mut(2);
546 assert_eq!(c3.count(), 0);
550 fn test_chunks_exact_mut_nth() {
551 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
552 let mut c = v.chunks_exact_mut(2);
553 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
554 assert_eq!(c.next().unwrap(), &[4, 5]);
556 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
557 let mut c2 = v2.chunks_exact_mut(3);
558 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
559 assert_eq!(c2.next(), None);
563 fn test_chunks_exact_mut_nth_back() {
564 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
565 let mut c = v.chunks_exact_mut(2);
566 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
567 assert_eq!(c.next().unwrap(), &[0, 1]);
568 assert_eq!(c.next(), None);
570 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
571 let mut c2 = v2.chunks_exact_mut(3);
572 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
573 assert_eq!(c2.next(), None);
574 assert_eq!(c2.next_back(), None);
576 let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
577 let mut c3 = v3.chunks_exact_mut(10);
578 assert_eq!(c3.nth_back(0), None);
582 fn test_chunks_exact_mut_last() {
583 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
584 let c = v.chunks_exact_mut(2);
585 assert_eq!(c.last().unwrap(), &[4, 5]);
587 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
588 let c2 = v2.chunks_exact_mut(2);
589 assert_eq!(c2.last().unwrap(), &[2, 3]);
593 fn test_chunks_exact_mut_remainder() {
594 let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
595 let c = v.chunks_exact_mut(2);
596 assert_eq!(c.into_remainder(), &[4]);
600 fn test_chunks_exact_mut_zip() {
601 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
602 let v2: &[i32] = &[6, 7, 8, 9, 10];
604 for (a, b) in v1.chunks_exact_mut(2).zip(v2.chunks_exact(2)) {
605 let sum = b.iter().sum::<i32>();
610 assert_eq!(v1, [13, 14, 19, 20, 4]);
614 fn test_array_chunks_infer() {
615 let v: &[i32] = &[0, 1, 2, 3, 4, -4];
616 let c = v.array_chunks();
617 for &[a, b, c] in c {
618 assert_eq!(a + b + c, 3);
621 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
622 let total = v2.array_chunks().map(|&[a, b]| a * b).sum::<i32>();
623 assert_eq!(total, 2 * 3 + 4 * 5);
627 fn test_array_chunks_count() {
628 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
629 let c = v.array_chunks::<3>();
630 assert_eq!(c.count(), 2);
632 let v2: &[i32] = &[0, 1, 2, 3, 4];
633 let c2 = v2.array_chunks::<2>();
634 assert_eq!(c2.count(), 2);
636 let v3: &[i32] = &[];
637 let c3 = v3.array_chunks::<2>();
638 assert_eq!(c3.count(), 0);
642 fn test_array_chunks_nth() {
643 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
644 let mut c = v.array_chunks::<2>();
645 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
646 assert_eq!(c.next().unwrap(), &[4, 5]);
648 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
649 let mut c2 = v2.array_chunks::<3>();
650 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
651 assert_eq!(c2.next(), None);
655 fn test_array_chunks_nth_back() {
656 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
657 let mut c = v.array_chunks::<2>();
658 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
659 assert_eq!(c.next().unwrap(), &[0, 1]);
660 assert_eq!(c.next(), None);
662 let v2: &[i32] = &[0, 1, 2, 3, 4];
663 let mut c2 = v2.array_chunks::<3>();
664 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
665 assert_eq!(c2.next(), None);
666 assert_eq!(c2.next_back(), None);
668 let v3: &[i32] = &[0, 1, 2, 3, 4];
669 let mut c3 = v3.array_chunks::<10>();
670 assert_eq!(c3.nth_back(0), None);
674 fn test_array_chunks_last() {
675 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
676 let c = v.array_chunks::<2>();
677 assert_eq!(c.last().unwrap(), &[4, 5]);
679 let v2: &[i32] = &[0, 1, 2, 3, 4];
680 let c2 = v2.array_chunks::<2>();
681 assert_eq!(c2.last().unwrap(), &[2, 3]);
685 fn test_array_chunks_remainder() {
686 let v: &[i32] = &[0, 1, 2, 3, 4];
687 let c = v.array_chunks::<2>();
688 assert_eq!(c.remainder(), &[4]);
692 fn test_array_chunks_zip() {
693 let v1: &[i32] = &[0, 1, 2, 3, 4];
694 let v2: &[i32] = &[6, 7, 8, 9, 10];
698 .zip(v2.array_chunks::<2>())
699 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
700 .collect::<Vec<_>>();
701 assert_eq!(res, vec![14, 22]);
705 fn test_array_chunks_mut_infer() {
706 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
707 for a in v.array_chunks_mut() {
708 let sum = a.iter().sum::<i32>();
711 assert_eq!(v, &[3, 3, 3, 12, 12, 12, 6]);
713 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
714 v2.array_chunks_mut().for_each(|[a, b]| core::mem::swap(a, b));
715 assert_eq!(v2, &[1, 0, 3, 2, 5, 4, 6]);
719 fn test_array_chunks_mut_count() {
720 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
721 let c = v.array_chunks_mut::<3>();
722 assert_eq!(c.count(), 2);
724 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
725 let c2 = v2.array_chunks_mut::<2>();
726 assert_eq!(c2.count(), 2);
728 let v3: &mut [i32] = &mut [];
729 let c3 = v3.array_chunks_mut::<2>();
730 assert_eq!(c3.count(), 0);
734 fn test_array_chunks_mut_nth() {
735 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
736 let mut c = v.array_chunks_mut::<2>();
737 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
738 assert_eq!(c.next().unwrap(), &[4, 5]);
740 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
741 let mut c2 = v2.array_chunks_mut::<3>();
742 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
743 assert_eq!(c2.next(), None);
747 fn test_array_chunks_mut_nth_back() {
748 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
749 let mut c = v.array_chunks_mut::<2>();
750 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
751 assert_eq!(c.next().unwrap(), &[0, 1]);
752 assert_eq!(c.next(), None);
754 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
755 let mut c2 = v2.array_chunks_mut::<3>();
756 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
757 assert_eq!(c2.next(), None);
758 assert_eq!(c2.next_back(), None);
760 let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
761 let mut c3 = v3.array_chunks_mut::<10>();
762 assert_eq!(c3.nth_back(0), None);
766 fn test_array_chunks_mut_last() {
767 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
768 let c = v.array_chunks_mut::<2>();
769 assert_eq!(c.last().unwrap(), &[4, 5]);
771 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
772 let c2 = v2.array_chunks_mut::<2>();
773 assert_eq!(c2.last().unwrap(), &[2, 3]);
777 fn test_array_chunks_mut_remainder() {
778 let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
779 let c = v.array_chunks_mut::<2>();
780 assert_eq!(c.into_remainder(), &[4]);
784 fn test_array_chunks_mut_zip() {
785 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
786 let v2: &[i32] = &[6, 7, 8, 9, 10];
788 for (a, b) in v1.array_chunks_mut::<2>().zip(v2.array_chunks::<2>()) {
789 let sum = b.iter().sum::<i32>();
794 assert_eq!(v1, [13, 14, 19, 20, 4]);
798 fn test_array_windows_infer() {
799 let v: &[i32] = &[0, 1, 0, 1];
800 assert_eq!(v.array_windows::<2>().count(), 3);
801 let c = v.array_windows();
803 assert_eq!(a + b, 1);
806 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
807 let total = v2.array_windows().map(|&[a, b, c]| a + b + c).sum::<i32>();
808 assert_eq!(total, 3 + 6 + 9 + 12 + 15);
812 fn test_array_windows_count() {
813 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
814 let c = v.array_windows::<3>();
815 assert_eq!(c.count(), 4);
817 let v2: &[i32] = &[0, 1, 2, 3, 4];
818 let c2 = v2.array_windows::<6>();
819 assert_eq!(c2.count(), 0);
821 let v3: &[i32] = &[];
822 let c3 = v3.array_windows::<2>();
823 assert_eq!(c3.count(), 0);
825 let v4: &[()] = &[(); usize::MAX];
826 let c4 = v4.array_windows::<1>();
827 assert_eq!(c4.count(), usize::MAX);
831 fn test_array_windows_nth() {
832 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
833 let snd = v.array_windows::<4>().nth(1);
834 assert_eq!(snd, Some(&[1, 2, 3, 4]));
835 let mut arr_windows = v.array_windows::<2>();
836 assert_ne!(arr_windows.nth(0), arr_windows.nth(0));
837 let last = v.array_windows::<3>().last();
838 assert_eq!(last, Some(&[3, 4, 5]));
842 fn test_array_windows_nth_back() {
843 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
844 let snd = v.array_windows::<4>().nth_back(1);
845 assert_eq!(snd, Some(&[1, 2, 3, 4]));
846 let mut arr_windows = v.array_windows::<2>();
847 assert_ne!(arr_windows.nth_back(0), arr_windows.nth_back(0));
851 fn test_rchunks_count() {
852 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
853 let c = v.rchunks(3);
854 assert_eq!(c.count(), 2);
856 let v2: &[i32] = &[0, 1, 2, 3, 4];
857 let c2 = v2.rchunks(2);
858 assert_eq!(c2.count(), 3);
860 let v3: &[i32] = &[];
861 let c3 = v3.rchunks(2);
862 assert_eq!(c3.count(), 0);
866 fn test_rchunks_nth() {
867 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
868 let mut c = v.rchunks(2);
869 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
870 assert_eq!(c.next().unwrap(), &[0, 1]);
872 let v2: &[i32] = &[0, 1, 2, 3, 4];
873 let mut c2 = v2.rchunks(3);
874 assert_eq!(c2.nth(1).unwrap(), &[0, 1]);
875 assert_eq!(c2.next(), None);
879 fn test_rchunks_nth_back() {
880 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
881 let mut c = v.rchunks(2);
882 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
883 assert_eq!(c.next_back().unwrap(), &[4, 5]);
885 let v2: &[i32] = &[0, 1, 2, 3, 4];
886 let mut c2 = v2.rchunks(3);
887 assert_eq!(c2.nth_back(1).unwrap(), &[2, 3, 4]);
888 assert_eq!(c2.next_back(), None);
892 fn test_rchunks_next() {
893 let v = [0, 1, 2, 3, 4, 5];
894 let mut c = v.rchunks(2);
895 assert_eq!(c.next().unwrap(), &[4, 5]);
896 assert_eq!(c.next().unwrap(), &[2, 3]);
897 assert_eq!(c.next().unwrap(), &[0, 1]);
898 assert_eq!(c.next(), None);
900 let v = [0, 1, 2, 3, 4, 5, 6, 7];
901 let mut c = v.rchunks(3);
902 assert_eq!(c.next().unwrap(), &[5, 6, 7]);
903 assert_eq!(c.next().unwrap(), &[2, 3, 4]);
904 assert_eq!(c.next().unwrap(), &[0, 1]);
905 assert_eq!(c.next(), None);
909 fn test_rchunks_next_back() {
910 let v = [0, 1, 2, 3, 4, 5];
911 let mut c = v.rchunks(2);
912 assert_eq!(c.next_back().unwrap(), &[0, 1]);
913 assert_eq!(c.next_back().unwrap(), &[2, 3]);
914 assert_eq!(c.next_back().unwrap(), &[4, 5]);
915 assert_eq!(c.next_back(), None);
917 let v = [0, 1, 2, 3, 4, 5, 6, 7];
918 let mut c = v.rchunks(3);
919 assert_eq!(c.next_back().unwrap(), &[0, 1]);
920 assert_eq!(c.next_back().unwrap(), &[2, 3, 4]);
921 assert_eq!(c.next_back().unwrap(), &[5, 6, 7]);
922 assert_eq!(c.next_back(), None);
926 fn test_rchunks_last() {
927 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
928 let c = v.rchunks(2);
929 assert_eq!(c.last().unwrap()[1], 1);
931 let v2: &[i32] = &[0, 1, 2, 3, 4];
932 let c2 = v2.rchunks(2);
933 assert_eq!(c2.last().unwrap()[0], 0);
937 fn test_rchunks_zip() {
938 let v1: &[i32] = &[0, 1, 2, 3, 4];
939 let v2: &[i32] = &[6, 7, 8, 9, 10];
944 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
945 .collect::<Vec<_>>();
946 assert_eq!(res, vec![26, 18, 6]);
950 fn test_rchunks_mut_count() {
951 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
952 let c = v.rchunks_mut(3);
953 assert_eq!(c.count(), 2);
955 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
956 let c2 = v2.rchunks_mut(2);
957 assert_eq!(c2.count(), 3);
959 let v3: &mut [i32] = &mut [];
960 let c3 = v3.rchunks_mut(2);
961 assert_eq!(c3.count(), 0);
965 fn test_rchunks_mut_nth() {
966 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
967 let mut c = v.rchunks_mut(2);
968 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
969 assert_eq!(c.next().unwrap(), &[0, 1]);
971 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
972 let mut c2 = v2.rchunks_mut(3);
973 assert_eq!(c2.nth(1).unwrap(), &[0, 1]);
974 assert_eq!(c2.next(), None);
978 fn test_rchunks_mut_nth_back() {
979 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
980 let mut c = v.rchunks_mut(2);
981 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
982 assert_eq!(c.next_back().unwrap(), &[4, 5]);
984 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
985 let mut c2 = v2.rchunks_mut(3);
986 assert_eq!(c2.nth_back(1).unwrap(), &[2, 3, 4]);
987 assert_eq!(c2.next_back(), None);
991 fn test_rchunks_mut_next() {
992 let mut v = [0, 1, 2, 3, 4, 5];
993 let mut c = v.rchunks_mut(2);
994 assert_eq!(c.next().unwrap(), &mut [4, 5]);
995 assert_eq!(c.next().unwrap(), &mut [2, 3]);
996 assert_eq!(c.next().unwrap(), &mut [0, 1]);
997 assert_eq!(c.next(), None);
999 let mut v = [0, 1, 2, 3, 4, 5, 6, 7];
1000 let mut c = v.rchunks_mut(3);
1001 assert_eq!(c.next().unwrap(), &mut [5, 6, 7]);
1002 assert_eq!(c.next().unwrap(), &mut [2, 3, 4]);
1003 assert_eq!(c.next().unwrap(), &mut [0, 1]);
1004 assert_eq!(c.next(), None);
1008 fn test_rchunks_mut_next_back() {
1009 let mut v = [0, 1, 2, 3, 4, 5];
1010 let mut c = v.rchunks_mut(2);
1011 assert_eq!(c.next_back().unwrap(), &mut [0, 1]);
1012 assert_eq!(c.next_back().unwrap(), &mut [2, 3]);
1013 assert_eq!(c.next_back().unwrap(), &mut [4, 5]);
1014 assert_eq!(c.next_back(), None);
1016 let mut v = [0, 1, 2, 3, 4, 5, 6, 7];
1017 let mut c = v.rchunks_mut(3);
1018 assert_eq!(c.next_back().unwrap(), &mut [0, 1]);
1019 assert_eq!(c.next_back().unwrap(), &mut [2, 3, 4]);
1020 assert_eq!(c.next_back().unwrap(), &mut [5, 6, 7]);
1021 assert_eq!(c.next_back(), None);
1025 fn test_rchunks_mut_last() {
1026 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1027 let c = v.rchunks_mut(2);
1028 assert_eq!(c.last().unwrap(), &[0, 1]);
1030 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
1031 let c2 = v2.rchunks_mut(2);
1032 assert_eq!(c2.last().unwrap(), &[0]);
1036 fn test_rchunks_mut_zip() {
1037 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
1038 let v2: &[i32] = &[6, 7, 8, 9, 10];
1040 for (a, b) in v1.rchunks_mut(2).zip(v2.rchunks(2)) {
1041 let sum = b.iter().sum::<i32>();
1046 assert_eq!(v1, [6, 16, 17, 22, 23]);
1050 fn test_rchunks_exact_count() {
1051 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1052 let c = v.rchunks_exact(3);
1053 assert_eq!(c.count(), 2);
1055 let v2: &[i32] = &[0, 1, 2, 3, 4];
1056 let c2 = v2.rchunks_exact(2);
1057 assert_eq!(c2.count(), 2);
1059 let v3: &[i32] = &[];
1060 let c3 = v3.rchunks_exact(2);
1061 assert_eq!(c3.count(), 0);
1065 fn test_rchunks_exact_nth() {
1066 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1067 let mut c = v.rchunks_exact(2);
1068 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
1069 assert_eq!(c.next().unwrap(), &[0, 1]);
1071 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
1072 let mut c2 = v2.rchunks_exact(3);
1073 assert_eq!(c2.nth(1).unwrap(), &[1, 2, 3]);
1074 assert_eq!(c2.next(), None);
1078 fn test_rchunks_exact_nth_back() {
1079 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1080 let mut c = v.rchunks_exact(2);
1081 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
1082 assert_eq!(c.next_back().unwrap(), &[4, 5]);
1084 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
1085 let mut c2 = v2.rchunks_exact(3);
1086 assert_eq!(c2.nth_back(1).unwrap(), &[4, 5, 6]);
1087 assert_eq!(c2.next(), None);
1091 fn test_rchunks_exact_last() {
1092 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1093 let c = v.rchunks_exact(2);
1094 assert_eq!(c.last().unwrap(), &[0, 1]);
1096 let v2: &[i32] = &[0, 1, 2, 3, 4];
1097 let c2 = v2.rchunks_exact(2);
1098 assert_eq!(c2.last().unwrap(), &[1, 2]);
1102 fn test_rchunks_exact_remainder() {
1103 let v: &[i32] = &[0, 1, 2, 3, 4];
1104 let c = v.rchunks_exact(2);
1105 assert_eq!(c.remainder(), &[0]);
1109 fn test_rchunks_exact_zip() {
1110 let v1: &[i32] = &[0, 1, 2, 3, 4];
1111 let v2: &[i32] = &[6, 7, 8, 9, 10];
1115 .zip(v2.rchunks_exact(2))
1116 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
1117 .collect::<Vec<_>>();
1118 assert_eq!(res, vec![26, 18]);
1122 fn test_rchunks_exact_mut_count() {
1123 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1124 let c = v.rchunks_exact_mut(3);
1125 assert_eq!(c.count(), 2);
1127 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
1128 let c2 = v2.rchunks_exact_mut(2);
1129 assert_eq!(c2.count(), 2);
1131 let v3: &mut [i32] = &mut [];
1132 let c3 = v3.rchunks_exact_mut(2);
1133 assert_eq!(c3.count(), 0);
1137 fn test_rchunks_exact_mut_nth() {
1138 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1139 let mut c = v.rchunks_exact_mut(2);
1140 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
1141 assert_eq!(c.next().unwrap(), &[0, 1]);
1143 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
1144 let mut c2 = v2.rchunks_exact_mut(3);
1145 assert_eq!(c2.nth(1).unwrap(), &[1, 2, 3]);
1146 assert_eq!(c2.next(), None);
1150 fn test_rchunks_exact_mut_nth_back() {
1151 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1152 let mut c = v.rchunks_exact_mut(2);
1153 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
1154 assert_eq!(c.next_back().unwrap(), &[4, 5]);
1156 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
1157 let mut c2 = v2.rchunks_exact_mut(3);
1158 assert_eq!(c2.nth_back(1).unwrap(), &[4, 5, 6]);
1159 assert_eq!(c2.next(), None);
1163 fn test_rchunks_exact_mut_last() {
1164 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1165 let c = v.rchunks_exact_mut(2);
1166 assert_eq!(c.last().unwrap(), &[0, 1]);
1168 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
1169 let c2 = v2.rchunks_exact_mut(2);
1170 assert_eq!(c2.last().unwrap(), &[1, 2]);
1174 fn test_rchunks_exact_mut_remainder() {
1175 let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
1176 let c = v.rchunks_exact_mut(2);
1177 assert_eq!(c.into_remainder(), &[0]);
1181 fn test_rchunks_exact_mut_zip() {
1182 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
1183 let v2: &[i32] = &[6, 7, 8, 9, 10];
1185 for (a, b) in v1.rchunks_exact_mut(2).zip(v2.rchunks_exact(2)) {
1186 let sum = b.iter().sum::<i32>();
1191 assert_eq!(v1, [0, 16, 17, 22, 23]);
1195 fn chunks_mut_are_send_and_sync() {
1196 use std::cell::Cell;
1197 use std::slice::{ChunksExactMut, ChunksMut, RChunksExactMut, RChunksMut};
1198 use std::sync::MutexGuard;
1201 fn assert_send_and_sync()
1203 ChunksMut<'static, Cell<i32>>: Send,
1204 ChunksMut<'static, MutexGuard<'static, u32>>: Sync,
1205 ChunksExactMut<'static, Cell<i32>>: Send,
1206 ChunksExactMut<'static, MutexGuard<'static, u32>>: Sync,
1207 RChunksMut<'static, Cell<i32>>: Send,
1208 RChunksMut<'static, MutexGuard<'static, u32>>: Sync,
1209 RChunksExactMut<'static, Cell<i32>>: Send,
1210 RChunksExactMut<'static, MutexGuard<'static, u32>>: Sync,
1216 fn test_windows_count() {
1217 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1218 let c = v.windows(3);
1219 assert_eq!(c.count(), 4);
1221 let v2: &[i32] = &[0, 1, 2, 3, 4];
1222 let c2 = v2.windows(6);
1223 assert_eq!(c2.count(), 0);
1225 let v3: &[i32] = &[];
1226 let c3 = v3.windows(2);
1227 assert_eq!(c3.count(), 0);
1229 let v4 = &[(); usize::MAX];
1230 let c4 = v4.windows(1);
1231 assert_eq!(c4.count(), usize::MAX);
1235 fn test_windows_nth() {
1236 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1237 let mut c = v.windows(2);
1238 assert_eq!(c.nth(2).unwrap()[1], 3);
1239 assert_eq!(c.next().unwrap()[0], 3);
1241 let v2: &[i32] = &[0, 1, 2, 3, 4];
1242 let mut c2 = v2.windows(4);
1243 assert_eq!(c2.nth(1).unwrap()[1], 2);
1244 assert_eq!(c2.next(), None);
1248 fn test_windows_nth_back() {
1249 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1250 let mut c = v.windows(2);
1251 assert_eq!(c.nth_back(2).unwrap()[0], 2);
1252 assert_eq!(c.next_back().unwrap()[1], 2);
1254 let v2: &[i32] = &[0, 1, 2, 3, 4];
1255 let mut c2 = v2.windows(4);
1256 assert_eq!(c2.nth_back(1).unwrap()[1], 1);
1257 assert_eq!(c2.next_back(), None);
1261 fn test_windows_last() {
1262 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1263 let c = v.windows(2);
1264 assert_eq!(c.last().unwrap()[1], 5);
1266 let v2: &[i32] = &[0, 1, 2, 3, 4];
1267 let c2 = v2.windows(2);
1268 assert_eq!(c2.last().unwrap()[0], 3);
1272 fn test_windows_zip() {
1273 let v1: &[i32] = &[0, 1, 2, 3, 4];
1274 let v2: &[i32] = &[6, 7, 8, 9, 10];
1279 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
1280 .collect::<Vec<_>>();
1282 assert_eq!(res, [14, 18, 22, 26]);
1287 fn test_iter_ref_consistency() {
1288 use std::fmt::Debug;
1290 fn test<T: Copy + Debug + PartialEq>(x: T) {
1291 let v: &[T] = &[x, x, x];
1292 let v_ptrs: [*const T; 3] = match v {
1293 [ref v1, ref v2, ref v3] => [v1 as *const _, v2 as *const _, v3 as *const _],
1294 _ => unreachable!(),
1300 assert_eq!(&v[i] as *const _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1301 let nth = v.iter().nth(i).unwrap();
1302 assert_eq!(nth as *const _, v_ptrs[i]);
1304 assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1306 // stepping through with nth(0)
1308 let mut it = v.iter();
1310 let next = it.nth(0).unwrap();
1311 assert_eq!(next as *const _, v_ptrs[i]);
1313 assert_eq!(it.nth(0), None);
1318 let mut it = v.iter();
1320 let remaining = len - i;
1321 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1323 let next = it.next().unwrap();
1324 assert_eq!(next as *const _, v_ptrs[i]);
1326 assert_eq!(it.size_hint(), (0, Some(0)));
1327 assert_eq!(it.next(), None, "The final call to next() should return None");
1332 let mut it = v.iter();
1334 let remaining = len - i;
1335 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1337 let prev = it.next_back().unwrap();
1338 assert_eq!(prev as *const _, v_ptrs[remaining - 1]);
1340 assert_eq!(it.size_hint(), (0, Some(0)));
1341 assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1345 fn test_mut<T: Copy + Debug + PartialEq>(x: T) {
1346 let v: &mut [T] = &mut [x, x, x];
1347 let v_ptrs: [*mut T; 3] = match v {
1348 [ref v1, ref v2, ref v3] => {
1349 [v1 as *const _ as *mut _, v2 as *const _ as *mut _, v3 as *const _ as *mut _]
1351 _ => unreachable!(),
1357 assert_eq!(&mut v[i] as *mut _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1358 let nth = v.iter_mut().nth(i).unwrap();
1359 assert_eq!(nth as *mut _, v_ptrs[i]);
1361 assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1363 // stepping through with nth(0)
1365 let mut it = v.iter();
1367 let next = it.nth(0).unwrap();
1368 assert_eq!(next as *const _, v_ptrs[i]);
1370 assert_eq!(it.nth(0), None);
1375 let mut it = v.iter_mut();
1377 let remaining = len - i;
1378 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1380 let next = it.next().unwrap();
1381 assert_eq!(next as *mut _, v_ptrs[i]);
1383 assert_eq!(it.size_hint(), (0, Some(0)));
1384 assert_eq!(it.next(), None, "The final call to next() should return None");
1389 let mut it = v.iter_mut();
1391 let remaining = len - i;
1392 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1394 let prev = it.next_back().unwrap();
1395 assert_eq!(prev as *mut _, v_ptrs[remaining - 1]);
1397 assert_eq!(it.size_hint(), (0, Some(0)));
1398 assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1402 // Make sure iterators and slice patterns yield consistent addresses for various types,
1406 test([0u32; 0]); // ZST with alignment > 0
1409 test_mut([0u32; 0]); // ZST with alignment > 0
1412 // The current implementation of SliceIndex fails to handle methods
1413 // orthogonally from range types; therefore, it is worth testing
1414 // all of the indexing operations on each input.
1416 // This checks all six indexing methods, given an input range that
1417 // should succeed. (it is NOT suitable for testing invalid inputs)
1418 macro_rules! assert_range_eq {
1419 ($arr:expr, $range:expr, $expected:expr) => {
1421 let mut expected = $expected;
1424 let expected: &[_] = &expected;
1426 assert_eq!(&s[$range], expected, "(in assertion for: index)");
1427 assert_eq!(s.get($range), Some(expected), "(in assertion for: get)");
1430 s.get_unchecked($range),
1432 "(in assertion for: get_unchecked)",
1437 let s: &mut [_] = &mut arr;
1438 let expected: &mut [_] = &mut expected;
1440 assert_eq!(&mut s[$range], expected, "(in assertion for: index_mut)",);
1443 Some(&mut expected[..]),
1444 "(in assertion for: get_mut)",
1448 s.get_unchecked_mut($range),
1450 "(in assertion for: get_unchecked_mut)",
1457 // Make sure the macro can actually detect bugs,
1458 // because if it can't, then what are we even doing here?
1460 // (Be aware this only demonstrates the ability to detect bugs
1461 // in the FIRST method that panics, as the macro is not designed
1462 // to be used in `should_panic`)
1464 #[should_panic(expected = "out of range")]
1465 fn assert_range_eq_can_fail_by_panic() {
1466 assert_range_eq!([0, 1, 2], 0..5, [0, 1, 2]);
1469 // (Be aware this only demonstrates the ability to detect bugs
1470 // in the FIRST method it calls, as the macro is not designed
1471 // to be used in `should_panic`)
1473 #[should_panic(expected = "==")]
1474 fn assert_range_eq_can_fail_by_inequality() {
1475 assert_range_eq!([0, 1, 2], 0..2, [0, 1, 2]);
1478 // Test cases for bad index operations.
1480 // This generates `should_panic` test cases for Index/IndexMut
1481 // and `None` test cases for get/get_mut.
1482 macro_rules! panic_cases {
1484 // each test case needs a unique name to namespace the tests
1485 in mod $case_name:ident {
1490 // one or more similar inputs for which data[input] succeeds,
1491 // and the corresponding output as an array. This helps validate
1492 // "critical points" where an input range straddles the boundary
1493 // between valid and invalid.
1494 // (such as the input `len..len`, which is just barely valid)
1496 good: data[$good:expr] == $output:expr;
1499 bad: data[$bad:expr];
1500 message: $expect_msg:expr;
1504 #[allow(unused_imports)]
1505 use core::ops::Bound;
1511 $( assert_range_eq!($data, $good, $output); )*
1515 assert_eq!(v.get($bad), None, "(in None assertion for get)");
1519 let v: &mut [_] = &mut v;
1520 assert_eq!(v.get_mut($bad), None, "(in None assertion for get_mut)");
1525 #[should_panic(expected = $expect_msg)]
1533 #[should_panic(expected = $expect_msg)]
1534 fn index_mut_fail() {
1536 let v: &mut [_] = &mut v;
1537 let _v = &mut v[$bad];
1545 let v = [0, 1, 2, 3, 4, 5];
1547 assert_range_eq!(v, .., [0, 1, 2, 3, 4, 5]);
1548 assert_range_eq!(v, ..2, [0, 1]);
1549 assert_range_eq!(v, ..=1, [0, 1]);
1550 assert_range_eq!(v, 2.., [2, 3, 4, 5]);
1551 assert_range_eq!(v, 1..4, [1, 2, 3]);
1552 assert_range_eq!(v, 1..=3, [1, 2, 3]);
1556 in mod rangefrom_len {
1557 data: [0, 1, 2, 3, 4, 5];
1559 good: data[6..] == [];
1561 message: "out of range";
1564 in mod rangeto_len {
1565 data: [0, 1, 2, 3, 4, 5];
1567 good: data[..6] == [0, 1, 2, 3, 4, 5];
1569 message: "out of range";
1572 in mod rangetoinclusive_len {
1573 data: [0, 1, 2, 3, 4, 5];
1575 good: data[..=5] == [0, 1, 2, 3, 4, 5];
1577 message: "out of range";
1580 in mod rangeinclusive_len {
1581 data: [0, 1, 2, 3, 4, 5];
1583 good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1585 message: "out of range";
1588 in mod range_len_len {
1589 data: [0, 1, 2, 3, 4, 5];
1591 good: data[6..6] == [];
1593 message: "out of range";
1596 in mod rangeinclusive_len_len {
1597 data: [0, 1, 2, 3, 4, 5];
1599 good: data[6..=5] == [];
1601 message: "out of range";
1604 in mod boundpair_len {
1605 data: [0, 1, 2, 3, 4, 5];
1607 good: data[(Bound::Included(6), Bound::Unbounded)] == [];
1608 good: data[(Bound::Unbounded, Bound::Included(5))] == [0, 1, 2, 3, 4, 5];
1609 good: data[(Bound::Unbounded, Bound::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1610 good: data[(Bound::Included(0), Bound::Included(5))] == [0, 1, 2, 3, 4, 5];
1611 good: data[(Bound::Included(0), Bound::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1612 good: data[(Bound::Included(2), Bound::Excluded(4))] == [2, 3];
1613 good: data[(Bound::Excluded(1), Bound::Included(4))] == [2, 3, 4];
1614 good: data[(Bound::Excluded(5), Bound::Excluded(6))] == [];
1615 good: data[(Bound::Included(6), Bound::Excluded(6))] == [];
1616 good: data[(Bound::Excluded(5), Bound::Included(5))] == [];
1617 good: data[(Bound::Included(6), Bound::Included(5))] == [];
1618 bad: data[(Bound::Unbounded, Bound::Included(6))];
1619 message: "out of range";
1624 in mod rangeinclusive_exhausted {
1625 data: [0, 1, 2, 3, 4, 5];
1627 good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1629 let mut iter = 0..=5;
1630 iter.by_ref().count(); // exhaust it
1634 // 0..=6 is out of range before exhaustion, so it
1635 // stands to reason that it still would be after.
1637 let mut iter = 0..=6;
1638 iter.by_ref().count(); // exhaust it
1641 message: "out of range";
1646 in mod range_neg_width {
1647 data: [0, 1, 2, 3, 4, 5];
1649 good: data[4..4] == [];
1651 message: "but ends at";
1654 in mod rangeinclusive_neg_width {
1655 data: [0, 1, 2, 3, 4, 5];
1657 good: data[4..=3] == [];
1659 message: "but ends at";
1662 in mod boundpair_neg_width {
1663 data: [0, 1, 2, 3, 4, 5];
1665 good: data[(Bound::Included(4), Bound::Excluded(4))] == [];
1666 bad: data[(Bound::Included(4), Bound::Excluded(3))];
1667 message: "but ends at";
1672 in mod rangeinclusive_overflow {
1675 // note: using 0 specifically ensures that the result of overflowing is 0..0,
1676 // so that `get` doesn't simply return None for the wrong reason.
1677 bad: data[0 ..= usize::MAX];
1678 message: "maximum usize";
1681 in mod rangetoinclusive_overflow {
1684 bad: data[..= usize::MAX];
1685 message: "maximum usize";
1688 in mod boundpair_overflow_end {
1691 bad: data[(Bound::Unbounded, Bound::Included(usize::MAX))];
1692 message: "maximum usize";
1695 in mod boundpair_overflow_start {
1698 bad: data[(Bound::Excluded(usize::MAX), Bound::Unbounded)];
1699 message: "maximum usize";
1705 fn test_find_rfind() {
1706 let v = [0, 1, 2, 3, 4, 5];
1707 let mut iter = v.iter();
1708 let mut i = v.len();
1709 while let Some(&elt) = iter.rfind(|_| true) {
1711 assert_eq!(elt, v[i]);
1714 assert_eq!(v.iter().rfind(|&&x| x <= 3), Some(&3));
1718 fn test_iter_folds() {
1719 let a = [1, 2, 3, 4, 5]; // len>4 so the unroll is used
1720 assert_eq!(a.iter().fold(0, |acc, &x| 2 * acc + x), 57);
1721 assert_eq!(a.iter().rfold(0, |acc, &x| 2 * acc + x), 129);
1722 let fold = |acc: i32, &x| acc.checked_mul(2)?.checked_add(x);
1723 assert_eq!(a.iter().try_fold(0, &fold), Some(57));
1724 assert_eq!(a.iter().try_rfold(0, &fold), Some(129));
1726 // short-circuiting try_fold, through other methods
1727 let a = [0, 1, 2, 3, 5, 5, 5, 7, 8, 9];
1728 let mut iter = a.iter();
1729 assert_eq!(iter.position(|&x| x == 3), Some(3));
1730 assert_eq!(iter.rfind(|&&x| x == 5), Some(&5));
1731 assert_eq!(iter.len(), 2);
1735 fn test_rotate_left() {
1736 const N: usize = 600;
1737 let a: &mut [_] = &mut [0; N];
1746 assert_eq!(a[(i + k) % N], i);
1751 fn test_rotate_right() {
1752 const N: usize = 600;
1753 let a: &mut [_] = &mut [0; N];
1761 assert_eq!(a[(i + 42) % N], i);
1766 #[cfg_attr(miri, ignore)] // Miri is too slow
1767 fn brute_force_rotate_test_0() {
1768 // In case of edge cases involving multiple algorithms
1772 let mut v = Vec::with_capacity(len);
1776 v[..].rotate_right(s);
1777 for i in 0..v.len() {
1778 assert_eq!(v[i], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1785 fn brute_force_rotate_test_1() {
1786 // `ptr_rotate` covers so many kinds of pointer usage, that this is just a good test for
1787 // pointers in general. This uses a `[usize; 4]` to hit all algorithms without overwhelming miri
1791 let mut v: Vec<[usize; 4]> = Vec::with_capacity(len);
1793 v.push([i, 0, 0, 0]);
1795 v[..].rotate_right(s);
1796 for i in 0..v.len() {
1797 assert_eq!(v[i][0], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1804 #[cfg(not(target_arch = "wasm32"))]
1805 fn sort_unstable() {
1806 use core::cmp::Ordering::{Equal, Greater, Less};
1807 use core::slice::heapsort;
1808 use rand::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng};
1810 // Miri is too slow (but still need to `chain` to make the types match)
1811 let lens = if cfg!(miri) { (2..20).chain(0..0) } else { (2..25).chain(500..510) };
1812 let rounds = if cfg!(miri) { 1 } else { 100 };
1814 let mut v = [0; 600];
1815 let mut tmp = [0; 600];
1816 let mut rng = StdRng::from_entropy();
1819 let v = &mut v[0..len];
1820 let tmp = &mut tmp[0..len];
1822 for &modulus in &[5, 10, 100, 1000] {
1823 for _ in 0..rounds {
1825 v[i] = rng.gen::<i32>() % modulus;
1828 // Sort in default order.
1829 tmp.copy_from_slice(v);
1830 tmp.sort_unstable();
1831 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1833 // Sort in ascending order.
1834 tmp.copy_from_slice(v);
1835 tmp.sort_unstable_by(|a, b| a.cmp(b));
1836 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1838 // Sort in descending order.
1839 tmp.copy_from_slice(v);
1840 tmp.sort_unstable_by(|a, b| b.cmp(a));
1841 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1843 // Test heapsort using `<` operator.
1844 tmp.copy_from_slice(v);
1845 heapsort(tmp, |a, b| a < b);
1846 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1848 // Test heapsort using `>` operator.
1849 tmp.copy_from_slice(v);
1850 heapsort(tmp, |a, b| a > b);
1851 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1856 // Sort using a completely random comparison function.
1857 // This will reorder the elements *somehow*, but won't panic.
1858 for i in 0..v.len() {
1861 v.sort_unstable_by(|_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1863 for i in 0..v.len() {
1864 assert_eq!(v[i], i as i32);
1867 // Should not panic.
1868 [0i32; 0].sort_unstable();
1869 [(); 10].sort_unstable();
1870 [(); 100].sort_unstable();
1872 let mut v = [0xDEADBEEFu64];
1874 assert!(v == [0xDEADBEEF]);
1878 #[cfg(not(target_arch = "wasm32"))]
1879 #[cfg_attr(miri, ignore)] // Miri is too slow
1880 fn select_nth_unstable() {
1881 use core::cmp::Ordering::{Equal, Greater, Less};
1882 use rand::rngs::StdRng;
1883 use rand::seq::SliceRandom;
1884 use rand::{Rng, SeedableRng};
1886 let mut rng = StdRng::from_entropy();
1888 for len in (2..21).chain(500..501) {
1889 let mut orig = vec![0; len];
1891 for &modulus in &[5, 10, 1000] {
1894 orig[i] = rng.gen::<i32>() % modulus;
1898 let mut v = orig.clone();
1903 // Sort in default order.
1904 for pivot in 0..len {
1905 let mut v = orig.clone();
1906 v.select_nth_unstable(pivot);
1908 assert_eq!(v_sorted[pivot], v[pivot]);
1910 for j in pivot..len {
1911 assert!(v[i] <= v[j]);
1916 // Sort in ascending order.
1917 for pivot in 0..len {
1918 let mut v = orig.clone();
1919 let (left, pivot, right) = v.select_nth_unstable_by(pivot, |a, b| a.cmp(b));
1921 assert_eq!(left.len() + right.len(), len - 1);
1924 assert!(l <= pivot);
1925 for r in right.iter_mut() {
1927 assert!(pivot <= r);
1932 // Sort in descending order.
1933 let sort_descending_comparator = |a: &i32, b: &i32| b.cmp(a);
1934 let v_sorted_descending = {
1935 let mut v = orig.clone();
1936 v.sort_by(sort_descending_comparator);
1940 for pivot in 0..len {
1941 let mut v = orig.clone();
1942 v.select_nth_unstable_by(pivot, sort_descending_comparator);
1944 assert_eq!(v_sorted_descending[pivot], v[pivot]);
1946 for j in pivot..len {
1947 assert!(v[j] <= v[i]);
1955 // Sort at index using a completely random comparison function.
1956 // This will reorder the elements *somehow*, but won't panic.
1957 let mut v = [0; 500];
1958 for i in 0..v.len() {
1962 for pivot in 0..v.len() {
1963 v.select_nth_unstable_by(pivot, |_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1965 for i in 0..v.len() {
1966 assert_eq!(v[i], i as i32);
1970 // Should not panic.
1971 [(); 10].select_nth_unstable(0);
1972 [(); 10].select_nth_unstable(5);
1973 [(); 10].select_nth_unstable(9);
1974 [(); 100].select_nth_unstable(0);
1975 [(); 100].select_nth_unstable(50);
1976 [(); 100].select_nth_unstable(99);
1978 let mut v = [0xDEADBEEFu64];
1979 v.select_nth_unstable(0);
1980 assert!(v == [0xDEADBEEF]);
1984 #[should_panic(expected = "index 0 greater than length of slice")]
1985 fn select_nth_unstable_zero_length() {
1986 [0i32; 0].select_nth_unstable(0);
1990 #[should_panic(expected = "index 20 greater than length of slice")]
1991 fn select_nth_unstable_past_length() {
1992 [0i32; 10].select_nth_unstable(20);
1996 use core::slice::memchr::{memchr, memrchr};
1998 // test fallback implementations on all platforms
2001 assert_eq!(Some(0), memchr(b'a', b"a"));
2005 fn matches_begin() {
2006 assert_eq!(Some(0), memchr(b'a', b"aaaa"));
2011 assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
2016 assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
2020 fn matches_past_nul() {
2021 assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
2025 fn no_match_empty() {
2026 assert_eq!(None, memchr(b'a', b""));
2031 assert_eq!(None, memchr(b'a', b"xyz"));
2035 fn matches_one_reversed() {
2036 assert_eq!(Some(0), memrchr(b'a', b"a"));
2040 fn matches_begin_reversed() {
2041 assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
2045 fn matches_end_reversed() {
2046 assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
2050 fn matches_nul_reversed() {
2051 assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
2055 fn matches_past_nul_reversed() {
2056 assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
2060 fn no_match_empty_reversed() {
2061 assert_eq!(None, memrchr(b'a', b""));
2065 fn no_match_reversed() {
2066 assert_eq!(None, memrchr(b'a', b"xyz"));
2070 fn each_alignment_reversed() {
2071 let mut data = [1u8; 64];
2075 for start in 0..16 {
2076 assert_eq!(Some(pos - start), memrchr(needle, &data[start..]));
2082 fn test_align_to_simple() {
2083 let bytes = [1u8, 2, 3, 4, 5, 6, 7];
2084 let (prefix, aligned, suffix) = unsafe { bytes.align_to::<u16>() };
2085 assert_eq!(aligned.len(), 3);
2086 assert!(prefix == [1] || suffix == [7]);
2087 let expect1 = [1 << 8 | 2, 3 << 8 | 4, 5 << 8 | 6];
2088 let expect2 = [1 | 2 << 8, 3 | 4 << 8, 5 | 6 << 8];
2089 let expect3 = [2 << 8 | 3, 4 << 8 | 5, 6 << 8 | 7];
2090 let expect4 = [2 | 3 << 8, 4 | 5 << 8, 6 | 7 << 8];
2092 aligned == expect1 || aligned == expect2 || aligned == expect3 || aligned == expect4,
2093 "aligned={:?} expected={:?} || {:?} || {:?} || {:?}",
2103 fn test_align_to_zst() {
2104 let bytes = [1, 2, 3, 4, 5, 6, 7];
2105 let (prefix, aligned, suffix) = unsafe { bytes.align_to::<()>() };
2106 assert_eq!(aligned.len(), 0);
2107 assert!(prefix == [1, 2, 3, 4, 5, 6, 7] || suffix == [1, 2, 3, 4, 5, 6, 7]);
2111 fn test_align_to_non_trivial() {
2113 struct U64(u64, u64);
2115 struct U64U64U32(u64, u64, u32);
2126 let (prefix, aligned, suffix) = unsafe { data.align_to::<U64U64U32>() };
2127 assert_eq!(aligned.len(), 4);
2128 assert_eq!(prefix.len() + suffix.len(), 2);
2132 fn test_align_to_empty_mid() {
2135 // Make sure that we do not create empty unaligned slices for the mid part, even when the
2136 // overall slice is too short to contain an aligned address.
2137 let bytes = [1, 2, 3, 4, 5, 6, 7];
2139 for offset in 0..4 {
2140 let (_, mid, _) = unsafe { bytes[offset..offset + 1].align_to::<Chunk>() };
2141 assert_eq!(mid.as_ptr() as usize % mem::align_of::<Chunk>(), 0);
2146 fn test_align_to_mut_aliasing() {
2147 let mut val = [1u8, 2, 3, 4, 5];
2148 // `align_to_mut` used to create `mid` in a way that there was some intermediate
2149 // incorrect aliasing, invalidating the resulting `mid` slice.
2150 let (begin, mid, end) = unsafe { val.align_to_mut::<[u8; 2]>() };
2151 assert!(begin.len() == 0);
2152 assert!(end.len() == 1);
2154 assert_eq!(val, [3, 4, 3, 4, 5])
2158 fn test_slice_partition_dedup_by() {
2159 let mut slice: [i32; 9] = [1, -1, 2, 3, 1, -5, 5, -2, 2];
2161 let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.abs() == b.abs());
2163 assert_eq!(dedup, [1, 2, 3, 1, -5, -2]);
2164 assert_eq!(duplicates, [5, -1, 2]);
2168 fn test_slice_partition_dedup_empty() {
2169 let mut slice: [i32; 0] = [];
2171 let (dedup, duplicates) = slice.partition_dedup();
2173 assert_eq!(dedup, []);
2174 assert_eq!(duplicates, []);
2178 fn test_slice_partition_dedup_one() {
2179 let mut slice = [12];
2181 let (dedup, duplicates) = slice.partition_dedup();
2183 assert_eq!(dedup, [12]);
2184 assert_eq!(duplicates, []);
2188 fn test_slice_partition_dedup_multiple_ident() {
2189 let mut slice = [12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11];
2191 let (dedup, duplicates) = slice.partition_dedup();
2193 assert_eq!(dedup, [12, 11]);
2194 assert_eq!(duplicates, [12, 12, 12, 12, 11, 11, 11, 11, 11]);
2198 fn test_slice_partition_dedup_partialeq() {
2200 struct Foo(i32, i32);
2202 impl PartialEq for Foo {
2203 fn eq(&self, other: &Foo) -> bool {
2208 let mut slice = [Foo(0, 1), Foo(0, 5), Foo(1, 7), Foo(1, 9)];
2210 let (dedup, duplicates) = slice.partition_dedup();
2212 assert_eq!(dedup, [Foo(0, 1), Foo(1, 7)]);
2213 assert_eq!(duplicates, [Foo(0, 5), Foo(1, 9)]);
2217 fn test_copy_within() {
2218 // Start to end, with a RangeTo.
2219 let mut bytes = *b"Hello, World!";
2220 bytes.copy_within(..3, 10);
2221 assert_eq!(&bytes, b"Hello, WorHel");
2223 // End to start, with a RangeFrom.
2224 let mut bytes = *b"Hello, World!";
2225 bytes.copy_within(10.., 0);
2226 assert_eq!(&bytes, b"ld!lo, World!");
2228 // Overlapping, with a RangeInclusive.
2229 let mut bytes = *b"Hello, World!";
2230 bytes.copy_within(0..=11, 1);
2231 assert_eq!(&bytes, b"HHello, World");
2233 // Whole slice, with a RangeFull.
2234 let mut bytes = *b"Hello, World!";
2235 bytes.copy_within(.., 0);
2236 assert_eq!(&bytes, b"Hello, World!");
2238 // Ensure that copying at the end of slice won't cause UB.
2239 let mut bytes = *b"Hello, World!";
2240 bytes.copy_within(13..13, 5);
2241 assert_eq!(&bytes, b"Hello, World!");
2242 bytes.copy_within(5..5, 13);
2243 assert_eq!(&bytes, b"Hello, World!");
2247 #[should_panic(expected = "range end index 14 out of range for slice of length 13")]
2248 fn test_copy_within_panics_src_too_long() {
2249 let mut bytes = *b"Hello, World!";
2250 // The length is only 13, so 14 is out of bounds.
2251 bytes.copy_within(10..14, 0);
2255 #[should_panic(expected = "dest is out of bounds")]
2256 fn test_copy_within_panics_dest_too_long() {
2257 let mut bytes = *b"Hello, World!";
2258 // The length is only 13, so a slice of length 4 starting at index 10 is out of bounds.
2259 bytes.copy_within(0..4, 10);
2263 #[should_panic(expected = "slice index starts at 2 but ends at 1")]
2264 fn test_copy_within_panics_src_inverted() {
2265 let mut bytes = *b"Hello, World!";
2266 // 2 is greater than 1, so this range is invalid.
2267 bytes.copy_within(2..1, 0);
2270 #[should_panic(expected = "attempted to index slice up to maximum usize")]
2271 fn test_copy_within_panics_src_out_of_bounds() {
2272 let mut bytes = *b"Hello, World!";
2273 // an inclusive range ending at usize::MAX would make src_end overflow
2274 bytes.copy_within(usize::MAX..=usize::MAX, 0);
2278 fn test_is_sorted() {
2279 let empty: [i32; 0] = [];
2281 assert!([1, 2, 2, 9].is_sorted());
2282 assert!(![1, 3, 2].is_sorted());
2283 assert!([0].is_sorted());
2284 assert!(empty.is_sorted());
2285 assert!(![0.0, 1.0, f32::NAN].is_sorted());
2286 assert!([-2, -1, 0, 3].is_sorted());
2287 assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
2288 assert!(!["c", "bb", "aaa"].is_sorted());
2289 assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
2293 fn test_slice_run_destructors() {
2294 // Make sure that destructors get run on slice literals
2299 impl<'a> Drop for Foo<'a> {
2300 fn drop(&mut self) {
2301 self.x.set(self.x.get() + 1);
2305 fn foo(x: &Cell<isize>) -> Foo<'_> {
2309 let x = &Cell::new(0);
2313 assert_eq!(l[0].x.get(), 0);
2316 assert_eq!(x.get(), 1);
2320 fn test_const_from_ref() {
2321 const VALUE: &i32 = &1;
2322 const SLICE: &[i32] = core::slice::from_ref(VALUE);
2324 assert!(core::ptr::eq(VALUE, &SLICE[0]))
2328 fn test_slice_fill_with_uninit() {
2329 // This should not UB. See #87891
2330 let mut a = [MaybeUninit::<u8>::uninit(); 10];
2331 a.fill(MaybeUninit::uninit());
2336 let mut x = ["a", "b", "c", "d"];
2338 assert_eq!(x, ["a", "d", "c", "b"]);
2340 assert_eq!(x, ["b", "d", "c", "a"]);
2345 #[should_panic(expected = "index out of bounds: the len is 4 but the index is 4")]
2346 fn index_a_equals_len() {
2347 let mut x = ["a", "b", "c", "d"];
2352 #[should_panic(expected = "index out of bounds: the len is 4 but the index is 4")]
2353 fn index_b_equals_len() {
2354 let mut x = ["a", "b", "c", "d"];
2359 #[should_panic(expected = "index out of bounds: the len is 4 but the index is 5")]
2360 fn index_a_greater_than_len() {
2361 let mut x = ["a", "b", "c", "d"];
2366 #[should_panic(expected = "index out of bounds: the len is 4 but the index is 5")]
2367 fn index_b_greater_than_len() {
2368 let mut x = ["a", "b", "c", "d"];
2374 fn slice_split_array_mut() {
2375 let v = &mut [1, 2, 3, 4, 5, 6][..];
2378 let (left, right) = v.split_array_mut::<0>();
2379 assert_eq!(left, &mut []);
2380 assert_eq!(right, [1, 2, 3, 4, 5, 6]);
2384 let (left, right) = v.split_array_mut::<6>();
2385 assert_eq!(left, &mut [1, 2, 3, 4, 5, 6]);
2386 assert_eq!(right, []);
2391 fn slice_rsplit_array_mut() {
2392 let v = &mut [1, 2, 3, 4, 5, 6][..];
2395 let (left, right) = v.rsplit_array_mut::<0>();
2396 assert_eq!(left, [1, 2, 3, 4, 5, 6]);
2397 assert_eq!(right, &mut []);
2401 let (left, right) = v.rsplit_array_mut::<6>();
2402 assert_eq!(left, []);
2403 assert_eq!(right, &mut [1, 2, 3, 4, 5, 6]);
2408 fn split_as_slice() {
2409 let arr = [1, 2, 3, 4, 5, 6];
2410 let mut split = arr.split(|v| v % 2 == 0);
2411 assert_eq!(split.as_slice(), &[1, 2, 3, 4, 5, 6]);
2412 assert!(split.next().is_some());
2413 assert_eq!(split.as_slice(), &[3, 4, 5, 6]);
2414 assert!(split.next().is_some());
2415 assert!(split.next().is_some());
2416 assert_eq!(split.as_slice(), &[]);
2421 fn slice_split_array_ref_out_of_bounds() {
2422 let v = &[1, 2, 3, 4, 5, 6][..];
2424 let _ = v.split_array_ref::<7>();
2429 fn slice_split_array_mut_out_of_bounds() {
2430 let v = &mut [1, 2, 3, 4, 5, 6][..];
2432 let _ = v.split_array_mut::<7>();
2437 fn slice_rsplit_array_ref_out_of_bounds() {
2438 let v = &[1, 2, 3, 4, 5, 6][..];
2440 let _ = v.rsplit_array_ref::<7>();
2445 fn slice_rsplit_array_mut_out_of_bounds() {
2446 let v = &mut [1, 2, 3, 4, 5, 6][..];
2448 let _ = v.rsplit_array_mut::<7>();
2451 macro_rules! take_tests {
2452 (slice: &[], $($tts:tt)*) => {
2453 take_tests!(ty: &[()], slice: &[], $($tts)*);
2455 (slice: &mut [], $($tts:tt)*) => {
2456 take_tests!(ty: &mut [()], slice: &mut [], $($tts)*);
2458 (slice: &$slice:expr, $($tts:tt)*) => {
2459 take_tests!(ty: &[_], slice: &$slice, $($tts)*);
2461 (slice: &mut $slice:expr, $($tts:tt)*) => {
2462 take_tests!(ty: &mut [_], slice: &mut $slice, $($tts)*);
2464 (ty: $ty:ty, slice: $slice:expr, method: $method:ident, $(($test_name:ident, ($($args:expr),*), $output:expr, $remaining:expr),)*) => {
2468 let mut slice: $ty = $slice;
2469 assert_eq!($output, slice.$method($($args)*));
2470 let remaining: $ty = $remaining;
2471 assert_eq!(remaining, slice);
2478 slice: &[0, 1, 2, 3], method: take,
2479 (take_in_bounds_range_to, (..1), Some(&[0] as _), &[1, 2, 3]),
2480 (take_in_bounds_range_to_inclusive, (..=0), Some(&[0] as _), &[1, 2, 3]),
2481 (take_in_bounds_range_from, (2..), Some(&[2, 3] as _), &[0, 1]),
2482 (take_oob_range_to, (..5), None, &[0, 1, 2, 3]),
2483 (take_oob_range_to_inclusive, (..=4), None, &[0, 1, 2, 3]),
2484 (take_oob_range_from, (5..), None, &[0, 1, 2, 3]),
2488 slice: &mut [0, 1, 2, 3], method: take_mut,
2489 (take_mut_in_bounds_range_to, (..1), Some(&mut [0] as _), &mut [1, 2, 3]),
2490 (take_mut_in_bounds_range_to_inclusive, (..=0), Some(&mut [0] as _), &mut [1, 2, 3]),
2491 (take_mut_in_bounds_range_from, (2..), Some(&mut [2, 3] as _), &mut [0, 1]),
2492 (take_mut_oob_range_to, (..5), None, &mut [0, 1, 2, 3]),
2493 (take_mut_oob_range_to_inclusive, (..=4), None, &mut [0, 1, 2, 3]),
2494 (take_mut_oob_range_from, (5..), None, &mut [0, 1, 2, 3]),
2498 slice: &[1, 2], method: take_first,
2499 (take_first_nonempty, (), Some(&1), &[2]),
2503 slice: &mut [1, 2], method: take_first_mut,
2504 (take_first_mut_nonempty, (), Some(&mut 1), &mut [2]),
2508 slice: &[1, 2], method: take_last,
2509 (take_last_nonempty, (), Some(&2), &[1]),
2513 slice: &mut [1, 2], method: take_last_mut,
2514 (take_last_mut_nonempty, (), Some(&mut 2), &mut [1]),
2518 slice: &[], method: take_first,
2519 (take_first_empty, (), None, &[]),
2523 slice: &mut [], method: take_first_mut,
2524 (take_first_mut_empty, (), None, &mut []),
2528 slice: &[], method: take_last,
2529 (take_last_empty, (), None, &[]),
2533 slice: &mut [], method: take_last_mut,
2534 (take_last_mut_empty, (), None, &mut []),
2537 #[cfg(not(miri))] // unused in Miri
2538 const EMPTY_MAX: &'static [()] = &[(); usize::MAX];
2540 // can't be a constant due to const mutability rules
2541 #[cfg(not(miri))] // unused in Miri
2542 macro_rules! empty_max_mut {
2544 &mut [(); usize::MAX] as _
2548 #[cfg(not(miri))] // Comparing usize::MAX many elements takes forever in Miri (and in rustc without optimizations)
2550 slice: &[(); usize::MAX], method: take,
2551 (take_in_bounds_max_range_to, (..usize::MAX), Some(EMPTY_MAX), &[(); 0]),
2552 (take_oob_max_range_to_inclusive, (..=usize::MAX), None, EMPTY_MAX),
2553 (take_in_bounds_max_range_from, (usize::MAX..), Some(&[] as _), EMPTY_MAX),
2556 #[cfg(not(miri))] // Comparing usize::MAX many elements takes forever in Miri (and in rustc without optimizations)
2558 slice: &mut [(); usize::MAX], method: take_mut,
2559 (take_mut_in_bounds_max_range_to, (..usize::MAX), Some(empty_max_mut!()), &mut [(); 0]),
2560 (take_mut_oob_max_range_to_inclusive, (..=usize::MAX), None, empty_max_mut!()),
2561 (take_mut_in_bounds_max_range_from, (usize::MAX..), Some(&mut [] as _), empty_max_mut!()),
2565 fn test_slice_from_ptr_range() {
2566 let arr = ["foo".to_owned(), "bar".to_owned()];
2567 let range = arr.as_ptr_range();
2569 assert_eq!(slice::from_ptr_range(range), &arr);
2572 let mut arr = [1, 2, 3];
2573 let range = arr.as_mut_ptr_range();
2575 assert_eq!(slice::from_mut_ptr_range(range), &mut [1, 2, 3]);
2578 let arr: [Vec<String>; 0] = [];
2579 let range = arr.as_ptr_range();
2581 assert_eq!(slice::from_ptr_range(range), &arr);
2586 #[should_panic = "slice len overflow"]
2587 fn test_flatten_size_overflow() {
2588 let x = &[[(); usize::MAX]; 2][..];
2589 let _ = x.flatten();
2593 #[should_panic = "slice len overflow"]
2594 fn test_flatten_mut_size_overflow() {
2595 let x = &mut [[(); usize::MAX]; 2][..];
2596 let _ = x.flatten_mut();