1 //! Tests for the `cargo bench` command.
2
3 use cargo_test_support::is_nightly;
4 use cargo_test_support::paths::CargoPathExt;
5 use cargo_test_support::{basic_bin_manifest, basic_lib_manifest, basic_manifest, project};
6
7 #[cargo_test]
cargo_bench_simple()8 fn cargo_bench_simple() {
9 if !is_nightly() {
10 return;
11 }
12
13 let p = project()
14 .file("Cargo.toml", &basic_bin_manifest("foo"))
15 .file(
16 "src/main.rs",
17 r#"
18 #![feature(test)]
19 #[cfg(test)]
20 extern crate test;
21
22 fn hello() -> &'static str {
23 "hello"
24 }
25
26 pub fn main() {
27 println!("{}", hello())
28 }
29
30 #[bench]
31 fn bench_hello(_b: &mut test::Bencher) {
32 assert_eq!(hello(), "hello")
33 }
34 "#,
35 )
36 .build();
37
38 p.cargo("build").run();
39 assert!(p.bin("foo").is_file());
40
41 p.process(&p.bin("foo")).with_stdout("hello\n").run();
42
43 p.cargo("bench")
44 .with_stderr(
45 "\
46 [COMPILING] foo v0.5.0 ([CWD])
47 [FINISHED] bench [optimized] target(s) in [..]
48 [RUNNING] [..] (target/release/deps/foo-[..][EXE])",
49 )
50 .with_stdout_contains("test bench_hello ... bench: [..]")
51 .run();
52 }
53
54 #[cargo_test]
bench_bench_implicit()55 fn bench_bench_implicit() {
56 if !is_nightly() {
57 return;
58 }
59
60 let p = project()
61 .file(
62 "src/main.rs",
63 r#"
64 #![feature(test)]
65 #[cfg(test)]
66 extern crate test;
67 #[bench] fn run1(_ben: &mut test::Bencher) { }
68 fn main() { println!("Hello main!"); }
69 "#,
70 )
71 .file(
72 "tests/other.rs",
73 r#"
74 #![feature(test)]
75 extern crate test;
76 #[bench] fn run3(_ben: &mut test::Bencher) { }
77 "#,
78 )
79 .file(
80 "benches/mybench.rs",
81 r#"
82 #![feature(test)]
83 extern crate test;
84 #[bench] fn run2(_ben: &mut test::Bencher) { }
85 "#,
86 )
87 .build();
88
89 p.cargo("bench --benches")
90 .with_stderr(
91 "\
92 [COMPILING] foo v0.0.1 ([CWD])
93 [FINISHED] bench [optimized] target(s) in [..]
94 [RUNNING] [..] (target/release/deps/foo-[..][EXE])
95 [RUNNING] [..] (target/release/deps/mybench-[..][EXE])
96 ",
97 )
98 .with_stdout_contains("test run2 ... bench: [..]")
99 .run();
100 }
101
102 #[cargo_test]
bench_bin_implicit()103 fn bench_bin_implicit() {
104 if !is_nightly() {
105 return;
106 }
107
108 let p = project()
109 .file(
110 "src/main.rs",
111 r#"
112 #![feature(test)]
113 #[cfg(test)]
114 extern crate test;
115 #[bench] fn run1(_ben: &mut test::Bencher) { }
116 fn main() { println!("Hello main!"); }
117 "#,
118 )
119 .file(
120 "tests/other.rs",
121 r#"
122 #![feature(test)]
123 extern crate test;
124 #[bench] fn run3(_ben: &mut test::Bencher) { }
125 "#,
126 )
127 .file(
128 "benches/mybench.rs",
129 r#"
130 #![feature(test)]
131 extern crate test;
132 #[bench] fn run2(_ben: &mut test::Bencher) { }
133 "#,
134 )
135 .build();
136
137 p.cargo("bench --bins")
138 .with_stderr(
139 "\
140 [COMPILING] foo v0.0.1 ([CWD])
141 [FINISHED] bench [optimized] target(s) in [..]
142 [RUNNING] [..] (target/release/deps/foo-[..][EXE])
143 ",
144 )
145 .with_stdout_contains("test run1 ... bench: [..]")
146 .run();
147 }
148
149 #[cargo_test]
bench_tarname()150 fn bench_tarname() {
151 if !is_nightly() {
152 return;
153 }
154
155 let p = project()
156 .file(
157 "benches/bin1.rs",
158 r#"
159 #![feature(test)]
160 extern crate test;
161 #[bench] fn run1(_ben: &mut test::Bencher) { }
162 "#,
163 )
164 .file(
165 "benches/bin2.rs",
166 r#"
167 #![feature(test)]
168 extern crate test;
169 #[bench] fn run2(_ben: &mut test::Bencher) { }
170 "#,
171 )
172 .build();
173
174 p.cargo("bench --bench bin2")
175 .with_stderr(
176 "\
177 [COMPILING] foo v0.0.1 ([CWD])
178 [FINISHED] bench [optimized] target(s) in [..]
179 [RUNNING] [..] (target/release/deps/bin2-[..][EXE])
180 ",
181 )
182 .with_stdout_contains("test run2 ... bench: [..]")
183 .run();
184 }
185
186 #[cargo_test]
bench_multiple_targets()187 fn bench_multiple_targets() {
188 if !is_nightly() {
189 return;
190 }
191
192 let p = project()
193 .file(
194 "benches/bin1.rs",
195 r#"
196 #![feature(test)]
197 extern crate test;
198 #[bench] fn run1(_ben: &mut test::Bencher) { }
199 "#,
200 )
201 .file(
202 "benches/bin2.rs",
203 r#"
204 #![feature(test)]
205 extern crate test;
206 #[bench] fn run2(_ben: &mut test::Bencher) { }
207 "#,
208 )
209 .file(
210 "benches/bin3.rs",
211 r#"
212 #![feature(test)]
213 extern crate test;
214 #[bench] fn run3(_ben: &mut test::Bencher) { }
215 "#,
216 )
217 .build();
218
219 p.cargo("bench --bench bin1 --bench bin2")
220 .with_stdout_contains("test run1 ... bench: [..]")
221 .with_stdout_contains("test run2 ... bench: [..]")
222 .with_stdout_does_not_contain("[..]run3[..]")
223 .run();
224 }
225
226 #[cargo_test]
cargo_bench_verbose()227 fn cargo_bench_verbose() {
228 if !is_nightly() {
229 return;
230 }
231
232 let p = project()
233 .file("Cargo.toml", &basic_bin_manifest("foo"))
234 .file(
235 "src/main.rs",
236 r#"
237 #![feature(test)]
238 #[cfg(test)]
239 extern crate test;
240 fn main() {}
241 #[bench] fn bench_hello(_b: &mut test::Bencher) {}
242 "#,
243 )
244 .build();
245
246 p.cargo("bench -v hello")
247 .with_stderr(
248 "\
249 [COMPILING] foo v0.5.0 ([CWD])
250 [RUNNING] `rustc [..] src/main.rs [..]`
251 [FINISHED] bench [optimized] target(s) in [..]
252 [RUNNING] `[..]target/release/deps/foo-[..][EXE] hello --bench`",
253 )
254 .with_stdout_contains("test bench_hello ... bench: [..]")
255 .run();
256 }
257
258 #[cargo_test]
many_similar_names()259 fn many_similar_names() {
260 if !is_nightly() {
261 return;
262 }
263
264 let p = project()
265 .file(
266 "src/lib.rs",
267 "
268 #![feature(test)]
269 #[cfg(test)]
270 extern crate test;
271 pub fn foo() {}
272 #[bench] fn lib_bench(_b: &mut test::Bencher) {}
273 ",
274 )
275 .file(
276 "src/main.rs",
277 "
278 #![feature(test)]
279 #[cfg(test)]
280 extern crate foo;
281 #[cfg(test)]
282 extern crate test;
283 fn main() {}
284 #[bench] fn bin_bench(_b: &mut test::Bencher) { foo::foo() }
285 ",
286 )
287 .file(
288 "benches/foo.rs",
289 r#"
290 #![feature(test)]
291 extern crate foo;
292 extern crate test;
293 #[bench] fn bench_bench(_b: &mut test::Bencher) { foo::foo() }
294 "#,
295 )
296 .build();
297
298 p.cargo("bench")
299 .with_stdout_contains("test bin_bench ... bench: 0 ns/iter (+/- 0)")
300 .with_stdout_contains("test lib_bench ... bench: 0 ns/iter (+/- 0)")
301 .with_stdout_contains("test bench_bench ... bench: 0 ns/iter (+/- 0)")
302 .run();
303 }
304
305 #[cargo_test]
cargo_bench_failing_test()306 fn cargo_bench_failing_test() {
307 if !is_nightly() {
308 return;
309 }
310
311 let p = project()
312 .file("Cargo.toml", &basic_bin_manifest("foo"))
313 .file(
314 "src/main.rs",
315 r#"
316 #![feature(test)]
317 #[cfg(test)]
318 extern crate test;
319 fn hello() -> &'static str {
320 "hello"
321 }
322
323 pub fn main() {
324 println!("{}", hello())
325 }
326
327 #[bench]
328 fn bench_hello(_b: &mut test::Bencher) {
329 assert_eq!(hello(), "nope")
330 }
331 "#,
332 )
333 .build();
334
335 p.cargo("build").run();
336 assert!(p.bin("foo").is_file());
337
338 p.process(&p.bin("foo")).with_stdout("hello\n").run();
339
340 // Force libtest into serial execution so that the test header will be printed.
341 p.cargo("bench -- --test-threads=1")
342 .with_stdout_contains("test bench_hello ...[..]")
343 .with_stderr_contains(
344 "\
345 [COMPILING] foo v0.5.0 ([CWD])[..]
346 [FINISHED] bench [optimized] target(s) in [..]
347 [RUNNING] [..] (target/release/deps/foo-[..][EXE])",
348 )
349 .with_stdout_contains(
350 "[..]thread '[..]' panicked at 'assertion failed: `(left == right)`[..]",
351 )
352 .with_stdout_contains("[..]left: `\"hello\"`[..]")
353 .with_stdout_contains("[..]right: `\"nope\"`[..]")
354 .with_stdout_contains("[..]src/main.rs:15[..]")
355 .with_status(101)
356 .run();
357 }
358
359 #[cargo_test]
bench_with_lib_dep()360 fn bench_with_lib_dep() {
361 if !is_nightly() {
362 return;
363 }
364
365 let p = project()
366 .file(
367 "Cargo.toml",
368 r#"
369 [project]
370 name = "foo"
371 version = "0.0.1"
372 authors = []
373
374 [[bin]]
375 name = "baz"
376 path = "src/main.rs"
377 "#,
378 )
379 .file(
380 "src/lib.rs",
381 r#"
382 #![feature(test)]
383 #[cfg(test)]
384 extern crate test;
385 ///
386 /// ```rust
387 /// extern crate foo;
388 /// fn main() {
389 /// println!("{}", foo::foo());
390 /// }
391 /// ```
392 ///
393 pub fn foo(){}
394 #[bench] fn lib_bench(_b: &mut test::Bencher) {}
395 "#,
396 )
397 .file(
398 "src/main.rs",
399 "
400 #![feature(test)]
401 #[allow(unused_extern_crates)]
402 extern crate foo;
403 #[cfg(test)]
404 extern crate test;
405
406 fn main() {}
407
408 #[bench]
409 fn bin_bench(_b: &mut test::Bencher) {}
410 ",
411 )
412 .build();
413
414 p.cargo("bench")
415 .with_stderr(
416 "\
417 [COMPILING] foo v0.0.1 ([CWD])
418 [FINISHED] bench [optimized] target(s) in [..]
419 [RUNNING] [..] (target/release/deps/foo-[..][EXE])
420 [RUNNING] [..] (target/release/deps/baz-[..][EXE])",
421 )
422 .with_stdout_contains("test lib_bench ... bench: [..]")
423 .with_stdout_contains("test bin_bench ... bench: [..]")
424 .run();
425 }
426
427 #[cargo_test]
bench_with_deep_lib_dep()428 fn bench_with_deep_lib_dep() {
429 if !is_nightly() {
430 return;
431 }
432
433 let p = project()
434 .at("bar")
435 .file(
436 "Cargo.toml",
437 r#"
438 [package]
439 name = "bar"
440 version = "0.0.1"
441 authors = []
442
443 [dependencies.foo]
444 path = "../foo"
445 "#,
446 )
447 .file(
448 "src/lib.rs",
449 "
450 #![feature(test)]
451 #[cfg(test)]
452 extern crate foo;
453 #[cfg(test)]
454 extern crate test;
455 #[bench]
456 fn bar_bench(_b: &mut test::Bencher) {
457 foo::foo();
458 }
459 ",
460 )
461 .build();
462 let _p2 = project()
463 .file(
464 "src/lib.rs",
465 "
466 #![feature(test)]
467 #[cfg(test)]
468 extern crate test;
469
470 pub fn foo() {}
471
472 #[bench]
473 fn foo_bench(_b: &mut test::Bencher) {}
474 ",
475 )
476 .build();
477
478 p.cargo("bench")
479 .with_stderr(
480 "\
481 [COMPILING] foo v0.0.1 ([..])
482 [COMPILING] bar v0.0.1 ([CWD])
483 [FINISHED] bench [optimized] target(s) in [..]
484 [RUNNING] [..] (target/release/deps/bar-[..][EXE])",
485 )
486 .with_stdout_contains("test bar_bench ... bench: [..]")
487 .run();
488 }
489
490 #[cargo_test]
external_bench_explicit()491 fn external_bench_explicit() {
492 if !is_nightly() {
493 return;
494 }
495
496 let p = project()
497 .file(
498 "Cargo.toml",
499 r#"
500 [project]
501 name = "foo"
502 version = "0.0.1"
503 authors = []
504
505 [[bench]]
506 name = "bench"
507 path = "src/bench.rs"
508 "#,
509 )
510 .file(
511 "src/lib.rs",
512 r#"
513 #![feature(test)]
514 #[cfg(test)]
515 extern crate test;
516 pub fn get_hello() -> &'static str { "Hello" }
517
518 #[bench]
519 fn internal_bench(_b: &mut test::Bencher) {}
520 "#,
521 )
522 .file(
523 "src/bench.rs",
524 r#"
525 #![feature(test)]
526 #[allow(unused_extern_crates)]
527 extern crate foo;
528 extern crate test;
529
530 #[bench]
531 fn external_bench(_b: &mut test::Bencher) {}
532 "#,
533 )
534 .build();
535
536 p.cargo("bench")
537 .with_stderr(
538 "\
539 [COMPILING] foo v0.0.1 ([CWD])
540 [FINISHED] bench [optimized] target(s) in [..]
541 [RUNNING] [..] (target/release/deps/foo-[..][EXE])
542 [RUNNING] [..] (target/release/deps/bench-[..][EXE])",
543 )
544 .with_stdout_contains("test internal_bench ... bench: [..]")
545 .with_stdout_contains("test external_bench ... bench: [..]")
546 .run();
547 }
548
549 #[cargo_test]
external_bench_implicit()550 fn external_bench_implicit() {
551 if !is_nightly() {
552 return;
553 }
554
555 let p = project()
556 .file(
557 "src/lib.rs",
558 r#"
559 #![feature(test)]
560 #[cfg(test)]
561 extern crate test;
562
563 pub fn get_hello() -> &'static str { "Hello" }
564
565 #[bench]
566 fn internal_bench(_b: &mut test::Bencher) {}
567 "#,
568 )
569 .file(
570 "benches/external.rs",
571 r#"
572 #![feature(test)]
573 #[allow(unused_extern_crates)]
574 extern crate foo;
575 extern crate test;
576
577 #[bench]
578 fn external_bench(_b: &mut test::Bencher) {}
579 "#,
580 )
581 .build();
582
583 p.cargo("bench")
584 .with_stderr(
585 "\
586 [COMPILING] foo v0.0.1 ([CWD])
587 [FINISHED] bench [optimized] target(s) in [..]
588 [RUNNING] [..] (target/release/deps/foo-[..][EXE])
589 [RUNNING] [..] (target/release/deps/external-[..][EXE])",
590 )
591 .with_stdout_contains("test internal_bench ... bench: [..]")
592 .with_stdout_contains("test external_bench ... bench: [..]")
593 .run();
594 }
595
596 #[cargo_test]
bench_autodiscover_2015()597 fn bench_autodiscover_2015() {
598 if !is_nightly() {
599 return;
600 }
601
602 let p = project()
603 .file(
604 "Cargo.toml",
605 r#"
606 [project]
607 name = "foo"
608 version = "0.0.1"
609 authors = []
610 edition = "2015"
611
612 [features]
613 magic = []
614
615 [[bench]]
616 name = "bench_magic"
617 required-features = ["magic"]
618 "#,
619 )
620 .file("src/lib.rs", "")
621 .file(
622 "benches/bench_basic.rs",
623 r#"
624 #![feature(test)]
625 #[allow(unused_extern_crates)]
626 extern crate foo;
627 extern crate test;
628
629 #[bench]
630 fn bench_basic(_b: &mut test::Bencher) {}
631 "#,
632 )
633 .file(
634 "benches/bench_magic.rs",
635 r#"
636 #![feature(test)]
637 #[allow(unused_extern_crates)]
638 extern crate foo;
639 extern crate test;
640
641 #[bench]
642 fn bench_magic(_b: &mut test::Bencher) {}
643 "#,
644 )
645 .build();
646
647 p.cargo("bench bench_basic")
648 .with_stderr(
649 "warning: \
650 An explicit [[bench]] section is specified in Cargo.toml which currently
651 disables Cargo from automatically inferring other benchmark targets.
652 This inference behavior will change in the Rust 2018 edition and the following
653 files will be included as a benchmark target:
654
655 * [..]bench_basic.rs
656
657 This is likely to break cargo build or cargo test as these files may not be
658 ready to be compiled as a benchmark target today. You can future-proof yourself
659 and disable this warning by adding `autobenches = false` to your [package]
660 section. You may also move the files to a location where Cargo would not
661 automatically infer them to be a target, such as in subfolders.
662
663 For more information on this warning you can consult
664 https://github.com/rust-lang/cargo/issues/5330
665 [COMPILING] foo v0.0.1 ([CWD])
666 [FINISHED] bench [optimized] target(s) in [..]
667 [RUNNING] [..] (target/release/deps/foo-[..][EXE])
668 ",
669 )
670 .run();
671 }
672
673 #[cargo_test]
dont_run_examples()674 fn dont_run_examples() {
675 if !is_nightly() {
676 return;
677 }
678
679 let p = project()
680 .file("src/lib.rs", "")
681 .file(
682 "examples/dont-run-me-i-will-fail.rs",
683 r#"fn main() { panic!("Examples should not be run by 'cargo test'"); }"#,
684 )
685 .build();
686 p.cargo("bench").run();
687 }
688
689 #[cargo_test]
pass_through_command_line()690 fn pass_through_command_line() {
691 if !is_nightly() {
692 return;
693 }
694
695 let p = project()
696 .file(
697 "src/lib.rs",
698 "
699 #![feature(test)]
700 #[cfg(test)]
701 extern crate test;
702
703 #[bench] fn foo(_b: &mut test::Bencher) {}
704 #[bench] fn bar(_b: &mut test::Bencher) {}
705 ",
706 )
707 .build();
708
709 p.cargo("bench bar")
710 .with_stderr(
711 "\
712 [COMPILING] foo v0.0.1 ([CWD])
713 [FINISHED] bench [optimized] target(s) in [..]
714 [RUNNING] [..] (target/release/deps/foo-[..][EXE])",
715 )
716 .with_stdout_contains("test bar ... bench: [..]")
717 .run();
718
719 p.cargo("bench foo")
720 .with_stderr(
721 "[FINISHED] bench [optimized] target(s) in [..]
722 [RUNNING] [..] (target/release/deps/foo-[..][EXE])",
723 )
724 .with_stdout_contains("test foo ... bench: [..]")
725 .run();
726 }
727
728 // Regression test for running cargo-bench twice with
729 // tests in an rlib
730 #[cargo_test]
cargo_bench_twice()731 fn cargo_bench_twice() {
732 if !is_nightly() {
733 return;
734 }
735
736 let p = project()
737 .file("Cargo.toml", &basic_lib_manifest("foo"))
738 .file(
739 "src/foo.rs",
740 r#"
741 #![crate_type = "rlib"]
742 #![feature(test)]
743 #[cfg(test)]
744 extern crate test;
745
746 #[bench]
747 fn dummy_bench(b: &mut test::Bencher) { }
748 "#,
749 )
750 .build();
751
752 for _ in 0..2 {
753 p.cargo("bench").run();
754 }
755 }
756
757 #[cargo_test]
lib_bin_same_name()758 fn lib_bin_same_name() {
759 if !is_nightly() {
760 return;
761 }
762
763 let p = project()
764 .file(
765 "Cargo.toml",
766 r#"
767 [project]
768 name = "foo"
769 version = "0.0.1"
770 authors = []
771
772 [lib]
773 name = "foo"
774 [[bin]]
775 name = "foo"
776 "#,
777 )
778 .file(
779 "src/lib.rs",
780 "
781 #![feature(test)]
782 #[cfg(test)]
783 extern crate test;
784 #[bench] fn lib_bench(_b: &mut test::Bencher) {}
785 ",
786 )
787 .file(
788 "src/main.rs",
789 "
790 #![feature(test)]
791 #[allow(unused_extern_crates)]
792 extern crate foo;
793 #[cfg(test)]
794 extern crate test;
795
796 #[bench]
797 fn bin_bench(_b: &mut test::Bencher) {}
798 ",
799 )
800 .build();
801
802 p.cargo("bench")
803 .with_stderr(
804 "\
805 [COMPILING] foo v0.0.1 ([CWD])
806 [FINISHED] bench [optimized] target(s) in [..]
807 [RUNNING] [..] (target/release/deps/foo-[..][EXE])
808 [RUNNING] [..] (target/release/deps/foo-[..][EXE])",
809 )
810 .with_stdout_contains_n("test [..] ... bench: [..]", 2)
811 .run();
812 }
813
814 #[cargo_test]
lib_with_standard_name()815 fn lib_with_standard_name() {
816 if !is_nightly() {
817 return;
818 }
819
820 let p = project()
821 .file("Cargo.toml", &basic_manifest("syntax", "0.0.1"))
822 .file(
823 "src/lib.rs",
824 "
825 #![feature(test)]
826 #[cfg(test)]
827 extern crate test;
828
829 /// ```
830 /// syntax::foo();
831 /// ```
832 pub fn foo() {}
833
834 #[bench]
835 fn foo_bench(_b: &mut test::Bencher) {}
836 ",
837 )
838 .file(
839 "benches/bench.rs",
840 "
841 #![feature(test)]
842 extern crate syntax;
843 extern crate test;
844
845 #[bench]
846 fn bench(_b: &mut test::Bencher) { syntax::foo() }
847 ",
848 )
849 .build();
850
851 p.cargo("bench")
852 .with_stderr(
853 "\
854 [COMPILING] syntax v0.0.1 ([CWD])
855 [FINISHED] bench [optimized] target(s) in [..]
856 [RUNNING] [..] (target/release/deps/syntax-[..][EXE])
857 [RUNNING] [..] (target/release/deps/bench-[..][EXE])",
858 )
859 .with_stdout_contains("test foo_bench ... bench: [..]")
860 .with_stdout_contains("test bench ... bench: [..]")
861 .run();
862 }
863
864 #[cargo_test]
lib_with_standard_name2()865 fn lib_with_standard_name2() {
866 if !is_nightly() {
867 return;
868 }
869
870 let p = project()
871 .file(
872 "Cargo.toml",
873 r#"
874 [package]
875 name = "syntax"
876 version = "0.0.1"
877 authors = []
878
879 [lib]
880 name = "syntax"
881 bench = false
882 doctest = false
883 "#,
884 )
885 .file("src/lib.rs", "pub fn foo() {}")
886 .file(
887 "src/main.rs",
888 "
889 #![feature(test)]
890 #[cfg(test)]
891 extern crate syntax;
892 #[cfg(test)]
893 extern crate test;
894
895 fn main() {}
896
897 #[bench]
898 fn bench(_b: &mut test::Bencher) { syntax::foo() }
899 ",
900 )
901 .build();
902
903 p.cargo("bench")
904 .with_stderr(
905 "\
906 [COMPILING] syntax v0.0.1 ([CWD])
907 [FINISHED] bench [optimized] target(s) in [..]
908 [RUNNING] [..] (target/release/deps/syntax-[..][EXE])",
909 )
910 .with_stdout_contains("test bench ... bench: [..]")
911 .run();
912 }
913
914 #[cargo_test]
bench_dylib()915 fn bench_dylib() {
916 if !is_nightly() {
917 return;
918 }
919
920 let p = project()
921 .file(
922 "Cargo.toml",
923 r#"
924 [package]
925 name = "foo"
926 version = "0.0.1"
927 authors = []
928
929 [lib]
930 name = "foo"
931 crate_type = ["dylib"]
932
933 [dependencies.bar]
934 path = "bar"
935 "#,
936 )
937 .file(
938 "src/lib.rs",
939 r#"
940 #![feature(test)]
941 extern crate bar as the_bar;
942 #[cfg(test)]
943 extern crate test;
944
945 pub fn bar() { the_bar::baz(); }
946
947 #[bench]
948 fn foo(_b: &mut test::Bencher) {}
949 "#,
950 )
951 .file(
952 "benches/bench.rs",
953 r#"
954 #![feature(test)]
955 extern crate foo as the_foo;
956 extern crate test;
957
958 #[bench]
959 fn foo(_b: &mut test::Bencher) { the_foo::bar(); }
960 "#,
961 )
962 .file(
963 "bar/Cargo.toml",
964 r#"
965 [package]
966 name = "bar"
967 version = "0.0.1"
968 authors = []
969
970 [lib]
971 name = "bar"
972 crate_type = ["dylib"]
973 "#,
974 )
975 .file("bar/src/lib.rs", "pub fn baz() {}")
976 .build();
977
978 p.cargo("bench -v")
979 .with_stderr(
980 "\
981 [COMPILING] bar v0.0.1 ([CWD]/bar)
982 [RUNNING] [..] -C opt-level=3 [..]
983 [COMPILING] foo v0.0.1 ([CWD])
984 [RUNNING] [..] -C opt-level=3 [..]
985 [RUNNING] [..] -C opt-level=3 [..]
986 [RUNNING] [..] -C opt-level=3 [..]
987 [FINISHED] bench [optimized] target(s) in [..]
988 [RUNNING] `[..]target/release/deps/foo-[..][EXE] --bench`
989 [RUNNING] `[..]target/release/deps/bench-[..][EXE] --bench`",
990 )
991 .with_stdout_contains_n("test foo ... bench: [..]", 2)
992 .run();
993
994 p.root().move_into_the_past();
995 p.cargo("bench -v")
996 .with_stderr(
997 "\
998 [FRESH] bar v0.0.1 ([CWD]/bar)
999 [FRESH] foo v0.0.1 ([CWD])
1000 [FINISHED] bench [optimized] target(s) in [..]
1001 [RUNNING] `[..]target/release/deps/foo-[..][EXE] --bench`
1002 [RUNNING] `[..]target/release/deps/bench-[..][EXE] --bench`",
1003 )
1004 .with_stdout_contains_n("test foo ... bench: [..]", 2)
1005 .run();
1006 }
1007
1008 #[cargo_test]
bench_twice_with_build_cmd()1009 fn bench_twice_with_build_cmd() {
1010 if !is_nightly() {
1011 return;
1012 }
1013
1014 let p = project()
1015 .file(
1016 "Cargo.toml",
1017 r#"
1018 [package]
1019 name = "foo"
1020 version = "0.0.1"
1021 authors = []
1022 build = "build.rs"
1023 "#,
1024 )
1025 .file("build.rs", "fn main() {}")
1026 .file(
1027 "src/lib.rs",
1028 "
1029 #![feature(test)]
1030 #[cfg(test)]
1031 extern crate test;
1032 #[bench]
1033 fn foo(_b: &mut test::Bencher) {}
1034 ",
1035 )
1036 .build();
1037
1038 p.cargo("bench")
1039 .with_stderr(
1040 "\
1041 [COMPILING] foo v0.0.1 ([CWD])
1042 [FINISHED] bench [optimized] target(s) in [..]
1043 [RUNNING] [..] (target/release/deps/foo-[..][EXE])",
1044 )
1045 .with_stdout_contains("test foo ... bench: [..]")
1046 .run();
1047
1048 p.cargo("bench")
1049 .with_stderr(
1050 "[FINISHED] bench [optimized] target(s) in [..]
1051 [RUNNING] [..] (target/release/deps/foo-[..][EXE])",
1052 )
1053 .with_stdout_contains("test foo ... bench: [..]")
1054 .run();
1055 }
1056
1057 #[cargo_test]
bench_with_examples()1058 fn bench_with_examples() {
1059 if !is_nightly() {
1060 return;
1061 }
1062
1063 let p = project()
1064 .file(
1065 "Cargo.toml",
1066 r#"
1067 [package]
1068 name = "foo"
1069 version = "6.6.6"
1070 authors = []
1071
1072 [[example]]
1073 name = "teste1"
1074
1075 [[bench]]
1076 name = "testb1"
1077 "#,
1078 )
1079 .file(
1080 "src/lib.rs",
1081 r#"
1082 #![feature(test)]
1083 #[cfg(test)]
1084 extern crate test;
1085 #[cfg(test)]
1086 use test::Bencher;
1087
1088 pub fn f1() {
1089 println!("f1");
1090 }
1091
1092 pub fn f2() {}
1093
1094 #[bench]
1095 fn bench_bench1(_b: &mut Bencher) {
1096 f2();
1097 }
1098 "#,
1099 )
1100 .file(
1101 "benches/testb1.rs",
1102 "
1103 #![feature(test)]
1104 extern crate foo;
1105 extern crate test;
1106
1107 use test::Bencher;
1108
1109 #[bench]
1110 fn bench_bench2(_b: &mut Bencher) {
1111 foo::f2();
1112 }
1113 ",
1114 )
1115 .file(
1116 "examples/teste1.rs",
1117 r#"
1118 extern crate foo;
1119
1120 fn main() {
1121 println!("example1");
1122 foo::f1();
1123 }
1124 "#,
1125 )
1126 .build();
1127
1128 p.cargo("bench -v")
1129 .with_stderr(
1130 "\
1131 [COMPILING] foo v6.6.6 ([CWD])
1132 [RUNNING] `rustc [..]`
1133 [RUNNING] `rustc [..]`
1134 [RUNNING] `rustc [..]`
1135 [FINISHED] bench [optimized] target(s) in [..]
1136 [RUNNING] `[CWD]/target/release/deps/foo-[..][EXE] --bench`
1137 [RUNNING] `[CWD]/target/release/deps/testb1-[..][EXE] --bench`",
1138 )
1139 .with_stdout_contains("test bench_bench1 ... bench: [..]")
1140 .with_stdout_contains("test bench_bench2 ... bench: [..]")
1141 .run();
1142 }
1143
1144 #[cargo_test]
test_a_bench()1145 fn test_a_bench() {
1146 if !is_nightly() {
1147 return;
1148 }
1149
1150 let p = project()
1151 .file(
1152 "Cargo.toml",
1153 r#"
1154 [project]
1155 name = "foo"
1156 authors = []
1157 version = "0.1.0"
1158
1159 [lib]
1160 name = "foo"
1161 test = false
1162 doctest = false
1163
1164 [[bench]]
1165 name = "b"
1166 test = true
1167 "#,
1168 )
1169 .file("src/lib.rs", "")
1170 .file("benches/b.rs", "#[test] fn foo() {}")
1171 .build();
1172
1173 p.cargo("test")
1174 .with_stderr(
1175 "\
1176 [COMPILING] foo v0.1.0 ([..])
1177 [FINISHED] test [unoptimized + debuginfo] target(s) in [..]
1178 [RUNNING] [..] (target/debug/deps/b-[..][EXE])",
1179 )
1180 .with_stdout_contains("test foo ... ok")
1181 .run();
1182 }
1183
1184 #[cargo_test]
test_bench_no_run()1185 fn test_bench_no_run() {
1186 if !is_nightly() {
1187 return;
1188 }
1189
1190 let p = project()
1191 .file("src/lib.rs", "")
1192 .file(
1193 "benches/bbaz.rs",
1194 r#"
1195 #![feature(test)]
1196
1197 extern crate test;
1198
1199 use test::Bencher;
1200
1201 #[bench]
1202 fn bench_baz(_: &mut Bencher) {}
1203 "#,
1204 )
1205 .build();
1206
1207 p.cargo("bench --no-run")
1208 .with_stderr(
1209 "\
1210 [COMPILING] foo v0.0.1 ([..])
1211 [FINISHED] bench [optimized] target(s) in [..]
1212 ",
1213 )
1214 .run();
1215 }
1216
1217 #[cargo_test]
test_bench_no_fail_fast()1218 fn test_bench_no_fail_fast() {
1219 if !is_nightly() {
1220 return;
1221 }
1222
1223 let p = project()
1224 .file("Cargo.toml", &basic_bin_manifest("foo"))
1225 .file(
1226 "src/foo.rs",
1227 r#"
1228 #![feature(test)]
1229 #[cfg(test)]
1230 extern crate test;
1231 fn hello() -> &'static str {
1232 "hello"
1233 }
1234
1235 pub fn main() {
1236 println!("{}", hello())
1237 }
1238
1239 #[bench]
1240 fn bench_hello(_b: &mut test::Bencher) {
1241 assert_eq!(hello(), "hello")
1242 }
1243
1244 #[bench]
1245 fn bench_nope(_b: &mut test::Bencher) {
1246 assert_eq!("nope", hello())
1247 }
1248 "#,
1249 )
1250 .build();
1251
1252 p.cargo("bench --no-fail-fast -- --test-threads=1")
1253 .with_status(101)
1254 .with_stderr_contains("[RUNNING] [..] (target/release/deps/foo-[..][EXE])")
1255 .with_stdout_contains("running 2 tests")
1256 .with_stderr_contains("[RUNNING] [..] (target/release/deps/foo-[..][EXE])")
1257 .with_stdout_contains("test bench_hello [..]")
1258 .with_stdout_contains("test bench_nope [..]")
1259 .run();
1260 }
1261
1262 #[cargo_test]
test_bench_multiple_packages()1263 fn test_bench_multiple_packages() {
1264 if !is_nightly() {
1265 return;
1266 }
1267
1268 let p = project()
1269 .file(
1270 "Cargo.toml",
1271 r#"
1272 [project]
1273 name = "foo"
1274 authors = []
1275 version = "0.1.0"
1276
1277 [dependencies.bar]
1278 path = "../bar"
1279
1280 [dependencies.baz]
1281 path = "../baz"
1282 "#,
1283 )
1284 .file("src/lib.rs", "")
1285 .build();
1286
1287 let _bar = project()
1288 .at("bar")
1289 .file(
1290 "Cargo.toml",
1291 r#"
1292 [project]
1293 name = "bar"
1294 authors = []
1295 version = "0.1.0"
1296
1297 [[bench]]
1298 name = "bbar"
1299 test = true
1300 "#,
1301 )
1302 .file("src/lib.rs", "")
1303 .file(
1304 "benches/bbar.rs",
1305 r#"
1306 #![feature(test)]
1307 extern crate test;
1308
1309 use test::Bencher;
1310
1311 #[bench]
1312 fn bench_bar(_b: &mut Bencher) {}
1313 "#,
1314 )
1315 .build();
1316
1317 let _baz = project()
1318 .at("baz")
1319 .file(
1320 "Cargo.toml",
1321 r#"
1322 [project]
1323 name = "baz"
1324 authors = []
1325 version = "0.1.0"
1326
1327 [[bench]]
1328 name = "bbaz"
1329 test = true
1330 "#,
1331 )
1332 .file("src/lib.rs", "")
1333 .file(
1334 "benches/bbaz.rs",
1335 r#"
1336 #![feature(test)]
1337 extern crate test;
1338
1339 use test::Bencher;
1340
1341 #[bench]
1342 fn bench_baz(_b: &mut Bencher) {}
1343 "#,
1344 )
1345 .build();
1346
1347 p.cargo("bench -p bar -p baz")
1348 .with_stderr_contains("[RUNNING] [..] (target/release/deps/bbaz-[..][EXE])")
1349 .with_stdout_contains("test bench_baz ... bench: [..]")
1350 .with_stderr_contains("[RUNNING] [..] (target/release/deps/bbar-[..][EXE])")
1351 .with_stdout_contains("test bench_bar ... bench: [..]")
1352 .run();
1353 }
1354
1355 #[cargo_test]
bench_all_workspace()1356 fn bench_all_workspace() {
1357 if !is_nightly() {
1358 return;
1359 }
1360
1361 let p = project()
1362 .file(
1363 "Cargo.toml",
1364 r#"
1365 [project]
1366 name = "foo"
1367 version = "0.1.0"
1368
1369 [dependencies]
1370 bar = { path = "bar" }
1371
1372 [workspace]
1373 "#,
1374 )
1375 .file("src/main.rs", "fn main() {}")
1376 .file(
1377 "benches/foo.rs",
1378 r#"
1379 #![feature(test)]
1380 extern crate test;
1381
1382 use test::Bencher;
1383
1384 #[bench]
1385 fn bench_foo(_: &mut Bencher) -> () { () }
1386 "#,
1387 )
1388 .file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0"))
1389 .file("bar/src/lib.rs", "pub fn bar() {}")
1390 .file(
1391 "bar/benches/bar.rs",
1392 r#"
1393 #![feature(test)]
1394 extern crate test;
1395
1396 use test::Bencher;
1397
1398 #[bench]
1399 fn bench_bar(_: &mut Bencher) -> () { () }
1400 "#,
1401 )
1402 .build();
1403
1404 p.cargo("bench --workspace")
1405 .with_stderr_contains("[RUNNING] [..] (target/release/deps/bar-[..][EXE])")
1406 .with_stdout_contains("test bench_bar ... bench: [..]")
1407 .with_stderr_contains("[RUNNING] [..] (target/release/deps/foo-[..][EXE])")
1408 .with_stdout_contains("test bench_foo ... bench: [..]")
1409 .run();
1410 }
1411
1412 #[cargo_test]
bench_all_exclude()1413 fn bench_all_exclude() {
1414 if !is_nightly() {
1415 return;
1416 }
1417
1418 let p = project()
1419 .file(
1420 "Cargo.toml",
1421 r#"
1422 [project]
1423 name = "foo"
1424 version = "0.1.0"
1425
1426 [workspace]
1427 members = ["bar", "baz"]
1428 "#,
1429 )
1430 .file("src/main.rs", "fn main() {}")
1431 .file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0"))
1432 .file(
1433 "bar/src/lib.rs",
1434 r#"
1435 #![feature(test)]
1436 #[cfg(test)]
1437 extern crate test;
1438
1439 #[bench]
1440 pub fn bar(b: &mut test::Bencher) {
1441 b.iter(|| {});
1442 }
1443 "#,
1444 )
1445 .file("baz/Cargo.toml", &basic_manifest("baz", "0.1.0"))
1446 .file(
1447 "baz/src/lib.rs",
1448 "#[test] pub fn baz() { break_the_build(); }",
1449 )
1450 .build();
1451
1452 p.cargo("bench --workspace --exclude baz")
1453 .with_stdout_contains(
1454 "\
1455 running 1 test
1456 test bar ... bench: [..] ns/iter (+/- [..])",
1457 )
1458 .run();
1459 }
1460
1461 #[cargo_test]
bench_all_exclude_glob()1462 fn bench_all_exclude_glob() {
1463 if !is_nightly() {
1464 return;
1465 }
1466
1467 let p = project()
1468 .file(
1469 "Cargo.toml",
1470 r#"
1471 [project]
1472 name = "foo"
1473 version = "0.1.0"
1474
1475 [workspace]
1476 members = ["bar", "baz"]
1477 "#,
1478 )
1479 .file("src/main.rs", "fn main() {}")
1480 .file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0"))
1481 .file(
1482 "bar/src/lib.rs",
1483 r#"
1484 #![feature(test)]
1485 #[cfg(test)]
1486 extern crate test;
1487
1488 #[bench]
1489 pub fn bar(b: &mut test::Bencher) {
1490 b.iter(|| {});
1491 }
1492 "#,
1493 )
1494 .file("baz/Cargo.toml", &basic_manifest("baz", "0.1.0"))
1495 .file(
1496 "baz/src/lib.rs",
1497 "#[test] pub fn baz() { break_the_build(); }",
1498 )
1499 .build();
1500
1501 p.cargo("bench --workspace --exclude '*z'")
1502 .with_stdout_contains(
1503 "\
1504 running 1 test
1505 test bar ... bench: [..] ns/iter (+/- [..])",
1506 )
1507 .run();
1508 }
1509
1510 #[cargo_test]
bench_all_virtual_manifest()1511 fn bench_all_virtual_manifest() {
1512 if !is_nightly() {
1513 return;
1514 }
1515
1516 let p = project()
1517 .file(
1518 "Cargo.toml",
1519 r#"
1520 [workspace]
1521 members = ["bar", "baz"]
1522 "#,
1523 )
1524 .file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0"))
1525 .file("bar/src/lib.rs", "pub fn bar() {}")
1526 .file(
1527 "bar/benches/bar.rs",
1528 r#"
1529 #![feature(test)]
1530 extern crate test;
1531
1532 use test::Bencher;
1533
1534 #[bench]
1535 fn bench_bar(_: &mut Bencher) -> () { () }
1536 "#,
1537 )
1538 .file("baz/Cargo.toml", &basic_manifest("baz", "0.1.0"))
1539 .file("baz/src/lib.rs", "pub fn baz() {}")
1540 .file(
1541 "baz/benches/baz.rs",
1542 r#"
1543 #![feature(test)]
1544 extern crate test;
1545
1546 use test::Bencher;
1547
1548 #[bench]
1549 fn bench_baz(_: &mut Bencher) -> () { () }
1550 "#,
1551 )
1552 .build();
1553
1554 // The order in which bar and baz are built is not guaranteed
1555 p.cargo("bench --workspace")
1556 .with_stderr_contains("[RUNNING] [..] (target/release/deps/baz-[..][EXE])")
1557 .with_stdout_contains("test bench_baz ... bench: [..]")
1558 .with_stderr_contains("[RUNNING] [..] (target/release/deps/bar-[..][EXE])")
1559 .with_stdout_contains("test bench_bar ... bench: [..]")
1560 .run();
1561 }
1562
1563 #[cargo_test]
bench_virtual_manifest_glob()1564 fn bench_virtual_manifest_glob() {
1565 if !is_nightly() {
1566 return;
1567 }
1568
1569 let p = project()
1570 .file(
1571 "Cargo.toml",
1572 r#"
1573 [workspace]
1574 members = ["bar", "baz"]
1575 "#,
1576 )
1577 .file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0"))
1578 .file("bar/src/lib.rs", "pub fn bar() { break_the_build(); }")
1579 .file(
1580 "bar/benches/bar.rs",
1581 r#"
1582 #![feature(test)]
1583 extern crate test;
1584
1585 use test::Bencher;
1586
1587 #[bench]
1588 fn bench_bar(_: &mut Bencher) -> () { break_the_build(); }
1589 "#,
1590 )
1591 .file("baz/Cargo.toml", &basic_manifest("baz", "0.1.0"))
1592 .file("baz/src/lib.rs", "pub fn baz() {}")
1593 .file(
1594 "baz/benches/baz.rs",
1595 r#"
1596 #![feature(test)]
1597 extern crate test;
1598
1599 use test::Bencher;
1600
1601 #[bench]
1602 fn bench_baz(_: &mut Bencher) -> () { () }
1603 "#,
1604 )
1605 .build();
1606
1607 // The order in which bar and baz are built is not guaranteed
1608 p.cargo("bench -p '*z'")
1609 .with_stderr_contains("[RUNNING] [..] (target/release/deps/baz-[..][EXE])")
1610 .with_stdout_contains("test bench_baz ... bench: [..]")
1611 .with_stderr_does_not_contain("[RUNNING] [..] (target/release/deps/bar-[..][EXE])")
1612 .with_stdout_does_not_contain("test bench_bar ... bench: [..]")
1613 .run();
1614 }
1615
1616 // https://github.com/rust-lang/cargo/issues/4287
1617 #[cargo_test]
legacy_bench_name()1618 fn legacy_bench_name() {
1619 if !is_nightly() {
1620 return;
1621 }
1622
1623 let p = project()
1624 .file(
1625 "Cargo.toml",
1626 r#"
1627 [project]
1628 name = "foo"
1629 version = "0.1.0"
1630
1631 [[bench]]
1632 name = "bench"
1633 "#,
1634 )
1635 .file("src/lib.rs", "pub fn foo() {}")
1636 .file(
1637 "src/bench.rs",
1638 r#"
1639 #![feature(test)]
1640 extern crate test;
1641
1642 use test::Bencher;
1643
1644 #[bench]
1645 fn bench_foo(_: &mut Bencher) -> () { () }
1646 "#,
1647 )
1648 .build();
1649
1650 p.cargo("bench")
1651 .with_stderr_contains(
1652 "\
1653 [WARNING] path `[..]src/bench.rs` was erroneously implicitly accepted for benchmark `bench`,
1654 please set bench.path in Cargo.toml",
1655 )
1656 .run();
1657 }
1658
1659 #[cargo_test]
bench_virtual_manifest_all_implied()1660 fn bench_virtual_manifest_all_implied() {
1661 if !is_nightly() {
1662 return;
1663 }
1664
1665 let p = project()
1666 .file(
1667 "Cargo.toml",
1668 r#"
1669 [workspace]
1670 members = ["bar", "baz"]
1671 "#,
1672 )
1673 .file("bar/Cargo.toml", &basic_manifest("bar", "0.1.0"))
1674 .file("bar/src/lib.rs", "pub fn foo() {}")
1675 .file(
1676 "bar/benches/bar.rs",
1677 r#"
1678 #![feature(test)]
1679 extern crate test;
1680 use test::Bencher;
1681 #[bench]
1682 fn bench_bar(_: &mut Bencher) -> () { () }
1683 "#,
1684 )
1685 .file("baz/Cargo.toml", &basic_manifest("baz", "0.1.0"))
1686 .file("baz/src/lib.rs", "pub fn baz() {}")
1687 .file(
1688 "baz/benches/baz.rs",
1689 r#"
1690 #![feature(test)]
1691 extern crate test;
1692 use test::Bencher;
1693 #[bench]
1694 fn bench_baz(_: &mut Bencher) -> () { () }
1695 "#,
1696 )
1697 .build();
1698
1699 // The order in which bar and baz are built is not guaranteed
1700
1701 p.cargo("bench")
1702 .with_stderr_contains("[RUNNING] [..] (target/release/deps/baz-[..][EXE])")
1703 .with_stdout_contains("test bench_baz ... bench: [..]")
1704 .with_stderr_contains("[RUNNING] [..] (target/release/deps/bar-[..][EXE])")
1705 .with_stdout_contains("test bench_bar ... bench: [..]")
1706 .run();
1707 }
1708
1709 #[cargo_test]
json_artifact_includes_executable_for_benchmark()1710 fn json_artifact_includes_executable_for_benchmark() {
1711 if !is_nightly() {
1712 return;
1713 }
1714
1715 let p = project()
1716 .file(
1717 "benches/benchmark.rs",
1718 r#"
1719 #![feature(test)]
1720 extern crate test;
1721
1722 use test::Bencher;
1723
1724 #[bench]
1725 fn bench_foo(_: &mut Bencher) -> () { () }
1726 "#,
1727 )
1728 .build();
1729
1730 p.cargo("bench --no-run --message-format=json")
1731 .with_json(
1732 r#"
1733 {
1734 "executable": "[..]/foo/target/release/deps/benchmark-[..][EXE]",
1735 "features": [],
1736 "filenames": "{...}",
1737 "fresh": false,
1738 "package_id": "foo 0.0.1 ([..])",
1739 "manifest_path": "[..]",
1740 "profile": "{...}",
1741 "reason": "compiler-artifact",
1742 "target": {
1743 "crate_types": [ "bin" ],
1744 "kind": [ "bench" ],
1745 "doc": false,
1746 "doctest": false,
1747 "edition": "2015",
1748 "name": "benchmark",
1749 "src_path": "[..]/foo/benches/benchmark.rs",
1750 "test": false
1751 }
1752 }
1753
1754 {"reason": "build-finished", "success": true}
1755 "#,
1756 )
1757 .run();
1758 }
1759