From 49127c64d6998526d9f723a653312d0cf5310454 Mon Sep 17 00:00:00 2001 From: Zalathar Date: Wed, 1 Nov 2023 21:28:53 +1100 Subject: [PATCH] coverage: Migrate `tests/coverage-map` into `tests/coverage` --- src/bootstrap/src/core/build_steps/test.rs | 18 +- tests/coverage-map/abort.rs | 66 ------ tests/coverage-map/assert.rs | 32 --- tests/coverage-map/async.rs | 128 ---------- tests/coverage-map/async2.rs | 57 ----- .../auxiliary/inline_always_with_dead_code.rs | 22 -- .../auxiliary/unused_mod_helper.rs | 4 - tests/coverage-map/auxiliary/used_crate.rs | 103 -------- .../auxiliary/used_inline_crate.rs | 85 ------- tests/coverage-map/bad_counter_ids.rs | 66 ------ tests/coverage-map/closure.rs | 220 ------------------ tests/coverage-map/closure_bug.rs | 44 ---- tests/coverage-map/closure_macro.rs | 40 ---- tests/coverage-map/closure_macro_async.rs | 77 ------ tests/coverage-map/conditions.rs | 86 ------- tests/coverage-map/continue.rs | 69 ------ tests/coverage-map/coroutine.rs | 30 --- tests/coverage-map/dead_code.rs | 37 --- tests/coverage-map/drop_trait.rs | 33 --- tests/coverage-map/fn_sig_into_try.rs | 41 ---- tests/coverage-map/generics.rs | 44 ---- tests/coverage-map/if.rs | 28 --- tests/coverage-map/if_else.rs | 40 ---- tests/coverage-map/inline-dead.rs | 27 --- tests/coverage-map/inline.rs | 51 ---- tests/coverage-map/inner_items.rs | 57 ----- tests/coverage-map/issue-83601.rs | 14 -- tests/coverage-map/issue-84561.rs | 182 --------------- tests/coverage-map/issue-85461.rs | 11 - tests/coverage-map/issue-93054.rs | 30 --- tests/coverage-map/lazy_boolean.rs | 61 ----- tests/coverage-map/long_and_wide.rs | 150 ------------ tests/coverage-map/loop_break_value.rs | 13 -- tests/coverage-map/loops_branches.rs | 60 ----- tests/coverage-map/match_or_pattern.rs | 43 ---- tests/coverage-map/nested_loops.rs | 25 -- tests/coverage-map/no_cov_crate.rs | 88 ------- tests/coverage-map/overflow.rs | 64 ----- tests/coverage-map/panic_unwind.rs | 31 --- tests/coverage-map/partial_eq.rs | 46 ---- tests/coverage-map/simple_loop.rs | 35 --- tests/coverage-map/simple_match.rs | 43 ---- tests/coverage-map/sort_groups.rs | 23 -- tests/coverage-map/test_harness.rs | 10 - tests/coverage-map/tight_inf_loop.rs | 5 - tests/coverage-map/trivial.rs | 3 - tests/coverage-map/try_error_result.rs | 118 ---------- tests/coverage-map/unreachable.rs | 37 --- tests/coverage-map/unused.rs | 41 ---- tests/coverage-map/unused_mod.rs | 6 - tests/coverage-map/uses_crate.rs | 19 -- tests/coverage-map/uses_inline_crate.rs | 22 -- tests/coverage-map/while.rs | 5 - tests/coverage-map/while_early_ret.rs | 42 ---- tests/coverage-map/yield.rs | 37 --- tests/{coverage-map => coverage}/README.md | 0 .../{coverage-map => coverage}/abort.cov-map | 0 .../{coverage-map => coverage}/assert.cov-map | 0 .../{coverage-map => coverage}/async.cov-map | 0 .../{coverage-map => coverage}/async2.cov-map | 0 .../bad_counter_ids.cov-map | 0 .../closure.cov-map | 0 .../closure_bug.cov-map | 0 .../closure_macro.cov-map | 0 .../closure_macro_async.cov-map | 0 .../conditions.cov-map | 0 .../continue.cov-map | 0 .../coroutine.cov-map | 0 .../dead_code.cov-map | 0 .../drop_trait.cov-map | 0 .../fn_sig_into_try.cov-map | 0 .../generics.cov-map | 0 tests/{coverage-map => coverage}/if.cov-map | 0 .../if_else.cov-map | 0 .../inline-dead.cov-map | 0 .../{coverage-map => coverage}/inline.cov-map | 0 .../inner_items.cov-map | 0 .../issue-83601.cov-map | 0 .../issue-84561.cov-map | 0 .../issue-85461.cov-map | 0 .../issue-93054.cov-map | 0 .../lazy_boolean.cov-map | 0 .../long_and_wide.cov-map | 0 .../loop_break_value.cov-map | 0 .../loops_branches.cov-map | 0 .../match_or_pattern.cov-map | 0 .../nested_loops.cov-map | 0 .../no_cov_crate.cov-map | 0 .../overflow.cov-map | 0 .../panic_unwind.cov-map | 0 .../partial_eq.cov-map | 0 .../simple_loop.cov-map | 0 .../simple_match.cov-map | 0 .../sort_groups.cov-map | 0 .../test_harness.cov-map | 0 .../tight_inf_loop.cov-map | 0 .../trivial.cov-map | 0 .../try_error_result.cov-map | 0 .../unreachable.cov-map | 0 .../{coverage-map => coverage}/unused.cov-map | 0 .../unused_mod.cov-map | 0 .../uses_crate.cov-map | 0 .../uses_inline_crate.cov-map | 0 .../{coverage-map => coverage}/while.cov-map | 0 .../while_early_ret.cov-map | 0 .../{coverage-map => coverage}/yield.cov-map | 0 106 files changed, 5 insertions(+), 2764 deletions(-) delete mode 100644 tests/coverage-map/abort.rs delete mode 100644 tests/coverage-map/assert.rs delete mode 100644 tests/coverage-map/async.rs delete mode 100644 tests/coverage-map/async2.rs delete mode 100644 tests/coverage-map/auxiliary/inline_always_with_dead_code.rs delete mode 100644 tests/coverage-map/auxiliary/unused_mod_helper.rs delete mode 100644 tests/coverage-map/auxiliary/used_crate.rs delete mode 100644 tests/coverage-map/auxiliary/used_inline_crate.rs delete mode 100644 tests/coverage-map/bad_counter_ids.rs delete mode 100644 tests/coverage-map/closure.rs delete mode 100644 tests/coverage-map/closure_bug.rs delete mode 100644 tests/coverage-map/closure_macro.rs delete mode 100644 tests/coverage-map/closure_macro_async.rs delete mode 100644 tests/coverage-map/conditions.rs delete mode 100644 tests/coverage-map/continue.rs delete mode 100644 tests/coverage-map/coroutine.rs delete mode 100644 tests/coverage-map/dead_code.rs delete mode 100644 tests/coverage-map/drop_trait.rs delete mode 100644 tests/coverage-map/fn_sig_into_try.rs delete mode 100644 tests/coverage-map/generics.rs delete mode 100644 tests/coverage-map/if.rs delete mode 100644 tests/coverage-map/if_else.rs delete mode 100644 tests/coverage-map/inline-dead.rs delete mode 100644 tests/coverage-map/inline.rs delete mode 100644 tests/coverage-map/inner_items.rs delete mode 100644 tests/coverage-map/issue-83601.rs delete mode 100644 tests/coverage-map/issue-84561.rs delete mode 100644 tests/coverage-map/issue-85461.rs delete mode 100644 tests/coverage-map/issue-93054.rs delete mode 100644 tests/coverage-map/lazy_boolean.rs delete mode 100644 tests/coverage-map/long_and_wide.rs delete mode 100644 tests/coverage-map/loop_break_value.rs delete mode 100644 tests/coverage-map/loops_branches.rs delete mode 100644 tests/coverage-map/match_or_pattern.rs delete mode 100644 tests/coverage-map/nested_loops.rs delete mode 100644 tests/coverage-map/no_cov_crate.rs delete mode 100644 tests/coverage-map/overflow.rs delete mode 100644 tests/coverage-map/panic_unwind.rs delete mode 100644 tests/coverage-map/partial_eq.rs delete mode 100644 tests/coverage-map/simple_loop.rs delete mode 100644 tests/coverage-map/simple_match.rs delete mode 100644 tests/coverage-map/sort_groups.rs delete mode 100644 tests/coverage-map/test_harness.rs delete mode 100644 tests/coverage-map/tight_inf_loop.rs delete mode 100644 tests/coverage-map/trivial.rs delete mode 100644 tests/coverage-map/try_error_result.rs delete mode 100644 tests/coverage-map/unreachable.rs delete mode 100644 tests/coverage-map/unused.rs delete mode 100644 tests/coverage-map/unused_mod.rs delete mode 100644 tests/coverage-map/uses_crate.rs delete mode 100644 tests/coverage-map/uses_inline_crate.rs delete mode 100644 tests/coverage-map/while.rs delete mode 100644 tests/coverage-map/while_early_ret.rs delete mode 100644 tests/coverage-map/yield.rs rename tests/{coverage-map => coverage}/README.md (100%) rename tests/{coverage-map => coverage}/abort.cov-map (100%) rename tests/{coverage-map => coverage}/assert.cov-map (100%) rename tests/{coverage-map => coverage}/async.cov-map (100%) rename tests/{coverage-map => coverage}/async2.cov-map (100%) rename tests/{coverage-map => coverage}/bad_counter_ids.cov-map (100%) rename tests/{coverage-map => coverage}/closure.cov-map (100%) rename tests/{coverage-map => coverage}/closure_bug.cov-map (100%) rename tests/{coverage-map => coverage}/closure_macro.cov-map (100%) rename tests/{coverage-map => coverage}/closure_macro_async.cov-map (100%) rename tests/{coverage-map => coverage}/conditions.cov-map (100%) rename tests/{coverage-map => coverage}/continue.cov-map (100%) rename tests/{coverage-map => coverage}/coroutine.cov-map (100%) rename tests/{coverage-map => coverage}/dead_code.cov-map (100%) rename tests/{coverage-map => coverage}/drop_trait.cov-map (100%) rename tests/{coverage-map => coverage}/fn_sig_into_try.cov-map (100%) rename tests/{coverage-map => coverage}/generics.cov-map (100%) rename tests/{coverage-map => coverage}/if.cov-map (100%) rename tests/{coverage-map => coverage}/if_else.cov-map (100%) rename tests/{coverage-map => coverage}/inline-dead.cov-map (100%) rename tests/{coverage-map => coverage}/inline.cov-map (100%) rename tests/{coverage-map => coverage}/inner_items.cov-map (100%) rename tests/{coverage-map => coverage}/issue-83601.cov-map (100%) rename tests/{coverage-map => coverage}/issue-84561.cov-map (100%) rename tests/{coverage-map => coverage}/issue-85461.cov-map (100%) rename tests/{coverage-map => coverage}/issue-93054.cov-map (100%) rename tests/{coverage-map => coverage}/lazy_boolean.cov-map (100%) rename tests/{coverage-map => coverage}/long_and_wide.cov-map (100%) rename tests/{coverage-map => coverage}/loop_break_value.cov-map (100%) rename tests/{coverage-map => coverage}/loops_branches.cov-map (100%) rename tests/{coverage-map => coverage}/match_or_pattern.cov-map (100%) rename tests/{coverage-map => coverage}/nested_loops.cov-map (100%) rename tests/{coverage-map => coverage}/no_cov_crate.cov-map (100%) rename tests/{coverage-map => coverage}/overflow.cov-map (100%) rename tests/{coverage-map => coverage}/panic_unwind.cov-map (100%) rename tests/{coverage-map => coverage}/partial_eq.cov-map (100%) rename tests/{coverage-map => coverage}/simple_loop.cov-map (100%) rename tests/{coverage-map => coverage}/simple_match.cov-map (100%) rename tests/{coverage-map => coverage}/sort_groups.cov-map (100%) rename tests/{coverage-map => coverage}/test_harness.cov-map (100%) rename tests/{coverage-map => coverage}/tight_inf_loop.cov-map (100%) rename tests/{coverage-map => coverage}/trivial.cov-map (100%) rename tests/{coverage-map => coverage}/try_error_result.cov-map (100%) rename tests/{coverage-map => coverage}/unreachable.cov-map (100%) rename tests/{coverage-map => coverage}/unused.cov-map (100%) rename tests/{coverage-map => coverage}/unused_mod.cov-map (100%) rename tests/{coverage-map => coverage}/uses_crate.cov-map (100%) rename tests/{coverage-map => coverage}/uses_inline_crate.cov-map (100%) rename tests/{coverage-map => coverage}/while.cov-map (100%) rename tests/{coverage-map => coverage}/while_early_ret.cov-map (100%) rename tests/{coverage-map => coverage}/yield.cov-map (100%) diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs index 11c9e1c7bc25b..da4b135083c63 100644 --- a/src/bootstrap/src/core/build_steps/test.rs +++ b/src/bootstrap/src/core/build_steps/test.rs @@ -1433,24 +1433,16 @@ impl Step for Coverage { } fn run(self, builder: &Builder<'_>) { - builder.ensure(Compiletest { - compiler: self.compiler, - target: self.target, - mode: "coverage-map", - suite: "coverage-map", - path: "tests/coverage-map", - compare_mode: None, - }); + self.run_unified_suite(builder, CoverageMap::MODE); self.run_unified_suite(builder, RunCoverage::MODE); } } -default_test!(CoverageMap { - path: "tests/coverage-map", - mode: "coverage-map", - suite: "coverage-map" +coverage_test_alias!(CoverageMap { + alias_and_mode: "coverage-map", + default: true, + only_hosts: false, }); - coverage_test_alias!(RunCoverage { alias_and_mode: "run-coverage", default: true, diff --git a/tests/coverage-map/abort.rs b/tests/coverage-map/abort.rs deleted file mode 100644 index 98264bdc1afe5..0000000000000 --- a/tests/coverage-map/abort.rs +++ /dev/null @@ -1,66 +0,0 @@ -#![feature(c_unwind)] -#![allow(unused_assignments)] - -extern "C" fn might_abort(should_abort: bool) { - if should_abort { - println!("aborting..."); - panic!("panics and aborts"); - } else { - println!("Don't Panic"); - } -} - -fn main() -> Result<(), u8> { - let mut countdown = 10; - while countdown > 0 { - if countdown < 5 { - might_abort(false); - } - // See discussion (below the `Notes` section) on coverage results for the closing brace. - if countdown < 5 { might_abort(false); } // Counts for different regions on one line. - // For the following example, the closing brace is the last character on the line. - // This shows the character after the closing brace is highlighted, even if that next - // character is a newline. - if countdown < 5 { might_abort(false); } - countdown -= 1; - } - Ok(()) -} - -// Notes: -// 1. Compare this program and its coverage results to those of the similar tests -// `panic_unwind.rs` and `try_error_result.rs`. -// 2. This test confirms the coverage generated when a program includes `UnwindAction::Terminate`. -// 3. The test does not invoke the abort. By executing to a successful completion, the coverage -// results show where the program did and did not execute. -// 4. If the program actually aborted, the coverage counters would not be saved (which "works as -// intended"). Coverage results would show no executed coverage regions. -// 6. If `should_abort` is `true` and the program aborts, the program exits with a `132` status -// (on Linux at least). - -/* - -Expect the following coverage results: - -```text - 16| 11| while countdown > 0 { - 17| 10| if countdown < 5 { - 18| 4| might_abort(false); - 19| 6| } -``` - -This is actually correct. - -The condition `countdown < 5` executed 10 times (10 loop iterations). - -It evaluated to `true` 4 times, and executed the `might_abort()` call. - -It skipped the body of the `might_abort()` call 6 times. If an `if` does not include an explicit -`else`, the coverage implementation injects a counter, at the character immediately after the `if`s -closing brace, to count the "implicit" `else`. This is the only way to capture the coverage of the -non-true condition. - -As another example of why this is important, say the condition was `countdown < 50`, which is always -`true`. In that case, we wouldn't have a test for what happens if `might_abort()` is not called. -The closing brace would have a count of `0`, highlighting the missed coverage. -*/ diff --git a/tests/coverage-map/assert.rs b/tests/coverage-map/assert.rs deleted file mode 100644 index 85e6662a6adc8..0000000000000 --- a/tests/coverage-map/assert.rs +++ /dev/null @@ -1,32 +0,0 @@ -#![allow(unused_assignments)] -// failure-status: 101 - -fn might_fail_assert(one_plus_one: u32) { - println!("does 1 + 1 = {}?", one_plus_one); - assert_eq!(1 + 1, one_plus_one, "the argument was wrong"); -} - -fn main() -> Result<(), u8> { - let mut countdown = 10; - while countdown > 0 { - if countdown == 1 { - might_fail_assert(3); - } else if countdown < 5 { - might_fail_assert(2); - } - countdown -= 1; - } - Ok(()) -} - -// Notes: -// 1. Compare this program and its coverage results to those of the very similar test -// `panic_unwind.rs`, and similar tests `abort.rs` and `try_error_result.rs`. -// 2. This test confirms the coverage generated when a program passes or fails an `assert!()` or -// related `assert_*!()` macro. -// 3. Notably, the `assert` macros *do not* generate `TerminatorKind::Assert`. The macros produce -// conditional expressions, `TerminatorKind::SwitchInt` branches, and a possible call to -// `begin_panic_fmt()` (that begins a panic unwind, if the assertion test fails). -// 4. `TerminatoKind::Assert` is, however, also present in the MIR generated for this test -// (and in many other coverage tests). The `Assert` terminator is typically generated by the -// Rust compiler to check for runtime failures, such as numeric overflows. diff --git a/tests/coverage-map/async.rs b/tests/coverage-map/async.rs deleted file mode 100644 index efd9e62d64e1d..0000000000000 --- a/tests/coverage-map/async.rs +++ /dev/null @@ -1,128 +0,0 @@ -#![allow(unused_assignments, dead_code)] - -// compile-flags: --edition=2018 -C opt-level=1 - -async fn c(x: u8) -> u8 { - if x == 8 { - 1 - } else { - 0 - } -} - -async fn d() -> u8 { 1 } - -async fn e() -> u8 { 1 } // unused function; executor does not block on `g()` - -async fn f() -> u8 { 1 } - -async fn foo() -> [bool; 10] { [false; 10] } // unused function; executor does not block on `h()` - -pub async fn g(x: u8) { - match x { - y if e().await == y => (), - y if f().await == y => (), - _ => (), - } -} - -async fn h(x: usize) { // The function signature is counted when called, but the body is not - // executed (not awaited) so the open brace has a `0` count (at least when - // displayed with `llvm-cov show` in color-mode). - match x { - y if foo().await[y] => (), - _ => (), - } -} - -async fn i(x: u8) { // line coverage is 1, but there are 2 regions: - // (a) the function signature, counted when the function is called; and - // (b) the open brace for the function body, counted once when the body is - // executed asynchronously. - match x { - y if c(x).await == y + 1 => { d().await; } - y if f().await == y + 1 => (), - _ => (), - } -} - -fn j(x: u8) { - // non-async versions of `c()`, `d()`, and `f()` to make it similar to async `i()`. - fn c(x: u8) -> u8 { - if x == 8 { - 1 // This line appears covered, but the 1-character expression span covering the `1` - // is not executed. (`llvm-cov show` displays a `^0` below the `1` ). This is because - // `fn j()` executes the open brace for the function body, followed by the function's - // first executable statement, `match x`. Inner function declarations are not - // "visible" to the MIR for `j()`, so the code region counts all lines between the - // open brace and the first statement as executed, which is, in a sense, true. - // `llvm-cov show` overcomes this kind of situation by showing the actual counts - // of the enclosed coverages, (that is, the `1` expression was not executed, and - // accurately displays a `0`). - } else { - 0 - } - } - fn d() -> u8 { 1 } // inner function is defined in-line, but the function is not executed - fn f() -> u8 { 1 } - match x { - y if c(x) == y + 1 => { d(); } - y if f() == y + 1 => (), - _ => (), - } -} - -fn k(x: u8) { // unused function - match x { - 1 => (), - 2 => (), - _ => (), - } -} - -fn l(x: u8) { - match x { - 1 => (), - 2 => (), - _ => (), - } -} - -async fn m(x: u8) -> u8 { x - 1 } - -fn main() { - let _ = g(10); - let _ = h(9); - let mut future = Box::pin(i(8)); - j(7); - l(6); - let _ = m(5); - executor::block_on(future.as_mut()); -} - -mod executor { - use core::{ - future::Future, - pin::Pin, - task::{Context, Poll, RawWaker, RawWakerVTable, Waker}, - }; - - pub fn block_on(mut future: F) -> F::Output { - let mut future = unsafe { Pin::new_unchecked(&mut future) }; - use std::hint::unreachable_unchecked; - static VTABLE: RawWakerVTable = RawWakerVTable::new( - |_| unsafe { unreachable_unchecked() }, // clone - |_| unsafe { unreachable_unchecked() }, // wake - |_| unsafe { unreachable_unchecked() }, // wake_by_ref - |_| (), - ); - let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) }; - let mut context = Context::from_waker(&waker); - - loop { - if let Poll::Ready(val) = future.as_mut().poll(&mut context) { - break val; - } - } - } -} diff --git a/tests/coverage-map/async2.rs b/tests/coverage-map/async2.rs deleted file mode 100644 index 2884ff297affd..0000000000000 --- a/tests/coverage-map/async2.rs +++ /dev/null @@ -1,57 +0,0 @@ -// compile-flags: --edition=2018 - -fn non_async_func() { - println!("non_async_func was covered"); - let b = true; - if b { - println!("non_async_func println in block"); - } -} - -async fn async_func() { - println!("async_func was covered"); - let b = true; - if b { - println!("async_func println in block"); - } -} - -async fn async_func_just_println() { - println!("async_func_just_println was covered"); -} - -fn main() { - println!("codecovsample::main"); - - non_async_func(); - - executor::block_on(async_func()); - executor::block_on(async_func_just_println()); -} - -mod executor { - use core::{ - future::Future, - pin::Pin, - task::{Context, Poll, RawWaker, RawWakerVTable, Waker}, - }; - - pub fn block_on(mut future: F) -> F::Output { - let mut future = unsafe { Pin::new_unchecked(&mut future) }; - use std::hint::unreachable_unchecked; - static VTABLE: RawWakerVTable = RawWakerVTable::new( - |_| unsafe { unreachable_unchecked() }, // clone - |_| unsafe { unreachable_unchecked() }, // wake - |_| unsafe { unreachable_unchecked() }, // wake_by_ref - |_| (), - ); - let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) }; - let mut context = Context::from_waker(&waker); - - loop { - if let Poll::Ready(val) = future.as_mut().poll(&mut context) { - break val; - } - } - } -} diff --git a/tests/coverage-map/auxiliary/inline_always_with_dead_code.rs b/tests/coverage-map/auxiliary/inline_always_with_dead_code.rs deleted file mode 100644 index 9dc50dae25ae2..0000000000000 --- a/tests/coverage-map/auxiliary/inline_always_with_dead_code.rs +++ /dev/null @@ -1,22 +0,0 @@ -// compile-flags: -Cinstrument-coverage -Ccodegen-units=4 -Copt-level=0 - -#![allow(dead_code)] - -mod foo { - #[inline(always)] - pub fn called() {} - - fn uncalled() {} -} - -pub mod bar { - pub fn call_me() { - super::foo::called(); - } -} - -pub mod baz { - pub fn call_me() { - super::foo::called(); - } -} diff --git a/tests/coverage-map/auxiliary/unused_mod_helper.rs b/tests/coverage-map/auxiliary/unused_mod_helper.rs deleted file mode 100644 index 88c5dac65cb50..0000000000000 --- a/tests/coverage-map/auxiliary/unused_mod_helper.rs +++ /dev/null @@ -1,4 +0,0 @@ -#[allow(dead_code)] -pub fn never_called_function() { - println!("I am never called"); -} diff --git a/tests/coverage-map/auxiliary/used_crate.rs b/tests/coverage-map/auxiliary/used_crate.rs deleted file mode 100644 index c086ef21e1a9f..0000000000000 --- a/tests/coverage-map/auxiliary/used_crate.rs +++ /dev/null @@ -1,103 +0,0 @@ -#![allow(unused_assignments, unused_variables)] -// Verify that coverage works with optimizations: -// compile-flags: -C opt-level=3 - -use std::fmt::Debug; - -pub fn used_function() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - let mut countdown = 0; - if is_true { - countdown = 10; - } - use_this_lib_crate(); -} - -pub fn used_only_from_bin_crate_generic_function(arg: T) { - println!("used_only_from_bin_crate_generic_function with {:?}", arg); -} -// Expect for above function: `Unexecuted instantiation` (see below) -pub fn used_only_from_this_lib_crate_generic_function(arg: T) { - println!("used_only_from_this_lib_crate_generic_function with {:?}", arg); -} - -pub fn used_from_bin_crate_and_lib_crate_generic_function(arg: T) { - println!("used_from_bin_crate_and_lib_crate_generic_function with {:?}", arg); -} - -pub fn used_with_same_type_from_bin_crate_and_lib_crate_generic_function(arg: T) { - println!("used_with_same_type_from_bin_crate_and_lib_crate_generic_function with {:?}", arg); -} - -pub fn unused_generic_function(arg: T) { - println!("unused_generic_function with {:?}", arg); -} - -pub fn unused_function() { - let is_true = std::env::args().len() == 1; - let mut countdown = 2; - if !is_true { - countdown = 20; - } -} - -#[allow(dead_code)] -fn unused_private_function() { - let is_true = std::env::args().len() == 1; - let mut countdown = 2; - if !is_true { - countdown = 20; - } -} - -fn use_this_lib_crate() { - used_from_bin_crate_and_lib_crate_generic_function("used from library used_crate.rs"); - used_with_same_type_from_bin_crate_and_lib_crate_generic_function( - "used from library used_crate.rs", - ); - let some_vec = vec![5, 6, 7, 8]; - used_only_from_this_lib_crate_generic_function(some_vec); - used_only_from_this_lib_crate_generic_function("used ONLY from library used_crate.rs"); -} - -// FIXME(#79651): "Unexecuted instantiation" errors appear in coverage results, -// for example: -// -// | Unexecuted instantiation: used_crate::used_only_from_bin_crate_generic_function::<_> -// -// These notices appear when `llvm-cov` shows instantiations. This may be a -// default option, but it can be suppressed with: -// -// ```shell -// $ `llvm-cov show --show-instantiations=0 ...` -// ``` -// -// The notice is triggered because the function is unused by the library itself, -// and when the library is compiled, a synthetic function is generated, so -// unused function coverage can be reported. Coverage can be skipped for unused -// generic functions with: -// -// ```shell -// $ `rustc -Zunstable-options -C instrument-coverage=except-unused-generics ...` -// ``` -// -// Even though this function is used by `uses_crate.rs` (and -// counted), with substitutions for `T`, those instantiations are only generated -// when the generic function is actually used (from the binary, not from this -// library crate). So the test result shows coverage for all instantiated -// versions and their generic type substitutions, plus the `Unexecuted -// instantiation` message for the non-substituted version. This is valid, but -// unfortunately a little confusing. -// -// The library crate has its own coverage map, and the only way to show unused -// coverage of a generic function is to include the generic function in the -// coverage map, marked as an "unused function". If the library were used by -// another binary that never used this generic function, then it would be valid -// to show the unused generic, with unknown substitution (`_`). -// -// The alternative is to exclude all generics from being included in the "unused -// functions" list, which would then omit coverage results for -// `unused_generic_function()`, below. diff --git a/tests/coverage-map/auxiliary/used_inline_crate.rs b/tests/coverage-map/auxiliary/used_inline_crate.rs deleted file mode 100644 index e8929de6b360a..0000000000000 --- a/tests/coverage-map/auxiliary/used_inline_crate.rs +++ /dev/null @@ -1,85 +0,0 @@ -#![allow(unused_assignments, unused_variables)] -// Verify that coverage works with optimizations: -// compile-flags: -C opt-level=3 - -use std::fmt::Debug; - -pub fn used_function() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - let mut countdown = 0; - if is_true { - countdown = 10; - } - use_this_lib_crate(); -} - -#[inline(always)] -pub fn used_inline_function() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - let mut countdown = 0; - if is_true { - countdown = 10; - } - use_this_lib_crate(); -} - -#[inline(always)] -pub fn used_only_from_bin_crate_generic_function(arg: T) { - println!("used_only_from_bin_crate_generic_function with {:?}", arg); -} -// Expect for above function: `Unexecuted instantiation` (see notes in `used_crate.rs`) - -#[inline(always)] -pub fn used_only_from_this_lib_crate_generic_function(arg: T) { - println!("used_only_from_this_lib_crate_generic_function with {:?}", arg); -} - -#[inline(always)] -pub fn used_from_bin_crate_and_lib_crate_generic_function(arg: T) { - println!("used_from_bin_crate_and_lib_crate_generic_function with {:?}", arg); -} - -#[inline(always)] -pub fn used_with_same_type_from_bin_crate_and_lib_crate_generic_function(arg: T) { - println!("used_with_same_type_from_bin_crate_and_lib_crate_generic_function with {:?}", arg); -} - -#[inline(always)] -pub fn unused_generic_function(arg: T) { - println!("unused_generic_function with {:?}", arg); -} - -#[inline(always)] -pub fn unused_function() { - let is_true = std::env::args().len() == 1; - let mut countdown = 2; - if !is_true { - countdown = 20; - } -} - -#[inline(always)] -#[allow(dead_code)] -fn unused_private_function() { - let is_true = std::env::args().len() == 1; - let mut countdown = 2; - if !is_true { - countdown = 20; - } -} - -fn use_this_lib_crate() { - used_from_bin_crate_and_lib_crate_generic_function("used from library used_crate.rs"); - used_with_same_type_from_bin_crate_and_lib_crate_generic_function( - "used from library used_crate.rs", - ); - let some_vec = vec![5, 6, 7, 8]; - used_only_from_this_lib_crate_generic_function(some_vec); - used_only_from_this_lib_crate_generic_function("used ONLY from library used_crate.rs"); -} diff --git a/tests/coverage-map/bad_counter_ids.rs b/tests/coverage-map/bad_counter_ids.rs deleted file mode 100644 index ef5460102b70c..0000000000000 --- a/tests/coverage-map/bad_counter_ids.rs +++ /dev/null @@ -1,66 +0,0 @@ -#![feature(coverage_attribute)] -// compile-flags: --edition=2021 -Copt-level=0 -Zmir-opt-level=3 - -// Regression test for . -// -// If some coverage counters were removed by MIR optimizations, we need to take -// care not to refer to those counter IDs in coverage mappings, and instead -// replace them with a constant zero value. If we don't, `llvm-cov` might see -// a too-large counter ID and silently discard the entire function from its -// coverage reports. - -#[derive(Debug, PartialEq, Eq)] -struct Foo(u32); - -fn eq_good() { - println!("a"); - assert_eq!(Foo(1), Foo(1)); -} - -fn eq_good_message() { - println!("b"); - assert_eq!(Foo(1), Foo(1), "message b"); -} - -fn ne_good() { - println!("c"); - assert_ne!(Foo(1), Foo(3)); -} - -fn ne_good_message() { - println!("d"); - assert_ne!(Foo(1), Foo(3), "message d"); -} - -fn eq_bad() { - println!("e"); - assert_eq!(Foo(1), Foo(3)); -} - -fn eq_bad_message() { - println!("f"); - assert_eq!(Foo(1), Foo(3), "message f"); -} - -fn ne_bad() { - println!("g"); - assert_ne!(Foo(1), Foo(1)); -} - -fn ne_bad_message() { - println!("h"); - assert_ne!(Foo(1), Foo(1), "message h"); -} - -#[coverage(off)] -fn main() { - eq_good(); - eq_good_message(); - ne_good(); - ne_good_message(); - - assert!(std::panic::catch_unwind(eq_bad).is_err()); - assert!(std::panic::catch_unwind(eq_bad_message).is_err()); - assert!(std::panic::catch_unwind(ne_bad).is_err()); - assert!(std::panic::catch_unwind(ne_bad_message).is_err()); -} diff --git a/tests/coverage-map/closure.rs b/tests/coverage-map/closure.rs deleted file mode 100644 index 16a2c4e33bd48..0000000000000 --- a/tests/coverage-map/closure.rs +++ /dev/null @@ -1,220 +0,0 @@ -#![allow(unused_assignments, unused_variables)] -// compile-flags: -C opt-level=2 - -// This test used to be sensitive to certain coverage-specific hacks in -// `rustc_middle/mir/mono.rs`, but those hacks were later cleaned up by -// . - -fn main() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - let is_false = !is_true; - - let mut some_string = Some(String::from("the string content")); - println!( - "The string or alt: {}" - , - some_string - . - unwrap_or_else - ( - || - { - let mut countdown = 0; - if is_false { - countdown = 10; - } - "alt string 1".to_owned() - } - ) - ); - - some_string = Some(String::from("the string content")); - let - a - = - || - { - let mut countdown = 0; - if is_false { - countdown = 10; - } - "alt string 2".to_owned() - }; - println!( - "The string or alt: {}" - , - some_string - . - unwrap_or_else - ( - a - ) - ); - - some_string = None; - println!( - "The string or alt: {}" - , - some_string - . - unwrap_or_else - ( - || - { - let mut countdown = 0; - if is_false { - countdown = 10; - } - "alt string 3".to_owned() - } - ) - ); - - some_string = None; - let - a - = - || - { - let mut countdown = 0; - if is_false { - countdown = 10; - } - "alt string 4".to_owned() - }; - println!( - "The string or alt: {}" - , - some_string - . - unwrap_or_else - ( - a - ) - ); - - let - quote_closure - = - |val| - { - let mut countdown = 0; - if is_false { - countdown = 10; - } - format!("'{}'", val) - }; - println!( - "Repeated, quoted string: {:?}" - , - std::iter::repeat("repeat me") - .take(5) - .map - ( - quote_closure - ) - .collect::>() - ); - - let - _unused_closure - = - | - mut countdown - | - { - if is_false { - countdown = 10; - } - "closure should be unused".to_owned() - }; - - let mut countdown = 10; - let _short_unused_closure = | _unused_arg: u8 | countdown += 1; - - - let short_used_covered_closure_macro = | used_arg: u8 | println!("called"); - let short_used_not_covered_closure_macro = | used_arg: u8 | println!("not called"); - let _short_unused_closure_macro = | _unused_arg: u8 | println!("not called"); - - - - - let _short_unused_closure_block = | _unused_arg: u8 | { println!("not called") }; - - let _shortish_unused_closure = | _unused_arg: u8 | { - println!("not called") - }; - - let _as_short_unused_closure = | - _unused_arg: u8 - | { println!("not called") }; - - let _almost_as_short_unused_closure = | - _unused_arg: u8 - | { println!("not called") } - ; - - - - - - let _short_unused_closure_line_break_no_block = | _unused_arg: u8 | -println!("not called") - ; - - let _short_unused_closure_line_break_no_block2 = - | _unused_arg: u8 | - println!( - "not called" - ) - ; - - let short_used_not_covered_closure_line_break_no_block_embedded_branch = - | _unused_arg: u8 | - println!( - "not called: {}", - if is_true { "check" } else { "me" } - ) - ; - - let short_used_not_covered_closure_line_break_block_embedded_branch = - | _unused_arg: u8 | - { - println!( - "not called: {}", - if is_true { "check" } else { "me" } - ) - } - ; - - let short_used_covered_closure_line_break_no_block_embedded_branch = - | _unused_arg: u8 | - println!( - "not called: {}", - if is_true { "check" } else { "me" } - ) - ; - - let short_used_covered_closure_line_break_block_embedded_branch = - | _unused_arg: u8 | - { - println!( - "not called: {}", - if is_true { "check" } else { "me" } - ) - } - ; - - if is_false { - short_used_not_covered_closure_macro(0); - short_used_not_covered_closure_line_break_no_block_embedded_branch(0); - short_used_not_covered_closure_line_break_block_embedded_branch(0); - } - short_used_covered_closure_macro(0); - short_used_covered_closure_line_break_no_block_embedded_branch(0); - short_used_covered_closure_line_break_block_embedded_branch(0); -} diff --git a/tests/coverage-map/closure_bug.rs b/tests/coverage-map/closure_bug.rs deleted file mode 100644 index 739bc5f0b51c9..0000000000000 --- a/tests/coverage-map/closure_bug.rs +++ /dev/null @@ -1,44 +0,0 @@ -// Regression test for #115930. -// All of these closures are identical, and should produce identical output in -// the coverage report. However, an unstable sort was causing them to be treated -// inconsistently when preparing coverage spans. - -fn main() { - let truthy = std::env::args().len() == 1; - - let a - = - | - | - if truthy { true } else { false }; - - a(); - if truthy { a(); } - - let b - = - | - | - if truthy { true } else { false }; - - b(); - if truthy { b(); } - - let c - = - | - | - if truthy { true } else { false }; - - c(); - if truthy { c(); } - - let d - = - | - | - if truthy { true } else { false }; - - d(); - if truthy { d(); } -} diff --git a/tests/coverage-map/closure_macro.rs b/tests/coverage-map/closure_macro.rs deleted file mode 100644 index 9b289141c2e54..0000000000000 --- a/tests/coverage-map/closure_macro.rs +++ /dev/null @@ -1,40 +0,0 @@ -// compile-flags: --edition=2018 -#![feature(coverage_attribute)] - -macro_rules! bail { - ($msg:literal $(,)?) => { - if $msg.len() > 0 { - println!("no msg"); - } else { - println!($msg); - } - return Err(String::from($msg)); - }; -} - -macro_rules! on_error { - ($value:expr, $error_message:expr) => { - $value.or_else(|e| { // FIXME(85000): no coverage in closure macros - let message = format!($error_message, e); - if message.len() > 0 { - println!("{}", message); - Ok(String::from("ok")) - } else { - bail!("error"); - } - }) - }; -} - -fn load_configuration_files() -> Result { - Ok(String::from("config")) -} - -pub fn main() -> Result<(), String> { - println!("Starting service"); - let config = on_error!(load_configuration_files(), "Error loading configs: {}")?; - - let startup_delay_duration = String::from("arg"); - let _ = (config, startup_delay_duration); - Ok(()) -} diff --git a/tests/coverage-map/closure_macro_async.rs b/tests/coverage-map/closure_macro_async.rs deleted file mode 100644 index b4275599e5991..0000000000000 --- a/tests/coverage-map/closure_macro_async.rs +++ /dev/null @@ -1,77 +0,0 @@ -// compile-flags: --edition=2018 -#![feature(coverage_attribute)] - -macro_rules! bail { - ($msg:literal $(,)?) => { - if $msg.len() > 0 { - println!("no msg"); - } else { - println!($msg); - } - return Err(String::from($msg)); - }; -} - -macro_rules! on_error { - ($value:expr, $error_message:expr) => { - $value.or_else(|e| { // FIXME(85000): no coverage in closure macros - let message = format!($error_message, e); - if message.len() > 0 { - println!("{}", message); - Ok(String::from("ok")) - } else { - bail!("error"); - } - }) - }; -} - -fn load_configuration_files() -> Result { - Ok(String::from("config")) -} - -pub async fn test() -> Result<(), String> { - println!("Starting service"); - let config = on_error!(load_configuration_files(), "Error loading configs: {}")?; - - let startup_delay_duration = String::from("arg"); - let _ = (config, startup_delay_duration); - Ok(()) -} - -#[coverage(off)] -fn main() { - executor::block_on(test()).unwrap(); -} - -mod executor { - use core::{ - future::Future, - pin::Pin, - task::{Context, Poll, RawWaker, RawWakerVTable, Waker}, - }; - - #[coverage(off)] - pub fn block_on(mut future: F) -> F::Output { - let mut future = unsafe { Pin::new_unchecked(&mut future) }; - use std::hint::unreachable_unchecked; - static VTABLE: RawWakerVTable = RawWakerVTable::new( - #[coverage(off)] - |_| unsafe { unreachable_unchecked() }, // clone - #[coverage(off)] - |_| unsafe { unreachable_unchecked() }, // wake - #[coverage(off)] - |_| unsafe { unreachable_unchecked() }, // wake_by_ref - #[coverage(off)] - |_| (), - ); - let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) }; - let mut context = Context::from_waker(&waker); - - loop { - if let Poll::Ready(val) = future.as_mut().poll(&mut context) { - break val; - } - } - } -} diff --git a/tests/coverage-map/conditions.rs b/tests/coverage-map/conditions.rs deleted file mode 100644 index fa7f2a116c21e..0000000000000 --- a/tests/coverage-map/conditions.rs +++ /dev/null @@ -1,86 +0,0 @@ -#![allow(unused_assignments, unused_variables)] - -fn main() { - let mut countdown = 0; - if true { - countdown = 10; - } - - const B: u32 = 100; - let x = if countdown > 7 { - countdown -= 4; - B - } else if countdown > 2 { - if countdown < 1 || countdown > 5 || countdown != 9 { - countdown = 0; - } - countdown -= 5; - countdown - } else { - return; - }; - - let mut countdown = 0; - if true { - countdown = 10; - } - - if countdown > 7 { - countdown -= 4; - } else if countdown > 2 { - if countdown < 1 || countdown > 5 || countdown != 9 { - countdown = 0; - } - countdown -= 5; - } else { - return; - } - - if true { - let mut countdown = 0; - if true { - countdown = 10; - } - - if countdown > 7 { - countdown -= 4; - } - else if countdown > 2 { - if countdown < 1 || countdown > 5 || countdown != 9 { - countdown = 0; - } - countdown -= 5; - } else { - return; - } - } - - let mut countdown = 0; - if true { - countdown = 1; - } - - let z = if countdown > 7 { - countdown -= 4; - } else if countdown > 2 { - if countdown < 1 || countdown > 5 || countdown != 9 { - countdown = 0; - } - countdown -= 5; - } else { - let should_be_reachable = countdown; - println!("reached"); - return; - }; - - let w = if countdown > 7 { - countdown -= 4; - } else if countdown > 2 { - if countdown < 1 || countdown > 5 || countdown != 9 { - countdown = 0; - } - countdown -= 5; - } else { - return; - }; -} diff --git a/tests/coverage-map/continue.rs b/tests/coverage-map/continue.rs deleted file mode 100644 index 624aa98341b80..0000000000000 --- a/tests/coverage-map/continue.rs +++ /dev/null @@ -1,69 +0,0 @@ -#![allow(unused_assignments, unused_variables)] - -fn main() { - let is_true = std::env::args().len() == 1; - - let mut x = 0; - for _ in 0..10 { - match is_true { - true => { - continue; - } - _ => { - x = 1; - } - } - x = 3; - } - for _ in 0..10 { - match is_true { - false => { - x = 1; - } - _ => { - continue; - } - } - x = 3; - } - for _ in 0..10 { - match is_true { - true => { - x = 1; - } - _ => { - continue; - } - } - x = 3; - } - for _ in 0..10 { - if is_true { - continue; - } - x = 3; - } - for _ in 0..10 { - match is_true { - false => { - x = 1; - } - _ => { - let _ = x; - } - } - x = 3; - } - for _ in 0..10 { - match is_true { - false => { - x = 1; - } - _ => { - break; - } - } - x = 3; - } - let _ = x; -} diff --git a/tests/coverage-map/coroutine.rs b/tests/coverage-map/coroutine.rs deleted file mode 100644 index 86d19af6f4f08..0000000000000 --- a/tests/coverage-map/coroutine.rs +++ /dev/null @@ -1,30 +0,0 @@ -#![feature(coroutines, coroutine_trait)] - -use std::ops::{Coroutine, CoroutineState}; -use std::pin::Pin; - -// The following implementation of a function called from a `yield` statement -// (apparently requiring the Result and the `String` type or constructor) -// creates conditions where the `coroutine::StateTransform` MIR transform will -// drop all `Counter` `Coverage` statements from a MIR. `simplify.rs` has logic -// to handle this condition, and still report dead block coverage. -fn get_u32(val: bool) -> Result { - if val { Ok(1) } else { Err(String::from("some error")) } -} - -fn main() { - let is_true = std::env::args().len() == 1; - let mut coroutine = || { - yield get_u32(is_true); - return "foo"; - }; - - match Pin::new(&mut coroutine).resume(()) { - CoroutineState::Yielded(Ok(1)) => {} - _ => panic!("unexpected return from resume"), - } - match Pin::new(&mut coroutine).resume(()) { - CoroutineState::Complete("foo") => {} - _ => panic!("unexpected return from resume"), - } -} diff --git a/tests/coverage-map/dead_code.rs b/tests/coverage-map/dead_code.rs deleted file mode 100644 index 3492712a6f98e..0000000000000 --- a/tests/coverage-map/dead_code.rs +++ /dev/null @@ -1,37 +0,0 @@ -#![allow(dead_code, unused_assignments, unused_variables)] - -pub fn unused_pub_fn_not_in_library() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - - let mut countdown = 0; - if is_true { - countdown = 10; - } -} - -fn unused_fn() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - - let mut countdown = 0; - if is_true { - countdown = 10; - } -} - -fn main() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - - let mut countdown = 0; - if is_true { - countdown = 10; - } -} diff --git a/tests/coverage-map/drop_trait.rs b/tests/coverage-map/drop_trait.rs deleted file mode 100644 index 7b062719c6b02..0000000000000 --- a/tests/coverage-map/drop_trait.rs +++ /dev/null @@ -1,33 +0,0 @@ -#![allow(unused_assignments)] -// failure-status: 1 - -struct Firework { - strength: i32, -} - -impl Drop for Firework { - fn drop(&mut self) { - println!("BOOM times {}!!!", self.strength); - } -} - -fn main() -> Result<(), u8> { - let _firecracker = Firework { strength: 1 }; - - let _tnt = Firework { strength: 100 }; - - if true { - println!("Exiting with error..."); - return Err(1); - } - - let _ = Firework { strength: 1000 }; - - Ok(()) -} - -// Expected program output: -// Exiting with error... -// BOOM times 100!!! -// BOOM times 1!!! -// Error: 1 diff --git a/tests/coverage-map/fn_sig_into_try.rs b/tests/coverage-map/fn_sig_into_try.rs deleted file mode 100644 index 92850c8a188fc..0000000000000 --- a/tests/coverage-map/fn_sig_into_try.rs +++ /dev/null @@ -1,41 +0,0 @@ -#![feature(coverage_attribute)] -// compile-flags: --edition=2021 - -// Regression test for inconsistent handling of function signature spans that -// are followed by code using the `?` operator. -// -// For each of these similar functions, the line containing the function -// signature should be handled in the same way. - -fn a() -> Option -{ - Some(7i32); - Some(0) -} - -fn b() -> Option -{ - Some(7i32)?; - Some(0) -} - -fn c() -> Option -{ - let _ = Some(7i32)?; - Some(0) -} - -fn d() -> Option -{ - let _: () = (); - Some(7i32)?; - Some(0) -} - -#[coverage(off)] -fn main() { - a(); - b(); - c(); - d(); -} diff --git a/tests/coverage-map/generics.rs b/tests/coverage-map/generics.rs deleted file mode 100644 index bf4c2d8d68532..0000000000000 --- a/tests/coverage-map/generics.rs +++ /dev/null @@ -1,44 +0,0 @@ -#![allow(unused_assignments)] -// failure-status: 1 - -struct Firework where T: Copy + std::fmt::Display { - strength: T, -} - -impl Firework where T: Copy + std::fmt::Display { - #[inline(always)] - fn set_strength(&mut self, new_strength: T) { - self.strength = new_strength; - } -} - -impl Drop for Firework where T: Copy + std::fmt::Display { - #[inline(always)] - fn drop(&mut self) { - println!("BOOM times {}!!!", self.strength); - } -} - -fn main() -> Result<(), u8> { - let mut firecracker = Firework { strength: 1 }; - firecracker.set_strength(2); - - let mut tnt = Firework { strength: 100.1 }; - tnt.set_strength(200.1); - tnt.set_strength(300.3); - - if true { - println!("Exiting with error..."); - return Err(1); - } - - let _ = Firework { strength: 1000 }; - - Ok(()) -} - -// Expected program output: -// Exiting with error... -// BOOM times 100!!! -// BOOM times 1!!! -// Error: 1 diff --git a/tests/coverage-map/if.rs b/tests/coverage-map/if.rs deleted file mode 100644 index 8ad5042ff7baf..0000000000000 --- a/tests/coverage-map/if.rs +++ /dev/null @@ -1,28 +0,0 @@ -#![allow(unused_assignments, unused_variables)] - -fn main() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let - is_true - = - std::env::args().len() - == - 1 - ; - let - mut - countdown - = - 0 - ; - if - is_true - { - countdown - = - 10 - ; - } -} diff --git a/tests/coverage-map/if_else.rs b/tests/coverage-map/if_else.rs deleted file mode 100644 index 3244e1e3afd2b..0000000000000 --- a/tests/coverage-map/if_else.rs +++ /dev/null @@ -1,40 +0,0 @@ -#![allow(unused_assignments, unused_variables)] - -fn main() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - - let mut countdown = 0; - if - is_true - { - countdown - = - 10 - ; - } - else // Note coverage region difference without semicolon - { - countdown - = - 100 - } - - if - is_true - { - countdown - = - 10 - ; - } - else - { - countdown - = - 100 - ; - } -} diff --git a/tests/coverage-map/inline-dead.rs b/tests/coverage-map/inline-dead.rs deleted file mode 100644 index 854fa06296752..0000000000000 --- a/tests/coverage-map/inline-dead.rs +++ /dev/null @@ -1,27 +0,0 @@ -// Regression test for issue #98833. -// compile-flags: -Zinline-mir -Cdebug-assertions=off - -fn main() { - println!("{}", live::()); - - let f = |x: bool| { - debug_assert!( - x - ); - }; - f(false); -} - -#[inline] -fn live() -> u32 { - if B { - dead() - } else { - 0 - } -} - -#[inline] -fn dead() -> u32 { - 42 -} diff --git a/tests/coverage-map/inline.rs b/tests/coverage-map/inline.rs deleted file mode 100644 index 9cfab9ddbadf2..0000000000000 --- a/tests/coverage-map/inline.rs +++ /dev/null @@ -1,51 +0,0 @@ -// compile-flags: -Zinline-mir - -use std::fmt::Display; - -fn main() { - permutations(&['a', 'b', 'c']); -} - -#[inline(always)] -fn permutations(xs: &[T]) { - let mut ys = xs.to_owned(); - permutate(&mut ys, 0); -} - -fn permutate(xs: &mut [T], k: usize) { - let n = length(xs); - if k == n { - display(xs); - } else if k < n { - for i in k..n { - swap(xs, i, k); - permutate(xs, k + 1); - swap(xs, i, k); - } - } else { - error(); - } -} - -fn length(xs: &[T]) -> usize { - xs.len() -} - -#[inline] -fn swap(xs: &mut [T], i: usize, j: usize) { - let t = xs[i]; - xs[i] = xs[j]; - xs[j] = t; -} - -fn display(xs: &[T]) { - for x in xs { - print!("{}", x); - } - println!(); -} - -#[inline(always)] -fn error() { - panic!("error"); -} diff --git a/tests/coverage-map/inner_items.rs b/tests/coverage-map/inner_items.rs deleted file mode 100644 index bcb62b3031cd9..0000000000000 --- a/tests/coverage-map/inner_items.rs +++ /dev/null @@ -1,57 +0,0 @@ -#![allow(unused_assignments, unused_variables, dead_code)] - -fn main() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - - let mut countdown = 0; - if is_true { - countdown = 10; - } - - mod in_mod { - const IN_MOD_CONST: u32 = 1000; - } - - fn in_func(a: u32) { - let b = 1; - let c = a + b; - println!("c = {}", c) - } - - struct InStruct { - in_struct_field: u32, - } - - const IN_CONST: u32 = 1234; - - trait InTrait { - fn trait_func(&mut self, incr: u32); - - fn default_trait_func(&mut self) { - in_func(IN_CONST); - self.trait_func(IN_CONST); - } - } - - impl InTrait for InStruct { - fn trait_func(&mut self, incr: u32) { - self.in_struct_field += incr; - in_func(self.in_struct_field); - } - } - - type InType = String; - - if is_true { - in_func(countdown); - } - - let mut val = InStruct { - in_struct_field: 101, - }; - - val.default_trait_func(); -} diff --git a/tests/coverage-map/issue-83601.rs b/tests/coverage-map/issue-83601.rs deleted file mode 100644 index 0b72a81947cc7..0000000000000 --- a/tests/coverage-map/issue-83601.rs +++ /dev/null @@ -1,14 +0,0 @@ -// Shows that rust-lang/rust/83601 is resolved - -#[derive(Debug, PartialEq, Eq)] -struct Foo(u32); - -fn main() { - let bar = Foo(1); - assert_eq!(bar, Foo(1)); - let baz = Foo(0); - assert_ne!(baz, Foo(1)); - println!("{:?}", Foo(1)); - println!("{:?}", bar); - println!("{:?}", baz); -} diff --git a/tests/coverage-map/issue-84561.rs b/tests/coverage-map/issue-84561.rs deleted file mode 100644 index facf5b5b4cfbe..0000000000000 --- a/tests/coverage-map/issue-84561.rs +++ /dev/null @@ -1,182 +0,0 @@ -// This demonstrated Issue #84561: function-like macros produce unintuitive coverage results. - -// failure-status: 101 -#[derive(PartialEq, Eq)] -struct Foo(u32); -fn test3() { - let is_true = std::env::args().len() == 1; - let bar = Foo(1); - assert_eq!(bar, Foo(1)); - let baz = Foo(0); - assert_ne!(baz, Foo(1)); - println!("{:?}", Foo(1)); - println!("{:?}", bar); - println!("{:?}", baz); - - assert_eq!(Foo(1), Foo(1)); - assert_ne!(Foo(0), Foo(1)); - assert_eq!(Foo(2), Foo(2)); - let bar = Foo(0); - assert_ne!(bar, Foo(3)); - assert_ne!(Foo(0), Foo(4)); - assert_eq!(Foo(3), Foo(3), "with a message"); - println!("{:?}", bar); - println!("{:?}", Foo(1)); - - assert_ne!(Foo(0), Foo(5), "{}", if is_true { "true message" } else { "false message" }); - assert_ne!( - Foo(0) - , - Foo(5) - , - "{}" - , - if - is_true - { - "true message" - } else { - "false message" - } - ); - - let is_true = std::env::args().len() == 1; - - assert_eq!( - Foo(1), - Foo(1) - ); - assert_ne!( - Foo(0), - Foo(1) - ); - assert_eq!( - Foo(2), - Foo(2) - ); - let bar = Foo(1); - assert_ne!( - bar, - Foo(3) - ); - if is_true { - assert_ne!( - Foo(0), - Foo(4) - ); - } else { - assert_eq!( - Foo(3), - Foo(3) - ); - } - if is_true { - assert_ne!( - Foo(0), - Foo(4), - "with a message" - ); - } else { - assert_eq!( - Foo(3), - Foo(3), - "with a message" - ); - } - assert_ne!( - if is_true { - Foo(0) - } else { - Foo(1) - }, - Foo(5) - ); - assert_ne!( - Foo(5), - if is_true { - Foo(0) - } else { - Foo(1) - } - ); - assert_ne!( - if is_true { - assert_eq!( - Foo(3), - Foo(3) - ); - Foo(0) - } else { - assert_ne!( - if is_true { - Foo(0) - } else { - Foo(1) - }, - Foo(5) - ); - Foo(1) - }, - Foo(5), - "with a message" - ); - assert_eq!( - Foo(1), - Foo(3), - "this assert should fail" - ); - assert_eq!( - Foo(3), - Foo(3), - "this assert should not be reached" - ); -} - -impl std::fmt::Debug for Foo { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - write!(f, "try and succeed")?; - Ok(()) - } -} - -static mut DEBUG_LEVEL_ENABLED: bool = false; - -macro_rules! debug { - ($($arg:tt)+) => ( - if unsafe { DEBUG_LEVEL_ENABLED } { - println!($($arg)+); - } - ); -} - -fn test1() { - debug!("debug is enabled"); - debug!("debug is enabled"); - let _ = 0; - debug!("debug is enabled"); - unsafe { - DEBUG_LEVEL_ENABLED = true; - } - debug!("debug is enabled"); -} - -macro_rules! call_debug { - ($($arg:tt)+) => ( - fn call_print(s: &str) { - print!("{}", s); - } - - call_print("called from call_debug: "); - debug!($($arg)+); - ); -} - -fn test2() { - call_debug!("debug is enabled"); -} - -fn main() { - test1(); - test2(); - test3(); -} diff --git a/tests/coverage-map/issue-85461.rs b/tests/coverage-map/issue-85461.rs deleted file mode 100644 index 9d4c90a827eeb..0000000000000 --- a/tests/coverage-map/issue-85461.rs +++ /dev/null @@ -1,11 +0,0 @@ -// Regression test for #85461: MSVC sometimes fail to link with dead code and #[inline(always)] - -// aux-build:inline_always_with_dead_code.rs -extern crate inline_always_with_dead_code; - -use inline_always_with_dead_code::{bar, baz}; - -fn main() { - bar::call_me(); - baz::call_me(); -} diff --git a/tests/coverage-map/issue-93054.rs b/tests/coverage-map/issue-93054.rs deleted file mode 100644 index da546cfeef854..0000000000000 --- a/tests/coverage-map/issue-93054.rs +++ /dev/null @@ -1,30 +0,0 @@ -#![allow(dead_code, unreachable_code)] - -// Regression test for #93054: Functions using uninhabited types often only have a single, -// unreachable basic block which doesn't get instrumented. This should not cause llvm-cov to fail. -// Since these kinds functions can't be invoked anyway, it's ok to not have coverage data for them. - -// compile-flags: --edition=2021 - -enum Never {} - -impl Never { - fn foo(self) { - match self {} - make().map(|never| match never {}); - } - - fn bar(&self) { - match *self {} - } -} - -async fn foo2(never: Never) { - match never {} -} - -fn make() -> Option { - None -} - -fn main() {} diff --git a/tests/coverage-map/lazy_boolean.rs b/tests/coverage-map/lazy_boolean.rs deleted file mode 100644 index bb6219e851c8a..0000000000000 --- a/tests/coverage-map/lazy_boolean.rs +++ /dev/null @@ -1,61 +0,0 @@ -#![allow(unused_assignments, unused_variables)] - -fn main() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - - let (mut a, mut b, mut c) = (0, 0, 0); - if is_true { - a = 1; - b = 10; - c = 100; - } - let - somebool - = - a < b - || - b < c - ; - let - somebool - = - b < a - || - b < c - ; - let somebool = a < b && b < c; - let somebool = b < a && b < c; - - if - ! - is_true - { - a = 2 - ; - } - - if - is_true - { - b = 30 - ; - } - else - { - c = 400 - ; - } - - if !is_true { - a = 2; - } - - if is_true { - b = 30; - } else { - c = 400; - } -} diff --git a/tests/coverage-map/long_and_wide.rs b/tests/coverage-map/long_and_wide.rs deleted file mode 100644 index a7cbcd4802791..0000000000000 --- a/tests/coverage-map/long_and_wide.rs +++ /dev/null @@ -1,150 +0,0 @@ -// compile-flags: --edition=2021 -// ignore-tidy-linelength - -// This file deliberately contains line and column numbers larger than 127, -// to verify that `coverage-dump`'s ULEB128 parser can handle them. - -fn main() { - wide_function(); - long_function(); - far_function(); -} - -#[rustfmt::skip] -fn wide_function() { /* */ (); } - -fn long_function() { - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // - // -} - -fn far_function() {} diff --git a/tests/coverage-map/loop_break_value.rs b/tests/coverage-map/loop_break_value.rs deleted file mode 100644 index dbc4fad7a2316..0000000000000 --- a/tests/coverage-map/loop_break_value.rs +++ /dev/null @@ -1,13 +0,0 @@ -#![allow(unused_assignments, unused_variables)] - -fn main() { - let result - = - loop - { - break - 10 - ; - } - ; -} diff --git a/tests/coverage-map/loops_branches.rs b/tests/coverage-map/loops_branches.rs deleted file mode 100644 index f3a343bcc1f42..0000000000000 --- a/tests/coverage-map/loops_branches.rs +++ /dev/null @@ -1,60 +0,0 @@ -#![allow(unused_assignments, unused_variables, while_true)] - -// This test confirms that (1) unexecuted infinite loops are handled correctly by the -// InstrumentCoverage MIR pass; and (2) Counter Expressions that subtract from zero can be dropped. - -struct DebugTest; - -impl std::fmt::Debug for DebugTest { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - if true { - if false { - while true {} - } - write!(f, "cool")?; - } else { - } - - for i in 0..10 { - if true { - if false { - while true {} - } - write!(f, "cool")?; - } else { - } - } - Ok(()) - } -} - -struct DisplayTest; - -impl std::fmt::Display for DisplayTest { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - if false { - } else { - if false { - while true {} - } - write!(f, "cool")?; - } - for i in 0..10 { - if false { - } else { - if false { - while true {} - } - write!(f, "cool")?; - } - } - Ok(()) - } -} - -fn main() { - let debug_test = DebugTest; - println!("{:?}", debug_test); - let display_test = DisplayTest; - println!("{}", display_test); -} diff --git a/tests/coverage-map/match_or_pattern.rs b/tests/coverage-map/match_or_pattern.rs deleted file mode 100644 index ab7aee51d1bc4..0000000000000 --- a/tests/coverage-map/match_or_pattern.rs +++ /dev/null @@ -1,43 +0,0 @@ -fn main() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - - let mut a: u8 = 0; - let mut b: u8 = 0; - if is_true { - a = 2; - b = 0; - } - match (a, b) { - // Or patterns generate MIR `SwitchInt` with multiple targets to the same `BasicBlock`. - // This test confirms a fix for Issue #79569. - (0 | 1, 2 | 3) => {} - _ => {} - } - if is_true { - a = 0; - b = 0; - } - match (a, b) { - (0 | 1, 2 | 3) => {} - _ => {} - } - if is_true { - a = 2; - b = 2; - } - match (a, b) { - (0 | 1, 2 | 3) => {} - _ => {} - } - if is_true { - a = 0; - b = 2; - } - match (a, b) { - (0 | 1, 2 | 3) => {} - _ => {} - } -} diff --git a/tests/coverage-map/nested_loops.rs b/tests/coverage-map/nested_loops.rs deleted file mode 100644 index 4c7c784279650..0000000000000 --- a/tests/coverage-map/nested_loops.rs +++ /dev/null @@ -1,25 +0,0 @@ -fn main() { - let is_true = std::env::args().len() == 1; - let mut countdown = 10; - - 'outer: while countdown > 0 { - let mut a = 100; - let mut b = 100; - for _ in 0..50 { - if a < 30 { - break; - } - a -= 5; - b -= 5; - if b < 90 { - a -= 10; - if is_true { - break 'outer; - } else { - a -= 2; - } - } - } - countdown -= 1; - } -} diff --git a/tests/coverage-map/no_cov_crate.rs b/tests/coverage-map/no_cov_crate.rs deleted file mode 100644 index e12e4bc55e3e4..0000000000000 --- a/tests/coverage-map/no_cov_crate.rs +++ /dev/null @@ -1,88 +0,0 @@ -// Enables `coverage(off)` on the entire crate -#![feature(coverage_attribute)] - -#[coverage(off)] -fn do_not_add_coverage_1() { - println!("called but not covered"); -} - -fn do_not_add_coverage_2() { - #![coverage(off)] - println!("called but not covered"); -} - -#[coverage(off)] -#[allow(dead_code)] -fn do_not_add_coverage_not_called() { - println!("not called and not covered"); -} - -fn add_coverage_1() { - println!("called and covered"); -} - -fn add_coverage_2() { - println!("called and covered"); -} - -#[allow(dead_code)] -fn add_coverage_not_called() { - println!("not called but covered"); -} - -// FIXME: These test-cases illustrate confusing results of nested functions. -// See https://github.com/rust-lang/rust/issues/93319 -mod nested_fns { - #[coverage(off)] - pub fn outer_not_covered(is_true: bool) { - fn inner(is_true: bool) { - if is_true { - println!("called and covered"); - } else { - println!("absolutely not covered"); - } - } - println!("called but not covered"); - inner(is_true); - } - - pub fn outer(is_true: bool) { - println!("called and covered"); - inner_not_covered(is_true); - - #[coverage(off)] - fn inner_not_covered(is_true: bool) { - if is_true { - println!("called but not covered"); - } else { - println!("absolutely not covered"); - } - } - } - - pub fn outer_both_covered(is_true: bool) { - println!("called and covered"); - inner(is_true); - - fn inner(is_true: bool) { - if is_true { - println!("called and covered"); - } else { - println!("absolutely not covered"); - } - } - } -} - -fn main() { - let is_true = std::env::args().len() == 1; - - do_not_add_coverage_1(); - do_not_add_coverage_2(); - add_coverage_1(); - add_coverage_2(); - - nested_fns::outer_not_covered(is_true); - nested_fns::outer(is_true); - nested_fns::outer_both_covered(is_true); -} diff --git a/tests/coverage-map/overflow.rs b/tests/coverage-map/overflow.rs deleted file mode 100644 index 1c40771b27478..0000000000000 --- a/tests/coverage-map/overflow.rs +++ /dev/null @@ -1,64 +0,0 @@ -#![allow(unused_assignments)] -// compile-flags: -Coverflow-checks=yes -// failure-status: 101 - -fn might_overflow(to_add: u32) -> u32 { - if to_add > 5 { - println!("this will probably overflow"); - } - let add_to = u32::MAX - 5; - println!("does {} + {} overflow?", add_to, to_add); - let result = to_add + add_to; - println!("continuing after overflow check"); - result -} - -fn main() -> Result<(), u8> { - let mut countdown = 10; - while countdown > 0 { - if countdown == 1 { - let result = might_overflow(10); - println!("Result: {}", result); - } else if countdown < 5 { - let result = might_overflow(1); - println!("Result: {}", result); - } - countdown -= 1; - } - Ok(()) -} - -// Notes: -// 1. Compare this program and its coverage results to those of the very similar test `assert.rs`, -// and similar tests `panic_unwind.rs`, abort.rs` and `try_error_result.rs`. -// 2. This test confirms the coverage generated when a program passes or fails a -// compiler-generated `TerminatorKind::Assert` (based on an overflow check, in this case). -// 3. Similar to how the coverage instrumentation handles `TerminatorKind::Call`, -// compiler-generated assertion failures are assumed to be a symptom of a program bug, not -// expected behavior. To simplify the coverage graphs and keep instrumented programs as -// small and fast as possible, `Assert` terminators are assumed to always succeed, and -// therefore are considered "non-branching" terminators. So, an `Assert` terminator does not -// get its own coverage counter. -// 4. After an unhandled panic or failed Assert, coverage results may not always be intuitive. -// In this test, the final count for the statements after the `if` block in `might_overflow()` -// is 4, even though the lines after `to_add + add_to` were executed only 3 times. Depending -// on the MIR graph and the structure of the code, this count could have been 3 (which might -// have been valid for the overflowed add `+`, but should have been 4 for the lines before -// the overflow. The reason for this potential uncertainty is, a `CounterKind` is incremented -// via StatementKind::Counter at the end of the block, but (as in the case in this test), -// a CounterKind::Expression is always evaluated. In this case, the expression was based on -// a `Counter` incremented as part of the evaluation of the `if` expression, which was -// executed, and counted, 4 times, before reaching the overflow add. - -// If the program did not overflow, the coverage for `might_overflow()` would look like this: -// -// 4| |fn might_overflow(to_add: u32) -> u32 { -// 5| 4| if to_add > 5 { -// 6| 0| println!("this will probably overflow"); -// 7| 4| } -// 8| 4| let add_to = u32::MAX - 5; -// 9| 4| println!("does {} + {} overflow?", add_to, to_add); -// 10| 4| let result = to_add + add_to; -// 11| 4| println!("continuing after overflow check"); -// 12| 4| result -// 13| 4|} diff --git a/tests/coverage-map/panic_unwind.rs b/tests/coverage-map/panic_unwind.rs deleted file mode 100644 index 638d2eb6aaaf8..0000000000000 --- a/tests/coverage-map/panic_unwind.rs +++ /dev/null @@ -1,31 +0,0 @@ -#![allow(unused_assignments)] -// failure-status: 101 - -fn might_panic(should_panic: bool) { - if should_panic { - println!("panicking..."); - panic!("panics"); - } else { - println!("Don't Panic"); - } -} - -fn main() -> Result<(), u8> { - let mut countdown = 10; - while countdown > 0 { - if countdown == 1 { - might_panic(true); - } else if countdown < 5 { - might_panic(false); - } - countdown -= 1; - } - Ok(()) -} - -// Notes: -// 1. Compare this program and its coverage results to those of the similar tests `abort.rs` and -// `try_error_result.rs`. -// 2. Since the `panic_unwind.rs` test is allowed to unwind, it is also allowed to execute the -// normal program exit cleanup, including writing out the current values of the coverage -// counters. diff --git a/tests/coverage-map/partial_eq.rs b/tests/coverage-map/partial_eq.rs deleted file mode 100644 index dd8b42c18cea9..0000000000000 --- a/tests/coverage-map/partial_eq.rs +++ /dev/null @@ -1,46 +0,0 @@ -// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the -// structure of this test. - -#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] -pub struct Version { - major: usize, - minor: usize, - patch: usize, -} - -impl Version { - pub fn new(major: usize, minor: usize, patch: usize) -> Self { - Self { - major, - minor, - patch, - } - } -} - -fn main() { - let version_3_2_1 = Version::new(3, 2, 1); - let version_3_3_0 = Version::new(3, 3, 0); - - println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0); -} - -/* - -This test verifies a bug was fixed that otherwise generated this error: - -thread 'rustc' panicked at 'No counters provided the source_hash for function: - Instance { - def: Item(WithOptConstParam { - did: DefId(0:101 ~ autocfg[c44a]::version::{impl#2}::partial_cmp), - const_param_did: None - }), - args: [] - }' -The `PartialOrd` derived by `Version` happened to generate a MIR that generated coverage -without a code region associated with any `Counter`. Code regions were associated with at least -one expression, which is allowed, but the `function_source_hash` was only passed to the codegen -(coverage mapgen) phase from a `Counter`s code region. A new method was added to pass the -`function_source_hash` without a code region, if necessary. - -*/ diff --git a/tests/coverage-map/simple_loop.rs b/tests/coverage-map/simple_loop.rs deleted file mode 100644 index 6f7f23475b826..0000000000000 --- a/tests/coverage-map/simple_loop.rs +++ /dev/null @@ -1,35 +0,0 @@ -#![allow(unused_assignments)] - -fn main() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - - let mut countdown = 0; - - if - is_true - { - countdown - = - 10 - ; - } - - loop - { - if - countdown - == - 0 - { - break - ; - } - countdown - -= - 1 - ; - } -} diff --git a/tests/coverage-map/simple_match.rs b/tests/coverage-map/simple_match.rs deleted file mode 100644 index be99e59a82685..0000000000000 --- a/tests/coverage-map/simple_match.rs +++ /dev/null @@ -1,43 +0,0 @@ -#![allow(unused_assignments, unused_variables)] - -fn main() { - // Initialize test constants in a way that cannot be determined at compile time, to ensure - // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from - // dependent conditions. - let is_true = std::env::args().len() == 1; - - let mut countdown = 1; - if is_true { - countdown = 0; - } - - for - _ - in - 0..2 - { - let z - ; - match - countdown - { - x - if - x - < - 1 - => - { - z = countdown - ; - let y = countdown - ; - countdown = 10 - ; - } - _ - => - {} - } - } -} diff --git a/tests/coverage-map/sort_groups.rs b/tests/coverage-map/sort_groups.rs deleted file mode 100644 index 5adbbc6a87d1f..0000000000000 --- a/tests/coverage-map/sort_groups.rs +++ /dev/null @@ -1,23 +0,0 @@ -// compile-flags: --edition=2021 - -// Demonstrate that `sort_subviews.py` can sort instantiation groups into a -// predictable order, while preserving their heterogeneous contents. - -fn main() { - let cond = std::env::args().len() > 1; - generic_fn::<()>(cond); - generic_fn::<&'static str>(!cond); - if std::hint::black_box(false) { - generic_fn::(cond); - } - generic_fn::(cond); - other_fn(); -} - -fn generic_fn(cond: bool) { - if cond { - println!("{}", std::any::type_name::()); - } -} - -fn other_fn() {} diff --git a/tests/coverage-map/test_harness.rs b/tests/coverage-map/test_harness.rs deleted file mode 100644 index 12a755734c198..0000000000000 --- a/tests/coverage-map/test_harness.rs +++ /dev/null @@ -1,10 +0,0 @@ -// Verify that the entry point injected by the test harness doesn't cause -// weird artifacts in the coverage report (e.g. issue #10749). - -// compile-flags: --test - -#[allow(dead_code)] -fn unused() {} - -#[test] -fn my_test() {} diff --git a/tests/coverage-map/tight_inf_loop.rs b/tests/coverage-map/tight_inf_loop.rs deleted file mode 100644 index cef99027aaa4f..0000000000000 --- a/tests/coverage-map/tight_inf_loop.rs +++ /dev/null @@ -1,5 +0,0 @@ -fn main() { - if false { - loop {} - } -} diff --git a/tests/coverage-map/trivial.rs b/tests/coverage-map/trivial.rs deleted file mode 100644 index d0a9b44fb3605..0000000000000 --- a/tests/coverage-map/trivial.rs +++ /dev/null @@ -1,3 +0,0 @@ -// compile-flags: --edition=2021 - -fn main() {} diff --git a/tests/coverage-map/try_error_result.rs b/tests/coverage-map/try_error_result.rs deleted file mode 100644 index 557cbf22bfad4..0000000000000 --- a/tests/coverage-map/try_error_result.rs +++ /dev/null @@ -1,118 +0,0 @@ -#![allow(unused_assignments)] -// failure-status: 1 - -fn call(return_error: bool) -> Result<(), ()> { - if return_error { - Err(()) - } else { - Ok(()) - } -} - -fn test1() -> Result<(), ()> { - let mut - countdown = 10 - ; - for - _ - in - 0..10 - { - countdown - -= 1 - ; - if - countdown < 5 - { - call(/*return_error=*/ true)?; - call(/*return_error=*/ false)?; - } - else - { - call(/*return_error=*/ false)?; - } - } - Ok(()) -} - -struct Thing1; -impl Thing1 { - fn get_thing_2(&self, return_error: bool) -> Result { - if return_error { - Err(()) - } else { - Ok(Thing2 {}) - } - } -} - -struct Thing2; -impl Thing2 { - fn call(&self, return_error: bool) -> Result { - if return_error { - Err(()) - } else { - Ok(57) - } - } -} - -fn test2() -> Result<(), ()> { - let thing1 = Thing1{}; - let mut - countdown = 10 - ; - for - _ - in - 0..10 - { - countdown - -= 1 - ; - if - countdown < 5 - { - thing1.get_thing_2(/*err=*/ false)?.call(/*err=*/ true).expect_err("call should fail"); - thing1 - . - get_thing_2(/*return_error=*/ false) - ? - . - call(/*return_error=*/ true) - . - expect_err( - "call should fail" - ); - let val = thing1.get_thing_2(/*return_error=*/ true)?.call(/*return_error=*/ true)?; - assert_eq!(val, 57); - let val = thing1.get_thing_2(/*return_error=*/ true)?.call(/*return_error=*/ false)?; - assert_eq!(val, 57); - } - else - { - let val = thing1.get_thing_2(/*return_error=*/ false)?.call(/*return_error=*/ false)?; - assert_eq!(val, 57); - let val = thing1 - .get_thing_2(/*return_error=*/ false)? - .call(/*return_error=*/ false)?; - assert_eq!(val, 57); - let val = thing1 - .get_thing_2(/*return_error=*/ false) - ? - .call(/*return_error=*/ false) - ? - ; - assert_eq!(val, 57); - } - } - Ok(()) -} - -fn main() -> Result<(), ()> { - test1().expect_err("test1 should fail"); - test2() - ? - ; - Ok(()) -} diff --git a/tests/coverage-map/unreachable.rs b/tests/coverage-map/unreachable.rs deleted file mode 100644 index 6385bfa160d7d..0000000000000 --- a/tests/coverage-map/unreachable.rs +++ /dev/null @@ -1,37 +0,0 @@ -#![feature(core_intrinsics)] -#![feature(coverage_attribute)] -// compile-flags: --edition=2021 - -// -// If we instrument a function for coverage, but all of its counter-increment -// statements are removed by MIR optimizations, LLVM will think it isn't -// instrumented and it will disappear from coverage maps and coverage reports. -// Most MIR opts won't cause this because they tend not to remove statements -// from bb0, but `UnreachablePropagation` can do so if it sees that bb0 ends -// with `TerminatorKind::Unreachable`. - -use std::hint::{black_box, unreachable_unchecked}; - -static UNREACHABLE_CLOSURE: fn() = || unsafe { unreachable_unchecked() }; - -fn unreachable_function() { - unsafe { unreachable_unchecked() } -} - -// Use an intrinsic to more reliably trigger unreachable-propagation. -fn unreachable_intrinsic() { - unsafe { std::intrinsics::unreachable() } -} - -#[coverage(off)] -fn main() { - if black_box(false) { - UNREACHABLE_CLOSURE(); - } - if black_box(false) { - unreachable_function(); - } - if black_box(false) { - unreachable_intrinsic(); - } -} diff --git a/tests/coverage-map/unused.rs b/tests/coverage-map/unused.rs deleted file mode 100644 index d985af135470e..0000000000000 --- a/tests/coverage-map/unused.rs +++ /dev/null @@ -1,41 +0,0 @@ -#![allow(dead_code, unused_assignments, unused_must_use, unused_variables)] - -fn foo(x: T) { - let mut i = 0; - while i < 10 { - i != 0 || i != 0; - i += 1; - } -} - -fn unused_template_func(x: T) { - let mut i = 0; - while i < 10 { - i != 0 || i != 0; - i += 1; - } -} - -fn unused_func(mut a: u32) { - if a != 0 { - a += 1; - } -} - -fn unused_func2(mut a: u32) { - if a != 0 { - a += 1; - } -} - -fn unused_func3(mut a: u32) { - if a != 0 { - a += 1; - } -} - -fn main() -> Result<(), u8> { - foo::(0); - foo::(0.0); - Ok(()) -} diff --git a/tests/coverage-map/unused_mod.rs b/tests/coverage-map/unused_mod.rs deleted file mode 100644 index 6e62839c99856..0000000000000 --- a/tests/coverage-map/unused_mod.rs +++ /dev/null @@ -1,6 +0,0 @@ -#[path = "auxiliary/unused_mod_helper.rs"] -mod unused_module; - -fn main() { - println!("hello world!"); -} diff --git a/tests/coverage-map/uses_crate.rs b/tests/coverage-map/uses_crate.rs deleted file mode 100644 index ab203ad781d66..0000000000000 --- a/tests/coverage-map/uses_crate.rs +++ /dev/null @@ -1,19 +0,0 @@ -// This test was failing on Linux for a while due to #110393 somehow making -// the unused functions not instrumented, but it seems to be fine now. - -// Validates coverage now works with optimizations -// compile-flags: -C opt-level=3 - -#![allow(unused_assignments, unused_variables)] - -// aux-build:used_crate.rs -extern crate used_crate; - -fn main() { - used_crate::used_function(); - let some_vec = vec![1, 2, 3, 4]; - used_crate::used_only_from_bin_crate_generic_function(&some_vec); - used_crate::used_only_from_bin_crate_generic_function("used from bin uses_crate.rs"); - used_crate::used_from_bin_crate_and_lib_crate_generic_function(some_vec); - used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function("interesting?"); -} diff --git a/tests/coverage-map/uses_inline_crate.rs b/tests/coverage-map/uses_inline_crate.rs deleted file mode 100644 index d7b4c3c057f46..0000000000000 --- a/tests/coverage-map/uses_inline_crate.rs +++ /dev/null @@ -1,22 +0,0 @@ -// This test was failing on Linux for a while due to #110393 somehow making -// the unused functions not instrumented, but it seems to be fine now. - -// Validates coverage now works with optimizations -// compile-flags: -C opt-level=3 - -#![allow(unused_assignments, unused_variables)] - -// aux-build:used_inline_crate.rs -extern crate used_inline_crate; - -fn main() { - used_inline_crate::used_function(); - used_inline_crate::used_inline_function(); - let some_vec = vec![1, 2, 3, 4]; - used_inline_crate::used_only_from_bin_crate_generic_function(&some_vec); - used_inline_crate::used_only_from_bin_crate_generic_function("used from bin uses_crate.rs"); - used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function(some_vec); - used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function( - "interesting?", - ); -} diff --git a/tests/coverage-map/while.rs b/tests/coverage-map/while.rs deleted file mode 100644 index 781b90b35663e..0000000000000 --- a/tests/coverage-map/while.rs +++ /dev/null @@ -1,5 +0,0 @@ -fn main() { - let num = 9; - while num >= 10 { - } -} diff --git a/tests/coverage-map/while_early_ret.rs b/tests/coverage-map/while_early_ret.rs deleted file mode 100644 index b2f0eee2cc0f4..0000000000000 --- a/tests/coverage-map/while_early_ret.rs +++ /dev/null @@ -1,42 +0,0 @@ -#![allow(unused_assignments)] -// failure-status: 1 - -fn main() -> Result<(), u8> { - let mut countdown = 10; - while - countdown - > - 0 - { - if - countdown - < - 5 - { - return - if - countdown - > - 8 - { - Ok(()) - } - else - { - Err(1) - } - ; - } - countdown - -= - 1 - ; - } - Ok(()) -} - -// ISSUE(77553): Originally, this test had `Err(1)` on line 22 (instead of `Ok(())`) and -// `std::process::exit(2)` on line 26 (instead of `Err(1)`); and this worked as expected on Linux -// and MacOS. But on Windows (MSVC, at least), the call to `std::process::exit()` exits the program -// without saving the InstrProf coverage counters. The use of `std::process:exit()` is not critical -// to the coverage test for early returns, but this is a limitation that should be fixed. diff --git a/tests/coverage-map/yield.rs b/tests/coverage-map/yield.rs deleted file mode 100644 index b7e2ba31b59c1..0000000000000 --- a/tests/coverage-map/yield.rs +++ /dev/null @@ -1,37 +0,0 @@ -#![feature(coroutines, coroutine_trait)] -#![allow(unused_assignments)] - -use std::ops::{Coroutine, CoroutineState}; -use std::pin::Pin; - -fn main() { - let mut coroutine = || { - yield 1; - return "foo"; - }; - - match Pin::new(&mut coroutine).resume(()) { - CoroutineState::Yielded(1) => {} - _ => panic!("unexpected value from resume"), - } - match Pin::new(&mut coroutine).resume(()) { - CoroutineState::Complete("foo") => {} - _ => panic!("unexpected value from resume"), - } - - let mut coroutine = || { - yield 1; - yield 2; - yield 3; - return "foo"; - }; - - match Pin::new(&mut coroutine).resume(()) { - CoroutineState::Yielded(1) => {} - _ => panic!("unexpected value from resume"), - } - match Pin::new(&mut coroutine).resume(()) { - CoroutineState::Yielded(2) => {} - _ => panic!("unexpected value from resume"), - } -} diff --git a/tests/coverage-map/README.md b/tests/coverage/README.md similarity index 100% rename from tests/coverage-map/README.md rename to tests/coverage/README.md diff --git a/tests/coverage-map/abort.cov-map b/tests/coverage/abort.cov-map similarity index 100% rename from tests/coverage-map/abort.cov-map rename to tests/coverage/abort.cov-map diff --git a/tests/coverage-map/assert.cov-map b/tests/coverage/assert.cov-map similarity index 100% rename from tests/coverage-map/assert.cov-map rename to tests/coverage/assert.cov-map diff --git a/tests/coverage-map/async.cov-map b/tests/coverage/async.cov-map similarity index 100% rename from tests/coverage-map/async.cov-map rename to tests/coverage/async.cov-map diff --git a/tests/coverage-map/async2.cov-map b/tests/coverage/async2.cov-map similarity index 100% rename from tests/coverage-map/async2.cov-map rename to tests/coverage/async2.cov-map diff --git a/tests/coverage-map/bad_counter_ids.cov-map b/tests/coverage/bad_counter_ids.cov-map similarity index 100% rename from tests/coverage-map/bad_counter_ids.cov-map rename to tests/coverage/bad_counter_ids.cov-map diff --git a/tests/coverage-map/closure.cov-map b/tests/coverage/closure.cov-map similarity index 100% rename from tests/coverage-map/closure.cov-map rename to tests/coverage/closure.cov-map diff --git a/tests/coverage-map/closure_bug.cov-map b/tests/coverage/closure_bug.cov-map similarity index 100% rename from tests/coverage-map/closure_bug.cov-map rename to tests/coverage/closure_bug.cov-map diff --git a/tests/coverage-map/closure_macro.cov-map b/tests/coverage/closure_macro.cov-map similarity index 100% rename from tests/coverage-map/closure_macro.cov-map rename to tests/coverage/closure_macro.cov-map diff --git a/tests/coverage-map/closure_macro_async.cov-map b/tests/coverage/closure_macro_async.cov-map similarity index 100% rename from tests/coverage-map/closure_macro_async.cov-map rename to tests/coverage/closure_macro_async.cov-map diff --git a/tests/coverage-map/conditions.cov-map b/tests/coverage/conditions.cov-map similarity index 100% rename from tests/coverage-map/conditions.cov-map rename to tests/coverage/conditions.cov-map diff --git a/tests/coverage-map/continue.cov-map b/tests/coverage/continue.cov-map similarity index 100% rename from tests/coverage-map/continue.cov-map rename to tests/coverage/continue.cov-map diff --git a/tests/coverage-map/coroutine.cov-map b/tests/coverage/coroutine.cov-map similarity index 100% rename from tests/coverage-map/coroutine.cov-map rename to tests/coverage/coroutine.cov-map diff --git a/tests/coverage-map/dead_code.cov-map b/tests/coverage/dead_code.cov-map similarity index 100% rename from tests/coverage-map/dead_code.cov-map rename to tests/coverage/dead_code.cov-map diff --git a/tests/coverage-map/drop_trait.cov-map b/tests/coverage/drop_trait.cov-map similarity index 100% rename from tests/coverage-map/drop_trait.cov-map rename to tests/coverage/drop_trait.cov-map diff --git a/tests/coverage-map/fn_sig_into_try.cov-map b/tests/coverage/fn_sig_into_try.cov-map similarity index 100% rename from tests/coverage-map/fn_sig_into_try.cov-map rename to tests/coverage/fn_sig_into_try.cov-map diff --git a/tests/coverage-map/generics.cov-map b/tests/coverage/generics.cov-map similarity index 100% rename from tests/coverage-map/generics.cov-map rename to tests/coverage/generics.cov-map diff --git a/tests/coverage-map/if.cov-map b/tests/coverage/if.cov-map similarity index 100% rename from tests/coverage-map/if.cov-map rename to tests/coverage/if.cov-map diff --git a/tests/coverage-map/if_else.cov-map b/tests/coverage/if_else.cov-map similarity index 100% rename from tests/coverage-map/if_else.cov-map rename to tests/coverage/if_else.cov-map diff --git a/tests/coverage-map/inline-dead.cov-map b/tests/coverage/inline-dead.cov-map similarity index 100% rename from tests/coverage-map/inline-dead.cov-map rename to tests/coverage/inline-dead.cov-map diff --git a/tests/coverage-map/inline.cov-map b/tests/coverage/inline.cov-map similarity index 100% rename from tests/coverage-map/inline.cov-map rename to tests/coverage/inline.cov-map diff --git a/tests/coverage-map/inner_items.cov-map b/tests/coverage/inner_items.cov-map similarity index 100% rename from tests/coverage-map/inner_items.cov-map rename to tests/coverage/inner_items.cov-map diff --git a/tests/coverage-map/issue-83601.cov-map b/tests/coverage/issue-83601.cov-map similarity index 100% rename from tests/coverage-map/issue-83601.cov-map rename to tests/coverage/issue-83601.cov-map diff --git a/tests/coverage-map/issue-84561.cov-map b/tests/coverage/issue-84561.cov-map similarity index 100% rename from tests/coverage-map/issue-84561.cov-map rename to tests/coverage/issue-84561.cov-map diff --git a/tests/coverage-map/issue-85461.cov-map b/tests/coverage/issue-85461.cov-map similarity index 100% rename from tests/coverage-map/issue-85461.cov-map rename to tests/coverage/issue-85461.cov-map diff --git a/tests/coverage-map/issue-93054.cov-map b/tests/coverage/issue-93054.cov-map similarity index 100% rename from tests/coverage-map/issue-93054.cov-map rename to tests/coverage/issue-93054.cov-map diff --git a/tests/coverage-map/lazy_boolean.cov-map b/tests/coverage/lazy_boolean.cov-map similarity index 100% rename from tests/coverage-map/lazy_boolean.cov-map rename to tests/coverage/lazy_boolean.cov-map diff --git a/tests/coverage-map/long_and_wide.cov-map b/tests/coverage/long_and_wide.cov-map similarity index 100% rename from tests/coverage-map/long_and_wide.cov-map rename to tests/coverage/long_and_wide.cov-map diff --git a/tests/coverage-map/loop_break_value.cov-map b/tests/coverage/loop_break_value.cov-map similarity index 100% rename from tests/coverage-map/loop_break_value.cov-map rename to tests/coverage/loop_break_value.cov-map diff --git a/tests/coverage-map/loops_branches.cov-map b/tests/coverage/loops_branches.cov-map similarity index 100% rename from tests/coverage-map/loops_branches.cov-map rename to tests/coverage/loops_branches.cov-map diff --git a/tests/coverage-map/match_or_pattern.cov-map b/tests/coverage/match_or_pattern.cov-map similarity index 100% rename from tests/coverage-map/match_or_pattern.cov-map rename to tests/coverage/match_or_pattern.cov-map diff --git a/tests/coverage-map/nested_loops.cov-map b/tests/coverage/nested_loops.cov-map similarity index 100% rename from tests/coverage-map/nested_loops.cov-map rename to tests/coverage/nested_loops.cov-map diff --git a/tests/coverage-map/no_cov_crate.cov-map b/tests/coverage/no_cov_crate.cov-map similarity index 100% rename from tests/coverage-map/no_cov_crate.cov-map rename to tests/coverage/no_cov_crate.cov-map diff --git a/tests/coverage-map/overflow.cov-map b/tests/coverage/overflow.cov-map similarity index 100% rename from tests/coverage-map/overflow.cov-map rename to tests/coverage/overflow.cov-map diff --git a/tests/coverage-map/panic_unwind.cov-map b/tests/coverage/panic_unwind.cov-map similarity index 100% rename from tests/coverage-map/panic_unwind.cov-map rename to tests/coverage/panic_unwind.cov-map diff --git a/tests/coverage-map/partial_eq.cov-map b/tests/coverage/partial_eq.cov-map similarity index 100% rename from tests/coverage-map/partial_eq.cov-map rename to tests/coverage/partial_eq.cov-map diff --git a/tests/coverage-map/simple_loop.cov-map b/tests/coverage/simple_loop.cov-map similarity index 100% rename from tests/coverage-map/simple_loop.cov-map rename to tests/coverage/simple_loop.cov-map diff --git a/tests/coverage-map/simple_match.cov-map b/tests/coverage/simple_match.cov-map similarity index 100% rename from tests/coverage-map/simple_match.cov-map rename to tests/coverage/simple_match.cov-map diff --git a/tests/coverage-map/sort_groups.cov-map b/tests/coverage/sort_groups.cov-map similarity index 100% rename from tests/coverage-map/sort_groups.cov-map rename to tests/coverage/sort_groups.cov-map diff --git a/tests/coverage-map/test_harness.cov-map b/tests/coverage/test_harness.cov-map similarity index 100% rename from tests/coverage-map/test_harness.cov-map rename to tests/coverage/test_harness.cov-map diff --git a/tests/coverage-map/tight_inf_loop.cov-map b/tests/coverage/tight_inf_loop.cov-map similarity index 100% rename from tests/coverage-map/tight_inf_loop.cov-map rename to tests/coverage/tight_inf_loop.cov-map diff --git a/tests/coverage-map/trivial.cov-map b/tests/coverage/trivial.cov-map similarity index 100% rename from tests/coverage-map/trivial.cov-map rename to tests/coverage/trivial.cov-map diff --git a/tests/coverage-map/try_error_result.cov-map b/tests/coverage/try_error_result.cov-map similarity index 100% rename from tests/coverage-map/try_error_result.cov-map rename to tests/coverage/try_error_result.cov-map diff --git a/tests/coverage-map/unreachable.cov-map b/tests/coverage/unreachable.cov-map similarity index 100% rename from tests/coverage-map/unreachable.cov-map rename to tests/coverage/unreachable.cov-map diff --git a/tests/coverage-map/unused.cov-map b/tests/coverage/unused.cov-map similarity index 100% rename from tests/coverage-map/unused.cov-map rename to tests/coverage/unused.cov-map diff --git a/tests/coverage-map/unused_mod.cov-map b/tests/coverage/unused_mod.cov-map similarity index 100% rename from tests/coverage-map/unused_mod.cov-map rename to tests/coverage/unused_mod.cov-map diff --git a/tests/coverage-map/uses_crate.cov-map b/tests/coverage/uses_crate.cov-map similarity index 100% rename from tests/coverage-map/uses_crate.cov-map rename to tests/coverage/uses_crate.cov-map diff --git a/tests/coverage-map/uses_inline_crate.cov-map b/tests/coverage/uses_inline_crate.cov-map similarity index 100% rename from tests/coverage-map/uses_inline_crate.cov-map rename to tests/coverage/uses_inline_crate.cov-map diff --git a/tests/coverage-map/while.cov-map b/tests/coverage/while.cov-map similarity index 100% rename from tests/coverage-map/while.cov-map rename to tests/coverage/while.cov-map diff --git a/tests/coverage-map/while_early_ret.cov-map b/tests/coverage/while_early_ret.cov-map similarity index 100% rename from tests/coverage-map/while_early_ret.cov-map rename to tests/coverage/while_early_ret.cov-map diff --git a/tests/coverage-map/yield.cov-map b/tests/coverage/yield.cov-map similarity index 100% rename from tests/coverage-map/yield.cov-map rename to tests/coverage/yield.cov-map