]>
Commit | Line | Data |
---|---|---|
9c376795 | 1 | use std::cmp::Ordering::{Equal, Greater, Less}; |
29967ef6 | 2 | use std::convert::identity; |
94222f64 | 3 | use std::fmt; |
c34b1796 | 4 | use std::mem; |
0531ce1d | 5 | use std::panic; |
c34b1796 | 6 | use std::rc::Rc; |
abe05a73 | 7 | |
3157f602 XL |
8 | fn square(n: usize) -> usize { |
9 | n * n | |
10 | } | |
c34b1796 | 11 | |
3157f602 XL |
12 | fn is_odd(n: &usize) -> bool { |
13 | *n % 2 == 1 | |
14 | } | |
c34b1796 AL |
15 | |
16 | #[test] | |
17 | fn test_from_fn() { | |
18 | // Test on-stack from_fn. | |
19 | let mut v: Vec<_> = (0..3).map(square).collect(); | |
20 | { | |
21 | let v = v; | |
22 | assert_eq!(v.len(), 3); | |
23 | assert_eq!(v[0], 0); | |
24 | assert_eq!(v[1], 1); | |
25 | assert_eq!(v[2], 4); | |
26 | } | |
27 | ||
28 | // Test on-heap from_fn. | |
29 | v = (0..5).map(square).collect(); | |
30 | { | |
31 | let v = v; | |
32 | assert_eq!(v.len(), 5); | |
33 | assert_eq!(v[0], 0); | |
34 | assert_eq!(v[1], 1); | |
35 | assert_eq!(v[2], 4); | |
36 | assert_eq!(v[3], 9); | |
37 | assert_eq!(v[4], 16); | |
38 | } | |
39 | } | |
40 | ||
41 | #[test] | |
42 | fn test_from_elem() { | |
43 | // Test on-stack from_elem. | |
44 | let mut v = vec![10, 10]; | |
45 | { | |
46 | let v = v; | |
47 | assert_eq!(v.len(), 2); | |
48 | assert_eq!(v[0], 10); | |
49 | assert_eq!(v[1], 10); | |
50 | } | |
51 | ||
52 | // Test on-heap from_elem. | |
53 | v = vec![20; 6]; | |
54 | { | |
55 | let v = &v[..]; | |
56 | assert_eq!(v[0], 20); | |
57 | assert_eq!(v[1], 20); | |
58 | assert_eq!(v[2], 20); | |
59 | assert_eq!(v[3], 20); | |
60 | assert_eq!(v[4], 20); | |
61 | assert_eq!(v[5], 20); | |
62 | } | |
63 | } | |
64 | ||
65 | #[test] | |
66 | fn test_is_empty() { | |
67 | let xs: [i32; 0] = []; | |
68 | assert!(xs.is_empty()); | |
69 | assert!(![0].is_empty()); | |
70 | } | |
71 | ||
72 | #[test] | |
73 | fn test_len_divzero() { | |
74 | type Z = [i8; 0]; | |
3157f602 XL |
75 | let v0: &[Z] = &[]; |
76 | let v1: &[Z] = &[[]]; | |
77 | let v2: &[Z] = &[[], []]; | |
c34b1796 AL |
78 | assert_eq!(mem::size_of::<Z>(), 0); |
79 | assert_eq!(v0.len(), 0); | |
80 | assert_eq!(v1.len(), 1); | |
81 | assert_eq!(v2.len(), 2); | |
82 | } | |
83 | ||
84 | #[test] | |
85 | fn test_get() { | |
86 | let mut a = vec![11]; | |
87 | assert_eq!(a.get(1), None); | |
88 | a = vec![11, 12]; | |
89 | assert_eq!(a.get(1).unwrap(), &12); | |
90 | a = vec![11, 12, 13]; | |
91 | assert_eq!(a.get(1).unwrap(), &12); | |
92 | } | |
93 | ||
94 | #[test] | |
95 | fn test_first() { | |
96 | let mut a = vec![]; | |
97 | assert_eq!(a.first(), None); | |
98 | a = vec![11]; | |
99 | assert_eq!(a.first().unwrap(), &11); | |
100 | a = vec![11, 12]; | |
101 | assert_eq!(a.first().unwrap(), &11); | |
102 | } | |
103 | ||
104 | #[test] | |
105 | fn test_first_mut() { | |
106 | let mut a = vec![]; | |
107 | assert_eq!(a.first_mut(), None); | |
108 | a = vec![11]; | |
109 | assert_eq!(*a.first_mut().unwrap(), 11); | |
110 | a = vec![11, 12]; | |
111 | assert_eq!(*a.first_mut().unwrap(), 11); | |
112 | } | |
113 | ||
114 | #[test] | |
c1a9b12d | 115 | fn test_split_first() { |
c34b1796 AL |
116 | let mut a = vec![11]; |
117 | let b: &[i32] = &[]; | |
c1a9b12d SL |
118 | assert!(b.split_first().is_none()); |
119 | assert_eq!(a.split_first(), Some((&11, b))); | |
c34b1796 AL |
120 | a = vec![11, 12]; |
121 | let b: &[i32] = &[12]; | |
c1a9b12d | 122 | assert_eq!(a.split_first(), Some((&11, b))); |
c34b1796 AL |
123 | } |
124 | ||
125 | #[test] | |
c1a9b12d | 126 | fn test_split_first_mut() { |
c34b1796 AL |
127 | let mut a = vec![11]; |
128 | let b: &mut [i32] = &mut []; | |
c1a9b12d SL |
129 | assert!(b.split_first_mut().is_none()); |
130 | assert!(a.split_first_mut() == Some((&mut 11, b))); | |
c34b1796 AL |
131 | a = vec![11, 12]; |
132 | let b: &mut [_] = &mut [12]; | |
c1a9b12d | 133 | assert!(a.split_first_mut() == Some((&mut 11, b))); |
c34b1796 AL |
134 | } |
135 | ||
136 | #[test] | |
c1a9b12d | 137 | fn test_split_last() { |
c34b1796 AL |
138 | let mut a = vec![11]; |
139 | let b: &[i32] = &[]; | |
c1a9b12d SL |
140 | assert!(b.split_last().is_none()); |
141 | assert_eq!(a.split_last(), Some((&11, b))); | |
c34b1796 AL |
142 | a = vec![11, 12]; |
143 | let b: &[_] = &[11]; | |
c1a9b12d | 144 | assert_eq!(a.split_last(), Some((&12, b))); |
c34b1796 AL |
145 | } |
146 | ||
147 | #[test] | |
c1a9b12d | 148 | fn test_split_last_mut() { |
c34b1796 AL |
149 | let mut a = vec![11]; |
150 | let b: &mut [i32] = &mut []; | |
c1a9b12d SL |
151 | assert!(b.split_last_mut().is_none()); |
152 | assert!(a.split_last_mut() == Some((&mut 11, b))); | |
153 | ||
c34b1796 AL |
154 | a = vec![11, 12]; |
155 | let b: &mut [_] = &mut [11]; | |
c1a9b12d | 156 | assert!(a.split_last_mut() == Some((&mut 12, b))); |
c34b1796 AL |
157 | } |
158 | ||
159 | #[test] | |
160 | fn test_last() { | |
161 | let mut a = vec![]; | |
162 | assert_eq!(a.last(), None); | |
163 | a = vec![11]; | |
164 | assert_eq!(a.last().unwrap(), &11); | |
165 | a = vec![11, 12]; | |
166 | assert_eq!(a.last().unwrap(), &12); | |
167 | } | |
168 | ||
169 | #[test] | |
170 | fn test_last_mut() { | |
171 | let mut a = vec![]; | |
172 | assert_eq!(a.last_mut(), None); | |
173 | a = vec![11]; | |
174 | assert_eq!(*a.last_mut().unwrap(), 11); | |
175 | a = vec![11, 12]; | |
176 | assert_eq!(*a.last_mut().unwrap(), 12); | |
177 | } | |
178 | ||
179 | #[test] | |
180 | fn test_slice() { | |
181 | // Test fixed length vector. | |
182 | let vec_fixed = [1, 2, 3, 4]; | |
183 | let v_a = vec_fixed[1..vec_fixed.len()].to_vec(); | |
184 | assert_eq!(v_a.len(), 3); | |
185 | ||
186 | assert_eq!(v_a[0], 2); | |
187 | assert_eq!(v_a[1], 3); | |
188 | assert_eq!(v_a[2], 4); | |
189 | ||
190 | // Test on stack. | |
191 | let vec_stack: &[_] = &[1, 2, 3]; | |
192 | let v_b = vec_stack[1..3].to_vec(); | |
193 | assert_eq!(v_b.len(), 2); | |
194 | ||
195 | assert_eq!(v_b[0], 2); | |
196 | assert_eq!(v_b[1], 3); | |
197 | ||
198 | // Test `Box<[T]>` | |
199 | let vec_unique = vec![1, 2, 3, 4, 5, 6]; | |
200 | let v_d = vec_unique[1..6].to_vec(); | |
201 | assert_eq!(v_d.len(), 5); | |
202 | ||
203 | assert_eq!(v_d[0], 2); | |
204 | assert_eq!(v_d[1], 3); | |
205 | assert_eq!(v_d[2], 4); | |
206 | assert_eq!(v_d[3], 5); | |
207 | assert_eq!(v_d[4], 6); | |
208 | } | |
209 | ||
210 | #[test] | |
211 | fn test_slice_from() { | |
212 | let vec: &[_] = &[1, 2, 3, 4]; | |
213 | assert_eq!(&vec[..], vec); | |
214 | let b: &[_] = &[3, 4]; | |
215 | assert_eq!(&vec[2..], b); | |
216 | let b: &[_] = &[]; | |
217 | assert_eq!(&vec[4..], b); | |
218 | } | |
219 | ||
220 | #[test] | |
221 | fn test_slice_to() { | |
222 | let vec: &[_] = &[1, 2, 3, 4]; | |
223 | assert_eq!(&vec[..4], vec); | |
224 | let b: &[_] = &[1, 2]; | |
225 | assert_eq!(&vec[..2], b); | |
226 | let b: &[_] = &[]; | |
227 | assert_eq!(&vec[..0], b); | |
228 | } | |
229 | ||
c34b1796 AL |
230 | #[test] |
231 | fn test_pop() { | |
232 | let mut v = vec![5]; | |
233 | let e = v.pop(); | |
234 | assert_eq!(v.len(), 0); | |
235 | assert_eq!(e, Some(5)); | |
236 | let f = v.pop(); | |
237 | assert_eq!(f, None); | |
238 | let g = v.pop(); | |
239 | assert_eq!(g, None); | |
240 | } | |
241 | ||
242 | #[test] | |
243 | fn test_swap_remove() { | |
244 | let mut v = vec![1, 2, 3, 4, 5]; | |
245 | let mut e = v.swap_remove(0); | |
246 | assert_eq!(e, 1); | |
247 | assert_eq!(v, [5, 2, 3, 4]); | |
248 | e = v.swap_remove(3); | |
249 | assert_eq!(e, 4); | |
250 | assert_eq!(v, [5, 2, 3]); | |
251 | } | |
252 | ||
253 | #[test] | |
254 | #[should_panic] | |
255 | fn test_swap_remove_fail() { | |
256 | let mut v = vec![1]; | |
257 | let _ = v.swap_remove(0); | |
258 | let _ = v.swap_remove(0); | |
259 | } | |
260 | ||
261 | #[test] | |
262 | fn test_swap_remove_noncopyable() { | |
263 | // Tests that we don't accidentally run destructors twice. | |
264 | let mut v: Vec<Box<_>> = Vec::new(); | |
923072b8 FG |
265 | v.push(Box::new(0)); |
266 | v.push(Box::new(0)); | |
267 | v.push(Box::new(0)); | |
c34b1796 AL |
268 | let mut _e = v.swap_remove(0); |
269 | assert_eq!(v.len(), 2); | |
270 | _e = v.swap_remove(1); | |
271 | assert_eq!(v.len(), 1); | |
272 | _e = v.swap_remove(0); | |
273 | assert_eq!(v.len(), 0); | |
274 | } | |
275 | ||
276 | #[test] | |
277 | fn test_push() { | |
278 | // Test on-stack push(). | |
279 | let mut v = vec![]; | |
280 | v.push(1); | |
281 | assert_eq!(v.len(), 1); | |
282 | assert_eq!(v[0], 1); | |
283 | ||
284 | // Test on-heap push(). | |
285 | v.push(2); | |
286 | assert_eq!(v.len(), 2); | |
287 | assert_eq!(v[0], 1); | |
288 | assert_eq!(v[1], 2); | |
289 | } | |
290 | ||
291 | #[test] | |
292 | fn test_truncate() { | |
923072b8 | 293 | let mut v: Vec<Box<_>> = vec![Box::new(6), Box::new(5), Box::new(4)]; |
c34b1796 AL |
294 | v.truncate(1); |
295 | let v = v; | |
296 | assert_eq!(v.len(), 1); | |
297 | assert_eq!(*(v[0]), 6); | |
298 | // If the unsafe block didn't drop things properly, we blow up here. | |
299 | } | |
300 | ||
301 | #[test] | |
302 | fn test_clear() { | |
923072b8 | 303 | let mut v: Vec<Box<_>> = vec![Box::new(6), Box::new(5), Box::new(4)]; |
c34b1796 AL |
304 | v.clear(); |
305 | assert_eq!(v.len(), 0); | |
306 | // If the unsafe block didn't drop things properly, we blow up here. | |
307 | } | |
308 | ||
c34b1796 AL |
309 | #[test] |
310 | fn test_retain() { | |
311 | let mut v = vec![1, 2, 3, 4, 5]; | |
312 | v.retain(is_odd); | |
313 | assert_eq!(v, [1, 3, 5]); | |
314 | } | |
315 | ||
c34b1796 AL |
316 | #[test] |
317 | fn test_binary_search() { | |
3157f602 XL |
318 | assert_eq!([1, 2, 3, 4, 5].binary_search(&5).ok(), Some(4)); |
319 | assert_eq!([1, 2, 3, 4, 5].binary_search(&4).ok(), Some(3)); | |
320 | assert_eq!([1, 2, 3, 4, 5].binary_search(&3).ok(), Some(2)); | |
321 | assert_eq!([1, 2, 3, 4, 5].binary_search(&2).ok(), Some(1)); | |
322 | assert_eq!([1, 2, 3, 4, 5].binary_search(&1).ok(), Some(0)); | |
323 | ||
324 | assert_eq!([2, 4, 6, 8, 10].binary_search(&1).ok(), None); | |
325 | assert_eq!([2, 4, 6, 8, 10].binary_search(&5).ok(), None); | |
326 | assert_eq!([2, 4, 6, 8, 10].binary_search(&4).ok(), Some(1)); | |
327 | assert_eq!([2, 4, 6, 8, 10].binary_search(&10).ok(), Some(4)); | |
328 | ||
329 | assert_eq!([2, 4, 6, 8].binary_search(&1).ok(), None); | |
330 | assert_eq!([2, 4, 6, 8].binary_search(&5).ok(), None); | |
331 | assert_eq!([2, 4, 6, 8].binary_search(&4).ok(), Some(1)); | |
332 | assert_eq!([2, 4, 6, 8].binary_search(&8).ok(), Some(3)); | |
333 | ||
334 | assert_eq!([2, 4, 6].binary_search(&1).ok(), None); | |
335 | assert_eq!([2, 4, 6].binary_search(&5).ok(), None); | |
336 | assert_eq!([2, 4, 6].binary_search(&4).ok(), Some(1)); | |
337 | assert_eq!([2, 4, 6].binary_search(&6).ok(), Some(2)); | |
338 | ||
339 | assert_eq!([2, 4].binary_search(&1).ok(), None); | |
340 | assert_eq!([2, 4].binary_search(&5).ok(), None); | |
341 | assert_eq!([2, 4].binary_search(&2).ok(), Some(0)); | |
342 | assert_eq!([2, 4].binary_search(&4).ok(), Some(1)); | |
c34b1796 AL |
343 | |
344 | assert_eq!([2].binary_search(&1).ok(), None); | |
345 | assert_eq!([2].binary_search(&5).ok(), None); | |
346 | assert_eq!([2].binary_search(&2).ok(), Some(0)); | |
347 | ||
348 | assert_eq!([].binary_search(&1).ok(), None); | |
349 | assert_eq!([].binary_search(&5).ok(), None); | |
350 | ||
3157f602 XL |
351 | assert!([1, 1, 1, 1, 1].binary_search(&1).ok() != None); |
352 | assert!([1, 1, 1, 1, 2].binary_search(&1).ok() != None); | |
353 | assert!([1, 1, 1, 2, 2].binary_search(&1).ok() != None); | |
354 | assert!([1, 1, 2, 2, 2].binary_search(&1).ok() != None); | |
355 | assert_eq!([1, 2, 2, 2, 2].binary_search(&1).ok(), Some(0)); | |
c34b1796 | 356 | |
3157f602 XL |
357 | assert_eq!([1, 2, 3, 4, 5].binary_search(&6).ok(), None); |
358 | assert_eq!([1, 2, 3, 4, 5].binary_search(&0).ok(), None); | |
c34b1796 AL |
359 | } |
360 | ||
361 | #[test] | |
362 | fn test_reverse() { | |
363 | let mut v = vec![10, 20]; | |
364 | assert_eq!(v[0], 10); | |
365 | assert_eq!(v[1], 20); | |
366 | v.reverse(); | |
367 | assert_eq!(v[0], 20); | |
368 | assert_eq!(v[1], 10); | |
369 | ||
370 | let mut v3 = Vec::<i32>::new(); | |
371 | v3.reverse(); | |
372 | assert!(v3.is_empty()); | |
7cac9316 XL |
373 | |
374 | // check the 1-byte-types path | |
375 | let mut v = (-50..51i8).collect::<Vec<_>>(); | |
376 | v.reverse(); | |
377 | assert_eq!(v, (-50..51i8).rev().collect::<Vec<_>>()); | |
378 | ||
379 | // check the 2-byte-types path | |
380 | let mut v = (-50..51i16).collect::<Vec<_>>(); | |
381 | v.reverse(); | |
382 | assert_eq!(v, (-50..51i16).rev().collect::<Vec<_>>()); | |
c34b1796 AL |
383 | } |
384 | ||
7cac9316 | 385 | #[test] |
2c00a5a8 | 386 | fn test_rotate_left() { |
7cac9316 XL |
387 | let expected: Vec<_> = (0..13).collect(); |
388 | let mut v = Vec::new(); | |
389 | ||
390 | // no-ops | |
391 | v.clone_from(&expected); | |
2c00a5a8 | 392 | v.rotate_left(0); |
7cac9316 | 393 | assert_eq!(v, expected); |
2c00a5a8 | 394 | v.rotate_left(expected.len()); |
7cac9316 XL |
395 | assert_eq!(v, expected); |
396 | let mut zst_array = [(), (), ()]; | |
2c00a5a8 | 397 | zst_array.rotate_left(2); |
7cac9316 XL |
398 | |
399 | // happy path | |
400 | v = (5..13).chain(0..5).collect(); | |
2c00a5a8 | 401 | v.rotate_left(8); |
7cac9316 XL |
402 | assert_eq!(v, expected); |
403 | ||
404 | let expected: Vec<_> = (0..1000).collect(); | |
405 | ||
406 | // small rotations in large slice, uses ptr::copy | |
407 | v = (2..1000).chain(0..2).collect(); | |
2c00a5a8 | 408 | v.rotate_left(998); |
7cac9316 XL |
409 | assert_eq!(v, expected); |
410 | v = (998..1000).chain(0..998).collect(); | |
2c00a5a8 | 411 | v.rotate_left(2); |
7cac9316 XL |
412 | assert_eq!(v, expected); |
413 | ||
414 | // non-small prime rotation, has a few rounds of swapping | |
415 | v = (389..1000).chain(0..389).collect(); | |
dfeec247 | 416 | v.rotate_left(1000 - 389); |
2c00a5a8 XL |
417 | assert_eq!(v, expected); |
418 | } | |
419 | ||
420 | #[test] | |
421 | fn test_rotate_right() { | |
422 | let expected: Vec<_> = (0..13).collect(); | |
423 | let mut v = Vec::new(); | |
424 | ||
425 | // no-ops | |
426 | v.clone_from(&expected); | |
427 | v.rotate_right(0); | |
428 | assert_eq!(v, expected); | |
429 | v.rotate_right(expected.len()); | |
430 | assert_eq!(v, expected); | |
431 | let mut zst_array = [(), (), ()]; | |
432 | zst_array.rotate_right(2); | |
433 | ||
434 | // happy path | |
435 | v = (5..13).chain(0..5).collect(); | |
436 | v.rotate_right(5); | |
437 | assert_eq!(v, expected); | |
438 | ||
439 | let expected: Vec<_> = (0..1000).collect(); | |
440 | ||
441 | // small rotations in large slice, uses ptr::copy | |
442 | v = (2..1000).chain(0..2).collect(); | |
443 | v.rotate_right(2); | |
444 | assert_eq!(v, expected); | |
445 | v = (998..1000).chain(0..998).collect(); | |
446 | v.rotate_right(998); | |
447 | assert_eq!(v, expected); | |
448 | ||
449 | // non-small prime rotation, has a few rounds of swapping | |
450 | v = (389..1000).chain(0..389).collect(); | |
451 | v.rotate_right(389); | |
7cac9316 XL |
452 | assert_eq!(v, expected); |
453 | } | |
454 | ||
c34b1796 AL |
455 | #[test] |
456 | fn test_concat() { | |
457 | let v: [Vec<i32>; 0] = []; | |
458 | let c = v.concat(); | |
459 | assert_eq!(c, []); | |
460 | let d = [vec![1], vec![2, 3]].concat(); | |
461 | assert_eq!(d, [1, 2, 3]); | |
462 | ||
463 | let v: &[&[_]] = &[&[1], &[2, 3]]; | |
c1a9b12d | 464 | assert_eq!(v.join(&0), [1, 0, 2, 3]); |
c34b1796 | 465 | let v: &[&[_]] = &[&[1], &[2], &[3]]; |
c1a9b12d | 466 | assert_eq!(v.join(&0), [1, 0, 2, 0, 3]); |
c34b1796 AL |
467 | } |
468 | ||
469 | #[test] | |
c1a9b12d | 470 | fn test_join() { |
c34b1796 | 471 | let v: [Vec<i32>; 0] = []; |
c1a9b12d SL |
472 | assert_eq!(v.join(&0), []); |
473 | assert_eq!([vec![1], vec![2, 3]].join(&0), [1, 0, 2, 3]); | |
474 | assert_eq!([vec![1], vec![2], vec![3]].join(&0), [1, 0, 2, 0, 3]); | |
c34b1796 AL |
475 | |
476 | let v: [&[_]; 2] = [&[1], &[2, 3]]; | |
c1a9b12d | 477 | assert_eq!(v.join(&0), [1, 0, 2, 3]); |
c34b1796 | 478 | let v: [&[_]; 3] = [&[1], &[2], &[3]]; |
c1a9b12d | 479 | assert_eq!(v.join(&0), [1, 0, 2, 0, 3]); |
c34b1796 AL |
480 | } |
481 | ||
94b46f34 XL |
482 | #[test] |
483 | fn test_join_nocopy() { | |
484 | let v: [String; 0] = []; | |
485 | assert_eq!(v.join(","), ""); | |
486 | assert_eq!(["a".to_string(), "ab".into()].join(","), "a,ab"); | |
487 | assert_eq!(["a".to_string(), "ab".into(), "abc".into()].join(","), "a,ab,abc"); | |
488 | assert_eq!(["a".to_string(), "ab".into(), "".into()].join(","), "a,ab,"); | |
489 | } | |
490 | ||
c34b1796 AL |
491 | #[test] |
492 | fn test_insert() { | |
493 | let mut a = vec![1, 2, 4]; | |
494 | a.insert(2, 3); | |
495 | assert_eq!(a, [1, 2, 3, 4]); | |
496 | ||
497 | let mut a = vec![1, 2, 3]; | |
498 | a.insert(0, 0); | |
499 | assert_eq!(a, [0, 1, 2, 3]); | |
500 | ||
501 | let mut a = vec![1, 2, 3]; | |
502 | a.insert(3, 4); | |
503 | assert_eq!(a, [1, 2, 3, 4]); | |
504 | ||
505 | let mut a = vec![]; | |
506 | a.insert(0, 1); | |
507 | assert_eq!(a, [1]); | |
508 | } | |
509 | ||
510 | #[test] | |
511 | #[should_panic] | |
512 | fn test_insert_oob() { | |
513 | let mut a = vec![1, 2, 3]; | |
514 | a.insert(4, 5); | |
515 | } | |
516 | ||
517 | #[test] | |
518 | fn test_remove() { | |
519 | let mut a = vec![1, 2, 3, 4]; | |
520 | ||
521 | assert_eq!(a.remove(2), 3); | |
522 | assert_eq!(a, [1, 2, 4]); | |
523 | ||
524 | assert_eq!(a.remove(2), 4); | |
525 | assert_eq!(a, [1, 2]); | |
526 | ||
527 | assert_eq!(a.remove(0), 1); | |
528 | assert_eq!(a, [2]); | |
529 | ||
530 | assert_eq!(a.remove(0), 2); | |
531 | assert_eq!(a, []); | |
532 | } | |
533 | ||
534 | #[test] | |
535 | #[should_panic] | |
536 | fn test_remove_fail() { | |
537 | let mut a = vec![1]; | |
538 | let _ = a.remove(0); | |
539 | let _ = a.remove(0); | |
540 | } | |
541 | ||
542 | #[test] | |
543 | fn test_capacity() { | |
544 | let mut v = vec![0]; | |
545 | v.reserve_exact(10); | |
546 | assert!(v.capacity() >= 11); | |
547 | } | |
548 | ||
549 | #[test] | |
550 | fn test_slice_2() { | |
551 | let v = vec![1, 2, 3, 4, 5]; | |
552 | let v = &v[1..3]; | |
553 | assert_eq!(v.len(), 2); | |
554 | assert_eq!(v[0], 2); | |
555 | assert_eq!(v[1], 3); | |
556 | } | |
557 | ||
54a0048b SL |
558 | macro_rules! assert_order { |
559 | (Greater, $a:expr, $b:expr) => { | |
560 | assert_eq!($a.cmp($b), Greater); | |
561 | assert!($a > $b); | |
562 | }; | |
563 | (Less, $a:expr, $b:expr) => { | |
564 | assert_eq!($a.cmp($b), Less); | |
565 | assert!($a < $b); | |
566 | }; | |
567 | (Equal, $a:expr, $b:expr) => { | |
568 | assert_eq!($a.cmp($b), Equal); | |
569 | assert_eq!($a, $b); | |
dfeec247 | 570 | }; |
54a0048b SL |
571 | } |
572 | ||
573 | #[test] | |
574 | fn test_total_ord_u8() { | |
575 | let c = &[1u8, 2, 3]; | |
576 | assert_order!(Greater, &[1u8, 2, 3, 4][..], &c[..]); | |
577 | let c = &[1u8, 2, 3, 4]; | |
578 | assert_order!(Less, &[1u8, 2, 3][..], &c[..]); | |
579 | let c = &[1u8, 2, 3, 6]; | |
580 | assert_order!(Equal, &[1u8, 2, 3, 6][..], &c[..]); | |
581 | let c = &[1u8, 2, 3, 4, 5, 6]; | |
582 | assert_order!(Less, &[1u8, 2, 3, 4, 5, 5, 5, 5][..], &c[..]); | |
583 | let c = &[1u8, 2, 3, 4]; | |
584 | assert_order!(Greater, &[2u8, 2][..], &c[..]); | |
585 | } | |
586 | ||
c34b1796 | 587 | #[test] |
54a0048b | 588 | fn test_total_ord_i32() { |
c34b1796 | 589 | let c = &[1, 2, 3]; |
54a0048b | 590 | assert_order!(Greater, &[1, 2, 3, 4][..], &c[..]); |
c34b1796 | 591 | let c = &[1, 2, 3, 4]; |
54a0048b | 592 | assert_order!(Less, &[1, 2, 3][..], &c[..]); |
c34b1796 | 593 | let c = &[1, 2, 3, 6]; |
54a0048b | 594 | assert_order!(Equal, &[1, 2, 3, 6][..], &c[..]); |
c34b1796 | 595 | let c = &[1, 2, 3, 4, 5, 6]; |
54a0048b | 596 | assert_order!(Less, &[1, 2, 3, 4, 5, 5, 5, 5][..], &c[..]); |
c34b1796 | 597 | let c = &[1, 2, 3, 4]; |
54a0048b | 598 | assert_order!(Greater, &[2, 2][..], &c[..]); |
c34b1796 AL |
599 | } |
600 | ||
601 | #[test] | |
602 | fn test_iterator() { | |
603 | let xs = [1, 2, 5, 10, 11]; | |
604 | let mut it = xs.iter(); | |
605 | assert_eq!(it.size_hint(), (5, Some(5))); | |
606 | assert_eq!(it.next().unwrap(), &1); | |
607 | assert_eq!(it.size_hint(), (4, Some(4))); | |
608 | assert_eq!(it.next().unwrap(), &2); | |
609 | assert_eq!(it.size_hint(), (3, Some(3))); | |
610 | assert_eq!(it.next().unwrap(), &5); | |
611 | assert_eq!(it.size_hint(), (2, Some(2))); | |
612 | assert_eq!(it.next().unwrap(), &10); | |
613 | assert_eq!(it.size_hint(), (1, Some(1))); | |
614 | assert_eq!(it.next().unwrap(), &11); | |
615 | assert_eq!(it.size_hint(), (0, Some(0))); | |
616 | assert!(it.next().is_none()); | |
617 | } | |
618 | ||
c34b1796 AL |
619 | #[test] |
620 | fn test_iter_size_hints() { | |
621 | let mut xs = [1, 2, 5, 10, 11]; | |
622 | assert_eq!(xs.iter().size_hint(), (5, Some(5))); | |
623 | assert_eq!(xs.iter_mut().size_hint(), (5, Some(5))); | |
624 | } | |
625 | ||
9e0c209e SL |
626 | #[test] |
627 | fn test_iter_as_slice() { | |
628 | let xs = [1, 2, 5, 10, 11]; | |
629 | let mut iter = xs.iter(); | |
630 | assert_eq!(iter.as_slice(), &[1, 2, 5, 10, 11]); | |
631 | iter.next(); | |
632 | assert_eq!(iter.as_slice(), &[2, 5, 10, 11]); | |
633 | } | |
634 | ||
635 | #[test] | |
636 | fn test_iter_as_ref() { | |
637 | let xs = [1, 2, 5, 10, 11]; | |
638 | let mut iter = xs.iter(); | |
639 | assert_eq!(iter.as_ref(), &[1, 2, 5, 10, 11]); | |
640 | iter.next(); | |
641 | assert_eq!(iter.as_ref(), &[2, 5, 10, 11]); | |
642 | } | |
643 | ||
c34b1796 AL |
644 | #[test] |
645 | fn test_iter_clone() { | |
646 | let xs = [1, 2, 5]; | |
647 | let mut it = xs.iter(); | |
648 | it.next(); | |
649 | let mut jt = it.clone(); | |
650 | assert_eq!(it.next(), jt.next()); | |
651 | assert_eq!(it.next(), jt.next()); | |
652 | assert_eq!(it.next(), jt.next()); | |
653 | } | |
654 | ||
476ff2be SL |
655 | #[test] |
656 | fn test_iter_is_empty() { | |
657 | let xs = [1, 2, 5, 10, 11]; | |
658 | for i in 0..xs.len() { | |
659 | for j in i..xs.len() { | |
660 | assert_eq!(xs[i..j].iter().is_empty(), xs[i..j].is_empty()); | |
661 | } | |
662 | } | |
663 | } | |
664 | ||
c34b1796 AL |
665 | #[test] |
666 | fn test_mut_iterator() { | |
667 | let mut xs = [1, 2, 3, 4, 5]; | |
668 | for x in &mut xs { | |
669 | *x += 1; | |
670 | } | |
671 | assert!(xs == [2, 3, 4, 5, 6]) | |
672 | } | |
673 | ||
674 | #[test] | |
675 | fn test_rev_iterator() { | |
c34b1796 AL |
676 | let xs = [1, 2, 5, 10, 11]; |
677 | let ys = [11, 10, 5, 2, 1]; | |
678 | let mut i = 0; | |
679 | for &x in xs.iter().rev() { | |
680 | assert_eq!(x, ys[i]); | |
681 | i += 1; | |
682 | } | |
683 | assert_eq!(i, 5); | |
684 | } | |
685 | ||
686 | #[test] | |
687 | fn test_mut_rev_iterator() { | |
688 | let mut xs = [1, 2, 3, 4, 5]; | |
3157f602 | 689 | for (i, x) in xs.iter_mut().rev().enumerate() { |
c34b1796 AL |
690 | *x += i; |
691 | } | |
692 | assert!(xs == [5, 5, 5, 5, 5]) | |
693 | } | |
694 | ||
695 | #[test] | |
696 | fn test_move_iterator() { | |
3157f602 | 697 | let xs = vec![1, 2, 3, 4, 5]; |
dfeec247 | 698 | assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10 * a + b), 12345); |
c34b1796 AL |
699 | } |
700 | ||
701 | #[test] | |
702 | fn test_move_rev_iterator() { | |
3157f602 | 703 | let xs = vec![1, 2, 3, 4, 5]; |
dfeec247 | 704 | assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10 * a + b), 54321); |
c34b1796 AL |
705 | } |
706 | ||
707 | #[test] | |
49aad941 | 708 | fn test_split_iterator() { |
3157f602 | 709 | let xs = &[1, 2, 3, 4, 5]; |
c34b1796 AL |
710 | |
711 | let splits: &[&[_]] = &[&[1], &[3], &[5]]; | |
3157f602 XL |
712 | assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(), splits); |
713 | let splits: &[&[_]] = &[&[], &[2, 3, 4, 5]]; | |
714 | assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(), splits); | |
715 | let splits: &[&[_]] = &[&[1, 2, 3, 4], &[]]; | |
716 | assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(), splits); | |
717 | let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; | |
718 | assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(), splits); | |
c34b1796 | 719 | let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]]; |
3157f602 | 720 | assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(), splits); |
c34b1796 AL |
721 | |
722 | let xs: &[i32] = &[]; | |
723 | let splits: &[&[i32]] = &[&[]]; | |
724 | assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits); | |
725 | } | |
726 | ||
74b04a01 | 727 | #[test] |
49aad941 | 728 | fn test_split_iterator_inclusive() { |
74b04a01 XL |
729 | let xs = &[1, 2, 3, 4, 5]; |
730 | ||
731 | let splits: &[&[_]] = &[&[1, 2], &[3, 4], &[5]]; | |
732 | assert_eq!(xs.split_inclusive(|x| *x % 2 == 0).collect::<Vec<_>>(), splits); | |
733 | let splits: &[&[_]] = &[&[1], &[2, 3, 4, 5]]; | |
734 | assert_eq!(xs.split_inclusive(|x| *x == 1).collect::<Vec<_>>(), splits); | |
735 | let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; | |
736 | assert_eq!(xs.split_inclusive(|x| *x == 5).collect::<Vec<_>>(), splits); | |
737 | let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; | |
738 | assert_eq!(xs.split_inclusive(|x| *x == 10).collect::<Vec<_>>(), splits); | |
739 | let splits: &[&[_]] = &[&[1], &[2], &[3], &[4], &[5]]; | |
740 | assert_eq!(xs.split_inclusive(|_| true).collect::<Vec<&[i32]>>(), splits); | |
741 | ||
742 | let xs: &[i32] = &[]; | |
a2a8927a | 743 | let splits: &[&[i32]] = &[]; |
74b04a01 XL |
744 | assert_eq!(xs.split_inclusive(|x| *x == 5).collect::<Vec<&[i32]>>(), splits); |
745 | } | |
746 | ||
747 | #[test] | |
49aad941 | 748 | fn test_split_iterator_inclusive_reverse() { |
74b04a01 XL |
749 | let xs = &[1, 2, 3, 4, 5]; |
750 | ||
751 | let splits: &[&[_]] = &[&[5], &[3, 4], &[1, 2]]; | |
752 | assert_eq!(xs.split_inclusive(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits); | |
753 | let splits: &[&[_]] = &[&[2, 3, 4, 5], &[1]]; | |
754 | assert_eq!(xs.split_inclusive(|x| *x == 1).rev().collect::<Vec<_>>(), splits); | |
755 | let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; | |
756 | assert_eq!(xs.split_inclusive(|x| *x == 5).rev().collect::<Vec<_>>(), splits); | |
757 | let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; | |
758 | assert_eq!(xs.split_inclusive(|x| *x == 10).rev().collect::<Vec<_>>(), splits); | |
759 | let splits: &[&[_]] = &[&[5], &[4], &[3], &[2], &[1]]; | |
760 | assert_eq!(xs.split_inclusive(|_| true).rev().collect::<Vec<_>>(), splits); | |
761 | ||
762 | let xs: &[i32] = &[]; | |
a2a8927a | 763 | let splits: &[&[i32]] = &[]; |
74b04a01 XL |
764 | assert_eq!(xs.split_inclusive(|x| *x == 5).rev().collect::<Vec<_>>(), splits); |
765 | } | |
766 | ||
767 | #[test] | |
49aad941 | 768 | fn test_split_iterator_mut_inclusive() { |
74b04a01 XL |
769 | let xs = &mut [1, 2, 3, 4, 5]; |
770 | ||
771 | let splits: &[&[_]] = &[&[1, 2], &[3, 4], &[5]]; | |
772 | assert_eq!(xs.split_inclusive_mut(|x| *x % 2 == 0).collect::<Vec<_>>(), splits); | |
773 | let splits: &[&[_]] = &[&[1], &[2, 3, 4, 5]]; | |
774 | assert_eq!(xs.split_inclusive_mut(|x| *x == 1).collect::<Vec<_>>(), splits); | |
775 | let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; | |
776 | assert_eq!(xs.split_inclusive_mut(|x| *x == 5).collect::<Vec<_>>(), splits); | |
777 | let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; | |
778 | assert_eq!(xs.split_inclusive_mut(|x| *x == 10).collect::<Vec<_>>(), splits); | |
779 | let splits: &[&[_]] = &[&[1], &[2], &[3], &[4], &[5]]; | |
780 | assert_eq!(xs.split_inclusive_mut(|_| true).collect::<Vec<_>>(), splits); | |
781 | ||
782 | let xs: &mut [i32] = &mut []; | |
a2a8927a | 783 | let splits: &[&[i32]] = &[]; |
74b04a01 XL |
784 | assert_eq!(xs.split_inclusive_mut(|x| *x == 5).collect::<Vec<_>>(), splits); |
785 | } | |
786 | ||
787 | #[test] | |
49aad941 | 788 | fn test_split_iterator_mut_inclusive_reverse() { |
74b04a01 XL |
789 | let xs = &mut [1, 2, 3, 4, 5]; |
790 | ||
791 | let splits: &[&[_]] = &[&[5], &[3, 4], &[1, 2]]; | |
792 | assert_eq!(xs.split_inclusive_mut(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits); | |
793 | let splits: &[&[_]] = &[&[2, 3, 4, 5], &[1]]; | |
794 | assert_eq!(xs.split_inclusive_mut(|x| *x == 1).rev().collect::<Vec<_>>(), splits); | |
795 | let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; | |
796 | assert_eq!(xs.split_inclusive_mut(|x| *x == 5).rev().collect::<Vec<_>>(), splits); | |
797 | let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; | |
798 | assert_eq!(xs.split_inclusive_mut(|x| *x == 10).rev().collect::<Vec<_>>(), splits); | |
799 | let splits: &[&[_]] = &[&[5], &[4], &[3], &[2], &[1]]; | |
800 | assert_eq!(xs.split_inclusive_mut(|_| true).rev().collect::<Vec<_>>(), splits); | |
801 | ||
802 | let xs: &mut [i32] = &mut []; | |
a2a8927a | 803 | let splits: &[&[i32]] = &[]; |
74b04a01 XL |
804 | assert_eq!(xs.split_inclusive_mut(|x| *x == 5).rev().collect::<Vec<_>>(), splits); |
805 | } | |
806 | ||
c34b1796 | 807 | #[test] |
49aad941 | 808 | fn test_splitn_iterator() { |
3157f602 | 809 | let xs = &[1, 2, 3, 4, 5]; |
c34b1796 | 810 | |
3157f602 XL |
811 | let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; |
812 | assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits); | |
813 | let splits: &[&[_]] = &[&[1], &[3, 4, 5]]; | |
814 | assert_eq!(xs.splitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits); | |
815 | let splits: &[&[_]] = &[&[], &[], &[], &[4, 5]]; | |
816 | assert_eq!(xs.splitn(4, |_| true).collect::<Vec<_>>(), splits); | |
c34b1796 AL |
817 | |
818 | let xs: &[i32] = &[]; | |
819 | let splits: &[&[i32]] = &[&[]]; | |
820 | assert_eq!(xs.splitn(2, |x| *x == 5).collect::<Vec<_>>(), splits); | |
821 | } | |
822 | ||
823 | #[test] | |
49aad941 | 824 | fn test_splitn_iterator_mut() { |
3157f602 | 825 | let xs = &mut [1, 2, 3, 4, 5]; |
c34b1796 | 826 | |
3157f602 | 827 | let splits: &[&mut [_]] = &[&mut [1, 2, 3, 4, 5]]; |
dfeec247 | 828 | assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits); |
3157f602 | 829 | let splits: &[&mut [_]] = &[&mut [1], &mut [3, 4, 5]]; |
dfeec247 | 830 | assert_eq!(xs.splitn_mut(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits); |
3157f602 XL |
831 | let splits: &[&mut [_]] = &[&mut [], &mut [], &mut [], &mut [4, 5]]; |
832 | assert_eq!(xs.splitn_mut(4, |_| true).collect::<Vec<_>>(), splits); | |
c34b1796 AL |
833 | |
834 | let xs: &mut [i32] = &mut []; | |
3157f602 XL |
835 | let splits: &[&mut [i32]] = &[&mut []]; |
836 | assert_eq!(xs.splitn_mut(2, |x| *x == 5).collect::<Vec<_>>(), splits); | |
c34b1796 AL |
837 | } |
838 | ||
839 | #[test] | |
49aad941 | 840 | fn test_rsplit_iterator() { |
3157f602 | 841 | let xs = &[1, 2, 3, 4, 5]; |
c34b1796 AL |
842 | |
843 | let splits: &[&[_]] = &[&[5], &[3], &[1]]; | |
3157f602 XL |
844 | assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits); |
845 | let splits: &[&[_]] = &[&[2, 3, 4, 5], &[]]; | |
846 | assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(), splits); | |
847 | let splits: &[&[_]] = &[&[], &[1, 2, 3, 4]]; | |
848 | assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(), splits); | |
849 | let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; | |
850 | assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(), splits); | |
c34b1796 AL |
851 | |
852 | let xs: &[i32] = &[]; | |
853 | let splits: &[&[i32]] = &[&[]]; | |
854 | assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits); | |
855 | } | |
856 | ||
857 | #[test] | |
49aad941 | 858 | fn test_rsplitn_iterator() { |
3157f602 | 859 | let xs = &[1, 2, 3, 4, 5]; |
c34b1796 | 860 | |
3157f602 XL |
861 | let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; |
862 | assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits); | |
863 | let splits: &[&[_]] = &[&[5], &[1, 2, 3]]; | |
864 | assert_eq!(xs.rsplitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits); | |
865 | let splits: &[&[_]] = &[&[], &[], &[], &[1, 2]]; | |
866 | assert_eq!(xs.rsplitn(4, |_| true).collect::<Vec<_>>(), splits); | |
c34b1796 | 867 | |
3157f602 | 868 | let xs: &[i32] = &[]; |
c34b1796 AL |
869 | let splits: &[&[i32]] = &[&[]]; |
870 | assert_eq!(xs.rsplitn(2, |x| *x == 5).collect::<Vec<&[i32]>>(), splits); | |
871 | assert!(xs.rsplitn(0, |x| *x % 2 == 0).next().is_none()); | |
872 | } | |
873 | ||
94222f64 XL |
874 | #[test] |
875 | fn test_split_iterators_size_hint() { | |
876 | #[derive(Copy, Clone)] | |
877 | enum Bounds { | |
878 | Lower, | |
879 | Upper, | |
880 | } | |
881 | fn assert_tight_size_hints(mut it: impl Iterator, which: Bounds, ctx: impl fmt::Display) { | |
882 | match which { | |
883 | Bounds::Lower => { | |
884 | let mut lower_bounds = vec![it.size_hint().0]; | |
885 | while let Some(_) = it.next() { | |
886 | lower_bounds.push(it.size_hint().0); | |
887 | } | |
888 | let target: Vec<_> = (0..lower_bounds.len()).rev().collect(); | |
889 | assert_eq!(lower_bounds, target, "lower bounds incorrect or not tight: {}", ctx); | |
890 | } | |
891 | Bounds::Upper => { | |
892 | let mut upper_bounds = vec![it.size_hint().1]; | |
893 | while let Some(_) = it.next() { | |
894 | upper_bounds.push(it.size_hint().1); | |
895 | } | |
896 | let target: Vec<_> = (0..upper_bounds.len()).map(Some).rev().collect(); | |
897 | assert_eq!(upper_bounds, target, "upper bounds incorrect or not tight: {}", ctx); | |
898 | } | |
899 | } | |
900 | } | |
901 | ||
902 | for len in 0..=2 { | |
903 | let mut v: Vec<u8> = (0..len).collect(); | |
904 | ||
905 | // p: predicate, b: bound selection | |
906 | for (p, b) in [ | |
907 | // with a predicate always returning false, the split*-iterators | |
908 | // become maximally short, so the size_hint lower bounds are tight | |
909 | ((|_| false) as fn(&_) -> _, Bounds::Lower), | |
910 | // with a predicate always returning true, the split*-iterators | |
911 | // become maximally long, so the size_hint upper bounds are tight | |
912 | ((|_| true) as fn(&_) -> _, Bounds::Upper), | |
913 | ] { | |
914 | use assert_tight_size_hints as a; | |
915 | use format_args as f; | |
916 | ||
917 | a(v.split(p), b, "split"); | |
918 | a(v.split_mut(p), b, "split_mut"); | |
919 | a(v.split_inclusive(p), b, "split_inclusive"); | |
920 | a(v.split_inclusive_mut(p), b, "split_inclusive_mut"); | |
921 | a(v.rsplit(p), b, "rsplit"); | |
922 | a(v.rsplit_mut(p), b, "rsplit_mut"); | |
923 | ||
924 | for n in 0..=3 { | |
5e7ed085 FG |
925 | a(v.splitn(n, p), b, f!("splitn, n = {n}")); |
926 | a(v.splitn_mut(n, p), b, f!("splitn_mut, n = {n}")); | |
927 | a(v.rsplitn(n, p), b, f!("rsplitn, n = {n}")); | |
928 | a(v.rsplitn_mut(n, p), b, f!("rsplitn_mut, n = {n}")); | |
94222f64 XL |
929 | } |
930 | } | |
931 | } | |
932 | } | |
933 | ||
c34b1796 | 934 | #[test] |
49aad941 | 935 | fn test_windows_iterator() { |
3157f602 | 936 | let v = &[1, 2, 3, 4]; |
c34b1796 | 937 | |
3157f602 | 938 | let wins: &[&[_]] = &[&[1, 2], &[2, 3], &[3, 4]]; |
c34b1796 AL |
939 | assert_eq!(v.windows(2).collect::<Vec<_>>(), wins); |
940 | ||
3157f602 | 941 | let wins: &[&[_]] = &[&[1, 2, 3], &[2, 3, 4]]; |
c34b1796 AL |
942 | assert_eq!(v.windows(3).collect::<Vec<_>>(), wins); |
943 | assert!(v.windows(6).next().is_none()); | |
944 | ||
3157f602 | 945 | let wins: &[&[_]] = &[&[3, 4], &[2, 3], &[1, 2]]; |
c34b1796 | 946 | assert_eq!(v.windows(2).rev().collect::<Vec<&[_]>>(), wins); |
c34b1796 AL |
947 | } |
948 | ||
949 | #[test] | |
950 | #[should_panic] | |
49aad941 | 951 | fn test_windows_iterator_0() { |
3157f602 | 952 | let v = &[1, 2, 3, 4]; |
c34b1796 AL |
953 | let _it = v.windows(0); |
954 | } | |
955 | ||
956 | #[test] | |
49aad941 | 957 | fn test_chunks_iterator() { |
3157f602 | 958 | let v = &[1, 2, 3, 4, 5]; |
c34b1796 AL |
959 | |
960 | assert_eq!(v.chunks(2).len(), 3); | |
961 | ||
3157f602 | 962 | let chunks: &[&[_]] = &[&[1, 2], &[3, 4], &[5]]; |
c34b1796 | 963 | assert_eq!(v.chunks(2).collect::<Vec<_>>(), chunks); |
3157f602 | 964 | let chunks: &[&[_]] = &[&[1, 2, 3], &[4, 5]]; |
c34b1796 | 965 | assert_eq!(v.chunks(3).collect::<Vec<_>>(), chunks); |
3157f602 | 966 | let chunks: &[&[_]] = &[&[1, 2, 3, 4, 5]]; |
c34b1796 AL |
967 | assert_eq!(v.chunks(6).collect::<Vec<_>>(), chunks); |
968 | ||
3157f602 | 969 | let chunks: &[&[_]] = &[&[5], &[3, 4], &[1, 2]]; |
c34b1796 | 970 | assert_eq!(v.chunks(2).rev().collect::<Vec<_>>(), chunks); |
c34b1796 AL |
971 | } |
972 | ||
973 | #[test] | |
974 | #[should_panic] | |
49aad941 | 975 | fn test_chunks_iterator_0() { |
3157f602 | 976 | let v = &[1, 2, 3, 4]; |
c34b1796 AL |
977 | let _it = v.chunks(0); |
978 | } | |
979 | ||
2c00a5a8 | 980 | #[test] |
49aad941 | 981 | fn test_chunks_exact_iterator() { |
2c00a5a8 XL |
982 | let v = &[1, 2, 3, 4, 5]; |
983 | ||
0bf4aa26 | 984 | assert_eq!(v.chunks_exact(2).len(), 2); |
2c00a5a8 XL |
985 | |
986 | let chunks: &[&[_]] = &[&[1, 2], &[3, 4]]; | |
0bf4aa26 | 987 | assert_eq!(v.chunks_exact(2).collect::<Vec<_>>(), chunks); |
2c00a5a8 | 988 | let chunks: &[&[_]] = &[&[1, 2, 3]]; |
0bf4aa26 | 989 | assert_eq!(v.chunks_exact(3).collect::<Vec<_>>(), chunks); |
2c00a5a8 | 990 | let chunks: &[&[_]] = &[]; |
0bf4aa26 | 991 | assert_eq!(v.chunks_exact(6).collect::<Vec<_>>(), chunks); |
2c00a5a8 XL |
992 | |
993 | let chunks: &[&[_]] = &[&[3, 4], &[1, 2]]; | |
0bf4aa26 | 994 | assert_eq!(v.chunks_exact(2).rev().collect::<Vec<_>>(), chunks); |
2c00a5a8 XL |
995 | } |
996 | ||
997 | #[test] | |
998 | #[should_panic] | |
49aad941 | 999 | fn test_chunks_exact_iterator_0() { |
2c00a5a8 | 1000 | let v = &[1, 2, 3, 4]; |
0bf4aa26 XL |
1001 | let _it = v.chunks_exact(0); |
1002 | } | |
1003 | ||
1004 | #[test] | |
49aad941 | 1005 | fn test_rchunks_iterator() { |
0bf4aa26 XL |
1006 | let v = &[1, 2, 3, 4, 5]; |
1007 | ||
1008 | assert_eq!(v.rchunks(2).len(), 3); | |
1009 | ||
1010 | let chunks: &[&[_]] = &[&[4, 5], &[2, 3], &[1]]; | |
1011 | assert_eq!(v.rchunks(2).collect::<Vec<_>>(), chunks); | |
1012 | let chunks: &[&[_]] = &[&[3, 4, 5], &[1, 2]]; | |
1013 | assert_eq!(v.rchunks(3).collect::<Vec<_>>(), chunks); | |
1014 | let chunks: &[&[_]] = &[&[1, 2, 3, 4, 5]]; | |
1015 | assert_eq!(v.rchunks(6).collect::<Vec<_>>(), chunks); | |
1016 | ||
1017 | let chunks: &[&[_]] = &[&[1], &[2, 3], &[4, 5]]; | |
1018 | assert_eq!(v.rchunks(2).rev().collect::<Vec<_>>(), chunks); | |
1019 | } | |
1020 | ||
1021 | #[test] | |
1022 | #[should_panic] | |
49aad941 | 1023 | fn test_rchunks_iterator_0() { |
0bf4aa26 XL |
1024 | let v = &[1, 2, 3, 4]; |
1025 | let _it = v.rchunks(0); | |
1026 | } | |
1027 | ||
1028 | #[test] | |
49aad941 | 1029 | fn test_rchunks_exact_iterator() { |
0bf4aa26 XL |
1030 | let v = &[1, 2, 3, 4, 5]; |
1031 | ||
1032 | assert_eq!(v.rchunks_exact(2).len(), 2); | |
1033 | ||
1034 | let chunks: &[&[_]] = &[&[4, 5], &[2, 3]]; | |
1035 | assert_eq!(v.rchunks_exact(2).collect::<Vec<_>>(), chunks); | |
1036 | let chunks: &[&[_]] = &[&[3, 4, 5]]; | |
1037 | assert_eq!(v.rchunks_exact(3).collect::<Vec<_>>(), chunks); | |
1038 | let chunks: &[&[_]] = &[]; | |
1039 | assert_eq!(v.rchunks_exact(6).collect::<Vec<_>>(), chunks); | |
1040 | ||
1041 | let chunks: &[&[_]] = &[&[2, 3], &[4, 5]]; | |
1042 | assert_eq!(v.rchunks_exact(2).rev().collect::<Vec<_>>(), chunks); | |
1043 | } | |
1044 | ||
1045 | #[test] | |
1046 | #[should_panic] | |
49aad941 | 1047 | fn test_rchunks_exact_iterator_0() { |
0bf4aa26 XL |
1048 | let v = &[1, 2, 3, 4]; |
1049 | let _it = v.rchunks_exact(0); | |
2c00a5a8 XL |
1050 | } |
1051 | ||
c34b1796 AL |
1052 | #[test] |
1053 | fn test_reverse_part() { | |
3157f602 | 1054 | let mut values = [1, 2, 3, 4, 5]; |
c34b1796 | 1055 | values[1..4].reverse(); |
3157f602 | 1056 | assert!(values == [1, 4, 3, 2, 5]); |
c34b1796 AL |
1057 | } |
1058 | ||
1059 | #[test] | |
1060 | fn test_show() { | |
1061 | macro_rules! test_show_vec { | |
dfeec247 | 1062 | ($x:expr, $x_str:expr) => {{ |
c34b1796 | 1063 | let (x, x_str) = ($x, $x_str); |
5e7ed085 FG |
1064 | assert_eq!(format!("{x:?}"), x_str); |
1065 | assert_eq!(format!("{x:?}"), x_str); | |
dfeec247 | 1066 | }}; |
c34b1796 AL |
1067 | } |
1068 | let empty = Vec::<i32>::new(); | |
1069 | test_show_vec!(empty, "[]"); | |
1070 | test_show_vec!(vec![1], "[1]"); | |
1071 | test_show_vec!(vec![1, 2, 3], "[1, 2, 3]"); | |
3157f602 | 1072 | test_show_vec!(vec![vec![], vec![1], vec![1, 1]], "[[], [1], [1, 1]]"); |
c34b1796 | 1073 | |
3157f602 | 1074 | let empty_mut: &mut [i32] = &mut []; |
c34b1796 | 1075 | test_show_vec!(empty_mut, "[]"); |
3157f602 | 1076 | let v = &mut [1]; |
c34b1796 | 1077 | test_show_vec!(v, "[1]"); |
3157f602 | 1078 | let v = &mut [1, 2, 3]; |
c34b1796 | 1079 | test_show_vec!(v, "[1, 2, 3]"); |
3157f602 | 1080 | let v: &mut [&mut [_]] = &mut [&mut [], &mut [1], &mut [1, 1]]; |
c34b1796 AL |
1081 | test_show_vec!(v, "[[], [1], [1, 1]]"); |
1082 | } | |
1083 | ||
1084 | #[test] | |
1085 | fn test_vec_default() { | |
1086 | macro_rules! t { | |
1087 | ($ty:ty) => {{ | |
1088 | let v: $ty = Default::default(); | |
1089 | assert!(v.is_empty()); | |
dfeec247 | 1090 | }}; |
c34b1796 AL |
1091 | } |
1092 | ||
1093 | t!(&[i32]); | |
1094 | t!(Vec<i32>); | |
1095 | } | |
1096 | ||
c34b1796 AL |
1097 | #[test] |
1098 | #[should_panic] | |
1099 | fn test_overflow_does_not_cause_segfault() { | |
1100 | let mut v = vec![]; | |
1101 | v.reserve_exact(!0); | |
1102 | v.push(1); | |
1103 | v.push(2); | |
1104 | } | |
1105 | ||
1106 | #[test] | |
1107 | #[should_panic] | |
1108 | fn test_overflow_does_not_cause_segfault_managed() { | |
1109 | let mut v = vec![Rc::new(1)]; | |
1110 | v.reserve_exact(!0); | |
1111 | v.push(Rc::new(2)); | |
1112 | } | |
1113 | ||
1114 | #[test] | |
1115 | fn test_mut_split_at() { | |
3157f602 | 1116 | let mut values = [1, 2, 3, 4, 5]; |
c34b1796 AL |
1117 | { |
1118 | let (left, right) = values.split_at_mut(2); | |
1119 | { | |
1120 | let left: &[_] = left; | |
1121 | assert!(left[..left.len()] == [1, 2]); | |
1122 | } | |
1123 | for p in left { | |
1124 | *p += 1; | |
1125 | } | |
1126 | ||
1127 | { | |
1128 | let right: &[_] = right; | |
1129 | assert!(right[..right.len()] == [3, 4, 5]); | |
1130 | } | |
1131 | for p in right { | |
1132 | *p += 2; | |
1133 | } | |
1134 | } | |
1135 | ||
1136 | assert!(values == [2, 3, 5, 6, 7]); | |
1137 | } | |
1138 | ||
1139 | #[derive(Clone, PartialEq)] | |
1140 | struct Foo; | |
1141 | ||
1142 | #[test] | |
1143 | fn test_iter_zero_sized() { | |
1144 | let mut v = vec![Foo, Foo, Foo]; | |
1145 | assert_eq!(v.len(), 3); | |
1146 | let mut cnt = 0; | |
1147 | ||
1148 | for f in &v { | |
1149 | assert!(*f == Foo); | |
1150 | cnt += 1; | |
1151 | } | |
1152 | assert_eq!(cnt, 3); | |
1153 | ||
1154 | for f in &v[1..3] { | |
1155 | assert!(*f == Foo); | |
1156 | cnt += 1; | |
1157 | } | |
1158 | assert_eq!(cnt, 5); | |
1159 | ||
1160 | for f in &mut v { | |
1161 | assert!(*f == Foo); | |
1162 | cnt += 1; | |
1163 | } | |
1164 | assert_eq!(cnt, 8); | |
1165 | ||
1166 | for f in v { | |
1167 | assert!(f == Foo); | |
1168 | cnt += 1; | |
1169 | } | |
1170 | assert_eq!(cnt, 11); | |
1171 | ||
1172 | let xs: [Foo; 3] = [Foo, Foo, Foo]; | |
1173 | cnt = 0; | |
1174 | for f in &xs { | |
1175 | assert!(*f == Foo); | |
1176 | cnt += 1; | |
1177 | } | |
1178 | assert!(cnt == 3); | |
1179 | } | |
1180 | ||
1181 | #[test] | |
1182 | fn test_shrink_to_fit() { | |
1183 | let mut xs = vec![0, 1, 2, 3]; | |
1184 | for i in 4..100 { | |
1185 | xs.push(i) | |
1186 | } | |
1187 | assert_eq!(xs.capacity(), 128); | |
1188 | xs.shrink_to_fit(); | |
1189 | assert_eq!(xs.capacity(), 100); | |
1190 | assert_eq!(xs, (0..100).collect::<Vec<_>>()); | |
1191 | } | |
1192 | ||
1193 | #[test] | |
1194 | fn test_starts_with() { | |
1195 | assert!(b"foobar".starts_with(b"foo")); | |
1196 | assert!(!b"foobar".starts_with(b"oob")); | |
1197 | assert!(!b"foobar".starts_with(b"bar")); | |
1198 | assert!(!b"foo".starts_with(b"foobar")); | |
1199 | assert!(!b"bar".starts_with(b"foobar")); | |
1200 | assert!(b"foobar".starts_with(b"foobar")); | |
1201 | let empty: &[u8] = &[]; | |
1202 | assert!(empty.starts_with(empty)); | |
1203 | assert!(!empty.starts_with(b"foo")); | |
1204 | assert!(b"foobar".starts_with(empty)); | |
1205 | } | |
1206 | ||
1207 | #[test] | |
1208 | fn test_ends_with() { | |
1209 | assert!(b"foobar".ends_with(b"bar")); | |
1210 | assert!(!b"foobar".ends_with(b"oba")); | |
1211 | assert!(!b"foobar".ends_with(b"foo")); | |
1212 | assert!(!b"foo".ends_with(b"foobar")); | |
1213 | assert!(!b"bar".ends_with(b"foobar")); | |
1214 | assert!(b"foobar".ends_with(b"foobar")); | |
1215 | let empty: &[u8] = &[]; | |
1216 | assert!(empty.ends_with(empty)); | |
1217 | assert!(!empty.ends_with(b"foo")); | |
1218 | assert!(b"foobar".ends_with(empty)); | |
1219 | } | |
1220 | ||
1221 | #[test] | |
49aad941 | 1222 | fn test_mut_split_iterator() { |
3157f602 | 1223 | let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0]; |
c34b1796 AL |
1224 | assert_eq!(xs.split_mut(|x| *x == 0).count(), 6); |
1225 | for slice in xs.split_mut(|x| *x == 0) { | |
1226 | slice.reverse(); | |
1227 | } | |
3157f602 | 1228 | assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0]); |
c34b1796 | 1229 | |
3157f602 | 1230 | let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0, 6, 7]; |
c34b1796 AL |
1231 | for slice in xs.split_mut(|x| *x == 0).take(5) { |
1232 | slice.reverse(); | |
1233 | } | |
3157f602 | 1234 | assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0, 6, 7]); |
c34b1796 AL |
1235 | } |
1236 | ||
1237 | #[test] | |
49aad941 | 1238 | fn test_mut_split_iterator_rev() { |
3157f602 | 1239 | let mut xs = [1, 2, 0, 3, 4, 0, 0, 5, 6, 0]; |
c34b1796 AL |
1240 | for slice in xs.split_mut(|x| *x == 0).rev().take(4) { |
1241 | slice.reverse(); | |
1242 | } | |
3157f602 | 1243 | assert!(xs == [1, 2, 0, 4, 3, 0, 0, 6, 5, 0]); |
c34b1796 AL |
1244 | } |
1245 | ||
1246 | #[test] | |
1247 | fn test_get_mut() { | |
3157f602 | 1248 | let mut v = [0, 1, 2]; |
c34b1796 AL |
1249 | assert_eq!(v.get_mut(3), None); |
1250 | v.get_mut(1).map(|e| *e = 7); | |
1251 | assert_eq!(v[1], 7); | |
1252 | let mut x = 2; | |
1253 | assert_eq!(v.get_mut(2), Some(&mut x)); | |
1254 | } | |
1255 | ||
1256 | #[test] | |
1257 | fn test_mut_chunks() { | |
1258 | let mut v = [0, 1, 2, 3, 4, 5, 6]; | |
0bf4aa26 | 1259 | assert_eq!(v.chunks_mut(3).len(), 3); |
c34b1796 AL |
1260 | for (i, chunk) in v.chunks_mut(3).enumerate() { |
1261 | for x in chunk { | |
1262 | *x = i as u8; | |
1263 | } | |
1264 | } | |
1265 | let result = [0, 0, 0, 1, 1, 1, 2]; | |
2c00a5a8 | 1266 | assert_eq!(v, result); |
c34b1796 AL |
1267 | } |
1268 | ||
1269 | #[test] | |
1270 | fn test_mut_chunks_rev() { | |
1271 | let mut v = [0, 1, 2, 3, 4, 5, 6]; | |
1272 | for (i, chunk) in v.chunks_mut(3).rev().enumerate() { | |
1273 | for x in chunk { | |
1274 | *x = i as u8; | |
1275 | } | |
1276 | } | |
1277 | let result = [2, 2, 2, 1, 1, 1, 0]; | |
2c00a5a8 | 1278 | assert_eq!(v, result); |
c34b1796 AL |
1279 | } |
1280 | ||
1281 | #[test] | |
1282 | #[should_panic] | |
1283 | fn test_mut_chunks_0() { | |
1284 | let mut v = [1, 2, 3, 4]; | |
1285 | let _it = v.chunks_mut(0); | |
1286 | } | |
1287 | ||
2c00a5a8 | 1288 | #[test] |
0bf4aa26 | 1289 | fn test_mut_chunks_exact() { |
2c00a5a8 | 1290 | let mut v = [0, 1, 2, 3, 4, 5, 6]; |
0bf4aa26 XL |
1291 | assert_eq!(v.chunks_exact_mut(3).len(), 2); |
1292 | for (i, chunk) in v.chunks_exact_mut(3).enumerate() { | |
2c00a5a8 XL |
1293 | for x in chunk { |
1294 | *x = i as u8; | |
1295 | } | |
1296 | } | |
1297 | let result = [0, 0, 0, 1, 1, 1, 6]; | |
1298 | assert_eq!(v, result); | |
1299 | } | |
1300 | ||
1301 | #[test] | |
0bf4aa26 | 1302 | fn test_mut_chunks_exact_rev() { |
2c00a5a8 | 1303 | let mut v = [0, 1, 2, 3, 4, 5, 6]; |
0bf4aa26 | 1304 | for (i, chunk) in v.chunks_exact_mut(3).rev().enumerate() { |
2c00a5a8 XL |
1305 | for x in chunk { |
1306 | *x = i as u8; | |
1307 | } | |
1308 | } | |
1309 | let result = [1, 1, 1, 0, 0, 0, 6]; | |
1310 | assert_eq!(v, result); | |
1311 | } | |
1312 | ||
1313 | #[test] | |
1314 | #[should_panic] | |
0bf4aa26 XL |
1315 | fn test_mut_chunks_exact_0() { |
1316 | let mut v = [1, 2, 3, 4]; | |
1317 | let _it = v.chunks_exact_mut(0); | |
1318 | } | |
1319 | ||
1320 | #[test] | |
1321 | fn test_mut_rchunks() { | |
1322 | let mut v = [0, 1, 2, 3, 4, 5, 6]; | |
1323 | assert_eq!(v.rchunks_mut(3).len(), 3); | |
1324 | for (i, chunk) in v.rchunks_mut(3).enumerate() { | |
1325 | for x in chunk { | |
1326 | *x = i as u8; | |
1327 | } | |
1328 | } | |
1329 | let result = [2, 1, 1, 1, 0, 0, 0]; | |
1330 | assert_eq!(v, result); | |
1331 | } | |
1332 | ||
1333 | #[test] | |
1334 | fn test_mut_rchunks_rev() { | |
1335 | let mut v = [0, 1, 2, 3, 4, 5, 6]; | |
1336 | for (i, chunk) in v.rchunks_mut(3).rev().enumerate() { | |
1337 | for x in chunk { | |
1338 | *x = i as u8; | |
1339 | } | |
1340 | } | |
1341 | let result = [0, 1, 1, 1, 2, 2, 2]; | |
1342 | assert_eq!(v, result); | |
1343 | } | |
1344 | ||
1345 | #[test] | |
1346 | #[should_panic] | |
1347 | fn test_mut_rchunks_0() { | |
1348 | let mut v = [1, 2, 3, 4]; | |
1349 | let _it = v.rchunks_mut(0); | |
1350 | } | |
1351 | ||
1352 | #[test] | |
1353 | fn test_mut_rchunks_exact() { | |
1354 | let mut v = [0, 1, 2, 3, 4, 5, 6]; | |
1355 | assert_eq!(v.rchunks_exact_mut(3).len(), 2); | |
1356 | for (i, chunk) in v.rchunks_exact_mut(3).enumerate() { | |
1357 | for x in chunk { | |
1358 | *x = i as u8; | |
1359 | } | |
1360 | } | |
1361 | let result = [0, 1, 1, 1, 0, 0, 0]; | |
1362 | assert_eq!(v, result); | |
1363 | } | |
1364 | ||
1365 | #[test] | |
1366 | fn test_mut_rchunks_exact_rev() { | |
1367 | let mut v = [0, 1, 2, 3, 4, 5, 6]; | |
1368 | for (i, chunk) in v.rchunks_exact_mut(3).rev().enumerate() { | |
1369 | for x in chunk { | |
1370 | *x = i as u8; | |
1371 | } | |
1372 | } | |
1373 | let result = [0, 0, 0, 0, 1, 1, 1]; | |
1374 | assert_eq!(v, result); | |
1375 | } | |
1376 | ||
1377 | #[test] | |
1378 | #[should_panic] | |
1379 | fn test_mut_rchunks_exact_0() { | |
2c00a5a8 | 1380 | let mut v = [1, 2, 3, 4]; |
0bf4aa26 | 1381 | let _it = v.rchunks_exact_mut(0); |
2c00a5a8 XL |
1382 | } |
1383 | ||
c34b1796 AL |
1384 | #[test] |
1385 | fn test_mut_last() { | |
1386 | let mut x = [1, 2, 3, 4, 5]; | |
1387 | let h = x.last_mut(); | |
1388 | assert_eq!(*h.unwrap(), 5); | |
1389 | ||
1390 | let y: &mut [i32] = &mut []; | |
1391 | assert!(y.last_mut().is_none()); | |
1392 | } | |
1393 | ||
1394 | #[test] | |
1395 | fn test_to_vec() { | |
923072b8 | 1396 | let xs: Box<_> = Box::new([1, 2, 3]); |
c34b1796 AL |
1397 | let ys = xs.to_vec(); |
1398 | assert_eq!(ys, [1, 2, 3]); | |
1399 | } | |
1400 | ||
1b1a35ee XL |
1401 | #[test] |
1402 | fn test_in_place_iterator_specialization() { | |
923072b8 | 1403 | let src: Box<[usize]> = Box::new([1, 2, 3]); |
1b1a35ee XL |
1404 | let src_ptr = src.as_ptr(); |
1405 | let sink: Box<_> = src.into_vec().into_iter().map(std::convert::identity).collect(); | |
1406 | let sink_ptr = sink.as_ptr(); | |
1407 | assert_eq!(src_ptr, sink_ptr); | |
1408 | } | |
1409 | ||
c1a9b12d SL |
1410 | #[test] |
1411 | fn test_box_slice_clone() { | |
1412 | let data = vec![vec![0, 1], vec![0], vec![1]]; | |
1413 | let data2 = data.clone().into_boxed_slice().clone().to_vec(); | |
1414 | ||
1415 | assert_eq!(data, data2); | |
1416 | } | |
1417 | ||
1418 | #[test] | |
83c7162d | 1419 | #[allow(unused_must_use)] // here, we care about the side effects of `.clone()` |
c30ab7b3 | 1420 | #[cfg_attr(target_os = "emscripten", ignore)] |
fe692bf9 | 1421 | #[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")] |
c1a9b12d | 1422 | fn test_box_slice_clone_panics() { |
c1a9b12d | 1423 | use std::sync::atomic::{AtomicUsize, Ordering}; |
dfeec247 | 1424 | use std::sync::Arc; |
c1a9b12d SL |
1425 | |
1426 | struct Canary { | |
1427 | count: Arc<AtomicUsize>, | |
3157f602 | 1428 | panics: bool, |
c1a9b12d SL |
1429 | } |
1430 | ||
1431 | impl Drop for Canary { | |
1432 | fn drop(&mut self) { | |
1433 | self.count.fetch_add(1, Ordering::SeqCst); | |
1434 | } | |
1435 | } | |
1436 | ||
1437 | impl Clone for Canary { | |
1438 | fn clone(&self) -> Self { | |
3157f602 XL |
1439 | if self.panics { |
1440 | panic!() | |
1441 | } | |
c1a9b12d | 1442 | |
dfeec247 | 1443 | Canary { count: self.count.clone(), panics: self.panics } |
c1a9b12d SL |
1444 | } |
1445 | } | |
1446 | ||
1447 | let drop_count = Arc::new(AtomicUsize::new(0)); | |
dfeec247 XL |
1448 | let canary = Canary { count: drop_count.clone(), panics: false }; |
1449 | let panic = Canary { count: drop_count.clone(), panics: true }; | |
c1a9b12d | 1450 | |
60c5eb7d | 1451 | std::panic::catch_unwind(move || { |
dfeec247 XL |
1452 | // When xs is dropped, +5. |
1453 | let xs = | |
1454 | vec![canary.clone(), canary.clone(), canary.clone(), panic, canary].into_boxed_slice(); | |
c1a9b12d | 1455 | |
dfeec247 XL |
1456 | // When panic is cloned, +3. |
1457 | xs.clone(); | |
1458 | }) | |
1459 | .unwrap_err(); | |
c1a9b12d SL |
1460 | |
1461 | // Total = 8 | |
1462 | assert_eq!(drop_count.load(Ordering::SeqCst), 8); | |
1463 | } | |
1464 | ||
7453a54e SL |
1465 | #[test] |
1466 | fn test_copy_from_slice() { | |
1467 | let src = [0, 1, 2, 3, 4, 5]; | |
1468 | let mut dst = [0; 6]; | |
1469 | dst.copy_from_slice(&src); | |
1470 | assert_eq!(src, dst) | |
1471 | } | |
1472 | ||
1473 | #[test] | |
3dfed10e | 1474 | #[should_panic(expected = "source slice length (4) does not match destination slice length (5)")] |
7453a54e SL |
1475 | fn test_copy_from_slice_dst_longer() { |
1476 | let src = [0, 1, 2, 3]; | |
1477 | let mut dst = [0; 5]; | |
1478 | dst.copy_from_slice(&src); | |
1479 | } | |
1480 | ||
1481 | #[test] | |
3dfed10e | 1482 | #[should_panic(expected = "source slice length (4) does not match destination slice length (3)")] |
7453a54e SL |
1483 | fn test_copy_from_slice_dst_shorter() { |
1484 | let src = [0, 1, 2, 3]; | |
1485 | let mut dst = [0; 3]; | |
1486 | dst.copy_from_slice(&src); | |
1487 | } | |
0531ce1d | 1488 | |
8faf50e0 XL |
1489 | #[test] |
1490 | fn repeat_generic_slice() { | |
1491 | assert_eq!([1, 2].repeat(2), vec![1, 2, 1, 2]); | |
1492 | assert_eq!([1, 2, 3, 4].repeat(0), vec![]); | |
1493 | assert_eq!([1, 2, 3, 4].repeat(1), vec![1, 2, 3, 4]); | |
dfeec247 | 1494 | assert_eq!([1, 2, 3, 4].repeat(3), vec![1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]); |
8faf50e0 | 1495 | } |
29967ef6 XL |
1496 | |
1497 | #[test] | |
1498 | #[allow(unreachable_patterns)] | |
1499 | fn subslice_patterns() { | |
1500 | // This test comprehensively checks the passing static and dynamic semantics | |
1501 | // of subslice patterns `..`, `x @ ..`, `ref x @ ..`, and `ref mut @ ..` | |
1502 | // in slice patterns `[$($pat), $(,)?]` . | |
1503 | ||
1504 | #[derive(PartialEq, Debug, Clone)] | |
1505 | struct N(u8); | |
1506 | ||
1507 | macro_rules! n { | |
1508 | ($($e:expr),* $(,)?) => { | |
1509 | [$(N($e)),*] | |
1510 | } | |
1511 | } | |
1512 | ||
1513 | macro_rules! c { | |
1514 | ($inp:expr, $typ:ty, $out:expr $(,)?) => { | |
6a06907d | 1515 | assert_eq!($out, identity::<$typ>($inp)) |
29967ef6 XL |
1516 | }; |
1517 | } | |
1518 | ||
1519 | macro_rules! m { | |
1520 | ($e:expr, $p:pat => $b:expr) => { | |
1521 | match $e { | |
1522 | $p => $b, | |
1523 | _ => panic!(), | |
1524 | } | |
1525 | }; | |
1526 | } | |
1527 | ||
1528 | // == Slices == | |
1529 | ||
1530 | // Matching slices using `ref` patterns: | |
1531 | let mut v = vec![N(0), N(1), N(2), N(3), N(4)]; | |
1532 | let mut vc = (0..=4).collect::<Vec<u8>>(); | |
1533 | ||
1534 | let [..] = v[..]; // Always matches. | |
1535 | m!(v[..], [N(0), ref sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3])); | |
1536 | m!(v[..], [N(0), ref sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4])); | |
1537 | m!(v[..], [ref sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3])); | |
1538 | m!(v[..], [ref sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N])); | |
1539 | m!(v[..], [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N], &n![] as &[N])); | |
1540 | m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4))); | |
1541 | ||
1542 | // Matching slices using `ref mut` patterns: | |
1543 | let [..] = v[..]; // Always matches. | |
1544 | m!(v[..], [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3])); | |
1545 | m!(v[..], [N(0), ref mut sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4])); | |
1546 | m!(v[..], [ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3])); | |
1547 | m!(v[..], [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N])); | |
1548 | m!(v[..], [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N])); | |
1549 | m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4))); | |
1550 | ||
1551 | // Matching slices using default binding modes (&): | |
1552 | let [..] = &v[..]; // Always matches. | |
1553 | m!(&v[..], [N(0), sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3])); | |
1554 | m!(&v[..], [N(0), sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4])); | |
1555 | m!(&v[..], [sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3])); | |
1556 | m!(&v[..], [sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N])); | |
1557 | m!(&v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &[N], &n![] as &[N])); | |
1558 | m!(&vc[..], [x, .., y] => c!((x, y), (&u8, &u8), (&0, &4))); | |
1559 | ||
1560 | // Matching slices using default binding modes (&mut): | |
1561 | let [..] = &mut v[..]; // Always matches. | |
1562 | m!(&mut v[..], [N(0), sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3])); | |
1563 | m!(&mut v[..], [N(0), sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4])); | |
1564 | m!(&mut v[..], [sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3])); | |
1565 | m!(&mut v[..], [sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N])); | |
1566 | m!(&mut v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N])); | |
1567 | m!(&mut vc[..], [x, .., y] => c!((x, y), (&mut u8, &mut u8), (&mut 0, &mut 4))); | |
1568 | ||
1569 | // == Arrays == | |
1570 | let mut v = n![0, 1, 2, 3, 4]; | |
1571 | let vc = [0, 1, 2, 3, 4]; | |
1572 | ||
1573 | // Matching arrays by value: | |
1574 | m!(v.clone(), [N(0), sub @ .., N(4)] => c!(sub, [N; 3], n![1, 2, 3])); | |
1575 | m!(v.clone(), [N(0), sub @ ..] => c!(sub, [N; 4], n![1, 2, 3, 4])); | |
1576 | m!(v.clone(), [sub @ .., N(4)] => c!(sub, [N; 4], n![0, 1, 2, 3])); | |
1577 | m!(v.clone(), [sub @ .., _, _, _, _, _] => c!(sub, [N; 0], n![] as [N; 0])); | |
1578 | m!(v.clone(), [_, _, _, _, _, sub @ ..] => c!(sub, [N; 0], n![] as [N; 0])); | |
1579 | m!(v.clone(), [x, .., y] => c!((x, y), (N, N), (N(0), N(4)))); | |
1580 | m!(v.clone(), [..] => ()); | |
1581 | ||
1582 | // Matching arrays by ref patterns: | |
1583 | m!(v, [N(0), ref sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3])); | |
1584 | m!(v, [N(0), ref sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4])); | |
1585 | m!(v, [ref sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3])); | |
1586 | m!(v, [ref sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0])); | |
1587 | m!(v, [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0])); | |
1588 | m!(vc, [x, .., y] => c!((x, y), (u8, u8), (0, 4))); | |
1589 | ||
1590 | // Matching arrays by ref mut patterns: | |
1591 | m!(v, [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3])); | |
1592 | m!(v, [N(0), ref mut sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4])); | |
1593 | m!(v, [ref mut sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3])); | |
1594 | m!(v, [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0])); | |
1595 | m!(v, [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0])); | |
1596 | ||
1597 | // Matching arrays by default binding modes (&): | |
1598 | m!(&v, [N(0), sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3])); | |
1599 | m!(&v, [N(0), sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4])); | |
1600 | m!(&v, [sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3])); | |
1601 | m!(&v, [sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0])); | |
1602 | m!(&v, [_, _, _, _, _, sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0])); | |
1603 | m!(&v, [..] => ()); | |
1604 | m!(&v, [x, .., y] => c!((x, y), (&N, &N), (&N(0), &N(4)))); | |
1605 | ||
1606 | // Matching arrays by default binding modes (&mut): | |
1607 | m!(&mut v, [N(0), sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3])); | |
1608 | m!(&mut v, [N(0), sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4])); | |
1609 | m!(&mut v, [sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3])); | |
1610 | m!(&mut v, [sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0])); | |
1611 | m!(&mut v, [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0])); | |
1612 | m!(&mut v, [..] => ()); | |
1613 | m!(&mut v, [x, .., y] => c!((x, y), (&mut N, &mut N), (&mut N(0), &mut N(4)))); | |
1614 | } | |
5869c6ff XL |
1615 | |
1616 | #[test] | |
c0240ec0 | 1617 | fn test_chunk_by() { |
5869c6ff XL |
1618 | let slice = &[1, 1, 1, 3, 3, 2, 2, 2, 1, 0]; |
1619 | ||
c0240ec0 | 1620 | let mut iter = slice.chunk_by(|a, b| a == b); |
5869c6ff XL |
1621 | assert_eq!(iter.next(), Some(&[1, 1, 1][..])); |
1622 | assert_eq!(iter.next(), Some(&[3, 3][..])); | |
1623 | assert_eq!(iter.next(), Some(&[2, 2, 2][..])); | |
1624 | assert_eq!(iter.next(), Some(&[1][..])); | |
1625 | assert_eq!(iter.next(), Some(&[0][..])); | |
1626 | assert_eq!(iter.next(), None); | |
1627 | ||
c0240ec0 | 1628 | let mut iter = slice.chunk_by(|a, b| a == b); |
5869c6ff XL |
1629 | assert_eq!(iter.next_back(), Some(&[0][..])); |
1630 | assert_eq!(iter.next_back(), Some(&[1][..])); | |
1631 | assert_eq!(iter.next_back(), Some(&[2, 2, 2][..])); | |
1632 | assert_eq!(iter.next_back(), Some(&[3, 3][..])); | |
1633 | assert_eq!(iter.next_back(), Some(&[1, 1, 1][..])); | |
1634 | assert_eq!(iter.next_back(), None); | |
1635 | ||
c0240ec0 | 1636 | let mut iter = slice.chunk_by(|a, b| a == b); |
5869c6ff XL |
1637 | assert_eq!(iter.next(), Some(&[1, 1, 1][..])); |
1638 | assert_eq!(iter.next_back(), Some(&[0][..])); | |
1639 | assert_eq!(iter.next(), Some(&[3, 3][..])); | |
1640 | assert_eq!(iter.next_back(), Some(&[1][..])); | |
1641 | assert_eq!(iter.next(), Some(&[2, 2, 2][..])); | |
1642 | assert_eq!(iter.next_back(), None); | |
1643 | } | |
1644 | ||
1645 | #[test] | |
c0240ec0 | 1646 | fn test_chunk_by_mut() { |
5869c6ff XL |
1647 | let slice = &mut [1, 1, 1, 3, 3, 2, 2, 2, 1, 0]; |
1648 | ||
c0240ec0 | 1649 | let mut iter = slice.chunk_by_mut(|a, b| a == b); |
5869c6ff XL |
1650 | assert_eq!(iter.next(), Some(&mut [1, 1, 1][..])); |
1651 | assert_eq!(iter.next(), Some(&mut [3, 3][..])); | |
1652 | assert_eq!(iter.next(), Some(&mut [2, 2, 2][..])); | |
1653 | assert_eq!(iter.next(), Some(&mut [1][..])); | |
1654 | assert_eq!(iter.next(), Some(&mut [0][..])); | |
1655 | assert_eq!(iter.next(), None); | |
1656 | ||
c0240ec0 | 1657 | let mut iter = slice.chunk_by_mut(|a, b| a == b); |
5869c6ff XL |
1658 | assert_eq!(iter.next_back(), Some(&mut [0][..])); |
1659 | assert_eq!(iter.next_back(), Some(&mut [1][..])); | |
1660 | assert_eq!(iter.next_back(), Some(&mut [2, 2, 2][..])); | |
1661 | assert_eq!(iter.next_back(), Some(&mut [3, 3][..])); | |
1662 | assert_eq!(iter.next_back(), Some(&mut [1, 1, 1][..])); | |
1663 | assert_eq!(iter.next_back(), None); | |
1664 | ||
c0240ec0 | 1665 | let mut iter = slice.chunk_by_mut(|a, b| a == b); |
5869c6ff XL |
1666 | assert_eq!(iter.next(), Some(&mut [1, 1, 1][..])); |
1667 | assert_eq!(iter.next_back(), Some(&mut [0][..])); | |
1668 | assert_eq!(iter.next(), Some(&mut [3, 3][..])); | |
1669 | assert_eq!(iter.next_back(), Some(&mut [1][..])); | |
1670 | assert_eq!(iter.next(), Some(&mut [2, 2, 2][..])); | |
1671 | assert_eq!(iter.next_back(), None); | |
1672 | } |