]>
Commit | Line | Data |
---|---|---|
c34b1796 AL |
1 | // Copyright 2014 The Rust Project Developers. See the COPYRIGHT |
2 | // file at the top-level directory of this distribution and at | |
3 | // http://rust-lang.org/COPYRIGHT. | |
4 | // | |
5 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | |
6 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
7 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | |
8 | // option. This file may not be copied, modified, or distributed | |
9 | // except according to those terms. | |
10 | ||
11 | use std::iter::{FromIterator, repeat}; | |
12 | use std::mem::size_of; | |
13 | use std::vec::as_vec; | |
14 | ||
15 | use test::Bencher; | |
16 | ||
17 | struct DropCounter<'a> { | |
18 | count: &'a mut u32 | |
19 | } | |
20 | ||
c34b1796 AL |
21 | impl<'a> Drop for DropCounter<'a> { |
22 | fn drop(&mut self) { | |
23 | *self.count += 1; | |
24 | } | |
25 | } | |
26 | ||
27 | #[test] | |
28 | fn test_as_vec() { | |
29 | let xs = [1u8, 2u8, 3u8]; | |
30 | assert_eq!(&**as_vec(&xs), xs); | |
31 | } | |
32 | ||
33 | #[test] | |
34 | fn test_as_vec_dtor() { | |
35 | let (mut count_x, mut count_y) = (0, 0); | |
36 | { | |
37 | let xs = &[DropCounter { count: &mut count_x }, DropCounter { count: &mut count_y }]; | |
38 | assert_eq!(as_vec(xs).len(), 2); | |
39 | } | |
40 | assert_eq!(count_x, 1); | |
41 | assert_eq!(count_y, 1); | |
42 | } | |
43 | ||
44 | #[test] | |
45 | fn test_small_vec_struct() { | |
46 | assert!(size_of::<Vec<u8>>() == size_of::<usize>() * 3); | |
47 | } | |
48 | ||
49 | #[test] | |
50 | fn test_double_drop() { | |
51 | struct TwoVec<T> { | |
52 | x: Vec<T>, | |
53 | y: Vec<T> | |
54 | } | |
55 | ||
56 | let (mut count_x, mut count_y) = (0, 0); | |
57 | { | |
58 | let mut tv = TwoVec { | |
59 | x: Vec::new(), | |
60 | y: Vec::new() | |
61 | }; | |
62 | tv.x.push(DropCounter {count: &mut count_x}); | |
63 | tv.y.push(DropCounter {count: &mut count_y}); | |
64 | ||
65 | // If Vec had a drop flag, here is where it would be zeroed. | |
66 | // Instead, it should rely on its internal state to prevent | |
67 | // doing anything significant when dropped multiple times. | |
68 | drop(tv.x); | |
69 | ||
70 | // Here tv goes out of scope, tv.y should be dropped, but not tv.x. | |
71 | } | |
72 | ||
73 | assert_eq!(count_x, 1); | |
74 | assert_eq!(count_y, 1); | |
75 | } | |
76 | ||
77 | #[test] | |
78 | fn test_reserve() { | |
79 | let mut v = Vec::new(); | |
80 | assert_eq!(v.capacity(), 0); | |
81 | ||
82 | v.reserve(2); | |
83 | assert!(v.capacity() >= 2); | |
84 | ||
85 | for i in 0..16 { | |
86 | v.push(i); | |
87 | } | |
88 | ||
89 | assert!(v.capacity() >= 16); | |
90 | v.reserve(16); | |
91 | assert!(v.capacity() >= 32); | |
92 | ||
93 | v.push(16); | |
94 | ||
95 | v.reserve(16); | |
96 | assert!(v.capacity() >= 33) | |
97 | } | |
98 | ||
99 | #[test] | |
100 | fn test_extend() { | |
101 | let mut v = Vec::new(); | |
102 | let mut w = Vec::new(); | |
103 | ||
104 | v.extend(0..3); | |
105 | for i in 0..3 { w.push(i) } | |
106 | ||
107 | assert_eq!(v, w); | |
108 | ||
109 | v.extend(3..10); | |
110 | for i in 3..10 { w.push(i) } | |
111 | ||
112 | assert_eq!(v, w); | |
113 | } | |
114 | ||
115 | #[test] | |
116 | fn test_slice_from_mut() { | |
117 | let mut values = vec![1, 2, 3, 4, 5]; | |
118 | { | |
119 | let slice = &mut values[2 ..]; | |
120 | assert!(slice == [3, 4, 5]); | |
121 | for p in slice { | |
122 | *p += 2; | |
123 | } | |
124 | } | |
125 | ||
126 | assert!(values == [1, 2, 5, 6, 7]); | |
127 | } | |
128 | ||
129 | #[test] | |
130 | fn test_slice_to_mut() { | |
131 | let mut values = vec![1, 2, 3, 4, 5]; | |
132 | { | |
133 | let slice = &mut values[.. 2]; | |
134 | assert!(slice == [1, 2]); | |
135 | for p in slice { | |
136 | *p += 1; | |
137 | } | |
138 | } | |
139 | ||
140 | assert!(values == [2, 3, 3, 4, 5]); | |
141 | } | |
142 | ||
143 | #[test] | |
144 | fn test_split_at_mut() { | |
145 | let mut values = vec![1, 2, 3, 4, 5]; | |
146 | { | |
147 | let (left, right) = values.split_at_mut(2); | |
148 | { | |
149 | let left: &[_] = left; | |
150 | assert!(&left[..left.len()] == &[1, 2]); | |
151 | } | |
152 | for p in left { | |
153 | *p += 1; | |
154 | } | |
155 | ||
156 | { | |
157 | let right: &[_] = right; | |
158 | assert!(&right[..right.len()] == &[3, 4, 5]); | |
159 | } | |
160 | for p in right { | |
161 | *p += 2; | |
162 | } | |
163 | } | |
164 | ||
165 | assert_eq!(values, [2, 3, 5, 6, 7]); | |
166 | } | |
167 | ||
168 | #[test] | |
169 | fn test_clone() { | |
170 | let v: Vec<i32> = vec![]; | |
171 | let w = vec!(1, 2, 3); | |
172 | ||
173 | assert_eq!(v, v.clone()); | |
174 | ||
175 | let z = w.clone(); | |
176 | assert_eq!(w, z); | |
177 | // they should be disjoint in memory. | |
178 | assert!(w.as_ptr() != z.as_ptr()) | |
179 | } | |
180 | ||
181 | #[test] | |
182 | fn test_clone_from() { | |
183 | let mut v = vec!(); | |
184 | let three: Vec<Box<_>> = vec!(box 1, box 2, box 3); | |
185 | let two: Vec<Box<_>> = vec!(box 4, box 5); | |
186 | // zero, long | |
187 | v.clone_from(&three); | |
188 | assert_eq!(v, three); | |
189 | ||
190 | // equal | |
191 | v.clone_from(&three); | |
192 | assert_eq!(v, three); | |
193 | ||
194 | // long, short | |
195 | v.clone_from(&two); | |
196 | assert_eq!(v, two); | |
197 | ||
198 | // short, long | |
199 | v.clone_from(&three); | |
200 | assert_eq!(v, three) | |
201 | } | |
202 | ||
203 | #[test] | |
204 | fn test_retain() { | |
205 | let mut vec = vec![1, 2, 3, 4]; | |
206 | vec.retain(|&x| x % 2 == 0); | |
207 | assert_eq!(vec, [2, 4]); | |
208 | } | |
209 | ||
210 | #[test] | |
211 | fn zero_sized_values() { | |
212 | let mut v = Vec::new(); | |
213 | assert_eq!(v.len(), 0); | |
214 | v.push(()); | |
215 | assert_eq!(v.len(), 1); | |
216 | v.push(()); | |
217 | assert_eq!(v.len(), 2); | |
218 | assert_eq!(v.pop(), Some(())); | |
219 | assert_eq!(v.pop(), Some(())); | |
220 | assert_eq!(v.pop(), None); | |
221 | ||
222 | assert_eq!(v.iter().count(), 0); | |
223 | v.push(()); | |
224 | assert_eq!(v.iter().count(), 1); | |
225 | v.push(()); | |
226 | assert_eq!(v.iter().count(), 2); | |
227 | ||
228 | for &() in &v {} | |
229 | ||
230 | assert_eq!(v.iter_mut().count(), 2); | |
231 | v.push(()); | |
232 | assert_eq!(v.iter_mut().count(), 3); | |
233 | v.push(()); | |
234 | assert_eq!(v.iter_mut().count(), 4); | |
235 | ||
236 | for &mut () in &mut v {} | |
237 | unsafe { v.set_len(0); } | |
238 | assert_eq!(v.iter_mut().count(), 0); | |
239 | } | |
240 | ||
241 | #[test] | |
242 | fn test_partition() { | |
243 | assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3), (vec![], vec![])); | |
244 | assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4), (vec![1, 2, 3], vec![])); | |
245 | assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2), (vec![1], vec![2, 3])); | |
246 | assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0), (vec![], vec![1, 2, 3])); | |
247 | } | |
248 | ||
249 | #[test] | |
250 | fn test_zip_unzip() { | |
251 | let z1 = vec![(1, 4), (2, 5), (3, 6)]; | |
252 | ||
253 | let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip(); | |
254 | ||
255 | assert_eq!((1, 4), (left[0], right[0])); | |
256 | assert_eq!((2, 5), (left[1], right[1])); | |
257 | assert_eq!((3, 6), (left[2], right[2])); | |
258 | } | |
259 | ||
260 | #[test] | |
261 | fn test_unsafe_ptrs() { | |
262 | unsafe { | |
263 | // Test on-stack copy-from-buf. | |
264 | let a = [1, 2, 3]; | |
265 | let ptr = a.as_ptr(); | |
266 | let b = Vec::from_raw_buf(ptr, 3); | |
267 | assert_eq!(b, [1, 2, 3]); | |
268 | ||
269 | // Test on-heap copy-from-buf. | |
270 | let c = vec![1, 2, 3, 4, 5]; | |
271 | let ptr = c.as_ptr(); | |
272 | let d = Vec::from_raw_buf(ptr, 5); | |
273 | assert_eq!(d, [1, 2, 3, 4, 5]); | |
274 | } | |
275 | } | |
276 | ||
277 | #[test] | |
278 | fn test_vec_truncate_drop() { | |
279 | static mut drops: u32 = 0; | |
280 | struct Elem(i32); | |
281 | impl Drop for Elem { | |
282 | fn drop(&mut self) { | |
283 | unsafe { drops += 1; } | |
284 | } | |
285 | } | |
286 | ||
287 | let mut v = vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)]; | |
288 | assert_eq!(unsafe { drops }, 0); | |
289 | v.truncate(3); | |
290 | assert_eq!(unsafe { drops }, 2); | |
291 | v.truncate(0); | |
292 | assert_eq!(unsafe { drops }, 5); | |
293 | } | |
294 | ||
295 | #[test] | |
296 | #[should_panic] | |
297 | fn test_vec_truncate_fail() { | |
298 | struct BadElem(i32); | |
299 | impl Drop for BadElem { | |
300 | fn drop(&mut self) { | |
301 | let BadElem(ref mut x) = *self; | |
302 | if *x == 0xbadbeef { | |
303 | panic!("BadElem panic: 0xbadbeef") | |
304 | } | |
305 | } | |
306 | } | |
307 | ||
308 | let mut v = vec![BadElem(1), BadElem(2), BadElem(0xbadbeef), BadElem(4)]; | |
309 | v.truncate(0); | |
310 | } | |
311 | ||
312 | #[test] | |
313 | fn test_index() { | |
314 | let vec = vec![1, 2, 3]; | |
315 | assert!(vec[1] == 2); | |
316 | } | |
317 | ||
318 | #[test] | |
319 | #[should_panic] | |
320 | fn test_index_out_of_bounds() { | |
321 | let vec = vec![1, 2, 3]; | |
322 | let _ = vec[3]; | |
323 | } | |
324 | ||
325 | #[test] | |
326 | #[should_panic] | |
327 | fn test_slice_out_of_bounds_1() { | |
328 | let x = vec![1, 2, 3, 4, 5]; | |
329 | &x[-1..]; | |
330 | } | |
331 | ||
332 | #[test] | |
333 | #[should_panic] | |
334 | fn test_slice_out_of_bounds_2() { | |
335 | let x = vec![1, 2, 3, 4, 5]; | |
336 | &x[..6]; | |
337 | } | |
338 | ||
339 | #[test] | |
340 | #[should_panic] | |
341 | fn test_slice_out_of_bounds_3() { | |
342 | let x = vec![1, 2, 3, 4, 5]; | |
343 | &x[-1..4]; | |
344 | } | |
345 | ||
346 | #[test] | |
347 | #[should_panic] | |
348 | fn test_slice_out_of_bounds_4() { | |
349 | let x = vec![1, 2, 3, 4, 5]; | |
350 | &x[1..6]; | |
351 | } | |
352 | ||
353 | #[test] | |
354 | #[should_panic] | |
355 | fn test_slice_out_of_bounds_5() { | |
356 | let x = vec![1, 2, 3, 4, 5]; | |
357 | &x[3..2]; | |
358 | } | |
359 | ||
360 | #[test] | |
361 | #[should_panic] | |
362 | fn test_swap_remove_empty() { | |
363 | let mut vec= Vec::<i32>::new(); | |
364 | vec.swap_remove(0); | |
365 | } | |
366 | ||
367 | #[test] | |
368 | fn test_move_iter_unwrap() { | |
369 | let mut vec = Vec::with_capacity(7); | |
370 | vec.push(1); | |
371 | vec.push(2); | |
372 | let ptr = vec.as_ptr(); | |
373 | vec = vec.into_iter().into_inner(); | |
374 | assert_eq!(vec.as_ptr(), ptr); | |
375 | assert_eq!(vec.capacity(), 7); | |
376 | assert_eq!(vec.len(), 0); | |
377 | } | |
378 | ||
379 | #[test] | |
380 | #[should_panic] | |
381 | fn test_map_in_place_incompatible_types_fail() { | |
382 | let v = vec![0, 1, 2]; | |
383 | v.map_in_place(|_| ()); | |
384 | } | |
385 | ||
386 | #[test] | |
387 | fn test_map_in_place() { | |
388 | let v = vec![0, 1, 2]; | |
389 | assert_eq!(v.map_in_place(|i: u32| i as i32 - 1), [-1, 0, 1]); | |
390 | } | |
391 | ||
392 | #[test] | |
393 | fn test_map_in_place_zero_sized() { | |
394 | let v = vec![(), ()]; | |
395 | #[derive(PartialEq, Debug)] | |
396 | struct ZeroSized; | |
397 | assert_eq!(v.map_in_place(|_| ZeroSized), [ZeroSized, ZeroSized]); | |
398 | } | |
399 | ||
400 | #[test] | |
401 | fn test_map_in_place_zero_drop_count() { | |
402 | use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; | |
403 | ||
404 | #[derive(Clone, PartialEq, Debug)] | |
405 | struct Nothing; | |
406 | impl Drop for Nothing { fn drop(&mut self) { } } | |
407 | ||
408 | #[derive(Clone, PartialEq, Debug)] | |
409 | struct ZeroSized; | |
410 | impl Drop for ZeroSized { | |
411 | fn drop(&mut self) { | |
412 | DROP_COUNTER.fetch_add(1, Ordering::Relaxed); | |
413 | } | |
414 | } | |
415 | const NUM_ELEMENTS: usize = 2; | |
416 | static DROP_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT; | |
417 | ||
418 | let v = repeat(Nothing).take(NUM_ELEMENTS).collect::<Vec<_>>(); | |
419 | ||
420 | DROP_COUNTER.store(0, Ordering::Relaxed); | |
421 | ||
422 | let v = v.map_in_place(|_| ZeroSized); | |
423 | assert_eq!(DROP_COUNTER.load(Ordering::Relaxed), 0); | |
424 | drop(v); | |
425 | assert_eq!(DROP_COUNTER.load(Ordering::Relaxed), NUM_ELEMENTS); | |
426 | } | |
427 | ||
428 | #[test] | |
429 | fn test_move_items() { | |
430 | let vec = vec![1, 2, 3]; | |
431 | let mut vec2 = vec![]; | |
432 | for i in vec { | |
433 | vec2.push(i); | |
434 | } | |
435 | assert_eq!(vec2, [1, 2, 3]); | |
436 | } | |
437 | ||
438 | #[test] | |
439 | fn test_move_items_reverse() { | |
440 | let vec = vec![1, 2, 3]; | |
441 | let mut vec2 = vec![]; | |
442 | for i in vec.into_iter().rev() { | |
443 | vec2.push(i); | |
444 | } | |
445 | assert_eq!(vec2, [3, 2, 1]); | |
446 | } | |
447 | ||
448 | #[test] | |
449 | fn test_move_items_zero_sized() { | |
450 | let vec = vec![(), (), ()]; | |
451 | let mut vec2 = vec![]; | |
452 | for i in vec { | |
453 | vec2.push(i); | |
454 | } | |
455 | assert_eq!(vec2, [(), (), ()]); | |
456 | } | |
457 | ||
458 | #[test] | |
459 | fn test_drain_items() { | |
460 | let mut vec = vec![1, 2, 3]; | |
461 | let mut vec2 = vec![]; | |
d9579d0f | 462 | for i in vec.drain(..) { |
c34b1796 AL |
463 | vec2.push(i); |
464 | } | |
465 | assert_eq!(vec, []); | |
466 | assert_eq!(vec2, [ 1, 2, 3 ]); | |
467 | } | |
468 | ||
469 | #[test] | |
470 | fn test_drain_items_reverse() { | |
471 | let mut vec = vec![1, 2, 3]; | |
472 | let mut vec2 = vec![]; | |
d9579d0f | 473 | for i in vec.drain(..).rev() { |
c34b1796 AL |
474 | vec2.push(i); |
475 | } | |
476 | assert_eq!(vec, []); | |
477 | assert_eq!(vec2, [3, 2, 1]); | |
478 | } | |
479 | ||
480 | #[test] | |
481 | fn test_drain_items_zero_sized() { | |
482 | let mut vec = vec![(), (), ()]; | |
483 | let mut vec2 = vec![]; | |
d9579d0f | 484 | for i in vec.drain(..) { |
c34b1796 AL |
485 | vec2.push(i); |
486 | } | |
487 | assert_eq!(vec, []); | |
488 | assert_eq!(vec2, [(), (), ()]); | |
489 | } | |
490 | ||
d9579d0f AL |
491 | #[test] |
492 | #[should_panic] | |
493 | fn test_drain_out_of_bounds() { | |
494 | let mut v = vec![1, 2, 3, 4, 5]; | |
495 | v.drain(5..6); | |
496 | } | |
497 | ||
498 | #[test] | |
499 | fn test_drain_range() { | |
500 | let mut v = vec![1, 2, 3, 4, 5]; | |
501 | for _ in v.drain(4..) { | |
502 | } | |
503 | assert_eq!(v, &[1, 2, 3, 4]); | |
504 | ||
505 | let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect(); | |
506 | for _ in v.drain(1..4) { | |
507 | } | |
508 | assert_eq!(v, &[1.to_string(), 5.to_string()]); | |
509 | ||
510 | let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect(); | |
511 | for _ in v.drain(1..4).rev() { | |
512 | } | |
513 | assert_eq!(v, &[1.to_string(), 5.to_string()]); | |
514 | ||
515 | let mut v: Vec<_> = vec![(); 5]; | |
516 | for _ in v.drain(1..4).rev() { | |
517 | } | |
518 | assert_eq!(v, &[(), ()]); | |
519 | } | |
520 | ||
c34b1796 AL |
521 | #[test] |
522 | fn test_into_boxed_slice() { | |
523 | let xs = vec![1, 2, 3]; | |
524 | let ys = xs.into_boxed_slice(); | |
525 | assert_eq!(&*ys, [1, 2, 3]); | |
526 | } | |
527 | ||
528 | #[test] | |
529 | fn test_append() { | |
530 | let mut vec = vec![1, 2, 3]; | |
531 | let mut vec2 = vec![4, 5, 6]; | |
532 | vec.append(&mut vec2); | |
533 | assert_eq!(vec, [1, 2, 3, 4, 5, 6]); | |
534 | assert_eq!(vec2, []); | |
535 | } | |
536 | ||
537 | #[test] | |
538 | fn test_split_off() { | |
539 | let mut vec = vec![1, 2, 3, 4, 5, 6]; | |
540 | let vec2 = vec.split_off(4); | |
541 | assert_eq!(vec, [1, 2, 3, 4]); | |
542 | assert_eq!(vec2, [5, 6]); | |
543 | } | |
544 | ||
d9579d0f AL |
545 | #[test] |
546 | fn test_into_iter_count() { | |
547 | assert_eq!(vec![1, 2, 3].into_iter().count(), 3); | |
548 | } | |
549 | ||
c34b1796 AL |
550 | #[bench] |
551 | fn bench_new(b: &mut Bencher) { | |
552 | b.iter(|| { | |
553 | let v: Vec<u32> = Vec::new(); | |
554 | assert_eq!(v.len(), 0); | |
555 | assert_eq!(v.capacity(), 0); | |
556 | }) | |
557 | } | |
558 | ||
559 | fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) { | |
560 | b.bytes = src_len as u64; | |
561 | ||
562 | b.iter(|| { | |
563 | let v: Vec<u32> = Vec::with_capacity(src_len); | |
564 | assert_eq!(v.len(), 0); | |
565 | assert_eq!(v.capacity(), src_len); | |
566 | }) | |
567 | } | |
568 | ||
569 | #[bench] | |
570 | fn bench_with_capacity_0000(b: &mut Bencher) { | |
571 | do_bench_with_capacity(b, 0) | |
572 | } | |
573 | ||
574 | #[bench] | |
575 | fn bench_with_capacity_0010(b: &mut Bencher) { | |
576 | do_bench_with_capacity(b, 10) | |
577 | } | |
578 | ||
579 | #[bench] | |
580 | fn bench_with_capacity_0100(b: &mut Bencher) { | |
581 | do_bench_with_capacity(b, 100) | |
582 | } | |
583 | ||
584 | #[bench] | |
585 | fn bench_with_capacity_1000(b: &mut Bencher) { | |
586 | do_bench_with_capacity(b, 1000) | |
587 | } | |
588 | ||
589 | fn do_bench_from_fn(b: &mut Bencher, src_len: usize) { | |
590 | b.bytes = src_len as u64; | |
591 | ||
592 | b.iter(|| { | |
593 | let dst = (0..src_len).collect::<Vec<_>>(); | |
594 | assert_eq!(dst.len(), src_len); | |
595 | assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); | |
596 | }) | |
597 | } | |
598 | ||
599 | #[bench] | |
600 | fn bench_from_fn_0000(b: &mut Bencher) { | |
601 | do_bench_from_fn(b, 0) | |
602 | } | |
603 | ||
604 | #[bench] | |
605 | fn bench_from_fn_0010(b: &mut Bencher) { | |
606 | do_bench_from_fn(b, 10) | |
607 | } | |
608 | ||
609 | #[bench] | |
610 | fn bench_from_fn_0100(b: &mut Bencher) { | |
611 | do_bench_from_fn(b, 100) | |
612 | } | |
613 | ||
614 | #[bench] | |
615 | fn bench_from_fn_1000(b: &mut Bencher) { | |
616 | do_bench_from_fn(b, 1000) | |
617 | } | |
618 | ||
619 | fn do_bench_from_elem(b: &mut Bencher, src_len: usize) { | |
620 | b.bytes = src_len as u64; | |
621 | ||
622 | b.iter(|| { | |
623 | let dst: Vec<usize> = repeat(5).take(src_len).collect(); | |
624 | assert_eq!(dst.len(), src_len); | |
625 | assert!(dst.iter().all(|x| *x == 5)); | |
626 | }) | |
627 | } | |
628 | ||
629 | #[bench] | |
630 | fn bench_from_elem_0000(b: &mut Bencher) { | |
631 | do_bench_from_elem(b, 0) | |
632 | } | |
633 | ||
634 | #[bench] | |
635 | fn bench_from_elem_0010(b: &mut Bencher) { | |
636 | do_bench_from_elem(b, 10) | |
637 | } | |
638 | ||
639 | #[bench] | |
640 | fn bench_from_elem_0100(b: &mut Bencher) { | |
641 | do_bench_from_elem(b, 100) | |
642 | } | |
643 | ||
644 | #[bench] | |
645 | fn bench_from_elem_1000(b: &mut Bencher) { | |
646 | do_bench_from_elem(b, 1000) | |
647 | } | |
648 | ||
649 | fn do_bench_from_slice(b: &mut Bencher, src_len: usize) { | |
650 | let src: Vec<_> = FromIterator::from_iter(0..src_len); | |
651 | ||
652 | b.bytes = src_len as u64; | |
653 | ||
654 | b.iter(|| { | |
655 | let dst = src.clone()[..].to_vec(); | |
656 | assert_eq!(dst.len(), src_len); | |
657 | assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); | |
658 | }); | |
659 | } | |
660 | ||
661 | #[bench] | |
662 | fn bench_from_slice_0000(b: &mut Bencher) { | |
663 | do_bench_from_slice(b, 0) | |
664 | } | |
665 | ||
666 | #[bench] | |
667 | fn bench_from_slice_0010(b: &mut Bencher) { | |
668 | do_bench_from_slice(b, 10) | |
669 | } | |
670 | ||
671 | #[bench] | |
672 | fn bench_from_slice_0100(b: &mut Bencher) { | |
673 | do_bench_from_slice(b, 100) | |
674 | } | |
675 | ||
676 | #[bench] | |
677 | fn bench_from_slice_1000(b: &mut Bencher) { | |
678 | do_bench_from_slice(b, 1000) | |
679 | } | |
680 | ||
681 | fn do_bench_from_iter(b: &mut Bencher, src_len: usize) { | |
682 | let src: Vec<_> = FromIterator::from_iter(0..src_len); | |
683 | ||
684 | b.bytes = src_len as u64; | |
685 | ||
686 | b.iter(|| { | |
687 | let dst: Vec<_> = FromIterator::from_iter(src.clone().into_iter()); | |
688 | assert_eq!(dst.len(), src_len); | |
689 | assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); | |
690 | }); | |
691 | } | |
692 | ||
693 | #[bench] | |
694 | fn bench_from_iter_0000(b: &mut Bencher) { | |
695 | do_bench_from_iter(b, 0) | |
696 | } | |
697 | ||
698 | #[bench] | |
699 | fn bench_from_iter_0010(b: &mut Bencher) { | |
700 | do_bench_from_iter(b, 10) | |
701 | } | |
702 | ||
703 | #[bench] | |
704 | fn bench_from_iter_0100(b: &mut Bencher) { | |
705 | do_bench_from_iter(b, 100) | |
706 | } | |
707 | ||
708 | #[bench] | |
709 | fn bench_from_iter_1000(b: &mut Bencher) { | |
710 | do_bench_from_iter(b, 1000) | |
711 | } | |
712 | ||
713 | fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) { | |
714 | let dst: Vec<_> = FromIterator::from_iter(0..dst_len); | |
715 | let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len); | |
716 | ||
717 | b.bytes = src_len as u64; | |
718 | ||
719 | b.iter(|| { | |
720 | let mut dst = dst.clone(); | |
721 | dst.extend(src.clone().into_iter()); | |
722 | assert_eq!(dst.len(), dst_len + src_len); | |
723 | assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); | |
724 | }); | |
725 | } | |
726 | ||
727 | #[bench] | |
728 | fn bench_extend_0000_0000(b: &mut Bencher) { | |
729 | do_bench_extend(b, 0, 0) | |
730 | } | |
731 | ||
732 | #[bench] | |
733 | fn bench_extend_0000_0010(b: &mut Bencher) { | |
734 | do_bench_extend(b, 0, 10) | |
735 | } | |
736 | ||
737 | #[bench] | |
738 | fn bench_extend_0000_0100(b: &mut Bencher) { | |
739 | do_bench_extend(b, 0, 100) | |
740 | } | |
741 | ||
742 | #[bench] | |
743 | fn bench_extend_0000_1000(b: &mut Bencher) { | |
744 | do_bench_extend(b, 0, 1000) | |
745 | } | |
746 | ||
747 | #[bench] | |
748 | fn bench_extend_0010_0010(b: &mut Bencher) { | |
749 | do_bench_extend(b, 10, 10) | |
750 | } | |
751 | ||
752 | #[bench] | |
753 | fn bench_extend_0100_0100(b: &mut Bencher) { | |
754 | do_bench_extend(b, 100, 100) | |
755 | } | |
756 | ||
757 | #[bench] | |
758 | fn bench_extend_1000_1000(b: &mut Bencher) { | |
759 | do_bench_extend(b, 1000, 1000) | |
760 | } | |
761 | ||
762 | fn do_bench_push_all(b: &mut Bencher, dst_len: usize, src_len: usize) { | |
763 | let dst: Vec<_> = FromIterator::from_iter(0..dst_len); | |
764 | let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len); | |
765 | ||
766 | b.bytes = src_len as u64; | |
767 | ||
768 | b.iter(|| { | |
769 | let mut dst = dst.clone(); | |
770 | dst.push_all(&src); | |
771 | assert_eq!(dst.len(), dst_len + src_len); | |
772 | assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); | |
773 | }); | |
774 | } | |
775 | ||
776 | #[bench] | |
777 | fn bench_push_all_0000_0000(b: &mut Bencher) { | |
778 | do_bench_push_all(b, 0, 0) | |
779 | } | |
780 | ||
781 | #[bench] | |
782 | fn bench_push_all_0000_0010(b: &mut Bencher) { | |
783 | do_bench_push_all(b, 0, 10) | |
784 | } | |
785 | ||
786 | #[bench] | |
787 | fn bench_push_all_0000_0100(b: &mut Bencher) { | |
788 | do_bench_push_all(b, 0, 100) | |
789 | } | |
790 | ||
791 | #[bench] | |
792 | fn bench_push_all_0000_1000(b: &mut Bencher) { | |
793 | do_bench_push_all(b, 0, 1000) | |
794 | } | |
795 | ||
796 | #[bench] | |
797 | fn bench_push_all_0010_0010(b: &mut Bencher) { | |
798 | do_bench_push_all(b, 10, 10) | |
799 | } | |
800 | ||
801 | #[bench] | |
802 | fn bench_push_all_0100_0100(b: &mut Bencher) { | |
803 | do_bench_push_all(b, 100, 100) | |
804 | } | |
805 | ||
806 | #[bench] | |
807 | fn bench_push_all_1000_1000(b: &mut Bencher) { | |
808 | do_bench_push_all(b, 1000, 1000) | |
809 | } | |
810 | ||
811 | fn do_bench_push_all_move(b: &mut Bencher, dst_len: usize, src_len: usize) { | |
812 | let dst: Vec<_> = FromIterator::from_iter(0..dst_len); | |
813 | let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len); | |
814 | ||
815 | b.bytes = src_len as u64; | |
816 | ||
817 | b.iter(|| { | |
818 | let mut dst = dst.clone(); | |
819 | dst.extend(src.clone().into_iter()); | |
820 | assert_eq!(dst.len(), dst_len + src_len); | |
821 | assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); | |
822 | }); | |
823 | } | |
824 | ||
825 | #[bench] | |
826 | fn bench_push_all_move_0000_0000(b: &mut Bencher) { | |
827 | do_bench_push_all_move(b, 0, 0) | |
828 | } | |
829 | ||
830 | #[bench] | |
831 | fn bench_push_all_move_0000_0010(b: &mut Bencher) { | |
832 | do_bench_push_all_move(b, 0, 10) | |
833 | } | |
834 | ||
835 | #[bench] | |
836 | fn bench_push_all_move_0000_0100(b: &mut Bencher) { | |
837 | do_bench_push_all_move(b, 0, 100) | |
838 | } | |
839 | ||
840 | #[bench] | |
841 | fn bench_push_all_move_0000_1000(b: &mut Bencher) { | |
842 | do_bench_push_all_move(b, 0, 1000) | |
843 | } | |
844 | ||
845 | #[bench] | |
846 | fn bench_push_all_move_0010_0010(b: &mut Bencher) { | |
847 | do_bench_push_all_move(b, 10, 10) | |
848 | } | |
849 | ||
850 | #[bench] | |
851 | fn bench_push_all_move_0100_0100(b: &mut Bencher) { | |
852 | do_bench_push_all_move(b, 100, 100) | |
853 | } | |
854 | ||
855 | #[bench] | |
856 | fn bench_push_all_move_1000_1000(b: &mut Bencher) { | |
857 | do_bench_push_all_move(b, 1000, 1000) | |
858 | } | |
859 | ||
860 | fn do_bench_clone(b: &mut Bencher, src_len: usize) { | |
861 | let src: Vec<usize> = FromIterator::from_iter(0..src_len); | |
862 | ||
863 | b.bytes = src_len as u64; | |
864 | ||
865 | b.iter(|| { | |
866 | let dst = src.clone(); | |
867 | assert_eq!(dst.len(), src_len); | |
868 | assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); | |
869 | }); | |
870 | } | |
871 | ||
872 | #[bench] | |
873 | fn bench_clone_0000(b: &mut Bencher) { | |
874 | do_bench_clone(b, 0) | |
875 | } | |
876 | ||
877 | #[bench] | |
878 | fn bench_clone_0010(b: &mut Bencher) { | |
879 | do_bench_clone(b, 10) | |
880 | } | |
881 | ||
882 | #[bench] | |
883 | fn bench_clone_0100(b: &mut Bencher) { | |
884 | do_bench_clone(b, 100) | |
885 | } | |
886 | ||
887 | #[bench] | |
888 | fn bench_clone_1000(b: &mut Bencher) { | |
889 | do_bench_clone(b, 1000) | |
890 | } | |
891 | ||
892 | fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) { | |
893 | let dst: Vec<_> = FromIterator::from_iter(0..src_len); | |
894 | let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len); | |
895 | ||
896 | b.bytes = (times * src_len) as u64; | |
897 | ||
898 | b.iter(|| { | |
899 | let mut dst = dst.clone(); | |
900 | ||
901 | for _ in 0..times { | |
902 | dst.clone_from(&src); | |
903 | ||
904 | assert_eq!(dst.len(), src_len); | |
905 | assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x)); | |
906 | } | |
907 | }); | |
908 | } | |
909 | ||
910 | #[bench] | |
911 | fn bench_clone_from_01_0000_0000(b: &mut Bencher) { | |
912 | do_bench_clone_from(b, 1, 0, 0) | |
913 | } | |
914 | ||
915 | #[bench] | |
916 | fn bench_clone_from_01_0000_0010(b: &mut Bencher) { | |
917 | do_bench_clone_from(b, 1, 0, 10) | |
918 | } | |
919 | ||
920 | #[bench] | |
921 | fn bench_clone_from_01_0000_0100(b: &mut Bencher) { | |
922 | do_bench_clone_from(b, 1, 0, 100) | |
923 | } | |
924 | ||
925 | #[bench] | |
926 | fn bench_clone_from_01_0000_1000(b: &mut Bencher) { | |
927 | do_bench_clone_from(b, 1, 0, 1000) | |
928 | } | |
929 | ||
930 | #[bench] | |
931 | fn bench_clone_from_01_0010_0010(b: &mut Bencher) { | |
932 | do_bench_clone_from(b, 1, 10, 10) | |
933 | } | |
934 | ||
935 | #[bench] | |
936 | fn bench_clone_from_01_0100_0100(b: &mut Bencher) { | |
937 | do_bench_clone_from(b, 1, 100, 100) | |
938 | } | |
939 | ||
940 | #[bench] | |
941 | fn bench_clone_from_01_1000_1000(b: &mut Bencher) { | |
942 | do_bench_clone_from(b, 1, 1000, 1000) | |
943 | } | |
944 | ||
945 | #[bench] | |
946 | fn bench_clone_from_01_0010_0100(b: &mut Bencher) { | |
947 | do_bench_clone_from(b, 1, 10, 100) | |
948 | } | |
949 | ||
950 | #[bench] | |
951 | fn bench_clone_from_01_0100_1000(b: &mut Bencher) { | |
952 | do_bench_clone_from(b, 1, 100, 1000) | |
953 | } | |
954 | ||
955 | #[bench] | |
956 | fn bench_clone_from_01_0010_0000(b: &mut Bencher) { | |
957 | do_bench_clone_from(b, 1, 10, 0) | |
958 | } | |
959 | ||
960 | #[bench] | |
961 | fn bench_clone_from_01_0100_0010(b: &mut Bencher) { | |
962 | do_bench_clone_from(b, 1, 100, 10) | |
963 | } | |
964 | ||
965 | #[bench] | |
966 | fn bench_clone_from_01_1000_0100(b: &mut Bencher) { | |
967 | do_bench_clone_from(b, 1, 1000, 100) | |
968 | } | |
969 | ||
970 | #[bench] | |
971 | fn bench_clone_from_10_0000_0000(b: &mut Bencher) { | |
972 | do_bench_clone_from(b, 10, 0, 0) | |
973 | } | |
974 | ||
975 | #[bench] | |
976 | fn bench_clone_from_10_0000_0010(b: &mut Bencher) { | |
977 | do_bench_clone_from(b, 10, 0, 10) | |
978 | } | |
979 | ||
980 | #[bench] | |
981 | fn bench_clone_from_10_0000_0100(b: &mut Bencher) { | |
982 | do_bench_clone_from(b, 10, 0, 100) | |
983 | } | |
984 | ||
985 | #[bench] | |
986 | fn bench_clone_from_10_0000_1000(b: &mut Bencher) { | |
987 | do_bench_clone_from(b, 10, 0, 1000) | |
988 | } | |
989 | ||
990 | #[bench] | |
991 | fn bench_clone_from_10_0010_0010(b: &mut Bencher) { | |
992 | do_bench_clone_from(b, 10, 10, 10) | |
993 | } | |
994 | ||
995 | #[bench] | |
996 | fn bench_clone_from_10_0100_0100(b: &mut Bencher) { | |
997 | do_bench_clone_from(b, 10, 100, 100) | |
998 | } | |
999 | ||
1000 | #[bench] | |
1001 | fn bench_clone_from_10_1000_1000(b: &mut Bencher) { | |
1002 | do_bench_clone_from(b, 10, 1000, 1000) | |
1003 | } | |
1004 | ||
1005 | #[bench] | |
1006 | fn bench_clone_from_10_0010_0100(b: &mut Bencher) { | |
1007 | do_bench_clone_from(b, 10, 10, 100) | |
1008 | } | |
1009 | ||
1010 | #[bench] | |
1011 | fn bench_clone_from_10_0100_1000(b: &mut Bencher) { | |
1012 | do_bench_clone_from(b, 10, 100, 1000) | |
1013 | } | |
1014 | ||
1015 | #[bench] | |
1016 | fn bench_clone_from_10_0010_0000(b: &mut Bencher) { | |
1017 | do_bench_clone_from(b, 10, 10, 0) | |
1018 | } | |
1019 | ||
1020 | #[bench] | |
1021 | fn bench_clone_from_10_0100_0010(b: &mut Bencher) { | |
1022 | do_bench_clone_from(b, 10, 100, 10) | |
1023 | } | |
1024 | ||
1025 | #[bench] | |
1026 | fn bench_clone_from_10_1000_0100(b: &mut Bencher) { | |
1027 | do_bench_clone_from(b, 10, 1000, 100) | |
1028 | } |