2 use core::result::Result::{Err, Ok};
6 let b = [1, 2, 3, 5, 5];
7 assert_eq!(b.iter().position(|&v| v == 9), None);
8 assert_eq!(b.iter().position(|&v| v == 5), Some(3));
9 assert_eq!(b.iter().position(|&v| v == 3), Some(2));
10 assert_eq!(b.iter().position(|&v| v == 0), None);
15 let b = [1, 2, 3, 5, 5];
16 assert_eq!(b.iter().rposition(|&v| v == 9), None);
17 assert_eq!(b.iter().rposition(|&v| v == 5), Some(4));
18 assert_eq!(b.iter().rposition(|&v| v == 3), Some(2));
19 assert_eq!(b.iter().rposition(|&v| v == 0), None);
23 fn test_binary_search() {
25 assert_eq!(b.binary_search(&5), Err(0));
28 assert_eq!(b.binary_search(&3), Err(0));
29 assert_eq!(b.binary_search(&4), Ok(0));
30 assert_eq!(b.binary_search(&5), Err(1));
32 let b = [1, 2, 4, 6, 8, 9];
33 assert_eq!(b.binary_search(&5), Err(3));
34 assert_eq!(b.binary_search(&6), Ok(3));
35 assert_eq!(b.binary_search(&7), Err(4));
36 assert_eq!(b.binary_search(&8), Ok(4));
38 let b = [1, 2, 4, 5, 6, 8];
39 assert_eq!(b.binary_search(&9), Err(6));
41 let b = [1, 2, 4, 6, 7, 8, 9];
42 assert_eq!(b.binary_search(&6), Ok(3));
43 assert_eq!(b.binary_search(&5), Err(3));
44 assert_eq!(b.binary_search(&8), Ok(5));
46 let b = [1, 2, 4, 5, 6, 8, 9];
47 assert_eq!(b.binary_search(&7), Err(5));
48 assert_eq!(b.binary_search(&0), Err(0));
50 let b = [1, 3, 3, 3, 7];
51 assert_eq!(b.binary_search(&0), Err(0));
52 assert_eq!(b.binary_search(&1), Ok(0));
53 assert_eq!(b.binary_search(&2), Err(1));
54 assert!(match b.binary_search(&3) {
58 assert!(match b.binary_search(&3) {
62 assert_eq!(b.binary_search(&4), Err(4));
63 assert_eq!(b.binary_search(&5), Err(4));
64 assert_eq!(b.binary_search(&6), Err(4));
65 assert_eq!(b.binary_search(&7), Ok(4));
66 assert_eq!(b.binary_search(&8), Err(5));
70 // Test implementation specific behavior when finding equivalent elements.
71 // It is ok to break this test but when you do a crater run is highly advisable.
72 fn test_binary_search_implementation_details() {
73 let b = [1, 1, 2, 2, 3, 3, 3];
74 assert_eq!(b.binary_search(&1), Ok(1));
75 assert_eq!(b.binary_search(&2), Ok(3));
76 assert_eq!(b.binary_search(&3), Ok(6));
77 let b = [1, 1, 1, 1, 1, 3, 3, 3, 3];
78 assert_eq!(b.binary_search(&1), Ok(4));
79 assert_eq!(b.binary_search(&3), Ok(8));
80 let b = [1, 1, 1, 1, 3, 3, 3, 3, 3];
81 assert_eq!(b.binary_search(&1), Ok(3));
82 assert_eq!(b.binary_search(&3), Ok(8));
86 fn test_partition_point() {
88 assert_eq!(b.partition_point(|&x| x < 5), 0);
91 assert_eq!(b.partition_point(|&x| x < 3), 0);
92 assert_eq!(b.partition_point(|&x| x < 4), 0);
93 assert_eq!(b.partition_point(|&x| x < 5), 1);
95 let b = [1, 2, 4, 6, 8, 9];
96 assert_eq!(b.partition_point(|&x| x < 5), 3);
97 assert_eq!(b.partition_point(|&x| x < 6), 3);
98 assert_eq!(b.partition_point(|&x| x < 7), 4);
99 assert_eq!(b.partition_point(|&x| x < 8), 4);
101 let b = [1, 2, 4, 5, 6, 8];
102 assert_eq!(b.partition_point(|&x| x < 9), 6);
104 let b = [1, 2, 4, 6, 7, 8, 9];
105 assert_eq!(b.partition_point(|&x| x < 6), 3);
106 assert_eq!(b.partition_point(|&x| x < 5), 3);
107 assert_eq!(b.partition_point(|&x| x < 8), 5);
109 let b = [1, 2, 4, 5, 6, 8, 9];
110 assert_eq!(b.partition_point(|&x| x < 7), 5);
111 assert_eq!(b.partition_point(|&x| x < 0), 0);
113 let b = [1, 3, 3, 3, 7];
114 assert_eq!(b.partition_point(|&x| x < 0), 0);
115 assert_eq!(b.partition_point(|&x| x < 1), 0);
116 assert_eq!(b.partition_point(|&x| x < 2), 1);
117 assert_eq!(b.partition_point(|&x| x < 3), 1);
118 assert_eq!(b.partition_point(|&x| x < 4), 4);
119 assert_eq!(b.partition_point(|&x| x < 5), 4);
120 assert_eq!(b.partition_point(|&x| x < 6), 4);
121 assert_eq!(b.partition_point(|&x| x < 7), 4);
122 assert_eq!(b.partition_point(|&x| x < 8), 5);
126 fn test_iterator_nth() {
127 let v: &[_] = &[0, 1, 2, 3, 4];
128 for i in 0..v.len() {
129 assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
131 assert_eq!(v.iter().nth(v.len()), None);
133 let mut iter = v.iter();
134 assert_eq!(iter.nth(2).unwrap(), &v[2]);
135 assert_eq!(iter.nth(1).unwrap(), &v[4]);
139 fn test_iterator_nth_back() {
140 let v: &[_] = &[0, 1, 2, 3, 4];
141 for i in 0..v.len() {
142 assert_eq!(v.iter().nth_back(i).unwrap(), &v[v.len() - i - 1]);
144 assert_eq!(v.iter().nth_back(v.len()), None);
146 let mut iter = v.iter();
147 assert_eq!(iter.nth_back(2).unwrap(), &v[2]);
148 assert_eq!(iter.nth_back(1).unwrap(), &v[0]);
152 fn test_iterator_last() {
153 let v: &[_] = &[0, 1, 2, 3, 4];
154 assert_eq!(v.iter().last().unwrap(), &4);
155 assert_eq!(v[..1].iter().last().unwrap(), &0);
159 fn test_iterator_count() {
160 let v: &[_] = &[0, 1, 2, 3, 4];
161 assert_eq!(v.iter().count(), 5);
163 let mut iter2 = v.iter();
166 assert_eq!(iter2.count(), 3);
170 fn test_chunks_count() {
171 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
173 assert_eq!(c.count(), 2);
175 let v2: &[i32] = &[0, 1, 2, 3, 4];
176 let c2 = v2.chunks(2);
177 assert_eq!(c2.count(), 3);
179 let v3: &[i32] = &[];
180 let c3 = v3.chunks(2);
181 assert_eq!(c3.count(), 0);
185 fn test_chunks_nth() {
186 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
187 let mut c = v.chunks(2);
188 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
189 assert_eq!(c.next().unwrap(), &[4, 5]);
191 let v2: &[i32] = &[0, 1, 2, 3, 4];
192 let mut c2 = v2.chunks(3);
193 assert_eq!(c2.nth(1).unwrap(), &[3, 4]);
194 assert_eq!(c2.next(), None);
198 fn test_chunks_nth_back() {
199 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
200 let mut c = v.chunks(2);
201 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
202 assert_eq!(c.next().unwrap(), &[0, 1]);
203 assert_eq!(c.next(), None);
205 let v2: &[i32] = &[0, 1, 2, 3, 4];
206 let mut c2 = v2.chunks(3);
207 assert_eq!(c2.nth_back(1).unwrap(), &[0, 1, 2]);
208 assert_eq!(c2.next(), None);
209 assert_eq!(c2.next_back(), None);
211 let v3: &[i32] = &[0, 1, 2, 3, 4];
212 let mut c3 = v3.chunks(10);
213 assert_eq!(c3.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
214 assert_eq!(c3.next(), None);
216 let v4: &[i32] = &[0, 1, 2];
217 let mut c4 = v4.chunks(10);
218 assert_eq!(c4.nth_back(1_000_000_000usize), None);
222 fn test_chunks_last() {
223 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
225 assert_eq!(c.last().unwrap()[1], 5);
227 let v2: &[i32] = &[0, 1, 2, 3, 4];
228 let c2 = v2.chunks(2);
229 assert_eq!(c2.last().unwrap()[0], 4);
233 fn test_chunks_zip() {
234 let v1: &[i32] = &[0, 1, 2, 3, 4];
235 let v2: &[i32] = &[6, 7, 8, 9, 10];
240 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
241 .collect::<Vec<_>>();
242 assert_eq!(res, vec![14, 22, 14]);
246 fn test_chunks_mut_count() {
247 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
248 let c = v.chunks_mut(3);
249 assert_eq!(c.count(), 2);
251 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
252 let c2 = v2.chunks_mut(2);
253 assert_eq!(c2.count(), 3);
255 let v3: &mut [i32] = &mut [];
256 let c3 = v3.chunks_mut(2);
257 assert_eq!(c3.count(), 0);
261 fn test_chunks_mut_nth() {
262 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
263 let mut c = v.chunks_mut(2);
264 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
265 assert_eq!(c.next().unwrap(), &[4, 5]);
267 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
268 let mut c2 = v2.chunks_mut(3);
269 assert_eq!(c2.nth(1).unwrap(), &[3, 4]);
270 assert_eq!(c2.next(), None);
274 fn test_chunks_mut_nth_back() {
275 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
276 let mut c = v.chunks_mut(2);
277 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
278 assert_eq!(c.next().unwrap(), &[0, 1]);
280 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
281 let mut c1 = v1.chunks_mut(3);
282 assert_eq!(c1.nth_back(1).unwrap(), &[0, 1, 2]);
283 assert_eq!(c1.next(), None);
285 let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
286 let mut c3 = v3.chunks_mut(10);
287 assert_eq!(c3.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
288 assert_eq!(c3.next(), None);
290 let v4: &mut [i32] = &mut [0, 1, 2];
291 let mut c4 = v4.chunks_mut(10);
292 assert_eq!(c4.nth_back(1_000_000_000usize), None);
296 fn test_chunks_mut_last() {
297 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
298 let c = v.chunks_mut(2);
299 assert_eq!(c.last().unwrap(), &[4, 5]);
301 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
302 let c2 = v2.chunks_mut(2);
303 assert_eq!(c2.last().unwrap(), &[4]);
307 fn test_chunks_mut_zip() {
308 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
309 let v2: &[i32] = &[6, 7, 8, 9, 10];
311 for (a, b) in v1.chunks_mut(2).zip(v2.chunks(2)) {
312 let sum = b.iter().sum::<i32>();
317 assert_eq!(v1, [13, 14, 19, 20, 14]);
321 fn test_chunks_exact_count() {
322 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
323 let c = v.chunks_exact(3);
324 assert_eq!(c.count(), 2);
326 let v2: &[i32] = &[0, 1, 2, 3, 4];
327 let c2 = v2.chunks_exact(2);
328 assert_eq!(c2.count(), 2);
330 let v3: &[i32] = &[];
331 let c3 = v3.chunks_exact(2);
332 assert_eq!(c3.count(), 0);
336 fn test_chunks_exact_nth() {
337 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
338 let mut c = v.chunks_exact(2);
339 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
340 assert_eq!(c.next().unwrap(), &[4, 5]);
342 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
343 let mut c2 = v2.chunks_exact(3);
344 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
345 assert_eq!(c2.next(), None);
349 fn test_chunks_exact_nth_back() {
350 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
351 let mut c = v.chunks_exact(2);
352 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
353 assert_eq!(c.next().unwrap(), &[0, 1]);
354 assert_eq!(c.next(), None);
356 let v2: &[i32] = &[0, 1, 2, 3, 4];
357 let mut c2 = v2.chunks_exact(3);
358 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
359 assert_eq!(c2.next(), None);
360 assert_eq!(c2.next_back(), None);
362 let v3: &[i32] = &[0, 1, 2, 3, 4];
363 let mut c3 = v3.chunks_exact(10);
364 assert_eq!(c3.nth_back(0), None);
368 fn test_chunks_exact_last() {
369 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
370 let c = v.chunks_exact(2);
371 assert_eq!(c.last().unwrap(), &[4, 5]);
373 let v2: &[i32] = &[0, 1, 2, 3, 4];
374 let c2 = v2.chunks_exact(2);
375 assert_eq!(c2.last().unwrap(), &[2, 3]);
379 fn test_chunks_exact_remainder() {
380 let v: &[i32] = &[0, 1, 2, 3, 4];
381 let c = v.chunks_exact(2);
382 assert_eq!(c.remainder(), &[4]);
386 fn test_chunks_exact_zip() {
387 let v1: &[i32] = &[0, 1, 2, 3, 4];
388 let v2: &[i32] = &[6, 7, 8, 9, 10];
392 .zip(v2.chunks_exact(2))
393 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
394 .collect::<Vec<_>>();
395 assert_eq!(res, vec![14, 22]);
399 fn test_chunks_exact_mut_count() {
400 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
401 let c = v.chunks_exact_mut(3);
402 assert_eq!(c.count(), 2);
404 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
405 let c2 = v2.chunks_exact_mut(2);
406 assert_eq!(c2.count(), 2);
408 let v3: &mut [i32] = &mut [];
409 let c3 = v3.chunks_exact_mut(2);
410 assert_eq!(c3.count(), 0);
414 fn test_chunks_exact_mut_nth() {
415 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
416 let mut c = v.chunks_exact_mut(2);
417 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
418 assert_eq!(c.next().unwrap(), &[4, 5]);
420 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
421 let mut c2 = v2.chunks_exact_mut(3);
422 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
423 assert_eq!(c2.next(), None);
427 fn test_chunks_exact_mut_nth_back() {
428 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
429 let mut c = v.chunks_exact_mut(2);
430 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
431 assert_eq!(c.next().unwrap(), &[0, 1]);
432 assert_eq!(c.next(), None);
434 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
435 let mut c2 = v2.chunks_exact_mut(3);
436 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
437 assert_eq!(c2.next(), None);
438 assert_eq!(c2.next_back(), None);
440 let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
441 let mut c3 = v3.chunks_exact_mut(10);
442 assert_eq!(c3.nth_back(0), None);
446 fn test_chunks_exact_mut_last() {
447 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
448 let c = v.chunks_exact_mut(2);
449 assert_eq!(c.last().unwrap(), &[4, 5]);
451 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
452 let c2 = v2.chunks_exact_mut(2);
453 assert_eq!(c2.last().unwrap(), &[2, 3]);
457 fn test_chunks_exact_mut_remainder() {
458 let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
459 let c = v.chunks_exact_mut(2);
460 assert_eq!(c.into_remainder(), &[4]);
464 fn test_chunks_exact_mut_zip() {
465 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
466 let v2: &[i32] = &[6, 7, 8, 9, 10];
468 for (a, b) in v1.chunks_exact_mut(2).zip(v2.chunks_exact(2)) {
469 let sum = b.iter().sum::<i32>();
474 assert_eq!(v1, [13, 14, 19, 20, 4]);
478 fn test_array_chunks_infer() {
479 let v: &[i32] = &[0, 1, 2, 3, 4, -4];
480 let c = v.array_chunks();
481 for &[a, b, c] in c {
482 assert_eq!(a + b + c, 3);
485 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
486 let total = v2.array_chunks().map(|&[a, b]| a * b).sum::<i32>();
487 assert_eq!(total, 2 * 3 + 4 * 5);
491 fn test_array_chunks_count() {
492 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
493 let c = v.array_chunks::<3>();
494 assert_eq!(c.count(), 2);
496 let v2: &[i32] = &[0, 1, 2, 3, 4];
497 let c2 = v2.array_chunks::<2>();
498 assert_eq!(c2.count(), 2);
500 let v3: &[i32] = &[];
501 let c3 = v3.array_chunks::<2>();
502 assert_eq!(c3.count(), 0);
506 fn test_array_chunks_nth() {
507 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
508 let mut c = v.array_chunks::<2>();
509 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
510 assert_eq!(c.next().unwrap(), &[4, 5]);
512 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
513 let mut c2 = v2.array_chunks::<3>();
514 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
515 assert_eq!(c2.next(), None);
519 fn test_array_chunks_nth_back() {
520 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
521 let mut c = v.array_chunks::<2>();
522 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
523 assert_eq!(c.next().unwrap(), &[0, 1]);
524 assert_eq!(c.next(), None);
526 let v2: &[i32] = &[0, 1, 2, 3, 4];
527 let mut c2 = v2.array_chunks::<3>();
528 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
529 assert_eq!(c2.next(), None);
530 assert_eq!(c2.next_back(), None);
532 let v3: &[i32] = &[0, 1, 2, 3, 4];
533 let mut c3 = v3.array_chunks::<10>();
534 assert_eq!(c3.nth_back(0), None);
538 fn test_array_chunks_last() {
539 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
540 let c = v.array_chunks::<2>();
541 assert_eq!(c.last().unwrap(), &[4, 5]);
543 let v2: &[i32] = &[0, 1, 2, 3, 4];
544 let c2 = v2.array_chunks::<2>();
545 assert_eq!(c2.last().unwrap(), &[2, 3]);
549 fn test_array_chunks_remainder() {
550 let v: &[i32] = &[0, 1, 2, 3, 4];
551 let c = v.array_chunks::<2>();
552 assert_eq!(c.remainder(), &[4]);
556 fn test_array_chunks_zip() {
557 let v1: &[i32] = &[0, 1, 2, 3, 4];
558 let v2: &[i32] = &[6, 7, 8, 9, 10];
562 .zip(v2.array_chunks::<2>())
563 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
564 .collect::<Vec<_>>();
565 assert_eq!(res, vec![14, 22]);
569 fn test_array_chunks_mut_infer() {
570 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
571 for a in v.array_chunks_mut() {
572 let sum = a.iter().sum::<i32>();
575 assert_eq!(v, &[3, 3, 3, 12, 12, 12, 6]);
577 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
578 v2.array_chunks_mut().for_each(|[a, b]| core::mem::swap(a, b));
579 assert_eq!(v2, &[1, 0, 3, 2, 5, 4, 6]);
583 fn test_array_chunks_mut_count() {
584 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
585 let c = v.array_chunks_mut::<3>();
586 assert_eq!(c.count(), 2);
588 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
589 let c2 = v2.array_chunks_mut::<2>();
590 assert_eq!(c2.count(), 2);
592 let v3: &mut [i32] = &mut [];
593 let c3 = v3.array_chunks_mut::<2>();
594 assert_eq!(c3.count(), 0);
598 fn test_array_chunks_mut_nth() {
599 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
600 let mut c = v.array_chunks_mut::<2>();
601 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
602 assert_eq!(c.next().unwrap(), &[4, 5]);
604 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
605 let mut c2 = v2.array_chunks_mut::<3>();
606 assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
607 assert_eq!(c2.next(), None);
611 fn test_array_chunks_mut_nth_back() {
612 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
613 let mut c = v.array_chunks_mut::<2>();
614 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
615 assert_eq!(c.next().unwrap(), &[0, 1]);
616 assert_eq!(c.next(), None);
618 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
619 let mut c2 = v2.array_chunks_mut::<3>();
620 assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
621 assert_eq!(c2.next(), None);
622 assert_eq!(c2.next_back(), None);
624 let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
625 let mut c3 = v3.array_chunks_mut::<10>();
626 assert_eq!(c3.nth_back(0), None);
630 fn test_array_chunks_mut_last() {
631 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
632 let c = v.array_chunks_mut::<2>();
633 assert_eq!(c.last().unwrap(), &[4, 5]);
635 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
636 let c2 = v2.array_chunks_mut::<2>();
637 assert_eq!(c2.last().unwrap(), &[2, 3]);
641 fn test_array_chunks_mut_remainder() {
642 let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
643 let c = v.array_chunks_mut::<2>();
644 assert_eq!(c.into_remainder(), &[4]);
648 fn test_array_chunks_mut_zip() {
649 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
650 let v2: &[i32] = &[6, 7, 8, 9, 10];
652 for (a, b) in v1.array_chunks_mut::<2>().zip(v2.array_chunks::<2>()) {
653 let sum = b.iter().sum::<i32>();
658 assert_eq!(v1, [13, 14, 19, 20, 4]);
662 fn test_array_windows_infer() {
663 let v: &[i32] = &[0, 1, 0, 1];
664 assert_eq!(v.array_windows::<2>().count(), 3);
665 let c = v.array_windows();
667 assert_eq!(a + b, 1);
670 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
671 let total = v2.array_windows().map(|&[a, b, c]| a + b + c).sum::<i32>();
672 assert_eq!(total, 3 + 6 + 9 + 12 + 15);
676 fn test_array_windows_count() {
677 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
678 let c = v.array_windows::<3>();
679 assert_eq!(c.count(), 4);
681 let v2: &[i32] = &[0, 1, 2, 3, 4];
682 let c2 = v2.array_windows::<6>();
683 assert_eq!(c2.count(), 0);
685 let v3: &[i32] = &[];
686 let c3 = v3.array_windows::<2>();
687 assert_eq!(c3.count(), 0);
691 fn test_array_windows_nth() {
692 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
693 let snd = v.array_windows::<4>().nth(1);
694 assert_eq!(snd, Some(&[1, 2, 3, 4]));
695 let mut arr_windows = v.array_windows::<2>();
696 assert_ne!(arr_windows.nth(0), arr_windows.nth(0));
697 let last = v.array_windows::<3>().last();
698 assert_eq!(last, Some(&[3, 4, 5]));
702 fn test_array_windows_nth_back() {
703 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
704 let snd = v.array_windows::<4>().nth_back(1);
705 assert_eq!(snd, Some(&[1, 2, 3, 4]));
706 let mut arr_windows = v.array_windows::<2>();
707 assert_ne!(arr_windows.nth_back(0), arr_windows.nth_back(0));
711 fn test_rchunks_count() {
712 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
713 let c = v.rchunks(3);
714 assert_eq!(c.count(), 2);
716 let v2: &[i32] = &[0, 1, 2, 3, 4];
717 let c2 = v2.rchunks(2);
718 assert_eq!(c2.count(), 3);
720 let v3: &[i32] = &[];
721 let c3 = v3.rchunks(2);
722 assert_eq!(c3.count(), 0);
726 fn test_rchunks_nth() {
727 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
728 let mut c = v.rchunks(2);
729 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
730 assert_eq!(c.next().unwrap(), &[0, 1]);
732 let v2: &[i32] = &[0, 1, 2, 3, 4];
733 let mut c2 = v2.rchunks(3);
734 assert_eq!(c2.nth(1).unwrap(), &[0, 1]);
735 assert_eq!(c2.next(), None);
739 fn test_rchunks_nth_back() {
740 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
741 let mut c = v.rchunks(2);
742 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
743 assert_eq!(c.next_back().unwrap(), &[4, 5]);
745 let v2: &[i32] = &[0, 1, 2, 3, 4];
746 let mut c2 = v2.rchunks(3);
747 assert_eq!(c2.nth_back(1).unwrap(), &[2, 3, 4]);
748 assert_eq!(c2.next_back(), None);
752 fn test_rchunks_last() {
753 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
754 let c = v.rchunks(2);
755 assert_eq!(c.last().unwrap()[1], 1);
757 let v2: &[i32] = &[0, 1, 2, 3, 4];
758 let c2 = v2.rchunks(2);
759 assert_eq!(c2.last().unwrap()[0], 0);
763 fn test_rchunks_zip() {
764 let v1: &[i32] = &[0, 1, 2, 3, 4];
765 let v2: &[i32] = &[6, 7, 8, 9, 10];
770 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
771 .collect::<Vec<_>>();
772 assert_eq!(res, vec![26, 18, 6]);
776 fn test_rchunks_mut_count() {
777 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
778 let c = v.rchunks_mut(3);
779 assert_eq!(c.count(), 2);
781 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
782 let c2 = v2.rchunks_mut(2);
783 assert_eq!(c2.count(), 3);
785 let v3: &mut [i32] = &mut [];
786 let c3 = v3.rchunks_mut(2);
787 assert_eq!(c3.count(), 0);
791 fn test_rchunks_mut_nth() {
792 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
793 let mut c = v.rchunks_mut(2);
794 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
795 assert_eq!(c.next().unwrap(), &[0, 1]);
797 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
798 let mut c2 = v2.rchunks_mut(3);
799 assert_eq!(c2.nth(1).unwrap(), &[0, 1]);
800 assert_eq!(c2.next(), None);
804 fn test_rchunks_mut_nth_back() {
805 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
806 let mut c = v.rchunks_mut(2);
807 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
808 assert_eq!(c.next_back().unwrap(), &[4, 5]);
810 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
811 let mut c2 = v2.rchunks_mut(3);
812 assert_eq!(c2.nth_back(1).unwrap(), &[2, 3, 4]);
813 assert_eq!(c2.next_back(), None);
817 fn test_rchunks_mut_last() {
818 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
819 let c = v.rchunks_mut(2);
820 assert_eq!(c.last().unwrap(), &[0, 1]);
822 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
823 let c2 = v2.rchunks_mut(2);
824 assert_eq!(c2.last().unwrap(), &[0]);
828 fn test_rchunks_mut_zip() {
829 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
830 let v2: &[i32] = &[6, 7, 8, 9, 10];
832 for (a, b) in v1.rchunks_mut(2).zip(v2.rchunks(2)) {
833 let sum = b.iter().sum::<i32>();
838 assert_eq!(v1, [6, 16, 17, 22, 23]);
842 fn test_rchunks_exact_count() {
843 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
844 let c = v.rchunks_exact(3);
845 assert_eq!(c.count(), 2);
847 let v2: &[i32] = &[0, 1, 2, 3, 4];
848 let c2 = v2.rchunks_exact(2);
849 assert_eq!(c2.count(), 2);
851 let v3: &[i32] = &[];
852 let c3 = v3.rchunks_exact(2);
853 assert_eq!(c3.count(), 0);
857 fn test_rchunks_exact_nth() {
858 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
859 let mut c = v.rchunks_exact(2);
860 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
861 assert_eq!(c.next().unwrap(), &[0, 1]);
863 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
864 let mut c2 = v2.rchunks_exact(3);
865 assert_eq!(c2.nth(1).unwrap(), &[1, 2, 3]);
866 assert_eq!(c2.next(), None);
870 fn test_rchunks_exact_nth_back() {
871 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
872 let mut c = v.rchunks_exact(2);
873 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
874 assert_eq!(c.next_back().unwrap(), &[4, 5]);
876 let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
877 let mut c2 = v2.rchunks_exact(3);
878 assert_eq!(c2.nth_back(1).unwrap(), &[4, 5, 6]);
879 assert_eq!(c2.next(), None);
883 fn test_rchunks_exact_last() {
884 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
885 let c = v.rchunks_exact(2);
886 assert_eq!(c.last().unwrap(), &[0, 1]);
888 let v2: &[i32] = &[0, 1, 2, 3, 4];
889 let c2 = v2.rchunks_exact(2);
890 assert_eq!(c2.last().unwrap(), &[1, 2]);
894 fn test_rchunks_exact_remainder() {
895 let v: &[i32] = &[0, 1, 2, 3, 4];
896 let c = v.rchunks_exact(2);
897 assert_eq!(c.remainder(), &[0]);
901 fn test_rchunks_exact_zip() {
902 let v1: &[i32] = &[0, 1, 2, 3, 4];
903 let v2: &[i32] = &[6, 7, 8, 9, 10];
907 .zip(v2.rchunks_exact(2))
908 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
909 .collect::<Vec<_>>();
910 assert_eq!(res, vec![26, 18]);
914 fn test_rchunks_exact_mut_count() {
915 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
916 let c = v.rchunks_exact_mut(3);
917 assert_eq!(c.count(), 2);
919 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
920 let c2 = v2.rchunks_exact_mut(2);
921 assert_eq!(c2.count(), 2);
923 let v3: &mut [i32] = &mut [];
924 let c3 = v3.rchunks_exact_mut(2);
925 assert_eq!(c3.count(), 0);
929 fn test_rchunks_exact_mut_nth() {
930 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
931 let mut c = v.rchunks_exact_mut(2);
932 assert_eq!(c.nth(1).unwrap(), &[2, 3]);
933 assert_eq!(c.next().unwrap(), &[0, 1]);
935 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
936 let mut c2 = v2.rchunks_exact_mut(3);
937 assert_eq!(c2.nth(1).unwrap(), &[1, 2, 3]);
938 assert_eq!(c2.next(), None);
942 fn test_rchunks_exact_mut_nth_back() {
943 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
944 let mut c = v.rchunks_exact_mut(2);
945 assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
946 assert_eq!(c.next_back().unwrap(), &[4, 5]);
948 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
949 let mut c2 = v2.rchunks_exact_mut(3);
950 assert_eq!(c2.nth_back(1).unwrap(), &[4, 5, 6]);
951 assert_eq!(c2.next(), None);
955 fn test_rchunks_exact_mut_last() {
956 let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
957 let c = v.rchunks_exact_mut(2);
958 assert_eq!(c.last().unwrap(), &[0, 1]);
960 let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
961 let c2 = v2.rchunks_exact_mut(2);
962 assert_eq!(c2.last().unwrap(), &[1, 2]);
966 fn test_rchunks_exact_mut_remainder() {
967 let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
968 let c = v.rchunks_exact_mut(2);
969 assert_eq!(c.into_remainder(), &[0]);
973 fn test_rchunks_exact_mut_zip() {
974 let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
975 let v2: &[i32] = &[6, 7, 8, 9, 10];
977 for (a, b) in v1.rchunks_exact_mut(2).zip(v2.rchunks_exact(2)) {
978 let sum = b.iter().sum::<i32>();
983 assert_eq!(v1, [0, 16, 17, 22, 23]);
987 fn test_windows_count() {
988 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
989 let c = v.windows(3);
990 assert_eq!(c.count(), 4);
992 let v2: &[i32] = &[0, 1, 2, 3, 4];
993 let c2 = v2.windows(6);
994 assert_eq!(c2.count(), 0);
996 let v3: &[i32] = &[];
997 let c3 = v3.windows(2);
998 assert_eq!(c3.count(), 0);
1002 fn test_windows_nth() {
1003 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1004 let mut c = v.windows(2);
1005 assert_eq!(c.nth(2).unwrap()[1], 3);
1006 assert_eq!(c.next().unwrap()[0], 3);
1008 let v2: &[i32] = &[0, 1, 2, 3, 4];
1009 let mut c2 = v2.windows(4);
1010 assert_eq!(c2.nth(1).unwrap()[1], 2);
1011 assert_eq!(c2.next(), None);
1015 fn test_windows_nth_back() {
1016 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1017 let mut c = v.windows(2);
1018 assert_eq!(c.nth_back(2).unwrap()[0], 2);
1019 assert_eq!(c.next_back().unwrap()[1], 2);
1021 let v2: &[i32] = &[0, 1, 2, 3, 4];
1022 let mut c2 = v2.windows(4);
1023 assert_eq!(c2.nth_back(1).unwrap()[1], 1);
1024 assert_eq!(c2.next_back(), None);
1028 fn test_windows_last() {
1029 let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1030 let c = v.windows(2);
1031 assert_eq!(c.last().unwrap()[1], 5);
1033 let v2: &[i32] = &[0, 1, 2, 3, 4];
1034 let c2 = v2.windows(2);
1035 assert_eq!(c2.last().unwrap()[0], 3);
1039 fn test_windows_zip() {
1040 let v1: &[i32] = &[0, 1, 2, 3, 4];
1041 let v2: &[i32] = &[6, 7, 8, 9, 10];
1046 .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
1047 .collect::<Vec<_>>();
1049 assert_eq!(res, [14, 18, 22, 26]);
1054 fn test_iter_ref_consistency() {
1055 use std::fmt::Debug;
1057 fn test<T: Copy + Debug + PartialEq>(x: T) {
1058 let v: &[T] = &[x, x, x];
1059 let v_ptrs: [*const T; 3] = match v {
1060 [ref v1, ref v2, ref v3] => [v1 as *const _, v2 as *const _, v3 as *const _],
1061 _ => unreachable!(),
1067 assert_eq!(&v[i] as *const _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1068 let nth = v.iter().nth(i).unwrap();
1069 assert_eq!(nth as *const _, v_ptrs[i]);
1071 assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1073 // stepping through with nth(0)
1075 let mut it = v.iter();
1077 let next = it.nth(0).unwrap();
1078 assert_eq!(next as *const _, v_ptrs[i]);
1080 assert_eq!(it.nth(0), None);
1085 let mut it = v.iter();
1087 let remaining = len - i;
1088 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1090 let next = it.next().unwrap();
1091 assert_eq!(next as *const _, v_ptrs[i]);
1093 assert_eq!(it.size_hint(), (0, Some(0)));
1094 assert_eq!(it.next(), None, "The final call to next() should return None");
1099 let mut it = v.iter();
1101 let remaining = len - i;
1102 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1104 let prev = it.next_back().unwrap();
1105 assert_eq!(prev as *const _, v_ptrs[remaining - 1]);
1107 assert_eq!(it.size_hint(), (0, Some(0)));
1108 assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1112 fn test_mut<T: Copy + Debug + PartialEq>(x: T) {
1113 let v: &mut [T] = &mut [x, x, x];
1114 let v_ptrs: [*mut T; 3] = match v {
1115 [ref v1, ref v2, ref v3] => {
1116 [v1 as *const _ as *mut _, v2 as *const _ as *mut _, v3 as *const _ as *mut _]
1118 _ => unreachable!(),
1124 assert_eq!(&mut v[i] as *mut _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1125 let nth = v.iter_mut().nth(i).unwrap();
1126 assert_eq!(nth as *mut _, v_ptrs[i]);
1128 assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1130 // stepping through with nth(0)
1132 let mut it = v.iter();
1134 let next = it.nth(0).unwrap();
1135 assert_eq!(next as *const _, v_ptrs[i]);
1137 assert_eq!(it.nth(0), None);
1142 let mut it = v.iter_mut();
1144 let remaining = len - i;
1145 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1147 let next = it.next().unwrap();
1148 assert_eq!(next as *mut _, v_ptrs[i]);
1150 assert_eq!(it.size_hint(), (0, Some(0)));
1151 assert_eq!(it.next(), None, "The final call to next() should return None");
1156 let mut it = v.iter_mut();
1158 let remaining = len - i;
1159 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1161 let prev = it.next_back().unwrap();
1162 assert_eq!(prev as *mut _, v_ptrs[remaining - 1]);
1164 assert_eq!(it.size_hint(), (0, Some(0)));
1165 assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1169 // Make sure iterators and slice patterns yield consistent addresses for various types,
1173 test([0u32; 0]); // ZST with alignment > 0
1176 test_mut([0u32; 0]); // ZST with alignment > 0
1179 // The current implementation of SliceIndex fails to handle methods
1180 // orthogonally from range types; therefore, it is worth testing
1181 // all of the indexing operations on each input.
1183 // This checks all six indexing methods, given an input range that
1184 // should succeed. (it is NOT suitable for testing invalid inputs)
1185 macro_rules! assert_range_eq {
1186 ($arr:expr, $range:expr, $expected:expr) => {
1188 let mut expected = $expected;
1191 let expected: &[_] = &expected;
1193 assert_eq!(&s[$range], expected, "(in assertion for: index)");
1194 assert_eq!(s.get($range), Some(expected), "(in assertion for: get)");
1197 s.get_unchecked($range),
1199 "(in assertion for: get_unchecked)",
1204 let s: &mut [_] = &mut arr;
1205 let expected: &mut [_] = &mut expected;
1207 assert_eq!(&mut s[$range], expected, "(in assertion for: index_mut)",);
1210 Some(&mut expected[..]),
1211 "(in assertion for: get_mut)",
1215 s.get_unchecked_mut($range),
1217 "(in assertion for: get_unchecked_mut)",
1224 // Make sure the macro can actually detect bugs,
1225 // because if it can't, then what are we even doing here?
1227 // (Be aware this only demonstrates the ability to detect bugs
1228 // in the FIRST method that panics, as the macro is not designed
1229 // to be used in `should_panic`)
1231 #[should_panic(expected = "out of range")]
1232 fn assert_range_eq_can_fail_by_panic() {
1233 assert_range_eq!([0, 1, 2], 0..5, [0, 1, 2]);
1236 // (Be aware this only demonstrates the ability to detect bugs
1237 // in the FIRST method it calls, as the macro is not designed
1238 // to be used in `should_panic`)
1240 #[should_panic(expected = "==")]
1241 fn assert_range_eq_can_fail_by_inequality() {
1242 assert_range_eq!([0, 1, 2], 0..2, [0, 1, 2]);
1245 // Test cases for bad index operations.
1247 // This generates `should_panic` test cases for Index/IndexMut
1248 // and `None` test cases for get/get_mut.
1249 macro_rules! panic_cases {
1251 // each test case needs a unique name to namespace the tests
1252 in mod $case_name:ident {
1257 // one or more similar inputs for which data[input] succeeds,
1258 // and the corresponding output as an array. This helps validate
1259 // "critical points" where an input range straddles the boundary
1260 // between valid and invalid.
1261 // (such as the input `len..len`, which is just barely valid)
1263 good: data[$good:expr] == $output:expr;
1266 bad: data[$bad:expr];
1267 message: $expect_msg:expr;
1275 $( assert_range_eq!($data, $good, $output); )*
1279 assert_eq!(v.get($bad), None, "(in None assertion for get)");
1283 let v: &mut [_] = &mut v;
1284 assert_eq!(v.get_mut($bad), None, "(in None assertion for get_mut)");
1289 #[should_panic(expected = $expect_msg)]
1297 #[should_panic(expected = $expect_msg)]
1298 fn index_mut_fail() {
1300 let v: &mut [_] = &mut v;
1301 let _v = &mut v[$bad];
1309 let v = [0, 1, 2, 3, 4, 5];
1311 assert_range_eq!(v, .., [0, 1, 2, 3, 4, 5]);
1312 assert_range_eq!(v, ..2, [0, 1]);
1313 assert_range_eq!(v, ..=1, [0, 1]);
1314 assert_range_eq!(v, 2.., [2, 3, 4, 5]);
1315 assert_range_eq!(v, 1..4, [1, 2, 3]);
1316 assert_range_eq!(v, 1..=3, [1, 2, 3]);
1320 in mod rangefrom_len {
1321 data: [0, 1, 2, 3, 4, 5];
1323 good: data[6..] == [];
1325 message: "out of range";
1328 in mod rangeto_len {
1329 data: [0, 1, 2, 3, 4, 5];
1331 good: data[..6] == [0, 1, 2, 3, 4, 5];
1333 message: "out of range";
1336 in mod rangetoinclusive_len {
1337 data: [0, 1, 2, 3, 4, 5];
1339 good: data[..=5] == [0, 1, 2, 3, 4, 5];
1341 message: "out of range";
1344 in mod rangeinclusive_len {
1345 data: [0, 1, 2, 3, 4, 5];
1347 good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1349 message: "out of range";
1352 in mod range_len_len {
1353 data: [0, 1, 2, 3, 4, 5];
1355 good: data[6..6] == [];
1357 message: "out of range";
1360 in mod rangeinclusive_len_len {
1361 data: [0, 1, 2, 3, 4, 5];
1363 good: data[6..=5] == [];
1365 message: "out of range";
1370 in mod rangeinclusive_exhausted {
1371 data: [0, 1, 2, 3, 4, 5];
1373 good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1375 let mut iter = 0..=5;
1376 iter.by_ref().count(); // exhaust it
1380 // 0..=6 is out of range before exhaustion, so it
1381 // stands to reason that it still would be after.
1383 let mut iter = 0..=6;
1384 iter.by_ref().count(); // exhaust it
1387 message: "out of range";
1392 in mod range_neg_width {
1393 data: [0, 1, 2, 3, 4, 5];
1395 good: data[4..4] == [];
1397 message: "but ends at";
1400 in mod rangeinclusive_neg_width {
1401 data: [0, 1, 2, 3, 4, 5];
1403 good: data[4..=3] == [];
1405 message: "but ends at";
1410 in mod rangeinclusive_overflow {
1413 // note: using 0 specifically ensures that the result of overflowing is 0..0,
1414 // so that `get` doesn't simply return None for the wrong reason.
1415 bad: data[0 ..= usize::MAX];
1416 message: "maximum usize";
1419 in mod rangetoinclusive_overflow {
1422 bad: data[..= usize::MAX];
1423 message: "maximum usize";
1429 fn test_find_rfind() {
1430 let v = [0, 1, 2, 3, 4, 5];
1431 let mut iter = v.iter();
1432 let mut i = v.len();
1433 while let Some(&elt) = iter.rfind(|_| true) {
1435 assert_eq!(elt, v[i]);
1438 assert_eq!(v.iter().rfind(|&&x| x <= 3), Some(&3));
1442 fn test_iter_folds() {
1443 let a = [1, 2, 3, 4, 5]; // len>4 so the unroll is used
1444 assert_eq!(a.iter().fold(0, |acc, &x| 2 * acc + x), 57);
1445 assert_eq!(a.iter().rfold(0, |acc, &x| 2 * acc + x), 129);
1446 let fold = |acc: i32, &x| acc.checked_mul(2)?.checked_add(x);
1447 assert_eq!(a.iter().try_fold(0, &fold), Some(57));
1448 assert_eq!(a.iter().try_rfold(0, &fold), Some(129));
1450 // short-circuiting try_fold, through other methods
1451 let a = [0, 1, 2, 3, 5, 5, 5, 7, 8, 9];
1452 let mut iter = a.iter();
1453 assert_eq!(iter.position(|&x| x == 3), Some(3));
1454 assert_eq!(iter.rfind(|&&x| x == 5), Some(&5));
1455 assert_eq!(iter.len(), 2);
1459 fn test_rotate_left() {
1460 const N: usize = 600;
1461 let a: &mut [_] = &mut [0; N];
1470 assert_eq!(a[(i + k) % N], i);
1475 fn test_rotate_right() {
1476 const N: usize = 600;
1477 let a: &mut [_] = &mut [0; N];
1485 assert_eq!(a[(i + 42) % N], i);
1490 #[cfg_attr(miri, ignore)] // Miri is too slow
1491 fn brute_force_rotate_test_0() {
1492 // In case of edge cases involving multiple algorithms
1496 let mut v = Vec::with_capacity(len);
1500 v[..].rotate_right(s);
1501 for i in 0..v.len() {
1502 assert_eq!(v[i], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1509 fn brute_force_rotate_test_1() {
1510 // `ptr_rotate` covers so many kinds of pointer usage, that this is just a good test for
1511 // pointers in general. This uses a `[usize; 4]` to hit all algorithms without overwhelming miri
1515 let mut v: Vec<[usize; 4]> = Vec::with_capacity(len);
1517 v.push([i, 0, 0, 0]);
1519 v[..].rotate_right(s);
1520 for i in 0..v.len() {
1521 assert_eq!(v[i][0], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1528 #[cfg(not(target_arch = "wasm32"))]
1529 fn sort_unstable() {
1530 use core::cmp::Ordering::{Equal, Greater, Less};
1531 use core::slice::heapsort;
1532 use rand::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng};
1534 // Miri is too slow (but still need to `chain` to make the types match)
1535 let lens = if cfg!(miri) { (2..20).chain(0..0) } else { (2..25).chain(500..510) };
1536 let rounds = if cfg!(miri) { 1 } else { 100 };
1538 let mut v = [0; 600];
1539 let mut tmp = [0; 600];
1540 let mut rng = StdRng::from_entropy();
1543 let v = &mut v[0..len];
1544 let tmp = &mut tmp[0..len];
1546 for &modulus in &[5, 10, 100, 1000] {
1547 for _ in 0..rounds {
1549 v[i] = rng.gen::<i32>() % modulus;
1552 // Sort in default order.
1553 tmp.copy_from_slice(v);
1554 tmp.sort_unstable();
1555 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1557 // Sort in ascending order.
1558 tmp.copy_from_slice(v);
1559 tmp.sort_unstable_by(|a, b| a.cmp(b));
1560 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1562 // Sort in descending order.
1563 tmp.copy_from_slice(v);
1564 tmp.sort_unstable_by(|a, b| b.cmp(a));
1565 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1567 // Test heapsort using `<` operator.
1568 tmp.copy_from_slice(v);
1569 heapsort(tmp, |a, b| a < b);
1570 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1572 // Test heapsort using `>` operator.
1573 tmp.copy_from_slice(v);
1574 heapsort(tmp, |a, b| a > b);
1575 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1580 // Sort using a completely random comparison function.
1581 // This will reorder the elements *somehow*, but won't panic.
1582 for i in 0..v.len() {
1585 v.sort_unstable_by(|_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1587 for i in 0..v.len() {
1588 assert_eq!(v[i], i as i32);
1591 // Should not panic.
1592 [0i32; 0].sort_unstable();
1593 [(); 10].sort_unstable();
1594 [(); 100].sort_unstable();
1596 let mut v = [0xDEADBEEFu64];
1598 assert!(v == [0xDEADBEEF]);
1602 #[cfg(not(target_arch = "wasm32"))]
1603 #[cfg_attr(miri, ignore)] // Miri is too slow
1604 fn select_nth_unstable() {
1605 use core::cmp::Ordering::{Equal, Greater, Less};
1606 use rand::rngs::StdRng;
1607 use rand::seq::SliceRandom;
1608 use rand::{Rng, SeedableRng};
1610 let mut rng = StdRng::from_entropy();
1612 for len in (2..21).chain(500..501) {
1613 let mut orig = vec![0; len];
1615 for &modulus in &[5, 10, 1000] {
1618 orig[i] = rng.gen::<i32>() % modulus;
1622 let mut v = orig.clone();
1627 // Sort in default order.
1628 for pivot in 0..len {
1629 let mut v = orig.clone();
1630 v.select_nth_unstable(pivot);
1632 assert_eq!(v_sorted[pivot], v[pivot]);
1634 for j in pivot..len {
1635 assert!(v[i] <= v[j]);
1640 // Sort in ascending order.
1641 for pivot in 0..len {
1642 let mut v = orig.clone();
1643 let (left, pivot, right) = v.select_nth_unstable_by(pivot, |a, b| a.cmp(b));
1645 assert_eq!(left.len() + right.len(), len - 1);
1648 assert!(l <= pivot);
1649 for r in right.iter_mut() {
1651 assert!(pivot <= r);
1656 // Sort in descending order.
1657 let sort_descending_comparator = |a: &i32, b: &i32| b.cmp(a);
1658 let v_sorted_descending = {
1659 let mut v = orig.clone();
1660 v.sort_by(sort_descending_comparator);
1664 for pivot in 0..len {
1665 let mut v = orig.clone();
1666 v.select_nth_unstable_by(pivot, sort_descending_comparator);
1668 assert_eq!(v_sorted_descending[pivot], v[pivot]);
1670 for j in pivot..len {
1671 assert!(v[j] <= v[i]);
1679 // Sort at index using a completely random comparison function.
1680 // This will reorder the elements *somehow*, but won't panic.
1681 let mut v = [0; 500];
1682 for i in 0..v.len() {
1686 for pivot in 0..v.len() {
1687 v.select_nth_unstable_by(pivot, |_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1689 for i in 0..v.len() {
1690 assert_eq!(v[i], i as i32);
1694 // Should not panic.
1695 [(); 10].select_nth_unstable(0);
1696 [(); 10].select_nth_unstable(5);
1697 [(); 10].select_nth_unstable(9);
1698 [(); 100].select_nth_unstable(0);
1699 [(); 100].select_nth_unstable(50);
1700 [(); 100].select_nth_unstable(99);
1702 let mut v = [0xDEADBEEFu64];
1703 v.select_nth_unstable(0);
1704 assert!(v == [0xDEADBEEF]);
1708 #[should_panic(expected = "index 0 greater than length of slice")]
1709 fn select_nth_unstable_zero_length() {
1710 [0i32; 0].select_nth_unstable(0);
1714 #[should_panic(expected = "index 20 greater than length of slice")]
1715 fn select_nth_unstable_past_length() {
1716 [0i32; 10].select_nth_unstable(20);
1720 use core::slice::memchr::{memchr, memrchr};
1722 // test fallback implementations on all platforms
1725 assert_eq!(Some(0), memchr(b'a', b"a"));
1729 fn matches_begin() {
1730 assert_eq!(Some(0), memchr(b'a', b"aaaa"));
1735 assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
1740 assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
1744 fn matches_past_nul() {
1745 assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
1749 fn no_match_empty() {
1750 assert_eq!(None, memchr(b'a', b""));
1755 assert_eq!(None, memchr(b'a', b"xyz"));
1759 fn matches_one_reversed() {
1760 assert_eq!(Some(0), memrchr(b'a', b"a"));
1764 fn matches_begin_reversed() {
1765 assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
1769 fn matches_end_reversed() {
1770 assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
1774 fn matches_nul_reversed() {
1775 assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
1779 fn matches_past_nul_reversed() {
1780 assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
1784 fn no_match_empty_reversed() {
1785 assert_eq!(None, memrchr(b'a', b""));
1789 fn no_match_reversed() {
1790 assert_eq!(None, memrchr(b'a', b"xyz"));
1794 fn each_alignment_reversed() {
1795 let mut data = [1u8; 64];
1799 for start in 0..16 {
1800 assert_eq!(Some(pos - start), memrchr(needle, &data[start..]));
1806 fn test_align_to_simple() {
1807 let bytes = [1u8, 2, 3, 4, 5, 6, 7];
1808 let (prefix, aligned, suffix) = unsafe { bytes.align_to::<u16>() };
1809 assert_eq!(aligned.len(), 3);
1810 assert!(prefix == [1] || suffix == [7]);
1811 let expect1 = [1 << 8 | 2, 3 << 8 | 4, 5 << 8 | 6];
1812 let expect2 = [1 | 2 << 8, 3 | 4 << 8, 5 | 6 << 8];
1813 let expect3 = [2 << 8 | 3, 4 << 8 | 5, 6 << 8 | 7];
1814 let expect4 = [2 | 3 << 8, 4 | 5 << 8, 6 | 7 << 8];
1816 aligned == expect1 || aligned == expect2 || aligned == expect3 || aligned == expect4,
1817 "aligned={:?} expected={:?} || {:?} || {:?} || {:?}",
1827 fn test_align_to_zst() {
1828 let bytes = [1, 2, 3, 4, 5, 6, 7];
1829 let (prefix, aligned, suffix) = unsafe { bytes.align_to::<()>() };
1830 assert_eq!(aligned.len(), 0);
1831 assert!(prefix == [1, 2, 3, 4, 5, 6, 7] || suffix == [1, 2, 3, 4, 5, 6, 7]);
1835 fn test_align_to_non_trivial() {
1837 struct U64(u64, u64);
1839 struct U64U64U32(u64, u64, u32);
1850 let (prefix, aligned, suffix) = unsafe { data.align_to::<U64U64U32>() };
1851 assert_eq!(aligned.len(), 4);
1852 assert_eq!(prefix.len() + suffix.len(), 2);
1856 fn test_align_to_empty_mid() {
1859 // Make sure that we do not create empty unaligned slices for the mid part, even when the
1860 // overall slice is too short to contain an aligned address.
1861 let bytes = [1, 2, 3, 4, 5, 6, 7];
1863 for offset in 0..4 {
1864 let (_, mid, _) = unsafe { bytes[offset..offset + 1].align_to::<Chunk>() };
1865 assert_eq!(mid.as_ptr() as usize % mem::align_of::<Chunk>(), 0);
1870 fn test_align_to_mut_aliasing() {
1871 let mut val = [1u8, 2, 3, 4, 5];
1872 // `align_to_mut` used to create `mid` in a way that there was some intermediate
1873 // incorrect aliasing, invalidating the resulting `mid` slice.
1874 let (begin, mid, end) = unsafe { val.align_to_mut::<[u8; 2]>() };
1875 assert!(begin.len() == 0);
1876 assert!(end.len() == 1);
1878 assert_eq!(val, [3, 4, 3, 4, 5])
1882 fn test_slice_partition_dedup_by() {
1883 let mut slice: [i32; 9] = [1, -1, 2, 3, 1, -5, 5, -2, 2];
1885 let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.abs() == b.abs());
1887 assert_eq!(dedup, [1, 2, 3, 1, -5, -2]);
1888 assert_eq!(duplicates, [5, -1, 2]);
1892 fn test_slice_partition_dedup_empty() {
1893 let mut slice: [i32; 0] = [];
1895 let (dedup, duplicates) = slice.partition_dedup();
1897 assert_eq!(dedup, []);
1898 assert_eq!(duplicates, []);
1902 fn test_slice_partition_dedup_one() {
1903 let mut slice = [12];
1905 let (dedup, duplicates) = slice.partition_dedup();
1907 assert_eq!(dedup, [12]);
1908 assert_eq!(duplicates, []);
1912 fn test_slice_partition_dedup_multiple_ident() {
1913 let mut slice = [12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11];
1915 let (dedup, duplicates) = slice.partition_dedup();
1917 assert_eq!(dedup, [12, 11]);
1918 assert_eq!(duplicates, [12, 12, 12, 12, 11, 11, 11, 11, 11]);
1922 fn test_slice_partition_dedup_partialeq() {
1924 struct Foo(i32, i32);
1926 impl PartialEq for Foo {
1927 fn eq(&self, other: &Foo) -> bool {
1932 let mut slice = [Foo(0, 1), Foo(0, 5), Foo(1, 7), Foo(1, 9)];
1934 let (dedup, duplicates) = slice.partition_dedup();
1936 assert_eq!(dedup, [Foo(0, 1), Foo(1, 7)]);
1937 assert_eq!(duplicates, [Foo(0, 5), Foo(1, 9)]);
1941 fn test_copy_within() {
1942 // Start to end, with a RangeTo.
1943 let mut bytes = *b"Hello, World!";
1944 bytes.copy_within(..3, 10);
1945 assert_eq!(&bytes, b"Hello, WorHel");
1947 // End to start, with a RangeFrom.
1948 let mut bytes = *b"Hello, World!";
1949 bytes.copy_within(10.., 0);
1950 assert_eq!(&bytes, b"ld!lo, World!");
1952 // Overlapping, with a RangeInclusive.
1953 let mut bytes = *b"Hello, World!";
1954 bytes.copy_within(0..=11, 1);
1955 assert_eq!(&bytes, b"HHello, World");
1957 // Whole slice, with a RangeFull.
1958 let mut bytes = *b"Hello, World!";
1959 bytes.copy_within(.., 0);
1960 assert_eq!(&bytes, b"Hello, World!");
1962 // Ensure that copying at the end of slice won't cause UB.
1963 let mut bytes = *b"Hello, World!";
1964 bytes.copy_within(13..13, 5);
1965 assert_eq!(&bytes, b"Hello, World!");
1966 bytes.copy_within(5..5, 13);
1967 assert_eq!(&bytes, b"Hello, World!");
1971 #[should_panic(expected = "range end index 14 out of range for slice of length 13")]
1972 fn test_copy_within_panics_src_too_long() {
1973 let mut bytes = *b"Hello, World!";
1974 // The length is only 13, so 14 is out of bounds.
1975 bytes.copy_within(10..14, 0);
1979 #[should_panic(expected = "dest is out of bounds")]
1980 fn test_copy_within_panics_dest_too_long() {
1981 let mut bytes = *b"Hello, World!";
1982 // The length is only 13, so a slice of length 4 starting at index 10 is out of bounds.
1983 bytes.copy_within(0..4, 10);
1986 #[should_panic(expected = "slice index starts at 2 but ends at 1")]
1987 fn test_copy_within_panics_src_inverted() {
1988 let mut bytes = *b"Hello, World!";
1989 // 2 is greater than 1, so this range is invalid.
1990 bytes.copy_within(2..1, 0);
1993 #[should_panic(expected = "attempted to index slice up to maximum usize")]
1994 fn test_copy_within_panics_src_out_of_bounds() {
1995 let mut bytes = *b"Hello, World!";
1996 // an inclusive range ending at usize::MAX would make src_end overflow
1997 bytes.copy_within(usize::MAX..=usize::MAX, 0);
2001 fn test_is_sorted() {
2002 let empty: [i32; 0] = [];
2004 assert!([1, 2, 2, 9].is_sorted());
2005 assert!(![1, 3, 2].is_sorted());
2006 assert!([0].is_sorted());
2007 assert!(empty.is_sorted());
2008 assert!(![0.0, 1.0, f32::NAN].is_sorted());
2009 assert!([-2, -1, 0, 3].is_sorted());
2010 assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
2011 assert!(!["c", "bb", "aaa"].is_sorted());
2012 assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
2016 fn test_slice_run_destructors() {
2017 // Make sure that destructors get run on slice literals
2022 impl<'a> Drop for Foo<'a> {
2023 fn drop(&mut self) {
2024 self.x.set(self.x.get() + 1);
2028 fn foo(x: &Cell<isize>) -> Foo<'_> {
2032 let x = &Cell::new(0);
2036 assert_eq!(l[0].x.get(), 0);
2039 assert_eq!(x.get(), 1);