2 use core
::cmp
::Ordering
;
3 use core
::result
::Result
::{Err, Ok}
;
7 let b
= [1, 2, 3, 5, 5];
8 assert_eq
!(b
.iter().position(|&v
| v
== 9), None
);
9 assert_eq
!(b
.iter().position(|&v
| v
== 5), Some(3));
10 assert_eq
!(b
.iter().position(|&v
| v
== 3), Some(2));
11 assert_eq
!(b
.iter().position(|&v
| v
== 0), None
);
16 let b
= [1, 2, 3, 5, 5];
17 assert_eq
!(b
.iter().rposition(|&v
| v
== 9), None
);
18 assert_eq
!(b
.iter().rposition(|&v
| v
== 5), Some(4));
19 assert_eq
!(b
.iter().rposition(|&v
| v
== 3), Some(2));
20 assert_eq
!(b
.iter().rposition(|&v
| v
== 0), None
);
24 fn test_binary_search() {
26 assert_eq
!(b
.binary_search(&5), Err(0));
29 assert_eq
!(b
.binary_search(&3), Err(0));
30 assert_eq
!(b
.binary_search(&4), Ok(0));
31 assert_eq
!(b
.binary_search(&5), Err(1));
33 let b
= [1, 2, 4, 6, 8, 9];
34 assert_eq
!(b
.binary_search(&5), Err(3));
35 assert_eq
!(b
.binary_search(&6), Ok(3));
36 assert_eq
!(b
.binary_search(&7), Err(4));
37 assert_eq
!(b
.binary_search(&8), Ok(4));
39 let b
= [1, 2, 4, 5, 6, 8];
40 assert_eq
!(b
.binary_search(&9), Err(6));
42 let b
= [1, 2, 4, 6, 7, 8, 9];
43 assert_eq
!(b
.binary_search(&6), Ok(3));
44 assert_eq
!(b
.binary_search(&5), Err(3));
45 assert_eq
!(b
.binary_search(&8), Ok(5));
47 let b
= [1, 2, 4, 5, 6, 8, 9];
48 assert_eq
!(b
.binary_search(&7), Err(5));
49 assert_eq
!(b
.binary_search(&0), Err(0));
51 let b
= [1, 3, 3, 3, 7];
52 assert_eq
!(b
.binary_search(&0), Err(0));
53 assert_eq
!(b
.binary_search(&1), Ok(0));
54 assert_eq
!(b
.binary_search(&2), Err(1));
55 assert
!(match b
.binary_search(&3) {
59 assert
!(match b
.binary_search(&3) {
63 assert_eq
!(b
.binary_search(&4), Err(4));
64 assert_eq
!(b
.binary_search(&5), Err(4));
65 assert_eq
!(b
.binary_search(&6), Err(4));
66 assert_eq
!(b
.binary_search(&7), Ok(4));
67 assert_eq
!(b
.binary_search(&8), Err(5));
69 let b
= [(); usize::MAX
];
70 assert_eq
!(b
.binary_search(&()), Ok(usize::MAX
/ 2));
74 fn test_binary_search_by_overflow() {
75 let b
= [(); usize::MAX
];
76 assert_eq
!(b
.binary_search_by(|_
| Ordering
::Equal
), Ok(usize::MAX
/ 2));
77 assert_eq
!(b
.binary_search_by(|_
| Ordering
::Greater
), Err(0));
78 assert_eq
!(b
.binary_search_by(|_
| Ordering
::Less
), Err(usize::MAX
));
82 // Test implementation specific behavior when finding equivalent elements.
83 // It is ok to break this test but when you do a crater run is highly advisable.
84 fn test_binary_search_implementation_details() {
85 let b
= [1, 1, 2, 2, 3, 3, 3];
86 assert_eq
!(b
.binary_search(&1), Ok(1));
87 assert_eq
!(b
.binary_search(&2), Ok(3));
88 assert_eq
!(b
.binary_search(&3), Ok(5));
89 let b
= [1, 1, 1, 1, 1, 3, 3, 3, 3];
90 assert_eq
!(b
.binary_search(&1), Ok(4));
91 assert_eq
!(b
.binary_search(&3), Ok(7));
92 let b
= [1, 1, 1, 1, 3, 3, 3, 3, 3];
93 assert_eq
!(b
.binary_search(&1), Ok(2));
94 assert_eq
!(b
.binary_search(&3), Ok(4));
98 fn test_partition_point() {
100 assert_eq
!(b
.partition_point(|&x
| x
< 5), 0);
103 assert_eq
!(b
.partition_point(|&x
| x
< 3), 0);
104 assert_eq
!(b
.partition_point(|&x
| x
< 4), 0);
105 assert_eq
!(b
.partition_point(|&x
| x
< 5), 1);
107 let b
= [1, 2, 4, 6, 8, 9];
108 assert_eq
!(b
.partition_point(|&x
| x
< 5), 3);
109 assert_eq
!(b
.partition_point(|&x
| x
< 6), 3);
110 assert_eq
!(b
.partition_point(|&x
| x
< 7), 4);
111 assert_eq
!(b
.partition_point(|&x
| x
< 8), 4);
113 let b
= [1, 2, 4, 5, 6, 8];
114 assert_eq
!(b
.partition_point(|&x
| x
< 9), 6);
116 let b
= [1, 2, 4, 6, 7, 8, 9];
117 assert_eq
!(b
.partition_point(|&x
| x
< 6), 3);
118 assert_eq
!(b
.partition_point(|&x
| x
< 5), 3);
119 assert_eq
!(b
.partition_point(|&x
| x
< 8), 5);
121 let b
= [1, 2, 4, 5, 6, 8, 9];
122 assert_eq
!(b
.partition_point(|&x
| x
< 7), 5);
123 assert_eq
!(b
.partition_point(|&x
| x
< 0), 0);
125 let b
= [1, 3, 3, 3, 7];
126 assert_eq
!(b
.partition_point(|&x
| x
< 0), 0);
127 assert_eq
!(b
.partition_point(|&x
| x
< 1), 0);
128 assert_eq
!(b
.partition_point(|&x
| x
< 2), 1);
129 assert_eq
!(b
.partition_point(|&x
| x
< 3), 1);
130 assert_eq
!(b
.partition_point(|&x
| x
< 4), 4);
131 assert_eq
!(b
.partition_point(|&x
| x
< 5), 4);
132 assert_eq
!(b
.partition_point(|&x
| x
< 6), 4);
133 assert_eq
!(b
.partition_point(|&x
| x
< 7), 4);
134 assert_eq
!(b
.partition_point(|&x
| x
< 8), 5);
138 fn test_iterator_nth() {
139 let v
: &[_
] = &[0, 1, 2, 3, 4];
140 for i
in 0..v
.len() {
141 assert_eq
!(v
.iter().nth(i
).unwrap(), &v
[i
]);
143 assert_eq
!(v
.iter().nth(v
.len()), None
);
145 let mut iter
= v
.iter();
146 assert_eq
!(iter
.nth(2).unwrap(), &v
[2]);
147 assert_eq
!(iter
.nth(1).unwrap(), &v
[4]);
151 fn test_iterator_nth_back() {
152 let v
: &[_
] = &[0, 1, 2, 3, 4];
153 for i
in 0..v
.len() {
154 assert_eq
!(v
.iter().nth_back(i
).unwrap(), &v
[v
.len() - i
- 1]);
156 assert_eq
!(v
.iter().nth_back(v
.len()), None
);
158 let mut iter
= v
.iter();
159 assert_eq
!(iter
.nth_back(2).unwrap(), &v
[2]);
160 assert_eq
!(iter
.nth_back(1).unwrap(), &v
[0]);
164 fn test_iterator_last() {
165 let v
: &[_
] = &[0, 1, 2, 3, 4];
166 assert_eq
!(v
.iter().last().unwrap(), &4);
167 assert_eq
!(v
[..1].iter().last().unwrap(), &0);
171 fn test_iterator_count() {
172 let v
: &[_
] = &[0, 1, 2, 3, 4];
173 assert_eq
!(v
.iter().count(), 5);
175 let mut iter2
= v
.iter();
178 assert_eq
!(iter2
.count(), 3);
182 fn test_chunks_count() {
183 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
185 assert_eq
!(c
.count(), 2);
187 let v2
: &[i32] = &[0, 1, 2, 3, 4];
188 let c2
= v2
.chunks(2);
189 assert_eq
!(c2
.count(), 3);
191 let v3
: &[i32] = &[];
192 let c3
= v3
.chunks(2);
193 assert_eq
!(c3
.count(), 0);
197 fn test_chunks_nth() {
198 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
199 let mut c
= v
.chunks(2);
200 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
201 assert_eq
!(c
.next().unwrap(), &[4, 5]);
203 let v2
: &[i32] = &[0, 1, 2, 3, 4];
204 let mut c2
= v2
.chunks(3);
205 assert_eq
!(c2
.nth(1).unwrap(), &[3, 4]);
206 assert_eq
!(c2
.next(), None
);
210 fn test_chunks_nth_back() {
211 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
212 let mut c
= v
.chunks(2);
213 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
214 assert_eq
!(c
.next().unwrap(), &[0, 1]);
215 assert_eq
!(c
.next(), None
);
217 let v2
: &[i32] = &[0, 1, 2, 3, 4];
218 let mut c2
= v2
.chunks(3);
219 assert_eq
!(c2
.nth_back(1).unwrap(), &[0, 1, 2]);
220 assert_eq
!(c2
.next(), None
);
221 assert_eq
!(c2
.next_back(), None
);
223 let v3
: &[i32] = &[0, 1, 2, 3, 4];
224 let mut c3
= v3
.chunks(10);
225 assert_eq
!(c3
.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
226 assert_eq
!(c3
.next(), None
);
228 let v4
: &[i32] = &[0, 1, 2];
229 let mut c4
= v4
.chunks(10);
230 assert_eq
!(c4
.nth_back(1_000_000_000usize
), None
);
234 fn test_chunks_last() {
235 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
237 assert_eq
!(c
.last().unwrap()[1], 5);
239 let v2
: &[i32] = &[0, 1, 2, 3, 4];
240 let c2
= v2
.chunks(2);
241 assert_eq
!(c2
.last().unwrap()[0], 4);
245 fn test_chunks_zip() {
246 let v1
: &[i32] = &[0, 1, 2, 3, 4];
247 let v2
: &[i32] = &[6, 7, 8, 9, 10];
252 .map(|(a
, b
)| a
.iter().sum
::<i32>() + b
.iter().sum
::<i32>())
253 .collect
::<Vec
<_
>>();
254 assert_eq
!(res
, vec
![14, 22, 14]);
258 fn test_chunks_mut_count() {
259 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
260 let c
= v
.chunks_mut(3);
261 assert_eq
!(c
.count(), 2);
263 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
264 let c2
= v2
.chunks_mut(2);
265 assert_eq
!(c2
.count(), 3);
267 let v3
: &mut [i32] = &mut [];
268 let c3
= v3
.chunks_mut(2);
269 assert_eq
!(c3
.count(), 0);
273 fn test_chunks_mut_nth() {
274 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
275 let mut c
= v
.chunks_mut(2);
276 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
277 assert_eq
!(c
.next().unwrap(), &[4, 5]);
279 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
280 let mut c2
= v2
.chunks_mut(3);
281 assert_eq
!(c2
.nth(1).unwrap(), &[3, 4]);
282 assert_eq
!(c2
.next(), None
);
286 fn test_chunks_mut_nth_back() {
287 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
288 let mut c
= v
.chunks_mut(2);
289 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
290 assert_eq
!(c
.next().unwrap(), &[0, 1]);
292 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
293 let mut c1
= v1
.chunks_mut(3);
294 assert_eq
!(c1
.nth_back(1).unwrap(), &[0, 1, 2]);
295 assert_eq
!(c1
.next(), None
);
297 let v3
: &mut [i32] = &mut [0, 1, 2, 3, 4];
298 let mut c3
= v3
.chunks_mut(10);
299 assert_eq
!(c3
.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
300 assert_eq
!(c3
.next(), None
);
302 let v4
: &mut [i32] = &mut [0, 1, 2];
303 let mut c4
= v4
.chunks_mut(10);
304 assert_eq
!(c4
.nth_back(1_000_000_000usize
), None
);
308 fn test_chunks_mut_last() {
309 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
310 let c
= v
.chunks_mut(2);
311 assert_eq
!(c
.last().unwrap(), &[4, 5]);
313 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
314 let c2
= v2
.chunks_mut(2);
315 assert_eq
!(c2
.last().unwrap(), &[4]);
319 fn test_chunks_mut_zip() {
320 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
321 let v2
: &[i32] = &[6, 7, 8, 9, 10];
323 for (a
, b
) in v1
.chunks_mut(2).zip(v2
.chunks(2)) {
324 let sum
= b
.iter().sum
::<i32>();
329 assert_eq
!(v1
, [13, 14, 19, 20, 14]);
333 fn test_chunks_exact_count() {
334 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
335 let c
= v
.chunks_exact(3);
336 assert_eq
!(c
.count(), 2);
338 let v2
: &[i32] = &[0, 1, 2, 3, 4];
339 let c2
= v2
.chunks_exact(2);
340 assert_eq
!(c2
.count(), 2);
342 let v3
: &[i32] = &[];
343 let c3
= v3
.chunks_exact(2);
344 assert_eq
!(c3
.count(), 0);
348 fn test_chunks_exact_nth() {
349 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
350 let mut c
= v
.chunks_exact(2);
351 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
352 assert_eq
!(c
.next().unwrap(), &[4, 5]);
354 let v2
: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
355 let mut c2
= v2
.chunks_exact(3);
356 assert_eq
!(c2
.nth(1).unwrap(), &[3, 4, 5]);
357 assert_eq
!(c2
.next(), None
);
361 fn test_chunks_exact_nth_back() {
362 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
363 let mut c
= v
.chunks_exact(2);
364 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
365 assert_eq
!(c
.next().unwrap(), &[0, 1]);
366 assert_eq
!(c
.next(), None
);
368 let v2
: &[i32] = &[0, 1, 2, 3, 4];
369 let mut c2
= v2
.chunks_exact(3);
370 assert_eq
!(c2
.nth_back(0).unwrap(), &[0, 1, 2]);
371 assert_eq
!(c2
.next(), None
);
372 assert_eq
!(c2
.next_back(), None
);
374 let v3
: &[i32] = &[0, 1, 2, 3, 4];
375 let mut c3
= v3
.chunks_exact(10);
376 assert_eq
!(c3
.nth_back(0), None
);
380 fn test_chunks_exact_last() {
381 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
382 let c
= v
.chunks_exact(2);
383 assert_eq
!(c
.last().unwrap(), &[4, 5]);
385 let v2
: &[i32] = &[0, 1, 2, 3, 4];
386 let c2
= v2
.chunks_exact(2);
387 assert_eq
!(c2
.last().unwrap(), &[2, 3]);
391 fn test_chunks_exact_remainder() {
392 let v
: &[i32] = &[0, 1, 2, 3, 4];
393 let c
= v
.chunks_exact(2);
394 assert_eq
!(c
.remainder(), &[4]);
398 fn test_chunks_exact_zip() {
399 let v1
: &[i32] = &[0, 1, 2, 3, 4];
400 let v2
: &[i32] = &[6, 7, 8, 9, 10];
404 .zip(v2
.chunks_exact(2))
405 .map(|(a
, b
)| a
.iter().sum
::<i32>() + b
.iter().sum
::<i32>())
406 .collect
::<Vec
<_
>>();
407 assert_eq
!(res
, vec
![14, 22]);
411 fn test_chunks_exact_mut_count() {
412 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
413 let c
= v
.chunks_exact_mut(3);
414 assert_eq
!(c
.count(), 2);
416 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
417 let c2
= v2
.chunks_exact_mut(2);
418 assert_eq
!(c2
.count(), 2);
420 let v3
: &mut [i32] = &mut [];
421 let c3
= v3
.chunks_exact_mut(2);
422 assert_eq
!(c3
.count(), 0);
426 fn test_chunks_exact_mut_nth() {
427 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
428 let mut c
= v
.chunks_exact_mut(2);
429 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
430 assert_eq
!(c
.next().unwrap(), &[4, 5]);
432 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
433 let mut c2
= v2
.chunks_exact_mut(3);
434 assert_eq
!(c2
.nth(1).unwrap(), &[3, 4, 5]);
435 assert_eq
!(c2
.next(), None
);
439 fn test_chunks_exact_mut_nth_back() {
440 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
441 let mut c
= v
.chunks_exact_mut(2);
442 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
443 assert_eq
!(c
.next().unwrap(), &[0, 1]);
444 assert_eq
!(c
.next(), None
);
446 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
447 let mut c2
= v2
.chunks_exact_mut(3);
448 assert_eq
!(c2
.nth_back(0).unwrap(), &[0, 1, 2]);
449 assert_eq
!(c2
.next(), None
);
450 assert_eq
!(c2
.next_back(), None
);
452 let v3
: &mut [i32] = &mut [0, 1, 2, 3, 4];
453 let mut c3
= v3
.chunks_exact_mut(10);
454 assert_eq
!(c3
.nth_back(0), None
);
458 fn test_chunks_exact_mut_last() {
459 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
460 let c
= v
.chunks_exact_mut(2);
461 assert_eq
!(c
.last().unwrap(), &[4, 5]);
463 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
464 let c2
= v2
.chunks_exact_mut(2);
465 assert_eq
!(c2
.last().unwrap(), &[2, 3]);
469 fn test_chunks_exact_mut_remainder() {
470 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4];
471 let c
= v
.chunks_exact_mut(2);
472 assert_eq
!(c
.into_remainder(), &[4]);
476 fn test_chunks_exact_mut_zip() {
477 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
478 let v2
: &[i32] = &[6, 7, 8, 9, 10];
480 for (a
, b
) in v1
.chunks_exact_mut(2).zip(v2
.chunks_exact(2)) {
481 let sum
= b
.iter().sum
::<i32>();
486 assert_eq
!(v1
, [13, 14, 19, 20, 4]);
490 fn test_array_chunks_infer() {
491 let v
: &[i32] = &[0, 1, 2, 3, 4, -4];
492 let c
= v
.array_chunks();
493 for &[a
, b
, c
] in c
{
494 assert_eq
!(a
+ b
+ c
, 3);
497 let v2
: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
498 let total
= v2
.array_chunks().map(|&[a
, b
]| a
* b
).sum
::<i32>();
499 assert_eq
!(total
, 2 * 3 + 4 * 5);
503 fn test_array_chunks_count() {
504 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
505 let c
= v
.array_chunks
::<3>();
506 assert_eq
!(c
.count(), 2);
508 let v2
: &[i32] = &[0, 1, 2, 3, 4];
509 let c2
= v2
.array_chunks
::<2>();
510 assert_eq
!(c2
.count(), 2);
512 let v3
: &[i32] = &[];
513 let c3
= v3
.array_chunks
::<2>();
514 assert_eq
!(c3
.count(), 0);
518 fn test_array_chunks_nth() {
519 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
520 let mut c
= v
.array_chunks
::<2>();
521 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
522 assert_eq
!(c
.next().unwrap(), &[4, 5]);
524 let v2
: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
525 let mut c2
= v2
.array_chunks
::<3>();
526 assert_eq
!(c2
.nth(1).unwrap(), &[3, 4, 5]);
527 assert_eq
!(c2
.next(), None
);
531 fn test_array_chunks_nth_back() {
532 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
533 let mut c
= v
.array_chunks
::<2>();
534 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
535 assert_eq
!(c
.next().unwrap(), &[0, 1]);
536 assert_eq
!(c
.next(), None
);
538 let v2
: &[i32] = &[0, 1, 2, 3, 4];
539 let mut c2
= v2
.array_chunks
::<3>();
540 assert_eq
!(c2
.nth_back(0).unwrap(), &[0, 1, 2]);
541 assert_eq
!(c2
.next(), None
);
542 assert_eq
!(c2
.next_back(), None
);
544 let v3
: &[i32] = &[0, 1, 2, 3, 4];
545 let mut c3
= v3
.array_chunks
::<10>();
546 assert_eq
!(c3
.nth_back(0), None
);
550 fn test_array_chunks_last() {
551 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
552 let c
= v
.array_chunks
::<2>();
553 assert_eq
!(c
.last().unwrap(), &[4, 5]);
555 let v2
: &[i32] = &[0, 1, 2, 3, 4];
556 let c2
= v2
.array_chunks
::<2>();
557 assert_eq
!(c2
.last().unwrap(), &[2, 3]);
561 fn test_array_chunks_remainder() {
562 let v
: &[i32] = &[0, 1, 2, 3, 4];
563 let c
= v
.array_chunks
::<2>();
564 assert_eq
!(c
.remainder(), &[4]);
568 fn test_array_chunks_zip() {
569 let v1
: &[i32] = &[0, 1, 2, 3, 4];
570 let v2
: &[i32] = &[6, 7, 8, 9, 10];
574 .zip(v2
.array_chunks
::<2>())
575 .map(|(a
, b
)| a
.iter().sum
::<i32>() + b
.iter().sum
::<i32>())
576 .collect
::<Vec
<_
>>();
577 assert_eq
!(res
, vec
![14, 22]);
581 fn test_array_chunks_mut_infer() {
582 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
583 for a
in v
.array_chunks_mut() {
584 let sum
= a
.iter().sum
::<i32>();
587 assert_eq
!(v
, &[3, 3, 3, 12, 12, 12, 6]);
589 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
590 v2
.array_chunks_mut().for_each(|[a
, b
]| core
::mem
::swap(a
, b
));
591 assert_eq
!(v2
, &[1, 0, 3, 2, 5, 4, 6]);
595 fn test_array_chunks_mut_count() {
596 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
597 let c
= v
.array_chunks_mut
::<3>();
598 assert_eq
!(c
.count(), 2);
600 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
601 let c2
= v2
.array_chunks_mut
::<2>();
602 assert_eq
!(c2
.count(), 2);
604 let v3
: &mut [i32] = &mut [];
605 let c3
= v3
.array_chunks_mut
::<2>();
606 assert_eq
!(c3
.count(), 0);
610 fn test_array_chunks_mut_nth() {
611 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
612 let mut c
= v
.array_chunks_mut
::<2>();
613 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
614 assert_eq
!(c
.next().unwrap(), &[4, 5]);
616 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
617 let mut c2
= v2
.array_chunks_mut
::<3>();
618 assert_eq
!(c2
.nth(1).unwrap(), &[3, 4, 5]);
619 assert_eq
!(c2
.next(), None
);
623 fn test_array_chunks_mut_nth_back() {
624 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
625 let mut c
= v
.array_chunks_mut
::<2>();
626 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
627 assert_eq
!(c
.next().unwrap(), &[0, 1]);
628 assert_eq
!(c
.next(), None
);
630 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
631 let mut c2
= v2
.array_chunks_mut
::<3>();
632 assert_eq
!(c2
.nth_back(0).unwrap(), &[0, 1, 2]);
633 assert_eq
!(c2
.next(), None
);
634 assert_eq
!(c2
.next_back(), None
);
636 let v3
: &mut [i32] = &mut [0, 1, 2, 3, 4];
637 let mut c3
= v3
.array_chunks_mut
::<10>();
638 assert_eq
!(c3
.nth_back(0), None
);
642 fn test_array_chunks_mut_last() {
643 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
644 let c
= v
.array_chunks_mut
::<2>();
645 assert_eq
!(c
.last().unwrap(), &[4, 5]);
647 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
648 let c2
= v2
.array_chunks_mut
::<2>();
649 assert_eq
!(c2
.last().unwrap(), &[2, 3]);
653 fn test_array_chunks_mut_remainder() {
654 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4];
655 let c
= v
.array_chunks_mut
::<2>();
656 assert_eq
!(c
.into_remainder(), &[4]);
660 fn test_array_chunks_mut_zip() {
661 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
662 let v2
: &[i32] = &[6, 7, 8, 9, 10];
664 for (a
, b
) in v1
.array_chunks_mut
::<2>().zip(v2
.array_chunks
::<2>()) {
665 let sum
= b
.iter().sum
::<i32>();
670 assert_eq
!(v1
, [13, 14, 19, 20, 4]);
674 fn test_array_windows_infer() {
675 let v
: &[i32] = &[0, 1, 0, 1];
676 assert_eq
!(v
.array_windows
::<2>().count(), 3);
677 let c
= v
.array_windows();
679 assert_eq
!(a
+ b
, 1);
682 let v2
: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
683 let total
= v2
.array_windows().map(|&[a
, b
, c
]| a
+ b
+ c
).sum
::<i32>();
684 assert_eq
!(total
, 3 + 6 + 9 + 12 + 15);
688 fn test_array_windows_count() {
689 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
690 let c
= v
.array_windows
::<3>();
691 assert_eq
!(c
.count(), 4);
693 let v2
: &[i32] = &[0, 1, 2, 3, 4];
694 let c2
= v2
.array_windows
::<6>();
695 assert_eq
!(c2
.count(), 0);
697 let v3
: &[i32] = &[];
698 let c3
= v3
.array_windows
::<2>();
699 assert_eq
!(c3
.count(), 0);
703 fn test_array_windows_nth() {
704 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
705 let snd
= v
.array_windows
::<4>().nth(1);
706 assert_eq
!(snd
, Some(&[1, 2, 3, 4]));
707 let mut arr_windows
= v
.array_windows
::<2>();
708 assert_ne
!(arr_windows
.nth(0), arr_windows
.nth(0));
709 let last
= v
.array_windows
::<3>().last();
710 assert_eq
!(last
, Some(&[3, 4, 5]));
714 fn test_array_windows_nth_back() {
715 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
716 let snd
= v
.array_windows
::<4>().nth_back(1);
717 assert_eq
!(snd
, Some(&[1, 2, 3, 4]));
718 let mut arr_windows
= v
.array_windows
::<2>();
719 assert_ne
!(arr_windows
.nth_back(0), arr_windows
.nth_back(0));
723 fn test_rchunks_count() {
724 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
725 let c
= v
.rchunks(3);
726 assert_eq
!(c
.count(), 2);
728 let v2
: &[i32] = &[0, 1, 2, 3, 4];
729 let c2
= v2
.rchunks(2);
730 assert_eq
!(c2
.count(), 3);
732 let v3
: &[i32] = &[];
733 let c3
= v3
.rchunks(2);
734 assert_eq
!(c3
.count(), 0);
738 fn test_rchunks_nth() {
739 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
740 let mut c
= v
.rchunks(2);
741 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
742 assert_eq
!(c
.next().unwrap(), &[0, 1]);
744 let v2
: &[i32] = &[0, 1, 2, 3, 4];
745 let mut c2
= v2
.rchunks(3);
746 assert_eq
!(c2
.nth(1).unwrap(), &[0, 1]);
747 assert_eq
!(c2
.next(), None
);
751 fn test_rchunks_nth_back() {
752 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
753 let mut c
= v
.rchunks(2);
754 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
755 assert_eq
!(c
.next_back().unwrap(), &[4, 5]);
757 let v2
: &[i32] = &[0, 1, 2, 3, 4];
758 let mut c2
= v2
.rchunks(3);
759 assert_eq
!(c2
.nth_back(1).unwrap(), &[2, 3, 4]);
760 assert_eq
!(c2
.next_back(), None
);
764 fn test_rchunks_last() {
765 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
766 let c
= v
.rchunks(2);
767 assert_eq
!(c
.last().unwrap()[1], 1);
769 let v2
: &[i32] = &[0, 1, 2, 3, 4];
770 let c2
= v2
.rchunks(2);
771 assert_eq
!(c2
.last().unwrap()[0], 0);
775 fn test_rchunks_zip() {
776 let v1
: &[i32] = &[0, 1, 2, 3, 4];
777 let v2
: &[i32] = &[6, 7, 8, 9, 10];
782 .map(|(a
, b
)| a
.iter().sum
::<i32>() + b
.iter().sum
::<i32>())
783 .collect
::<Vec
<_
>>();
784 assert_eq
!(res
, vec
![26, 18, 6]);
788 fn test_rchunks_mut_count() {
789 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
790 let c
= v
.rchunks_mut(3);
791 assert_eq
!(c
.count(), 2);
793 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
794 let c2
= v2
.rchunks_mut(2);
795 assert_eq
!(c2
.count(), 3);
797 let v3
: &mut [i32] = &mut [];
798 let c3
= v3
.rchunks_mut(2);
799 assert_eq
!(c3
.count(), 0);
803 fn test_rchunks_mut_nth() {
804 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
805 let mut c
= v
.rchunks_mut(2);
806 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
807 assert_eq
!(c
.next().unwrap(), &[0, 1]);
809 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
810 let mut c2
= v2
.rchunks_mut(3);
811 assert_eq
!(c2
.nth(1).unwrap(), &[0, 1]);
812 assert_eq
!(c2
.next(), None
);
816 fn test_rchunks_mut_nth_back() {
817 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
818 let mut c
= v
.rchunks_mut(2);
819 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
820 assert_eq
!(c
.next_back().unwrap(), &[4, 5]);
822 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
823 let mut c2
= v2
.rchunks_mut(3);
824 assert_eq
!(c2
.nth_back(1).unwrap(), &[2, 3, 4]);
825 assert_eq
!(c2
.next_back(), None
);
829 fn test_rchunks_mut_last() {
830 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
831 let c
= v
.rchunks_mut(2);
832 assert_eq
!(c
.last().unwrap(), &[0, 1]);
834 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
835 let c2
= v2
.rchunks_mut(2);
836 assert_eq
!(c2
.last().unwrap(), &[0]);
840 fn test_rchunks_mut_zip() {
841 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
842 let v2
: &[i32] = &[6, 7, 8, 9, 10];
844 for (a
, b
) in v1
.rchunks_mut(2).zip(v2
.rchunks(2)) {
845 let sum
= b
.iter().sum
::<i32>();
850 assert_eq
!(v1
, [6, 16, 17, 22, 23]);
854 fn test_rchunks_exact_count() {
855 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
856 let c
= v
.rchunks_exact(3);
857 assert_eq
!(c
.count(), 2);
859 let v2
: &[i32] = &[0, 1, 2, 3, 4];
860 let c2
= v2
.rchunks_exact(2);
861 assert_eq
!(c2
.count(), 2);
863 let v3
: &[i32] = &[];
864 let c3
= v3
.rchunks_exact(2);
865 assert_eq
!(c3
.count(), 0);
869 fn test_rchunks_exact_nth() {
870 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
871 let mut c
= v
.rchunks_exact(2);
872 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
873 assert_eq
!(c
.next().unwrap(), &[0, 1]);
875 let v2
: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
876 let mut c2
= v2
.rchunks_exact(3);
877 assert_eq
!(c2
.nth(1).unwrap(), &[1, 2, 3]);
878 assert_eq
!(c2
.next(), None
);
882 fn test_rchunks_exact_nth_back() {
883 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
884 let mut c
= v
.rchunks_exact(2);
885 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
886 assert_eq
!(c
.next_back().unwrap(), &[4, 5]);
888 let v2
: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
889 let mut c2
= v2
.rchunks_exact(3);
890 assert_eq
!(c2
.nth_back(1).unwrap(), &[4, 5, 6]);
891 assert_eq
!(c2
.next(), None
);
895 fn test_rchunks_exact_last() {
896 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
897 let c
= v
.rchunks_exact(2);
898 assert_eq
!(c
.last().unwrap(), &[0, 1]);
900 let v2
: &[i32] = &[0, 1, 2, 3, 4];
901 let c2
= v2
.rchunks_exact(2);
902 assert_eq
!(c2
.last().unwrap(), &[1, 2]);
906 fn test_rchunks_exact_remainder() {
907 let v
: &[i32] = &[0, 1, 2, 3, 4];
908 let c
= v
.rchunks_exact(2);
909 assert_eq
!(c
.remainder(), &[0]);
913 fn test_rchunks_exact_zip() {
914 let v1
: &[i32] = &[0, 1, 2, 3, 4];
915 let v2
: &[i32] = &[6, 7, 8, 9, 10];
919 .zip(v2
.rchunks_exact(2))
920 .map(|(a
, b
)| a
.iter().sum
::<i32>() + b
.iter().sum
::<i32>())
921 .collect
::<Vec
<_
>>();
922 assert_eq
!(res
, vec
![26, 18]);
926 fn test_rchunks_exact_mut_count() {
927 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
928 let c
= v
.rchunks_exact_mut(3);
929 assert_eq
!(c
.count(), 2);
931 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
932 let c2
= v2
.rchunks_exact_mut(2);
933 assert_eq
!(c2
.count(), 2);
935 let v3
: &mut [i32] = &mut [];
936 let c3
= v3
.rchunks_exact_mut(2);
937 assert_eq
!(c3
.count(), 0);
941 fn test_rchunks_exact_mut_nth() {
942 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
943 let mut c
= v
.rchunks_exact_mut(2);
944 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
945 assert_eq
!(c
.next().unwrap(), &[0, 1]);
947 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
948 let mut c2
= v2
.rchunks_exact_mut(3);
949 assert_eq
!(c2
.nth(1).unwrap(), &[1, 2, 3]);
950 assert_eq
!(c2
.next(), None
);
954 fn test_rchunks_exact_mut_nth_back() {
955 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
956 let mut c
= v
.rchunks_exact_mut(2);
957 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
958 assert_eq
!(c
.next_back().unwrap(), &[4, 5]);
960 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
961 let mut c2
= v2
.rchunks_exact_mut(3);
962 assert_eq
!(c2
.nth_back(1).unwrap(), &[4, 5, 6]);
963 assert_eq
!(c2
.next(), None
);
967 fn test_rchunks_exact_mut_last() {
968 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
969 let c
= v
.rchunks_exact_mut(2);
970 assert_eq
!(c
.last().unwrap(), &[0, 1]);
972 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
973 let c2
= v2
.rchunks_exact_mut(2);
974 assert_eq
!(c2
.last().unwrap(), &[1, 2]);
978 fn test_rchunks_exact_mut_remainder() {
979 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4];
980 let c
= v
.rchunks_exact_mut(2);
981 assert_eq
!(c
.into_remainder(), &[0]);
985 fn test_rchunks_exact_mut_zip() {
986 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
987 let v2
: &[i32] = &[6, 7, 8, 9, 10];
989 for (a
, b
) in v1
.rchunks_exact_mut(2).zip(v2
.rchunks_exact(2)) {
990 let sum
= b
.iter().sum
::<i32>();
995 assert_eq
!(v1
, [0, 16, 17, 22, 23]);
999 fn test_windows_count() {
1000 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
1001 let c
= v
.windows(3);
1002 assert_eq
!(c
.count(), 4);
1004 let v2
: &[i32] = &[0, 1, 2, 3, 4];
1005 let c2
= v2
.windows(6);
1006 assert_eq
!(c2
.count(), 0);
1008 let v3
: &[i32] = &[];
1009 let c3
= v3
.windows(2);
1010 assert_eq
!(c3
.count(), 0);
1014 fn test_windows_nth() {
1015 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
1016 let mut c
= v
.windows(2);
1017 assert_eq
!(c
.nth(2).unwrap()[1], 3);
1018 assert_eq
!(c
.next().unwrap()[0], 3);
1020 let v2
: &[i32] = &[0, 1, 2, 3, 4];
1021 let mut c2
= v2
.windows(4);
1022 assert_eq
!(c2
.nth(1).unwrap()[1], 2);
1023 assert_eq
!(c2
.next(), None
);
1027 fn test_windows_nth_back() {
1028 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
1029 let mut c
= v
.windows(2);
1030 assert_eq
!(c
.nth_back(2).unwrap()[0], 2);
1031 assert_eq
!(c
.next_back().unwrap()[1], 2);
1033 let v2
: &[i32] = &[0, 1, 2, 3, 4];
1034 let mut c2
= v2
.windows(4);
1035 assert_eq
!(c2
.nth_back(1).unwrap()[1], 1);
1036 assert_eq
!(c2
.next_back(), None
);
1040 fn test_windows_last() {
1041 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
1042 let c
= v
.windows(2);
1043 assert_eq
!(c
.last().unwrap()[1], 5);
1045 let v2
: &[i32] = &[0, 1, 2, 3, 4];
1046 let c2
= v2
.windows(2);
1047 assert_eq
!(c2
.last().unwrap()[0], 3);
1051 fn test_windows_zip() {
1052 let v1
: &[i32] = &[0, 1, 2, 3, 4];
1053 let v2
: &[i32] = &[6, 7, 8, 9, 10];
1058 .map(|(a
, b
)| a
.iter().sum
::<i32>() + b
.iter().sum
::<i32>())
1059 .collect
::<Vec
<_
>>();
1061 assert_eq
!(res
, [14, 18, 22, 26]);
1066 fn test_iter_ref_consistency() {
1067 use std
::fmt
::Debug
;
1069 fn test
<T
: Copy
+ Debug
+ PartialEq
>(x
: T
) {
1070 let v
: &[T
] = &[x
, x
, x
];
1071 let v_ptrs
: [*const T
; 3] = match v
{
1072 [ref v1
, ref v2
, ref v3
] => [v1
as *const _
, v2
as *const _
, v3
as *const _
],
1073 _
=> unreachable
!(),
1079 assert_eq
!(&v
[i
] as *const _
, v_ptrs
[i
]); // check the v_ptrs array, just to be sure
1080 let nth
= v
.iter().nth(i
).unwrap();
1081 assert_eq
!(nth
as *const _
, v_ptrs
[i
]);
1083 assert_eq
!(v
.iter().nth(len
), None
, "nth(len) should return None");
1085 // stepping through with nth(0)
1087 let mut it
= v
.iter();
1089 let next
= it
.nth(0).unwrap();
1090 assert_eq
!(next
as *const _
, v_ptrs
[i
]);
1092 assert_eq
!(it
.nth(0), None
);
1097 let mut it
= v
.iter();
1099 let remaining
= len
- i
;
1100 assert_eq
!(it
.size_hint(), (remaining
, Some(remaining
)));
1102 let next
= it
.next().unwrap();
1103 assert_eq
!(next
as *const _
, v_ptrs
[i
]);
1105 assert_eq
!(it
.size_hint(), (0, Some(0)));
1106 assert_eq
!(it
.next(), None
, "The final call to next() should return None");
1111 let mut it
= v
.iter();
1113 let remaining
= len
- i
;
1114 assert_eq
!(it
.size_hint(), (remaining
, Some(remaining
)));
1116 let prev
= it
.next_back().unwrap();
1117 assert_eq
!(prev
as *const _
, v_ptrs
[remaining
- 1]);
1119 assert_eq
!(it
.size_hint(), (0, Some(0)));
1120 assert_eq
!(it
.next_back(), None
, "The final call to next_back() should return None");
1124 fn test_mut
<T
: Copy
+ Debug
+ PartialEq
>(x
: T
) {
1125 let v
: &mut [T
] = &mut [x
, x
, x
];
1126 let v_ptrs
: [*mut T
; 3] = match v
{
1127 [ref v1
, ref v2
, ref v3
] => {
1128 [v1
as *const _
as *mut _
, v2
as *const _
as *mut _
, v3
as *const _
as *mut _
]
1130 _
=> unreachable
!(),
1136 assert_eq
!(&mut v
[i
] as *mut _
, v_ptrs
[i
]); // check the v_ptrs array, just to be sure
1137 let nth
= v
.iter_mut().nth(i
).unwrap();
1138 assert_eq
!(nth
as *mut _
, v_ptrs
[i
]);
1140 assert_eq
!(v
.iter().nth(len
), None
, "nth(len) should return None");
1142 // stepping through with nth(0)
1144 let mut it
= v
.iter();
1146 let next
= it
.nth(0).unwrap();
1147 assert_eq
!(next
as *const _
, v_ptrs
[i
]);
1149 assert_eq
!(it
.nth(0), None
);
1154 let mut it
= v
.iter_mut();
1156 let remaining
= len
- i
;
1157 assert_eq
!(it
.size_hint(), (remaining
, Some(remaining
)));
1159 let next
= it
.next().unwrap();
1160 assert_eq
!(next
as *mut _
, v_ptrs
[i
]);
1162 assert_eq
!(it
.size_hint(), (0, Some(0)));
1163 assert_eq
!(it
.next(), None
, "The final call to next() should return None");
1168 let mut it
= v
.iter_mut();
1170 let remaining
= len
- i
;
1171 assert_eq
!(it
.size_hint(), (remaining
, Some(remaining
)));
1173 let prev
= it
.next_back().unwrap();
1174 assert_eq
!(prev
as *mut _
, v_ptrs
[remaining
- 1]);
1176 assert_eq
!(it
.size_hint(), (0, Some(0)));
1177 assert_eq
!(it
.next_back(), None
, "The final call to next_back() should return None");
1181 // Make sure iterators and slice patterns yield consistent addresses for various types,
1185 test([0u32; 0]); // ZST with alignment > 0
1188 test_mut([0u32; 0]); // ZST with alignment > 0
1191 // The current implementation of SliceIndex fails to handle methods
1192 // orthogonally from range types; therefore, it is worth testing
1193 // all of the indexing operations on each input.
1195 // This checks all six indexing methods, given an input range that
1196 // should succeed. (it is NOT suitable for testing invalid inputs)
1197 macro_rules
! assert_range_eq
{
1198 ($arr
:expr
, $range
:expr
, $expected
:expr
) => {
1200 let mut expected
= $expected
;
1203 let expected
: &[_
] = &expected
;
1205 assert_eq
!(&s
[$range
], expected
, "(in assertion for: index)");
1206 assert_eq
!(s
.get($range
), Some(expected
), "(in assertion for: get)");
1209 s
.get_unchecked($range
),
1211 "(in assertion for: get_unchecked)",
1216 let s
: &mut [_
] = &mut arr
;
1217 let expected
: &mut [_
] = &mut expected
;
1219 assert_eq
!(&mut s
[$range
], expected
, "(in assertion for: index_mut)",);
1222 Some(&mut expected
[..]),
1223 "(in assertion for: get_mut)",
1227 s
.get_unchecked_mut($range
),
1229 "(in assertion for: get_unchecked_mut)",
1236 // Make sure the macro can actually detect bugs,
1237 // because if it can't, then what are we even doing here?
1239 // (Be aware this only demonstrates the ability to detect bugs
1240 // in the FIRST method that panics, as the macro is not designed
1241 // to be used in `should_panic`)
1243 #[should_panic(expected = "out of range")]
1244 fn assert_range_eq_can_fail_by_panic() {
1245 assert_range_eq
!([0, 1, 2], 0..5, [0, 1, 2]);
1248 // (Be aware this only demonstrates the ability to detect bugs
1249 // in the FIRST method it calls, as the macro is not designed
1250 // to be used in `should_panic`)
1252 #[should_panic(expected = "==")]
1253 fn assert_range_eq_can_fail_by_inequality() {
1254 assert_range_eq
!([0, 1, 2], 0..2, [0, 1, 2]);
1257 // Test cases for bad index operations.
1259 // This generates `should_panic` test cases for Index/IndexMut
1260 // and `None` test cases for get/get_mut.
1261 macro_rules
! panic_cases
{
1263 // each test case needs a unique name to namespace the tests
1264 in mod $case_name
:ident
{
1269 // one or more similar inputs for which data[input] succeeds,
1270 // and the corresponding output as an array. This helps validate
1271 // "critical points" where an input range straddles the boundary
1272 // between valid and invalid.
1273 // (such as the input `len..len`, which is just barely valid)
1275 good
: data
[$good
:expr
] == $output
:expr
;
1278 bad
: data
[$bad
:expr
];
1279 message
: $expect_msg
:expr
;
1283 #[allow(unused_imports)]
1284 use core
::ops
::Bound
;
1290 $
( assert_range_eq
!($data
, $good
, $output
); )*
1294 assert_eq
!(v
.get($bad
), None
, "(in None assertion for get)");
1298 let v
: &mut [_
] = &mut v
;
1299 assert_eq
!(v
.get_mut($bad
), None
, "(in None assertion for get_mut)");
1304 #[should_panic(expected = $expect_msg)]
1312 #[should_panic(expected = $expect_msg)]
1313 fn index_mut_fail() {
1315 let v
: &mut [_
] = &mut v
;
1316 let _v
= &mut v
[$bad
];
1324 let v
= [0, 1, 2, 3, 4, 5];
1326 assert_range_eq
!(v
, .., [0, 1, 2, 3, 4, 5]);
1327 assert_range_eq
!(v
, ..2, [0, 1]);
1328 assert_range_eq
!(v
, ..=1, [0, 1]);
1329 assert_range_eq
!(v
, 2.., [2, 3, 4, 5]);
1330 assert_range_eq
!(v
, 1..4, [1, 2, 3]);
1331 assert_range_eq
!(v
, 1..=3, [1, 2, 3]);
1335 in mod rangefrom_len
{
1336 data
: [0, 1, 2, 3, 4, 5];
1338 good
: data
[6..] == [];
1340 message
: "out of range";
1343 in mod rangeto_len
{
1344 data
: [0, 1, 2, 3, 4, 5];
1346 good
: data
[..6] == [0, 1, 2, 3, 4, 5];
1348 message
: "out of range";
1351 in mod rangetoinclusive_len
{
1352 data
: [0, 1, 2, 3, 4, 5];
1354 good
: data
[..=5] == [0, 1, 2, 3, 4, 5];
1356 message
: "out of range";
1359 in mod rangeinclusive_len
{
1360 data
: [0, 1, 2, 3, 4, 5];
1362 good
: data
[0..=5] == [0, 1, 2, 3, 4, 5];
1364 message
: "out of range";
1367 in mod range_len_len
{
1368 data
: [0, 1, 2, 3, 4, 5];
1370 good
: data
[6..6] == [];
1372 message
: "out of range";
1375 in mod rangeinclusive_len_len
{
1376 data
: [0, 1, 2, 3, 4, 5];
1378 good
: data
[6..=5] == [];
1380 message
: "out of range";
1383 in mod boundpair_len
{
1384 data
: [0, 1, 2, 3, 4, 5];
1386 good
: data
[(Bound
::Included(6), Bound
::Unbounded
)] == [];
1387 good
: data
[(Bound
::Unbounded
, Bound
::Included(5))] == [0, 1, 2, 3, 4, 5];
1388 good
: data
[(Bound
::Unbounded
, Bound
::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1389 good
: data
[(Bound
::Included(0), Bound
::Included(5))] == [0, 1, 2, 3, 4, 5];
1390 good
: data
[(Bound
::Included(0), Bound
::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1391 good
: data
[(Bound
::Included(2), Bound
::Excluded(4))] == [2, 3];
1392 good
: data
[(Bound
::Excluded(1), Bound
::Included(4))] == [2, 3, 4];
1393 good
: data
[(Bound
::Excluded(5), Bound
::Excluded(6))] == [];
1394 good
: data
[(Bound
::Included(6), Bound
::Excluded(6))] == [];
1395 good
: data
[(Bound
::Excluded(5), Bound
::Included(5))] == [];
1396 good
: data
[(Bound
::Included(6), Bound
::Included(5))] == [];
1397 bad
: data
[(Bound
::Unbounded
, Bound
::Included(6))];
1398 message
: "out of range";
1403 in mod rangeinclusive_exhausted
{
1404 data
: [0, 1, 2, 3, 4, 5];
1406 good
: data
[0..=5] == [0, 1, 2, 3, 4, 5];
1408 let mut iter
= 0..=5;
1409 iter
.by_ref().count(); // exhaust it
1413 // 0..=6 is out of range before exhaustion, so it
1414 // stands to reason that it still would be after.
1416 let mut iter
= 0..=6;
1417 iter
.by_ref().count(); // exhaust it
1420 message
: "out of range";
1425 in mod range_neg_width
{
1426 data
: [0, 1, 2, 3, 4, 5];
1428 good
: data
[4..4] == [];
1430 message
: "but ends at";
1433 in mod rangeinclusive_neg_width
{
1434 data
: [0, 1, 2, 3, 4, 5];
1436 good
: data
[4..=3] == [];
1438 message
: "but ends at";
1441 in mod boundpair_neg_width
{
1442 data
: [0, 1, 2, 3, 4, 5];
1444 good
: data
[(Bound
::Included(4), Bound
::Excluded(4))] == [];
1445 bad
: data
[(Bound
::Included(4), Bound
::Excluded(3))];
1446 message
: "but ends at";
1451 in mod rangeinclusive_overflow
{
1454 // note: using 0 specifically ensures that the result of overflowing is 0..0,
1455 // so that `get` doesn't simply return None for the wrong reason.
1456 bad
: data
[0 ..= usize::MAX
];
1457 message
: "maximum usize";
1460 in mod rangetoinclusive_overflow
{
1463 bad
: data
[..= usize::MAX
];
1464 message
: "maximum usize";
1467 in mod boundpair_overflow_end
{
1470 bad
: data
[(Bound
::Unbounded
, Bound
::Included(usize::MAX
))];
1471 message
: "maximum usize";
1474 in mod boundpair_overflow_start
{
1477 bad
: data
[(Bound
::Excluded(usize::MAX
), Bound
::Unbounded
)];
1478 message
: "maximum usize";
1484 fn test_find_rfind() {
1485 let v
= [0, 1, 2, 3, 4, 5];
1486 let mut iter
= v
.iter();
1487 let mut i
= v
.len();
1488 while let Some(&elt
) = iter
.rfind(|_
| true) {
1490 assert_eq
!(elt
, v
[i
]);
1493 assert_eq
!(v
.iter().rfind(|&&x
| x
<= 3), Some(&3));
1497 fn test_iter_folds() {
1498 let a
= [1, 2, 3, 4, 5]; // len>4 so the unroll is used
1499 assert_eq
!(a
.iter().fold(0, |acc
, &x
| 2 * acc
+ x
), 57);
1500 assert_eq
!(a
.iter().rfold(0, |acc
, &x
| 2 * acc
+ x
), 129);
1501 let fold
= |acc
: i32, &x
| acc
.checked_mul(2)?
.checked_add(x
);
1502 assert_eq
!(a
.iter().try_fold(0, &fold
), Some(57));
1503 assert_eq
!(a
.iter().try_rfold(0, &fold
), Some(129));
1505 // short-circuiting try_fold, through other methods
1506 let a
= [0, 1, 2, 3, 5, 5, 5, 7, 8, 9];
1507 let mut iter
= a
.iter();
1508 assert_eq
!(iter
.position(|&x
| x
== 3), Some(3));
1509 assert_eq
!(iter
.rfind(|&&x
| x
== 5), Some(&5));
1510 assert_eq
!(iter
.len(), 2);
1514 fn test_rotate_left() {
1515 const N
: usize = 600;
1516 let a
: &mut [_
] = &mut [0; N
];
1525 assert_eq
!(a
[(i
+ k
) % N
], i
);
1530 fn test_rotate_right() {
1531 const N
: usize = 600;
1532 let a
: &mut [_
] = &mut [0; N
];
1540 assert_eq
!(a
[(i
+ 42) % N
], i
);
1545 #[cfg_attr(miri, ignore)] // Miri is too slow
1546 fn brute_force_rotate_test_0() {
1547 // In case of edge cases involving multiple algorithms
1551 let mut v
= Vec
::with_capacity(len
);
1555 v
[..].rotate_right(s
);
1556 for i
in 0..v
.len() {
1557 assert_eq
!(v
[i
], v
.len().wrapping_add(i
.wrapping_sub(s
)) % v
.len());
1564 fn brute_force_rotate_test_1() {
1565 // `ptr_rotate` covers so many kinds of pointer usage, that this is just a good test for
1566 // pointers in general. This uses a `[usize; 4]` to hit all algorithms without overwhelming miri
1570 let mut v
: Vec
<[usize; 4]> = Vec
::with_capacity(len
);
1572 v
.push([i
, 0, 0, 0]);
1574 v
[..].rotate_right(s
);
1575 for i
in 0..v
.len() {
1576 assert_eq
!(v
[i
][0], v
.len().wrapping_add(i
.wrapping_sub(s
)) % v
.len());
1583 #[cfg(not(target_arch = "wasm32"))]
1584 fn sort_unstable() {
1585 use core
::cmp
::Ordering
::{Equal, Greater, Less}
;
1586 use core
::slice
::heapsort
;
1587 use rand
::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng}
;
1589 // Miri is too slow (but still need to `chain` to make the types match)
1590 let lens
= if cfg
!(miri
) { (2..20).chain(0..0) }
else { (2..25).chain(500..510) }
;
1591 let rounds
= if cfg
!(miri
) { 1 }
else { 100 }
;
1593 let mut v
= [0; 600];
1594 let mut tmp
= [0; 600];
1595 let mut rng
= StdRng
::from_entropy();
1598 let v
= &mut v
[0..len
];
1599 let tmp
= &mut tmp
[0..len
];
1601 for &modulus
in &[5, 10, 100, 1000] {
1602 for _
in 0..rounds
{
1604 v
[i
] = rng
.gen
::<i32>() % modulus
;
1607 // Sort in default order.
1608 tmp
.copy_from_slice(v
);
1609 tmp
.sort_unstable();
1610 assert
!(tmp
.windows(2).all(|w
| w
[0] <= w
[1]));
1612 // Sort in ascending order.
1613 tmp
.copy_from_slice(v
);
1614 tmp
.sort_unstable_by(|a
, b
| a
.cmp(b
));
1615 assert
!(tmp
.windows(2).all(|w
| w
[0] <= w
[1]));
1617 // Sort in descending order.
1618 tmp
.copy_from_slice(v
);
1619 tmp
.sort_unstable_by(|a
, b
| b
.cmp(a
));
1620 assert
!(tmp
.windows(2).all(|w
| w
[0] >= w
[1]));
1622 // Test heapsort using `<` operator.
1623 tmp
.copy_from_slice(v
);
1624 heapsort(tmp
, |a
, b
| a
< b
);
1625 assert
!(tmp
.windows(2).all(|w
| w
[0] <= w
[1]));
1627 // Test heapsort using `>` operator.
1628 tmp
.copy_from_slice(v
);
1629 heapsort(tmp
, |a
, b
| a
> b
);
1630 assert
!(tmp
.windows(2).all(|w
| w
[0] >= w
[1]));
1635 // Sort using a completely random comparison function.
1636 // This will reorder the elements *somehow*, but won't panic.
1637 for i
in 0..v
.len() {
1640 v
.sort_unstable_by(|_
, _
| *[Less
, Equal
, Greater
].choose(&mut rng
).unwrap());
1642 for i
in 0..v
.len() {
1643 assert_eq
!(v
[i
], i
as i32);
1646 // Should not panic.
1647 [0i32; 0].sort_unstable();
1648 [(); 10].sort_unstable();
1649 [(); 100].sort_unstable();
1651 let mut v
= [0xDEADBEEFu64];
1653 assert
!(v
== [0xDEADBEEF]);
1657 #[cfg(not(target_arch = "wasm32"))]
1658 #[cfg_attr(miri, ignore)] // Miri is too slow
1659 fn select_nth_unstable() {
1660 use core
::cmp
::Ordering
::{Equal, Greater, Less}
;
1661 use rand
::rngs
::StdRng
;
1662 use rand
::seq
::SliceRandom
;
1663 use rand
::{Rng, SeedableRng}
;
1665 let mut rng
= StdRng
::from_entropy();
1667 for len
in (2..21).chain(500..501) {
1668 let mut orig
= vec
![0; len
];
1670 for &modulus
in &[5, 10, 1000] {
1673 orig
[i
] = rng
.gen
::<i32>() % modulus
;
1677 let mut v
= orig
.clone();
1682 // Sort in default order.
1683 for pivot
in 0..len
{
1684 let mut v
= orig
.clone();
1685 v
.select_nth_unstable(pivot
);
1687 assert_eq
!(v_sorted
[pivot
], v
[pivot
]);
1689 for j
in pivot
..len
{
1690 assert
!(v
[i
] <= v
[j
]);
1695 // Sort in ascending order.
1696 for pivot
in 0..len
{
1697 let mut v
= orig
.clone();
1698 let (left
, pivot
, right
) = v
.select_nth_unstable_by(pivot
, |a
, b
| a
.cmp(b
));
1700 assert_eq
!(left
.len() + right
.len(), len
- 1);
1703 assert
!(l
<= pivot
);
1704 for r
in right
.iter_mut() {
1706 assert
!(pivot
<= r
);
1711 // Sort in descending order.
1712 let sort_descending_comparator
= |a
: &i32, b
: &i32| b
.cmp(a
);
1713 let v_sorted_descending
= {
1714 let mut v
= orig
.clone();
1715 v
.sort_by(sort_descending_comparator
);
1719 for pivot
in 0..len
{
1720 let mut v
= orig
.clone();
1721 v
.select_nth_unstable_by(pivot
, sort_descending_comparator
);
1723 assert_eq
!(v_sorted_descending
[pivot
], v
[pivot
]);
1725 for j
in pivot
..len
{
1726 assert
!(v
[j
] <= v
[i
]);
1734 // Sort at index using a completely random comparison function.
1735 // This will reorder the elements *somehow*, but won't panic.
1736 let mut v
= [0; 500];
1737 for i
in 0..v
.len() {
1741 for pivot
in 0..v
.len() {
1742 v
.select_nth_unstable_by(pivot
, |_
, _
| *[Less
, Equal
, Greater
].choose(&mut rng
).unwrap());
1744 for i
in 0..v
.len() {
1745 assert_eq
!(v
[i
], i
as i32);
1749 // Should not panic.
1750 [(); 10].select_nth_unstable(0);
1751 [(); 10].select_nth_unstable(5);
1752 [(); 10].select_nth_unstable(9);
1753 [(); 100].select_nth_unstable(0);
1754 [(); 100].select_nth_unstable(50);
1755 [(); 100].select_nth_unstable(99);
1757 let mut v
= [0xDEADBEEFu64];
1758 v
.select_nth_unstable(0);
1759 assert
!(v
== [0xDEADBEEF]);
1763 #[should_panic(expected = "index 0 greater than length of slice")]
1764 fn select_nth_unstable_zero_length() {
1765 [0i32; 0].select_nth_unstable(0);
1769 #[should_panic(expected = "index 20 greater than length of slice")]
1770 fn select_nth_unstable_past_length() {
1771 [0i32; 10].select_nth_unstable(20);
1775 use core
::slice
::memchr
::{memchr, memrchr}
;
1777 // test fallback implementations on all platforms
1780 assert_eq
!(Some(0), memchr(b'a'
, b
"a"));
1784 fn matches_begin() {
1785 assert_eq
!(Some(0), memchr(b'a'
, b
"aaaa"));
1790 assert_eq
!(Some(4), memchr(b'z'
, b
"aaaaz"));
1795 assert_eq
!(Some(4), memchr(b'
\x00'
, b
"aaaa\x00"));
1799 fn matches_past_nul() {
1800 assert_eq
!(Some(5), memchr(b'z'
, b
"aaaa\x00z"));
1804 fn no_match_empty() {
1805 assert_eq
!(None
, memchr(b'a'
, b
""));
1810 assert_eq
!(None
, memchr(b'a'
, b
"xyz"));
1814 fn matches_one_reversed() {
1815 assert_eq
!(Some(0), memrchr(b'a'
, b
"a"));
1819 fn matches_begin_reversed() {
1820 assert_eq
!(Some(3), memrchr(b'a'
, b
"aaaa"));
1824 fn matches_end_reversed() {
1825 assert_eq
!(Some(0), memrchr(b'z'
, b
"zaaaa"));
1829 fn matches_nul_reversed() {
1830 assert_eq
!(Some(4), memrchr(b'
\x00'
, b
"aaaa\x00"));
1834 fn matches_past_nul_reversed() {
1835 assert_eq
!(Some(0), memrchr(b'z'
, b
"z\x00aaaa"));
1839 fn no_match_empty_reversed() {
1840 assert_eq
!(None
, memrchr(b'a'
, b
""));
1844 fn no_match_reversed() {
1845 assert_eq
!(None
, memrchr(b'a'
, b
"xyz"));
1849 fn each_alignment_reversed() {
1850 let mut data
= [1u8; 64];
1854 for start
in 0..16 {
1855 assert_eq
!(Some(pos
- start
), memrchr(needle
, &data
[start
..]));
1861 fn test_align_to_simple() {
1862 let bytes
= [1u8, 2, 3, 4, 5, 6, 7];
1863 let (prefix
, aligned
, suffix
) = unsafe { bytes.align_to::<u16>() }
;
1864 assert_eq
!(aligned
.len(), 3);
1865 assert
!(prefix
== [1] || suffix
== [7]);
1866 let expect1
= [1 << 8 | 2, 3 << 8 | 4, 5 << 8 | 6];
1867 let expect2
= [1 | 2 << 8, 3 | 4 << 8, 5 | 6 << 8];
1868 let expect3
= [2 << 8 | 3, 4 << 8 | 5, 6 << 8 | 7];
1869 let expect4
= [2 | 3 << 8, 4 | 5 << 8, 6 | 7 << 8];
1871 aligned
== expect1
|| aligned
== expect2
|| aligned
== expect3
|| aligned
== expect4
,
1872 "aligned={:?} expected={:?} || {:?} || {:?} || {:?}",
1882 fn test_align_to_zst() {
1883 let bytes
= [1, 2, 3, 4, 5, 6, 7];
1884 let (prefix
, aligned
, suffix
) = unsafe { bytes.align_to::<()>() }
;
1885 assert_eq
!(aligned
.len(), 0);
1886 assert
!(prefix
== [1, 2, 3, 4, 5, 6, 7] || suffix
== [1, 2, 3, 4, 5, 6, 7]);
1890 fn test_align_to_non_trivial() {
1892 struct U64(u64, u64);
1894 struct U64U64U32(u64, u64, u32);
1905 let (prefix
, aligned
, suffix
) = unsafe { data.align_to::<U64U64U32>() }
;
1906 assert_eq
!(aligned
.len(), 4);
1907 assert_eq
!(prefix
.len() + suffix
.len(), 2);
1911 fn test_align_to_empty_mid() {
1914 // Make sure that we do not create empty unaligned slices for the mid part, even when the
1915 // overall slice is too short to contain an aligned address.
1916 let bytes
= [1, 2, 3, 4, 5, 6, 7];
1918 for offset
in 0..4 {
1919 let (_
, mid
, _
) = unsafe { bytes[offset..offset + 1].align_to::<Chunk>() }
;
1920 assert_eq
!(mid
.as_ptr() as usize % mem
::align_of
::<Chunk
>(), 0);
1925 fn test_align_to_mut_aliasing() {
1926 let mut val
= [1u8, 2, 3, 4, 5];
1927 // `align_to_mut` used to create `mid` in a way that there was some intermediate
1928 // incorrect aliasing, invalidating the resulting `mid` slice.
1929 let (begin
, mid
, end
) = unsafe { val.align_to_mut::<[u8; 2]>() }
;
1930 assert
!(begin
.len() == 0);
1931 assert
!(end
.len() == 1);
1933 assert_eq
!(val
, [3, 4, 3, 4, 5])
1937 fn test_slice_partition_dedup_by() {
1938 let mut slice
: [i32; 9] = [1, -1, 2, 3, 1, -5, 5, -2, 2];
1940 let (dedup
, duplicates
) = slice
.partition_dedup_by(|a
, b
| a
.abs() == b
.abs());
1942 assert_eq
!(dedup
, [1, 2, 3, 1, -5, -2]);
1943 assert_eq
!(duplicates
, [5, -1, 2]);
1947 fn test_slice_partition_dedup_empty() {
1948 let mut slice
: [i32; 0] = [];
1950 let (dedup
, duplicates
) = slice
.partition_dedup();
1952 assert_eq
!(dedup
, []);
1953 assert_eq
!(duplicates
, []);
1957 fn test_slice_partition_dedup_one() {
1958 let mut slice
= [12];
1960 let (dedup
, duplicates
) = slice
.partition_dedup();
1962 assert_eq
!(dedup
, [12]);
1963 assert_eq
!(duplicates
, []);
1967 fn test_slice_partition_dedup_multiple_ident() {
1968 let mut slice
= [12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11];
1970 let (dedup
, duplicates
) = slice
.partition_dedup();
1972 assert_eq
!(dedup
, [12, 11]);
1973 assert_eq
!(duplicates
, [12, 12, 12, 12, 11, 11, 11, 11, 11]);
1977 fn test_slice_partition_dedup_partialeq() {
1979 struct Foo(i32, i32);
1981 impl PartialEq
for Foo
{
1982 fn eq(&self, other
: &Foo
) -> bool
{
1987 let mut slice
= [Foo(0, 1), Foo(0, 5), Foo(1, 7), Foo(1, 9)];
1989 let (dedup
, duplicates
) = slice
.partition_dedup();
1991 assert_eq
!(dedup
, [Foo(0, 1), Foo(1, 7)]);
1992 assert_eq
!(duplicates
, [Foo(0, 5), Foo(1, 9)]);
1996 fn test_copy_within() {
1997 // Start to end, with a RangeTo.
1998 let mut bytes
= *b
"Hello, World!";
1999 bytes
.copy_within(..3, 10);
2000 assert_eq
!(&bytes
, b
"Hello, WorHel");
2002 // End to start, with a RangeFrom.
2003 let mut bytes
= *b
"Hello, World!";
2004 bytes
.copy_within(10.., 0);
2005 assert_eq
!(&bytes
, b
"ld!lo, World!");
2007 // Overlapping, with a RangeInclusive.
2008 let mut bytes
= *b
"Hello, World!";
2009 bytes
.copy_within(0..=11, 1);
2010 assert_eq
!(&bytes
, b
"HHello, World");
2012 // Whole slice, with a RangeFull.
2013 let mut bytes
= *b
"Hello, World!";
2014 bytes
.copy_within(.., 0);
2015 assert_eq
!(&bytes
, b
"Hello, World!");
2017 // Ensure that copying at the end of slice won't cause UB.
2018 let mut bytes
= *b
"Hello, World!";
2019 bytes
.copy_within(13..13, 5);
2020 assert_eq
!(&bytes
, b
"Hello, World!");
2021 bytes
.copy_within(5..5, 13);
2022 assert_eq
!(&bytes
, b
"Hello, World!");
2026 #[should_panic(expected = "range end index 14 out of range for slice of length 13")]
2027 fn test_copy_within_panics_src_too_long() {
2028 let mut bytes
= *b
"Hello, World!";
2029 // The length is only 13, so 14 is out of bounds.
2030 bytes
.copy_within(10..14, 0);
2034 #[should_panic(expected = "dest is out of bounds")]
2035 fn test_copy_within_panics_dest_too_long() {
2036 let mut bytes
= *b
"Hello, World!";
2037 // The length is only 13, so a slice of length 4 starting at index 10 is out of bounds.
2038 bytes
.copy_within(0..4, 10);
2042 #[should_panic(expected = "slice index starts at 2 but ends at 1")]
2043 fn test_copy_within_panics_src_inverted() {
2044 let mut bytes
= *b
"Hello, World!";
2045 // 2 is greater than 1, so this range is invalid.
2046 bytes
.copy_within(2..1, 0);
2049 #[should_panic(expected = "attempted to index slice up to maximum usize")]
2050 fn test_copy_within_panics_src_out_of_bounds() {
2051 let mut bytes
= *b
"Hello, World!";
2052 // an inclusive range ending at usize::MAX would make src_end overflow
2053 bytes
.copy_within(usize::MAX
..=usize::MAX
, 0);
2057 fn test_is_sorted() {
2058 let empty
: [i32; 0] = [];
2060 assert
!([1, 2, 2, 9].is_sorted());
2061 assert
!(![1, 3, 2].is_sorted());
2062 assert
!([0].is_sorted());
2063 assert
!(empty
.is_sorted());
2064 assert
!(![0.0, 1.0, f32::NAN
].is_sorted());
2065 assert
!([-2, -1, 0, 3].is_sorted());
2066 assert
!(![-2i32, -1, 0, 3].is_sorted_by_key(|n
| n
.abs()));
2067 assert
!(!["c", "bb", "aaa"].is_sorted());
2068 assert
!(["c", "bb", "aaa"].is_sorted_by_key(|s
| s
.len()));
2072 fn test_slice_run_destructors() {
2073 // Make sure that destructors get run on slice literals
2078 impl<'a
> Drop
for Foo
<'a
> {
2079 fn drop(&mut self) {
2080 self.x
.set(self.x
.get() + 1);
2084 fn foo(x
: &Cell
<isize>) -> Foo
<'_
> {
2088 let x
= &Cell
::new(0);
2092 assert_eq
!(l
[0].x
.get(), 0);
2095 assert_eq
!(x
.get(), 1);