diff --git a/tests/coverage/assert.cov-map b/tests/coverage/assert.cov-map index 543ab89628281..4500eab355739 100644 --- a/tests/coverage/assert.cov-map +++ b/tests/coverage/assert.cov-map @@ -1,42 +1,72 @@ -Function name: assert::main -Raw bytes (76): 0x[01, 01, 06, 05, 01, 05, 17, 01, 09, 05, 13, 17, 0d, 01, 09, 0c, 01, 09, 01, 00, 1c, 01, 01, 09, 00, 16, 01, 00, 19, 00, 1b, 05, 01, 0b, 00, 18, 02, 01, 0c, 00, 1a, 09, 00, 1b, 02, 0a, 06, 02, 13, 00, 20, 0d, 00, 21, 02, 0a, 0e, 02, 09, 00, 0a, 02, 01, 09, 00, 17, 01, 02, 05, 00, 0b, 01, 01, 01, 00, 02] +Function name: assert::assert_a_plain +Raw bytes (54): 0x[01, 01, 00, 0a, 01, 06, 01, 00, 25, 01, 01, 05, 00, 0c, 01, 00, 0d, 00, 10, 01, 00, 11, 00, 18, 05, 01, 05, 00, 0f, 09, 01, 05, 00, 0f, 15, 01, 05, 00, 14, 0d, 00, 15, 00, 18, 11, 00, 1f, 00, 25, 15, 01, 01, 00, 02] Number of files: 1 - file 0 => $DIR/assert.rs -Number of expressions: 6 -- expression 0 operands: lhs = Counter(1), rhs = Counter(0) -- expression 1 operands: lhs = Counter(1), rhs = Expression(5, Add) -- expression 2 operands: lhs = Counter(0), rhs = Counter(2) -- expression 3 operands: lhs = Counter(1), rhs = Expression(4, Add) -- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(3) -- expression 5 operands: lhs = Counter(0), rhs = Counter(2) -Number of file 0 mappings: 12 -- Code(Counter(0)) at (prev + 9, 1) to (start + 0, 28) -- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 22) -- Code(Counter(0)) at (prev + 0, 25) to (start + 0, 27) -- Code(Counter(1)) at (prev + 1, 11) to (start + 0, 24) -- Code(Expression(0, Sub)) at (prev + 1, 12) to (start + 0, 26) - = (c1 - c0) -- Code(Counter(2)) at (prev + 0, 27) to (start + 2, 10) -- Code(Expression(1, Sub)) at (prev + 2, 19) to (start + 0, 32) - = (c1 - (c0 + c2)) -- Code(Counter(3)) at (prev + 0, 33) to (start + 2, 10) -- Code(Expression(3, Sub)) at (prev + 2, 9) to (start + 0, 10) - = (c1 - ((c0 + c2) + c3)) -- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 23) - = (c1 - c0) -- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 11) -- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2) -Highest counter ID seen: c3 +Number of expressions: 0 +Number of file 0 mappings: 10 +- Code(Counter(0)) at (prev + 6, 1) to (start + 0, 37) +- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 12) +- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 16) +- Code(Counter(0)) at (prev + 0, 17) to (start + 0, 24) +- Code(Counter(1)) at (prev + 1, 5) to (start + 0, 15) +- Code(Counter(2)) at (prev + 1, 5) to (start + 0, 15) +- Code(Counter(5)) at (prev + 1, 5) to (start + 0, 20) +- Code(Counter(3)) at (prev + 0, 21) to (start + 0, 24) +- Code(Counter(4)) at (prev + 0, 31) to (start + 0, 37) +- Code(Counter(5)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c5 + +Function name: assert::assert_b_message +Raw bytes (54): 0x[01, 01, 00, 0a, 01, 0d, 01, 00, 27, 01, 01, 05, 00, 0c, 01, 00, 0d, 00, 10, 01, 00, 11, 00, 18, 05, 01, 05, 00, 0f, 09, 01, 05, 00, 0f, 15, 01, 05, 00, 14, 0d, 00, 15, 00, 18, 11, 00, 1f, 00, 25, 15, 01, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/assert.rs +Number of expressions: 0 +Number of file 0 mappings: 10 +- Code(Counter(0)) at (prev + 13, 1) to (start + 0, 39) +- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 12) +- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 16) +- Code(Counter(0)) at (prev + 0, 17) to (start + 0, 24) +- Code(Counter(1)) at (prev + 1, 5) to (start + 0, 15) +- Code(Counter(2)) at (prev + 1, 5) to (start + 0, 15) +- Code(Counter(5)) at (prev + 1, 5) to (start + 0, 20) +- Code(Counter(3)) at (prev + 0, 21) to (start + 0, 24) +- Code(Counter(4)) at (prev + 0, 31) to (start + 0, 37) +- Code(Counter(5)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c5 + +Function name: assert::assert_c_format_inline +Raw bytes (54): 0x[01, 01, 00, 0a, 01, 14, 01, 00, 38, 01, 01, 05, 00, 0c, 01, 00, 0d, 00, 10, 01, 00, 11, 00, 18, 05, 01, 05, 00, 0f, 09, 01, 05, 00, 0f, 15, 01, 05, 00, 14, 0d, 00, 15, 00, 18, 11, 00, 1f, 00, 25, 15, 01, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/assert.rs +Number of expressions: 0 +Number of file 0 mappings: 10 +- Code(Counter(0)) at (prev + 20, 1) to (start + 0, 56) +- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 12) +- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 16) +- Code(Counter(0)) at (prev + 0, 17) to (start + 0, 24) +- Code(Counter(1)) at (prev + 1, 5) to (start + 0, 15) +- Code(Counter(2)) at (prev + 1, 5) to (start + 0, 15) +- Code(Counter(5)) at (prev + 1, 5) to (start + 0, 20) +- Code(Counter(3)) at (prev + 0, 21) to (start + 0, 24) +- Code(Counter(4)) at (prev + 0, 31) to (start + 0, 37) +- Code(Counter(5)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c5 -Function name: assert::might_fail_assert -Raw bytes (24): 0x[01, 01, 00, 04, 01, 04, 01, 00, 28, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0f, 05, 01, 01, 00, 02] +Function name: assert::assert_d_format_arg +Raw bytes (54): 0x[01, 01, 00, 0a, 01, 1b, 01, 00, 35, 01, 01, 05, 00, 0c, 01, 00, 0d, 00, 10, 01, 00, 11, 00, 18, 05, 01, 05, 00, 0f, 09, 01, 05, 00, 0f, 15, 01, 05, 00, 14, 0d, 00, 15, 00, 18, 11, 00, 1f, 00, 25, 15, 01, 01, 00, 02] Number of files: 1 - file 0 => $DIR/assert.rs Number of expressions: 0 -Number of file 0 mappings: 4 -- Code(Counter(0)) at (prev + 4, 1) to (start + 0, 40) -- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13) -- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15) -- Code(Counter(1)) at (prev + 1, 1) to (start + 0, 2) -Highest counter ID seen: c1 +Number of file 0 mappings: 10 +- Code(Counter(0)) at (prev + 27, 1) to (start + 0, 53) +- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 12) +- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 16) +- Code(Counter(0)) at (prev + 0, 17) to (start + 0, 24) +- Code(Counter(1)) at (prev + 1, 5) to (start + 0, 15) +- Code(Counter(2)) at (prev + 1, 5) to (start + 0, 15) +- Code(Counter(5)) at (prev + 1, 5) to (start + 0, 20) +- Code(Counter(3)) at (prev + 0, 21) to (start + 0, 24) +- Code(Counter(4)) at (prev + 0, 31) to (start + 0, 37) +- Code(Counter(5)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c5 diff --git a/tests/coverage/assert.coverage b/tests/coverage/assert.coverage index 29a5b48c0566a..d9171fd705c99 100644 --- a/tests/coverage/assert.coverage +++ b/tests/coverage/assert.coverage @@ -1,33 +1,42 @@ - LL| |#![allow(unused_assignments)] - LL| |//@ failure-status: 101 + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 LL| | - LL| 4|fn might_fail_assert(one_plus_one: u32) { - LL| 4| println!("does 1 + 1 = {}?", one_plus_one); - LL| 4| assert_eq!(1 + 1, one_plus_one, "the argument was wrong"); - LL| 3|} + LL| |use core::assert_matches; LL| | - LL| 1|fn main() -> Result<(), u8> { - LL| 1| let mut countdown = 10; - LL| 10| while countdown > 0 { - LL| 9| if countdown == 1 { - LL| 1| might_fail_assert(3); - LL| 8| } else if countdown < 5 { - LL| 3| might_fail_assert(2); - LL| 5| } - LL| 9| countdown -= 1; - LL| | } - LL| 1| Ok(()) + LL| 1|fn assert_a_plain(opt: Option<&str>) { + LL| 1| assert!(opt.is_some()); + LL| 1| assert_eq!(opt, Some("true")); + LL| 1| assert_ne!(opt, None); + LL| 1| assert_matches!(opt, Some("true")); LL| 1|} LL| | - LL| |// Notes: - LL| |// 1. Compare this program and its coverage results to those of the very similar test - LL| |// `panic_unwind.rs`, and similar tests `abort.rs` and `try_error_result.rs`. - LL| |// 2. This test confirms the coverage generated when a program passes or fails an `assert!()` or - LL| |// related `assert_*!()` macro. - LL| |// 3. Notably, the `assert` macros *do not* generate `TerminatorKind::Assert`. The macros produce - LL| |// conditional expressions, `TerminatorKind::SwitchInt` branches, and a possible call to - LL| |// `begin_panic_fmt()` (that begins a panic unwind, if the assertion test fails). - LL| |// 4. `TerminatorKind::Assert` is, however, also present in the MIR generated for this test - LL| |// (and in many other coverage tests). The `Assert` terminator is typically generated by the - LL| |// Rust compiler to check for runtime failures, such as numeric overflows. + LL| 1|fn assert_b_message(opt: Option<&str>) { + LL| 1| assert!(opt.is_some(), "message"); + LL| 1| assert_eq!(opt, Some("true"), "message"); + LL| 1| assert_ne!(opt, None, "message"); + LL| 1| assert_matches!(opt, Some("true"), "message"); + LL| 1|} + LL| | + LL| 1|fn assert_c_format_inline(opt: Option<&str>, msg: &str) { + LL| 1| assert!(opt.is_some(), "message: {msg}"); + LL| 1| assert_eq!(opt, Some("true"), "message: {msg}"); + LL| 1| assert_ne!(opt, None, "message: {msg}"); + LL| 1| assert_matches!(opt, Some("true"), "message: {msg}"); + LL| 1|} + LL| | + LL| 1|fn assert_d_format_arg(opt: Option<&str>, msg: &str) { + LL| 1| assert!(opt.is_some(), "message: {}", msg); + LL| 1| assert_eq!(opt, Some("true"), "message: {}", msg); + LL| 1| assert_ne!(opt, None, "message: {}", msg); + LL| 1| assert_matches!(opt, Some("true"), "message: {}", msg); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let opt = core::hint::black_box(Some("true")); + LL| | assert_a_plain(opt); + LL| | assert_b_message(opt); + LL| | assert_c_format_inline(opt, "message"); + LL| | assert_d_format_arg(opt, "message"); + LL| |} diff --git a/tests/coverage/assert.rs b/tests/coverage/assert.rs index 30d511f8f7a89..9c3151ba4ce17 100644 --- a/tests/coverage/assert.rs +++ b/tests/coverage/assert.rs @@ -1,32 +1,41 @@ -#![allow(unused_assignments)] -//@ failure-status: 101 +#![feature(coverage_attribute)] +//@ edition: 2024 -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"); +use core::assert_matches; + +fn assert_a_plain(opt: Option<&str>) { + assert!(opt.is_some()); + assert_eq!(opt, Some("true")); + assert_ne!(opt, None); + assert_matches!(opt, Some("true")); +} + +fn assert_b_message(opt: Option<&str>) { + assert!(opt.is_some(), "message"); + assert_eq!(opt, Some("true"), "message"); + assert_ne!(opt, None, "message"); + assert_matches!(opt, Some("true"), "message"); } -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(()) +fn assert_c_format_inline(opt: Option<&str>, msg: &str) { + assert!(opt.is_some(), "message: {msg}"); + assert_eq!(opt, Some("true"), "message: {msg}"); + assert_ne!(opt, None, "message: {msg}"); + assert_matches!(opt, Some("true"), "message: {msg}"); } -// 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. `TerminatorKind::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. +fn assert_d_format_arg(opt: Option<&str>, msg: &str) { + assert!(opt.is_some(), "message: {}", msg); + assert_eq!(opt, Some("true"), "message: {}", msg); + assert_ne!(opt, None, "message: {}", msg); + assert_matches!(opt, Some("true"), "message: {}", msg); +} + +#[coverage(off)] +fn main() { + let opt = core::hint::black_box(Some("true")); + assert_a_plain(opt); + assert_b_message(opt); + assert_c_format_inline(opt, "message"); + assert_d_format_arg(opt, "message"); +} diff --git a/tests/coverage/async.cov-map b/tests/coverage/async/async.cov-map similarity index 100% rename from tests/coverage/async.cov-map rename to tests/coverage/async/async.cov-map diff --git a/tests/coverage/async.coverage b/tests/coverage/async/async.coverage similarity index 100% rename from tests/coverage/async.coverage rename to tests/coverage/async/async.coverage diff --git a/tests/coverage/async.rs b/tests/coverage/async/async.rs similarity index 100% rename from tests/coverage/async.rs rename to tests/coverage/async/async.rs diff --git a/tests/coverage/async2.cov-map b/tests/coverage/async/async2.cov-map similarity index 100% rename from tests/coverage/async2.cov-map rename to tests/coverage/async/async2.cov-map diff --git a/tests/coverage/async2.coverage b/tests/coverage/async/async2.coverage similarity index 100% rename from tests/coverage/async2.coverage rename to tests/coverage/async/async2.coverage diff --git a/tests/coverage/async2.rs b/tests/coverage/async/async2.rs similarity index 100% rename from tests/coverage/async2.rs rename to tests/coverage/async/async2.rs diff --git a/tests/coverage/async_block.cov-map b/tests/coverage/async/async_block.cov-map similarity index 100% rename from tests/coverage/async_block.cov-map rename to tests/coverage/async/async_block.cov-map diff --git a/tests/coverage/async_block.coverage b/tests/coverage/async/async_block.coverage similarity index 100% rename from tests/coverage/async_block.coverage rename to tests/coverage/async/async_block.coverage diff --git a/tests/coverage/async_block.rs b/tests/coverage/async/async_block.rs similarity index 100% rename from tests/coverage/async_block.rs rename to tests/coverage/async/async_block.rs diff --git a/tests/coverage/async_closure.cov-map b/tests/coverage/async/async_closure.cov-map similarity index 100% rename from tests/coverage/async_closure.cov-map rename to tests/coverage/async/async_closure.cov-map diff --git a/tests/coverage/async_closure.coverage b/tests/coverage/async/async_closure.coverage similarity index 100% rename from tests/coverage/async_closure.coverage rename to tests/coverage/async/async_closure.coverage diff --git a/tests/coverage/async_closure.rs b/tests/coverage/async/async_closure.rs similarity index 100% rename from tests/coverage/async_closure.rs rename to tests/coverage/async/async_closure.rs diff --git a/tests/coverage/async_closure2.cov-map b/tests/coverage/async/async_closure2.cov-map similarity index 100% rename from tests/coverage/async_closure2.cov-map rename to tests/coverage/async/async_closure2.cov-map diff --git a/tests/coverage/async_closure2.coverage b/tests/coverage/async/async_closure2.coverage similarity index 100% rename from tests/coverage/async_closure2.coverage rename to tests/coverage/async/async_closure2.coverage diff --git a/tests/coverage/async_closure2.rs b/tests/coverage/async/async_closure2.rs similarity index 100% rename from tests/coverage/async_closure2.rs rename to tests/coverage/async/async_closure2.rs diff --git a/tests/coverage/auxiliary/executor.rs b/tests/coverage/async/auxiliary/executor.rs similarity index 100% rename from tests/coverage/auxiliary/executor.rs rename to tests/coverage/async/auxiliary/executor.rs diff --git a/tests/coverage/await_ready.cov-map b/tests/coverage/async/await_ready.cov-map similarity index 100% rename from tests/coverage/await_ready.cov-map rename to tests/coverage/async/await_ready.cov-map diff --git a/tests/coverage/await_ready.coverage b/tests/coverage/async/await_ready.coverage similarity index 100% rename from tests/coverage/await_ready.coverage rename to tests/coverage/async/await_ready.coverage diff --git a/tests/coverage/await_ready.rs b/tests/coverage/async/await_ready.rs similarity index 100% rename from tests/coverage/await_ready.rs rename to tests/coverage/async/await_ready.rs diff --git a/tests/coverage/closure_macro_async.cov-map b/tests/coverage/async/closure_macro_async.cov-map similarity index 100% rename from tests/coverage/closure_macro_async.cov-map rename to tests/coverage/async/closure_macro_async.cov-map diff --git a/tests/coverage/closure_macro_async.coverage b/tests/coverage/async/closure_macro_async.coverage similarity index 100% rename from tests/coverage/closure_macro_async.coverage rename to tests/coverage/async/closure_macro_async.coverage diff --git a/tests/coverage/closure_macro_async.rs b/tests/coverage/async/closure_macro_async.rs similarity index 100% rename from tests/coverage/closure_macro_async.rs rename to tests/coverage/async/closure_macro_async.rs diff --git a/tests/coverage/call-method.cov-map b/tests/coverage/call-method.cov-map new file mode 100644 index 0000000000000..534cc4b6a58af --- /dev/null +++ b/tests/coverage/call-method.cov-map @@ -0,0 +1,19 @@ +Function name: call_method::call_method +Raw bytes (59): 0x[01, 01, 00, 0b, 01, 08, 01, 00, 11, 01, 01, 09, 00, 0e, 01, 00, 11, 00, 16, 01, 02, 05, 00, 0a, 01, 02, 09, 00, 0f, 01, 02, 0d, 00, 12, 01, 04, 05, 05, 0a, 01, 00, 05, 00, 0a, 01, 07, 09, 00, 0f, 01, 02, 0d, 00, 12, 01, 03, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/call-method.rs +Number of expressions: 0 +Number of file 0 mappings: 11 +- Code(Counter(0)) at (prev + 8, 1) to (start + 0, 17) +- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 14) +- Code(Counter(0)) at (prev + 0, 17) to (start + 0, 22) +- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 10) +- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 15) +- Code(Counter(0)) at (prev + 2, 13) to (start + 0, 18) +- Code(Counter(0)) at (prev + 4, 5) to (start + 5, 10) +- Code(Counter(0)) at (prev + 0, 5) to (start + 0, 10) +- Code(Counter(0)) at (prev + 7, 9) to (start + 0, 15) +- Code(Counter(0)) at (prev + 2, 13) to (start + 0, 18) +- Code(Counter(0)) at (prev + 3, 1) to (start + 0, 2) +Highest counter ID seen: c0 + diff --git a/tests/coverage/call-method.coverage b/tests/coverage/call-method.coverage new file mode 100644 index 0000000000000..afcdb0adc7b73 --- /dev/null +++ b/tests/coverage/call-method.coverage @@ -0,0 +1,46 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ min-llvm-version: 23 + LL| | + LL| |// Basic test for method calls and chained method calls. + LL| | + LL| |#[rustfmt::skip] + LL| 1|fn call_method() { + LL| 1| let thing = Thing; + LL| | + LL| 1| thing + LL| | . + LL| 1| method + LL| | ( + LL| 1| "arg" + LL| | ) + LL| | ; + LL| | + LL| 1| thing + LL| 1| . + LL| 1| method + LL| 1| ( + LL| 1| "arg" + LL| 1| ) + LL| | . + LL| 1| method + LL| | ( + LL| 1| "arg" + LL| | ) + LL| | ; + LL| 1|} + LL| | + LL| |struct Thing; + LL| | + LL| |#[coverage(off)] + LL| |impl Thing { + LL| | fn method(&self, _arg: &str) -> &Self { + LL| | self + LL| | } + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | call_method(); + LL| |} + diff --git a/tests/coverage/call-method.rs b/tests/coverage/call-method.rs new file mode 100644 index 0000000000000..42b753503331b --- /dev/null +++ b/tests/coverage/call-method.rs @@ -0,0 +1,45 @@ +#![feature(coverage_attribute)] +//@ edition: 2024 +//@ min-llvm-version: 23 + +// Basic test for method calls and chained method calls. + +#[rustfmt::skip] +fn call_method() { + let thing = Thing; + + thing + . + method + ( + "arg" + ) + ; + + thing + . + method + ( + "arg" + ) + . + method + ( + "arg" + ) + ; +} + +struct Thing; + +#[coverage(off)] +impl Thing { + fn method(&self, _arg: &str) -> &Self { + self + } +} + +#[coverage(off)] +fn main() { + call_method(); +} diff --git a/tests/coverage/for.many.coverage b/tests/coverage/for.many.coverage new file mode 100644 index 0000000000000..c6908b64cd615 --- /dev/null +++ b/tests/coverage/for.many.coverage @@ -0,0 +1,39 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ revisions: zero one many + LL| |//@[one] ignore-coverage-map + LL| |//@[many] ignore-coverage-map + LL| | + LL| |// Basic test of `for` loops. + LL| | + LL| 1|fn for_loop(items: &[&str]) { + LL| 1| say("hello"); + LL| | + LL| 3| for item in items { + ^1 + LL| 3| say(item); + LL| 3| } + LL| | + LL| 3| for item in items { + ^1 + LL| 3| say(item) + LL| | } + LL| | + LL| 1| say("goodbye"); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let items = cfg_select!( + LL| | zero => &[], + LL| | one => &["one"], + LL| | many => &["one", "two", "three"], + LL| | ); + LL| | for_loop(items); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/for.one.coverage b/tests/coverage/for.one.coverage new file mode 100644 index 0000000000000..285d379c526f9 --- /dev/null +++ b/tests/coverage/for.one.coverage @@ -0,0 +1,37 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ revisions: zero one many + LL| |//@[one] ignore-coverage-map + LL| |//@[many] ignore-coverage-map + LL| | + LL| |// Basic test of `for` loops. + LL| | + LL| 1|fn for_loop(items: &[&str]) { + LL| 1| say("hello"); + LL| | + LL| 1| for item in items { + LL| 1| say(item); + LL| 1| } + LL| | + LL| 1| for item in items { + LL| 1| say(item) + LL| | } + LL| | + LL| 1| say("goodbye"); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let items = cfg_select!( + LL| | zero => &[], + LL| | one => &["one"], + LL| | many => &["one", "two", "three"], + LL| | ); + LL| | for_loop(items); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/for.rs b/tests/coverage/for.rs new file mode 100644 index 0000000000000..55a2cfc2c18d2 --- /dev/null +++ b/tests/coverage/for.rs @@ -0,0 +1,36 @@ +#![feature(coverage_attribute)] +//@ edition: 2024 +//@ revisions: zero one many +//@[one] ignore-coverage-map +//@[many] ignore-coverage-map + +// Basic test of `for` loops. + +fn for_loop(items: &[&str]) { + say("hello"); + + for item in items { + say(item); + } + + for item in items { + say(item) + } + + say("goodbye"); +} + +#[coverage(off)] +fn main() { + let items = cfg_select!( + zero => &[], + one => &["one"], + many => &["one", "two", "three"], + ); + for_loop(items); +} + +#[coverage(off)] +fn say(msg: &str) { + println!("{msg}"); +} diff --git a/tests/coverage/for.zero.cov-map b/tests/coverage/for.zero.cov-map new file mode 100644 index 0000000000000..4ac461b85719f --- /dev/null +++ b/tests/coverage/for.zero.cov-map @@ -0,0 +1,30 @@ +Function name: for::for_loop +Raw bytes (77): 0x[01, 01, 04, 05, 01, 09, 01, 09, 01, 09, 01, 0d, 01, 09, 01, 00, 1c, 01, 01, 05, 00, 08, 01, 00, 09, 00, 10, 02, 02, 09, 00, 0d, 01, 00, 11, 00, 16, 02, 00, 17, 02, 06, 0e, 04, 09, 00, 0d, 01, 00, 11, 00, 16, 0e, 01, 09, 00, 0c, 0e, 00, 0d, 00, 11, 01, 03, 05, 00, 08, 01, 00, 09, 00, 12, 01, 01, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/for.rs +Number of expressions: 4 +- expression 0 operands: lhs = Counter(1), rhs = Counter(0) +- expression 1 operands: lhs = Counter(2), rhs = Counter(0) +- expression 2 operands: lhs = Counter(2), rhs = Counter(0) +- expression 3 operands: lhs = Counter(2), rhs = Counter(0) +Number of file 0 mappings: 13 +- Code(Counter(0)) at (prev + 9, 1) to (start + 0, 28) +- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 8) +- Code(Counter(0)) at (prev + 0, 9) to (start + 0, 16) +- Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 13) + = (c1 - c0) +- Code(Counter(0)) at (prev + 0, 17) to (start + 0, 22) +- Code(Expression(0, Sub)) at (prev + 0, 23) to (start + 2, 6) + = (c1 - c0) +- Code(Expression(3, Sub)) at (prev + 4, 9) to (start + 0, 13) + = (c2 - c0) +- Code(Counter(0)) at (prev + 0, 17) to (start + 0, 22) +- Code(Expression(3, Sub)) at (prev + 1, 9) to (start + 0, 12) + = (c2 - c0) +- Code(Expression(3, Sub)) at (prev + 0, 13) to (start + 0, 17) + = (c2 - c0) +- Code(Counter(0)) at (prev + 3, 5) to (start + 0, 8) +- Code(Counter(0)) at (prev + 0, 9) to (start + 0, 18) +- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c0 + diff --git a/tests/coverage/for.zero.coverage b/tests/coverage/for.zero.coverage new file mode 100644 index 0000000000000..9376a371275d4 --- /dev/null +++ b/tests/coverage/for.zero.coverage @@ -0,0 +1,39 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ revisions: zero one many + LL| |//@[one] ignore-coverage-map + LL| |//@[many] ignore-coverage-map + LL| | + LL| |// Basic test of `for` loops. + LL| | + LL| 1|fn for_loop(items: &[&str]) { + LL| 1| say("hello"); + LL| | + LL| 1| for item in items { + ^0 + LL| 0| say(item); + LL| 0| } + LL| | + LL| 1| for item in items { + ^0 + LL| 0| say(item) + LL| | } + LL| | + LL| 1| say("goodbye"); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let items = cfg_select!( + LL| | zero => &[], + LL| | one => &["one"], + LL| | many => &["one", "two", "three"], + LL| | ); + LL| | for_loop(items); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/if-let-chain.none.cov-map b/tests/coverage/if-let-chain.none.cov-map new file mode 100644 index 0000000000000..9626b6cc8553b --- /dev/null +++ b/tests/coverage/if-let-chain.none.cov-map @@ -0,0 +1,40 @@ +Function name: if_let_chain::if_let_chain +Raw bytes (105): 0x[01, 01, 08, 09, 05, 0b, 09, 01, 05, 11, 0d, 11, 0d, 11, 0d, 1f, 11, 01, 0d, 11, 01, 09, 01, 00, 33, 09, 01, 11, 00, 18, 01, 00, 1c, 00, 27, 02, 01, 15, 00, 18, 09, 00, 1c, 00, 23, 02, 01, 05, 02, 06, 06, 02, 05, 00, 06, 11, 02, 11, 00, 18, 01, 00, 1c, 00, 27, 16, 01, 15, 00, 18, 11, 00, 1c, 00, 23, 16, 02, 09, 00, 0c, 16, 00, 0d, 00, 10, 1a, 01, 05, 00, 06, 01, 02, 05, 00, 08, 01, 00, 09, 00, 12, 01, 01, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/if-let-chain.rs +Number of expressions: 8 +- expression 0 operands: lhs = Counter(2), rhs = Counter(1) +- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(2) +- expression 2 operands: lhs = Counter(0), rhs = Counter(1) +- expression 3 operands: lhs = Counter(4), rhs = Counter(3) +- expression 4 operands: lhs = Counter(4), rhs = Counter(3) +- expression 5 operands: lhs = Counter(4), rhs = Counter(3) +- expression 6 operands: lhs = Expression(7, Add), rhs = Counter(4) +- expression 7 operands: lhs = Counter(0), rhs = Counter(3) +Number of file 0 mappings: 17 +- Code(Counter(0)) at (prev + 9, 1) to (start + 0, 51) +- Code(Counter(2)) at (prev + 1, 17) to (start + 0, 24) +- Code(Counter(0)) at (prev + 0, 28) to (start + 0, 39) +- Code(Expression(0, Sub)) at (prev + 1, 21) to (start + 0, 24) + = (c2 - c1) +- Code(Counter(2)) at (prev + 0, 28) to (start + 0, 35) +- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 2, 6) + = (c2 - c1) +- Code(Expression(1, Sub)) at (prev + 2, 5) to (start + 0, 6) + = ((c0 + c1) - c2) +- Code(Counter(4)) at (prev + 2, 17) to (start + 0, 24) +- Code(Counter(0)) at (prev + 0, 28) to (start + 0, 39) +- Code(Expression(5, Sub)) at (prev + 1, 21) to (start + 0, 24) + = (c4 - c3) +- Code(Counter(4)) at (prev + 0, 28) to (start + 0, 35) +- Code(Expression(5, Sub)) at (prev + 2, 9) to (start + 0, 12) + = (c4 - c3) +- Code(Expression(5, Sub)) at (prev + 0, 13) to (start + 0, 16) + = (c4 - c3) +- Code(Expression(6, Sub)) at (prev + 1, 5) to (start + 0, 6) + = ((c0 + c3) - c4) +- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 8) +- Code(Counter(0)) at (prev + 0, 9) to (start + 0, 18) +- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c4 + diff --git a/tests/coverage/if-let-chain.none.coverage b/tests/coverage/if-let-chain.none.coverage new file mode 100644 index 0000000000000..a5aba75201ead --- /dev/null +++ b/tests/coverage/if-let-chain.none.coverage @@ -0,0 +1,41 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ revisions: none one two + LL| |//@[one] ignore-coverage-map + LL| |//@[two] ignore-coverage-map + LL| | + LL| |// Basic test for if-let chains. + LL| | + LL| 1|fn if_let_chain(opt_opt_msg: Option>) { + LL| 1| if let Some(opt_msg) = opt_opt_msg + ^0 + LL| 0| && let Some(msg) = opt_msg + LL| 0| { + LL| 0| say(msg); + LL| 1| } + LL| | + LL| 1| if let Some(opt_msg) = opt_opt_msg + ^0 + LL| 0| && let Some(msg) = opt_msg + LL| | { + LL| 0| say(msg) + LL| 1| } + LL| | + LL| 1| say("goodbye"); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let opt_opt_msg = cfg_select!( + LL| | none => None, + LL| | one => Some(None), + LL| | two => Some(Some("hello")), + LL| | ); + LL| | if_let_chain(opt_opt_msg); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/if-let-chain.one.coverage b/tests/coverage/if-let-chain.one.coverage new file mode 100644 index 0000000000000..b4789e8593af6 --- /dev/null +++ b/tests/coverage/if-let-chain.one.coverage @@ -0,0 +1,41 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ revisions: none one two + LL| |//@[one] ignore-coverage-map + LL| |//@[two] ignore-coverage-map + LL| | + LL| |// Basic test for if-let chains. + LL| | + LL| 1|fn if_let_chain(opt_opt_msg: Option>) { + LL| 1| if let Some(opt_msg) = opt_opt_msg + LL| 1| && let Some(msg) = opt_msg + ^0 + LL| 0| { + LL| 0| say(msg); + LL| 1| } + LL| | + LL| 1| if let Some(opt_msg) = opt_opt_msg + LL| 1| && let Some(msg) = opt_msg + ^0 + LL| | { + LL| 0| say(msg) + LL| 1| } + LL| | + LL| 1| say("goodbye"); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let opt_opt_msg = cfg_select!( + LL| | none => None, + LL| | one => Some(None), + LL| | two => Some(Some("hello")), + LL| | ); + LL| | if_let_chain(opt_opt_msg); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/if-let-chain.rs b/tests/coverage/if-let-chain.rs new file mode 100644 index 0000000000000..816a22015a4c7 --- /dev/null +++ b/tests/coverage/if-let-chain.rs @@ -0,0 +1,38 @@ +#![feature(coverage_attribute)] +//@ edition: 2024 +//@ revisions: none one two +//@[one] ignore-coverage-map +//@[two] ignore-coverage-map + +// Basic test for if-let chains. + +fn if_let_chain(opt_opt_msg: Option>) { + if let Some(opt_msg) = opt_opt_msg + && let Some(msg) = opt_msg + { + say(msg); + } + + if let Some(opt_msg) = opt_opt_msg + && let Some(msg) = opt_msg + { + say(msg) + } + + say("goodbye"); +} + +#[coverage(off)] +fn main() { + let opt_opt_msg = cfg_select!( + none => None, + one => Some(None), + two => Some(Some("hello")), + ); + if_let_chain(opt_opt_msg); +} + +#[coverage(off)] +fn say(msg: &str) { + println!("{msg}"); +} diff --git a/tests/coverage/if-let-chain.two.coverage b/tests/coverage/if-let-chain.two.coverage new file mode 100644 index 0000000000000..491a704da1289 --- /dev/null +++ b/tests/coverage/if-let-chain.two.coverage @@ -0,0 +1,40 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ revisions: none one two + LL| |//@[one] ignore-coverage-map + LL| |//@[two] ignore-coverage-map + LL| | + LL| |// Basic test for if-let chains. + LL| | + LL| 1|fn if_let_chain(opt_opt_msg: Option>) { + LL| 1| if let Some(opt_msg) = opt_opt_msg + LL| 1| && let Some(msg) = opt_msg + LL| 1| { + LL| 1| say(msg); + LL| 1| } + ^0 + LL| | + LL| 1| if let Some(opt_msg) = opt_opt_msg + LL| 1| && let Some(msg) = opt_msg + LL| | { + LL| 1| say(msg) + LL| 0| } + LL| | + LL| 1| say("goodbye"); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let opt_opt_msg = cfg_select!( + LL| | none => None, + LL| | one => Some(None), + LL| | two => Some(Some("hello")), + LL| | ); + LL| | if_let_chain(opt_opt_msg); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/if-tail-expr.no.cov-map b/tests/coverage/if-tail-expr.no.cov-map new file mode 100644 index 0000000000000..3849ec62daae8 --- /dev/null +++ b/tests/coverage/if-tail-expr.no.cov-map @@ -0,0 +1,45 @@ +Function name: if_tail_expr::if_true +Raw bytes (135): 0x[01, 01, 08, 01, 05, 01, 09, 01, 09, 01, 0d, 01, 1f, 0d, 11, 01, 1f, 0d, 11, 17, 01, 09, 01, 00, 24, 01, 01, 05, 00, 08, 01, 00, 09, 00, 10, 01, 02, 08, 00, 0c, 05, 01, 09, 00, 0c, 05, 00, 0d, 00, 13, 02, 01, 05, 00, 06, 01, 02, 08, 00, 0c, 09, 01, 09, 00, 0c, 09, 00, 0d, 00, 13, 0a, 02, 09, 00, 0c, 0a, 00, 0d, 00, 14, 01, 03, 08, 00, 0c, 0d, 01, 09, 00, 0c, 0d, 00, 0d, 00, 13, 0e, 01, 0f, 00, 14, 11, 01, 09, 00, 0c, 11, 00, 0d, 00, 14, 1a, 02, 09, 00, 0c, 1a, 00, 0d, 00, 16, 01, 03, 05, 00, 08, 01, 00, 09, 00, 12, 01, 01, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/if-tail-expr.rs +Number of expressions: 8 +- expression 0 operands: lhs = Counter(0), rhs = Counter(1) +- expression 1 operands: lhs = Counter(0), rhs = Counter(2) +- expression 2 operands: lhs = Counter(0), rhs = Counter(2) +- expression 3 operands: lhs = Counter(0), rhs = Counter(3) +- expression 4 operands: lhs = Counter(0), rhs = Expression(7, Add) +- expression 5 operands: lhs = Counter(3), rhs = Counter(4) +- expression 6 operands: lhs = Counter(0), rhs = Expression(7, Add) +- expression 7 operands: lhs = Counter(3), rhs = Counter(4) +Number of file 0 mappings: 23 +- Code(Counter(0)) at (prev + 9, 1) to (start + 0, 36) +- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 8) +- Code(Counter(0)) at (prev + 0, 9) to (start + 0, 16) +- Code(Counter(0)) at (prev + 2, 8) to (start + 0, 12) +- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 12) +- Code(Counter(1)) at (prev + 0, 13) to (start + 0, 19) +- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 6) + = (c0 - c1) +- Code(Counter(0)) at (prev + 2, 8) to (start + 0, 12) +- Code(Counter(2)) at (prev + 1, 9) to (start + 0, 12) +- Code(Counter(2)) at (prev + 0, 13) to (start + 0, 19) +- Code(Expression(2, Sub)) at (prev + 2, 9) to (start + 0, 12) + = (c0 - c2) +- Code(Expression(2, Sub)) at (prev + 0, 13) to (start + 0, 20) + = (c0 - c2) +- Code(Counter(0)) at (prev + 3, 8) to (start + 0, 12) +- Code(Counter(3)) at (prev + 1, 9) to (start + 0, 12) +- Code(Counter(3)) at (prev + 0, 13) to (start + 0, 19) +- Code(Expression(3, Sub)) at (prev + 1, 15) to (start + 0, 20) + = (c0 - c3) +- Code(Counter(4)) at (prev + 1, 9) to (start + 0, 12) +- Code(Counter(4)) at (prev + 0, 13) to (start + 0, 20) +- Code(Expression(6, Sub)) at (prev + 2, 9) to (start + 0, 12) + = (c0 - (c3 + c4)) +- Code(Expression(6, Sub)) at (prev + 0, 13) to (start + 0, 22) + = (c0 - (c3 + c4)) +- Code(Counter(0)) at (prev + 3, 5) to (start + 0, 8) +- Code(Counter(0)) at (prev + 0, 9) to (start + 0, 18) +- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c4 + diff --git a/tests/coverage/if-tail-expr.no.coverage b/tests/coverage/if-tail-expr.no.coverage new file mode 100644 index 0000000000000..a33a58a6c30e6 --- /dev/null +++ b/tests/coverage/if-tail-expr.no.coverage @@ -0,0 +1,46 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ revisions: no yes + LL| |//@[yes] ignore-coverage-map + LL| | + LL| |// A variety of simple `if` expressions, in which the then/else blocks end with + LL| |// an expression. Contrast with `if-tail-stmt.rs`. + LL| | + LL| 1|fn if_true(cond: bool, other: bool) { + LL| 1| say("hello"); + LL| | + LL| 1| if cond { + LL| 0| say("true") + LL| 1| } + LL| | + LL| 1| if cond { + LL| 0| say("true") + LL| | } else { + LL| 1| say("false") + LL| | } + LL| | + LL| 1| if cond { + LL| 0| say("cond") + LL| 1| } else if other { + LL| 1| say("other") + LL| | } else { + LL| 0| say("neither") + LL| | } + LL| | + LL| 1| say("goodbye"); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let cond = cfg_select!( + LL| | no => false, + LL| | yes => true, + LL| | ); + LL| | if_true(cond, !cond); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/if-tail-expr.rs b/tests/coverage/if-tail-expr.rs new file mode 100644 index 0000000000000..778a9ecc8380c --- /dev/null +++ b/tests/coverage/if-tail-expr.rs @@ -0,0 +1,45 @@ +#![feature(coverage_attribute)] +//@ edition: 2024 +//@ revisions: no yes +//@[yes] ignore-coverage-map + +// A variety of simple `if` expressions, in which the then/else blocks end with +// an expression. Contrast with `if-tail-stmt.rs`. + +fn if_true(cond: bool, other: bool) { + say("hello"); + + if cond { + say("true") + } + + if cond { + say("true") + } else { + say("false") + } + + if cond { + say("cond") + } else if other { + say("other") + } else { + say("neither") + } + + say("goodbye"); +} + +#[coverage(off)] +fn main() { + let cond = cfg_select!( + no => false, + yes => true, + ); + if_true(cond, !cond); +} + +#[coverage(off)] +fn say(msg: &str) { + println!("{msg}"); +} diff --git a/tests/coverage/if-tail-expr.yes.coverage b/tests/coverage/if-tail-expr.yes.coverage new file mode 100644 index 0000000000000..111efccf59b15 --- /dev/null +++ b/tests/coverage/if-tail-expr.yes.coverage @@ -0,0 +1,46 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ revisions: no yes + LL| |//@[yes] ignore-coverage-map + LL| | + LL| |// A variety of simple `if` expressions, in which the then/else blocks end with + LL| |// an expression. Contrast with `if-tail-stmt.rs`. + LL| | + LL| 1|fn if_true(cond: bool, other: bool) { + LL| 1| say("hello"); + LL| | + LL| 1| if cond { + LL| 1| say("true") + LL| 0| } + LL| | + LL| 1| if cond { + LL| 1| say("true") + LL| | } else { + LL| 0| say("false") + LL| | } + LL| | + LL| 1| if cond { + LL| 1| say("cond") + LL| 0| } else if other { + LL| 0| say("other") + LL| | } else { + LL| 0| say("neither") + LL| | } + LL| | + LL| 1| say("goodbye"); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let cond = cfg_select!( + LL| | no => false, + LL| | yes => true, + LL| | ); + LL| | if_true(cond, !cond); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/if-tail-stmt.no.cov-map b/tests/coverage/if-tail-stmt.no.cov-map new file mode 100644 index 0000000000000..e5721e2dc4a74 --- /dev/null +++ b/tests/coverage/if-tail-stmt.no.cov-map @@ -0,0 +1,34 @@ +Function name: if_tail_stmt::if_true +Raw bytes (99): 0x[01, 01, 05, 01, 05, 01, 09, 01, 0d, 01, 13, 0d, 11, 11, 01, 09, 01, 00, 24, 01, 01, 05, 00, 08, 01, 00, 09, 00, 10, 01, 02, 08, 00, 0c, 05, 00, 0d, 02, 06, 02, 02, 05, 00, 06, 01, 02, 08, 00, 0c, 09, 00, 0d, 02, 06, 06, 02, 0c, 02, 06, 01, 04, 08, 00, 0c, 0d, 00, 0d, 02, 06, 0a, 02, 0f, 00, 14, 11, 00, 15, 02, 06, 0e, 02, 0c, 02, 06, 01, 04, 05, 00, 08, 01, 00, 09, 00, 12, 01, 01, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/if-tail-stmt.rs +Number of expressions: 5 +- expression 0 operands: lhs = Counter(0), rhs = Counter(1) +- expression 1 operands: lhs = Counter(0), rhs = Counter(2) +- expression 2 operands: lhs = Counter(0), rhs = Counter(3) +- expression 3 operands: lhs = Counter(0), rhs = Expression(4, Add) +- expression 4 operands: lhs = Counter(3), rhs = Counter(4) +Number of file 0 mappings: 17 +- Code(Counter(0)) at (prev + 9, 1) to (start + 0, 36) +- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 8) +- Code(Counter(0)) at (prev + 0, 9) to (start + 0, 16) +- Code(Counter(0)) at (prev + 2, 8) to (start + 0, 12) +- Code(Counter(1)) at (prev + 0, 13) to (start + 2, 6) +- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 6) + = (c0 - c1) +- Code(Counter(0)) at (prev + 2, 8) to (start + 0, 12) +- Code(Counter(2)) at (prev + 0, 13) to (start + 2, 6) +- Code(Expression(1, Sub)) at (prev + 2, 12) to (start + 2, 6) + = (c0 - c2) +- Code(Counter(0)) at (prev + 4, 8) to (start + 0, 12) +- Code(Counter(3)) at (prev + 0, 13) to (start + 2, 6) +- Code(Expression(2, Sub)) at (prev + 2, 15) to (start + 0, 20) + = (c0 - c3) +- Code(Counter(4)) at (prev + 0, 21) to (start + 2, 6) +- Code(Expression(3, Sub)) at (prev + 2, 12) to (start + 2, 6) + = (c0 - (c3 + c4)) +- Code(Counter(0)) at (prev + 4, 5) to (start + 0, 8) +- Code(Counter(0)) at (prev + 0, 9) to (start + 0, 18) +- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c4 + diff --git a/tests/coverage/if-tail-stmt.no.coverage b/tests/coverage/if-tail-stmt.no.coverage new file mode 100644 index 0000000000000..ca311f21ff229 --- /dev/null +++ b/tests/coverage/if-tail-stmt.no.coverage @@ -0,0 +1,46 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ revisions: no yes + LL| |//@[yes] ignore-coverage-map + LL| | + LL| |// A variety of simple `if` expressions, in which the then/else blocks end with + LL| |// a semicolon. Contrast with `if-tail-expr.rs`. + LL| | + LL| 1|fn if_true(cond: bool, other: bool) { + LL| 1| say("hello"); + LL| | + LL| 1| if cond { + LL| 0| say("true"); + LL| 1| } + LL| | + LL| 1| if cond { + LL| 0| say("true"); + LL| 1| } else { + LL| 1| say("false"); + LL| 1| } + LL| | + LL| 1| if cond { + LL| 0| say("cond"); + LL| 1| } else if other { + LL| 1| say("other"); + LL| 1| } else { + LL| 0| say("neither"); + LL| 0| } + LL| | + LL| 1| say("goodbye"); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let cond = cfg_select!( + LL| | no => false, + LL| | yes => true, + LL| | ); + LL| | if_true(cond, !cond); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/if-tail-stmt.rs b/tests/coverage/if-tail-stmt.rs new file mode 100644 index 0000000000000..f350c4eba90b0 --- /dev/null +++ b/tests/coverage/if-tail-stmt.rs @@ -0,0 +1,45 @@ +#![feature(coverage_attribute)] +//@ edition: 2024 +//@ revisions: no yes +//@[yes] ignore-coverage-map + +// A variety of simple `if` expressions, in which the then/else blocks end with +// a semicolon. Contrast with `if-tail-expr.rs`. + +fn if_true(cond: bool, other: bool) { + say("hello"); + + if cond { + say("true"); + } + + if cond { + say("true"); + } else { + say("false"); + } + + if cond { + say("cond"); + } else if other { + say("other"); + } else { + say("neither"); + } + + say("goodbye"); +} + +#[coverage(off)] +fn main() { + let cond = cfg_select!( + no => false, + yes => true, + ); + if_true(cond, !cond); +} + +#[coverage(off)] +fn say(msg: &str) { + println!("{msg}"); +} diff --git a/tests/coverage/if-tail-stmt.yes.coverage b/tests/coverage/if-tail-stmt.yes.coverage new file mode 100644 index 0000000000000..b4fa1884315e6 --- /dev/null +++ b/tests/coverage/if-tail-stmt.yes.coverage @@ -0,0 +1,48 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ revisions: no yes + LL| |//@[yes] ignore-coverage-map + LL| | + LL| |// A variety of simple `if` expressions, in which the then/else blocks end with + LL| |// a semicolon. Contrast with `if-tail-expr.rs`. + LL| | + LL| 1|fn if_true(cond: bool, other: bool) { + LL| 1| say("hello"); + LL| | + LL| 1| if cond { + LL| 1| say("true"); + LL| 1| } + ^0 + LL| | + LL| 1| if cond { + LL| 1| say("true"); + LL| 1| } else { + LL| 0| say("false"); + LL| 0| } + LL| | + LL| 1| if cond { + LL| 1| say("cond"); + LL| 1| } else if other { + ^0 + LL| 0| say("other"); + LL| 0| } else { + LL| 0| say("neither"); + LL| 0| } + LL| | + LL| 1| say("goodbye"); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let cond = cfg_select!( + LL| | no => false, + LL| | yes => true, + LL| | ); + LL| | if_true(cond, !cond); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/iffy/README.md b/tests/coverage/iffy/README.md new file mode 100644 index 0000000000000..0d8a866ed2685 --- /dev/null +++ b/tests/coverage/iffy/README.md @@ -0,0 +1,4 @@ +# `tests/coverage/iffy` + +Older tests that are of limited value for investigating specific problems, +but still have some worth in detecting regressions by adding variety to the test corpus. diff --git a/tests/coverage/abort.cov-map b/tests/coverage/iffy/abort.cov-map similarity index 100% rename from tests/coverage/abort.cov-map rename to tests/coverage/iffy/abort.cov-map diff --git a/tests/coverage/abort.coverage b/tests/coverage/iffy/abort.coverage similarity index 100% rename from tests/coverage/abort.coverage rename to tests/coverage/iffy/abort.coverage diff --git a/tests/coverage/abort.rs b/tests/coverage/iffy/abort.rs similarity index 100% rename from tests/coverage/abort.rs rename to tests/coverage/iffy/abort.rs diff --git a/tests/coverage/iffy/assert.cov-map b/tests/coverage/iffy/assert.cov-map new file mode 100644 index 0000000000000..543ab89628281 --- /dev/null +++ b/tests/coverage/iffy/assert.cov-map @@ -0,0 +1,42 @@ +Function name: assert::main +Raw bytes (76): 0x[01, 01, 06, 05, 01, 05, 17, 01, 09, 05, 13, 17, 0d, 01, 09, 0c, 01, 09, 01, 00, 1c, 01, 01, 09, 00, 16, 01, 00, 19, 00, 1b, 05, 01, 0b, 00, 18, 02, 01, 0c, 00, 1a, 09, 00, 1b, 02, 0a, 06, 02, 13, 00, 20, 0d, 00, 21, 02, 0a, 0e, 02, 09, 00, 0a, 02, 01, 09, 00, 17, 01, 02, 05, 00, 0b, 01, 01, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/assert.rs +Number of expressions: 6 +- expression 0 operands: lhs = Counter(1), rhs = Counter(0) +- expression 1 operands: lhs = Counter(1), rhs = Expression(5, Add) +- expression 2 operands: lhs = Counter(0), rhs = Counter(2) +- expression 3 operands: lhs = Counter(1), rhs = Expression(4, Add) +- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(3) +- expression 5 operands: lhs = Counter(0), rhs = Counter(2) +Number of file 0 mappings: 12 +- Code(Counter(0)) at (prev + 9, 1) to (start + 0, 28) +- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 22) +- Code(Counter(0)) at (prev + 0, 25) to (start + 0, 27) +- Code(Counter(1)) at (prev + 1, 11) to (start + 0, 24) +- Code(Expression(0, Sub)) at (prev + 1, 12) to (start + 0, 26) + = (c1 - c0) +- Code(Counter(2)) at (prev + 0, 27) to (start + 2, 10) +- Code(Expression(1, Sub)) at (prev + 2, 19) to (start + 0, 32) + = (c1 - (c0 + c2)) +- Code(Counter(3)) at (prev + 0, 33) to (start + 2, 10) +- Code(Expression(3, Sub)) at (prev + 2, 9) to (start + 0, 10) + = (c1 - ((c0 + c2) + c3)) +- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 23) + = (c1 - c0) +- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 11) +- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c3 + +Function name: assert::might_fail_assert +Raw bytes (24): 0x[01, 01, 00, 04, 01, 04, 01, 00, 28, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0f, 05, 01, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/assert.rs +Number of expressions: 0 +Number of file 0 mappings: 4 +- Code(Counter(0)) at (prev + 4, 1) to (start + 0, 40) +- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13) +- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15) +- Code(Counter(1)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c1 + diff --git a/tests/coverage/iffy/assert.coverage b/tests/coverage/iffy/assert.coverage new file mode 100644 index 0000000000000..29a5b48c0566a --- /dev/null +++ b/tests/coverage/iffy/assert.coverage @@ -0,0 +1,33 @@ + LL| |#![allow(unused_assignments)] + LL| |//@ failure-status: 101 + LL| | + LL| 4|fn might_fail_assert(one_plus_one: u32) { + LL| 4| println!("does 1 + 1 = {}?", one_plus_one); + LL| 4| assert_eq!(1 + 1, one_plus_one, "the argument was wrong"); + LL| 3|} + LL| | + LL| 1|fn main() -> Result<(), u8> { + LL| 1| let mut countdown = 10; + LL| 10| while countdown > 0 { + LL| 9| if countdown == 1 { + LL| 1| might_fail_assert(3); + LL| 8| } else if countdown < 5 { + LL| 3| might_fail_assert(2); + LL| 5| } + LL| 9| countdown -= 1; + LL| | } + LL| 1| Ok(()) + LL| 1|} + LL| | + LL| |// Notes: + LL| |// 1. Compare this program and its coverage results to those of the very similar test + LL| |// `panic_unwind.rs`, and similar tests `abort.rs` and `try_error_result.rs`. + LL| |// 2. This test confirms the coverage generated when a program passes or fails an `assert!()` or + LL| |// related `assert_*!()` macro. + LL| |// 3. Notably, the `assert` macros *do not* generate `TerminatorKind::Assert`. The macros produce + LL| |// conditional expressions, `TerminatorKind::SwitchInt` branches, and a possible call to + LL| |// `begin_panic_fmt()` (that begins a panic unwind, if the assertion test fails). + LL| |// 4. `TerminatorKind::Assert` is, however, also present in the MIR generated for this test + LL| |// (and in many other coverage tests). The `Assert` terminator is typically generated by the + LL| |// Rust compiler to check for runtime failures, such as numeric overflows. + diff --git a/tests/coverage/iffy/assert.rs b/tests/coverage/iffy/assert.rs new file mode 100644 index 0000000000000..30d511f8f7a89 --- /dev/null +++ b/tests/coverage/iffy/assert.rs @@ -0,0 +1,32 @@ +#![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. `TerminatorKind::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/auxiliary/inline_always_with_dead_code.rs b/tests/coverage/iffy/auxiliary/inline_always_with_dead_code.rs similarity index 100% rename from tests/coverage/auxiliary/inline_always_with_dead_code.rs rename to tests/coverage/iffy/auxiliary/inline_always_with_dead_code.rs diff --git a/tests/coverage/auxiliary/used_crate.rs b/tests/coverage/iffy/auxiliary/used_crate.rs similarity index 100% rename from tests/coverage/auxiliary/used_crate.rs rename to tests/coverage/iffy/auxiliary/used_crate.rs diff --git a/tests/coverage/auxiliary/used_inline_crate.rs b/tests/coverage/iffy/auxiliary/used_inline_crate.rs similarity index 100% rename from tests/coverage/auxiliary/used_inline_crate.rs rename to tests/coverage/iffy/auxiliary/used_inline_crate.rs diff --git a/tests/coverage/closure.cov-map b/tests/coverage/iffy/closure.cov-map similarity index 100% rename from tests/coverage/closure.cov-map rename to tests/coverage/iffy/closure.cov-map diff --git a/tests/coverage/closure.coverage b/tests/coverage/iffy/closure.coverage similarity index 100% rename from tests/coverage/closure.coverage rename to tests/coverage/iffy/closure.coverage diff --git a/tests/coverage/closure.rs b/tests/coverage/iffy/closure.rs similarity index 100% rename from tests/coverage/closure.rs rename to tests/coverage/iffy/closure.rs diff --git a/tests/coverage/closure_macro.cov-map b/tests/coverage/iffy/closure_macro.cov-map similarity index 100% rename from tests/coverage/closure_macro.cov-map rename to tests/coverage/iffy/closure_macro.cov-map diff --git a/tests/coverage/closure_macro.coverage b/tests/coverage/iffy/closure_macro.coverage similarity index 100% rename from tests/coverage/closure_macro.coverage rename to tests/coverage/iffy/closure_macro.coverage diff --git a/tests/coverage/closure_macro.rs b/tests/coverage/iffy/closure_macro.rs similarity index 100% rename from tests/coverage/closure_macro.rs rename to tests/coverage/iffy/closure_macro.rs diff --git a/tests/coverage/conditions.cov-map b/tests/coverage/iffy/conditions.cov-map similarity index 100% rename from tests/coverage/conditions.cov-map rename to tests/coverage/iffy/conditions.cov-map diff --git a/tests/coverage/conditions.coverage b/tests/coverage/iffy/conditions.coverage similarity index 100% rename from tests/coverage/conditions.coverage rename to tests/coverage/iffy/conditions.coverage diff --git a/tests/coverage/conditions.rs b/tests/coverage/iffy/conditions.rs similarity index 100% rename from tests/coverage/conditions.rs rename to tests/coverage/iffy/conditions.rs diff --git a/tests/coverage/continue.cov-map b/tests/coverage/iffy/continue.cov-map similarity index 100% rename from tests/coverage/continue.cov-map rename to tests/coverage/iffy/continue.cov-map diff --git a/tests/coverage/continue.coverage b/tests/coverage/iffy/continue.coverage similarity index 100% rename from tests/coverage/continue.coverage rename to tests/coverage/iffy/continue.coverage diff --git a/tests/coverage/continue.rs b/tests/coverage/iffy/continue.rs similarity index 100% rename from tests/coverage/continue.rs rename to tests/coverage/iffy/continue.rs diff --git a/tests/coverage/coroutine.cov-map b/tests/coverage/iffy/coroutine.cov-map similarity index 100% rename from tests/coverage/coroutine.cov-map rename to tests/coverage/iffy/coroutine.cov-map diff --git a/tests/coverage/coroutine.coverage b/tests/coverage/iffy/coroutine.coverage similarity index 100% rename from tests/coverage/coroutine.coverage rename to tests/coverage/iffy/coroutine.coverage diff --git a/tests/coverage/coroutine.rs b/tests/coverage/iffy/coroutine.rs similarity index 100% rename from tests/coverage/coroutine.rs rename to tests/coverage/iffy/coroutine.rs diff --git a/tests/coverage/drop_trait.cov-map b/tests/coverage/iffy/drop_trait.cov-map similarity index 100% rename from tests/coverage/drop_trait.cov-map rename to tests/coverage/iffy/drop_trait.cov-map diff --git a/tests/coverage/drop_trait.coverage b/tests/coverage/iffy/drop_trait.coverage similarity index 100% rename from tests/coverage/drop_trait.coverage rename to tests/coverage/iffy/drop_trait.coverage diff --git a/tests/coverage/drop_trait.rs b/tests/coverage/iffy/drop_trait.rs similarity index 100% rename from tests/coverage/drop_trait.rs rename to tests/coverage/iffy/drop_trait.rs diff --git a/tests/coverage/generics.cov-map b/tests/coverage/iffy/generics.cov-map similarity index 100% rename from tests/coverage/generics.cov-map rename to tests/coverage/iffy/generics.cov-map diff --git a/tests/coverage/generics.coverage b/tests/coverage/iffy/generics.coverage similarity index 100% rename from tests/coverage/generics.coverage rename to tests/coverage/iffy/generics.coverage diff --git a/tests/coverage/generics.rs b/tests/coverage/iffy/generics.rs similarity index 100% rename from tests/coverage/generics.rs rename to tests/coverage/iffy/generics.rs diff --git a/tests/coverage/if.cov-map b/tests/coverage/iffy/if.cov-map similarity index 100% rename from tests/coverage/if.cov-map rename to tests/coverage/iffy/if.cov-map diff --git a/tests/coverage/if.coverage b/tests/coverage/iffy/if.coverage similarity index 100% rename from tests/coverage/if.coverage rename to tests/coverage/iffy/if.coverage diff --git a/tests/coverage/if.rs b/tests/coverage/iffy/if.rs similarity index 100% rename from tests/coverage/if.rs rename to tests/coverage/iffy/if.rs diff --git a/tests/coverage/if_else.cov-map b/tests/coverage/iffy/if_else.cov-map similarity index 100% rename from tests/coverage/if_else.cov-map rename to tests/coverage/iffy/if_else.cov-map diff --git a/tests/coverage/if_else.coverage b/tests/coverage/iffy/if_else.coverage similarity index 100% rename from tests/coverage/if_else.coverage rename to tests/coverage/iffy/if_else.coverage diff --git a/tests/coverage/if_else.rs b/tests/coverage/iffy/if_else.rs similarity index 100% rename from tests/coverage/if_else.rs rename to tests/coverage/iffy/if_else.rs diff --git a/tests/coverage/inline-dead.cov-map b/tests/coverage/iffy/inline-dead.cov-map similarity index 100% rename from tests/coverage/inline-dead.cov-map rename to tests/coverage/iffy/inline-dead.cov-map diff --git a/tests/coverage/inline-dead.coverage b/tests/coverage/iffy/inline-dead.coverage similarity index 100% rename from tests/coverage/inline-dead.coverage rename to tests/coverage/iffy/inline-dead.coverage diff --git a/tests/coverage/inline-dead.rs b/tests/coverage/iffy/inline-dead.rs similarity index 100% rename from tests/coverage/inline-dead.rs rename to tests/coverage/iffy/inline-dead.rs diff --git a/tests/coverage/inline.cov-map b/tests/coverage/iffy/inline.cov-map similarity index 100% rename from tests/coverage/inline.cov-map rename to tests/coverage/iffy/inline.cov-map diff --git a/tests/coverage/inline.coverage b/tests/coverage/iffy/inline.coverage similarity index 100% rename from tests/coverage/inline.coverage rename to tests/coverage/iffy/inline.coverage diff --git a/tests/coverage/inline.rs b/tests/coverage/iffy/inline.rs similarity index 100% rename from tests/coverage/inline.rs rename to tests/coverage/iffy/inline.rs diff --git a/tests/coverage/inner_items.cov-map b/tests/coverage/iffy/inner_items.cov-map similarity index 100% rename from tests/coverage/inner_items.cov-map rename to tests/coverage/iffy/inner_items.cov-map diff --git a/tests/coverage/inner_items.coverage b/tests/coverage/iffy/inner_items.coverage similarity index 100% rename from tests/coverage/inner_items.coverage rename to tests/coverage/iffy/inner_items.coverage diff --git a/tests/coverage/inner_items.rs b/tests/coverage/iffy/inner_items.rs similarity index 100% rename from tests/coverage/inner_items.rs rename to tests/coverage/iffy/inner_items.rs diff --git a/tests/coverage/issue-83601.cov-map b/tests/coverage/iffy/issue-83601.cov-map similarity index 100% rename from tests/coverage/issue-83601.cov-map rename to tests/coverage/iffy/issue-83601.cov-map diff --git a/tests/coverage/issue-83601.coverage b/tests/coverage/iffy/issue-83601.coverage similarity index 100% rename from tests/coverage/issue-83601.coverage rename to tests/coverage/iffy/issue-83601.coverage diff --git a/tests/coverage/issue-83601.rs b/tests/coverage/iffy/issue-83601.rs similarity index 100% rename from tests/coverage/issue-83601.rs rename to tests/coverage/iffy/issue-83601.rs diff --git a/tests/coverage/issue-84561.cov-map b/tests/coverage/iffy/issue-84561.cov-map similarity index 100% rename from tests/coverage/issue-84561.cov-map rename to tests/coverage/iffy/issue-84561.cov-map diff --git a/tests/coverage/issue-84561.coverage b/tests/coverage/iffy/issue-84561.coverage similarity index 100% rename from tests/coverage/issue-84561.coverage rename to tests/coverage/iffy/issue-84561.coverage diff --git a/tests/coverage/issue-84561.rs b/tests/coverage/iffy/issue-84561.rs similarity index 100% rename from tests/coverage/issue-84561.rs rename to tests/coverage/iffy/issue-84561.rs diff --git a/tests/coverage/issue-85461.cov-map b/tests/coverage/iffy/issue-85461.cov-map similarity index 100% rename from tests/coverage/issue-85461.cov-map rename to tests/coverage/iffy/issue-85461.cov-map diff --git a/tests/coverage/issue-85461.coverage b/tests/coverage/iffy/issue-85461.coverage similarity index 100% rename from tests/coverage/issue-85461.coverage rename to tests/coverage/iffy/issue-85461.coverage diff --git a/tests/coverage/issue-85461.rs b/tests/coverage/iffy/issue-85461.rs similarity index 100% rename from tests/coverage/issue-85461.rs rename to tests/coverage/iffy/issue-85461.rs diff --git a/tests/coverage/issue-93054.cov-map b/tests/coverage/iffy/issue-93054.cov-map similarity index 100% rename from tests/coverage/issue-93054.cov-map rename to tests/coverage/iffy/issue-93054.cov-map diff --git a/tests/coverage/issue-93054.coverage b/tests/coverage/iffy/issue-93054.coverage similarity index 100% rename from tests/coverage/issue-93054.coverage rename to tests/coverage/iffy/issue-93054.coverage diff --git a/tests/coverage/issue-93054.rs b/tests/coverage/iffy/issue-93054.rs similarity index 100% rename from tests/coverage/issue-93054.rs rename to tests/coverage/iffy/issue-93054.rs diff --git a/tests/coverage/lazy_boolean.cov-map b/tests/coverage/iffy/lazy_boolean.cov-map similarity index 100% rename from tests/coverage/lazy_boolean.cov-map rename to tests/coverage/iffy/lazy_boolean.cov-map diff --git a/tests/coverage/lazy_boolean.coverage b/tests/coverage/iffy/lazy_boolean.coverage similarity index 100% rename from tests/coverage/lazy_boolean.coverage rename to tests/coverage/iffy/lazy_boolean.coverage diff --git a/tests/coverage/lazy_boolean.rs b/tests/coverage/iffy/lazy_boolean.rs similarity index 100% rename from tests/coverage/lazy_boolean.rs rename to tests/coverage/iffy/lazy_boolean.rs diff --git a/tests/coverage/loops_branches.cov-map b/tests/coverage/iffy/loops_branches.cov-map similarity index 100% rename from tests/coverage/loops_branches.cov-map rename to tests/coverage/iffy/loops_branches.cov-map diff --git a/tests/coverage/loops_branches.coverage b/tests/coverage/iffy/loops_branches.coverage similarity index 100% rename from tests/coverage/loops_branches.coverage rename to tests/coverage/iffy/loops_branches.coverage diff --git a/tests/coverage/loops_branches.rs b/tests/coverage/iffy/loops_branches.rs similarity index 100% rename from tests/coverage/loops_branches.rs rename to tests/coverage/iffy/loops_branches.rs diff --git a/tests/coverage/match_or_pattern.cov-map b/tests/coverage/iffy/match_or_pattern.cov-map similarity index 100% rename from tests/coverage/match_or_pattern.cov-map rename to tests/coverage/iffy/match_or_pattern.cov-map diff --git a/tests/coverage/match_or_pattern.coverage b/tests/coverage/iffy/match_or_pattern.coverage similarity index 100% rename from tests/coverage/match_or_pattern.coverage rename to tests/coverage/iffy/match_or_pattern.coverage diff --git a/tests/coverage/match_or_pattern.rs b/tests/coverage/iffy/match_or_pattern.rs similarity index 100% rename from tests/coverage/match_or_pattern.rs rename to tests/coverage/iffy/match_or_pattern.rs diff --git a/tests/coverage/nested_loops.cov-map b/tests/coverage/iffy/nested_loops.cov-map similarity index 100% rename from tests/coverage/nested_loops.cov-map rename to tests/coverage/iffy/nested_loops.cov-map diff --git a/tests/coverage/nested_loops.coverage b/tests/coverage/iffy/nested_loops.coverage similarity index 100% rename from tests/coverage/nested_loops.coverage rename to tests/coverage/iffy/nested_loops.coverage diff --git a/tests/coverage/nested_loops.rs b/tests/coverage/iffy/nested_loops.rs similarity index 100% rename from tests/coverage/nested_loops.rs rename to tests/coverage/iffy/nested_loops.rs diff --git a/tests/coverage/no_cov_crate.cov-map b/tests/coverage/iffy/no_cov_crate.cov-map similarity index 100% rename from tests/coverage/no_cov_crate.cov-map rename to tests/coverage/iffy/no_cov_crate.cov-map diff --git a/tests/coverage/no_cov_crate.coverage b/tests/coverage/iffy/no_cov_crate.coverage similarity index 100% rename from tests/coverage/no_cov_crate.coverage rename to tests/coverage/iffy/no_cov_crate.coverage diff --git a/tests/coverage/no_cov_crate.rs b/tests/coverage/iffy/no_cov_crate.rs similarity index 100% rename from tests/coverage/no_cov_crate.rs rename to tests/coverage/iffy/no_cov_crate.rs diff --git a/tests/coverage/overflow.cov-map b/tests/coverage/iffy/overflow.cov-map similarity index 100% rename from tests/coverage/overflow.cov-map rename to tests/coverage/iffy/overflow.cov-map diff --git a/tests/coverage/overflow.coverage b/tests/coverage/iffy/overflow.coverage similarity index 100% rename from tests/coverage/overflow.coverage rename to tests/coverage/iffy/overflow.coverage diff --git a/tests/coverage/overflow.rs b/tests/coverage/iffy/overflow.rs similarity index 100% rename from tests/coverage/overflow.rs rename to tests/coverage/iffy/overflow.rs diff --git a/tests/coverage/panic_unwind.cov-map b/tests/coverage/iffy/panic_unwind.cov-map similarity index 100% rename from tests/coverage/panic_unwind.cov-map rename to tests/coverage/iffy/panic_unwind.cov-map diff --git a/tests/coverage/panic_unwind.coverage b/tests/coverage/iffy/panic_unwind.coverage similarity index 100% rename from tests/coverage/panic_unwind.coverage rename to tests/coverage/iffy/panic_unwind.coverage diff --git a/tests/coverage/panic_unwind.rs b/tests/coverage/iffy/panic_unwind.rs similarity index 100% rename from tests/coverage/panic_unwind.rs rename to tests/coverage/iffy/panic_unwind.rs diff --git a/tests/coverage/partial_eq.cov-map b/tests/coverage/iffy/partial_eq.cov-map similarity index 100% rename from tests/coverage/partial_eq.cov-map rename to tests/coverage/iffy/partial_eq.cov-map diff --git a/tests/coverage/partial_eq.coverage b/tests/coverage/iffy/partial_eq.coverage similarity index 100% rename from tests/coverage/partial_eq.coverage rename to tests/coverage/iffy/partial_eq.coverage diff --git a/tests/coverage/partial_eq.rs b/tests/coverage/iffy/partial_eq.rs similarity index 100% rename from tests/coverage/partial_eq.rs rename to tests/coverage/iffy/partial_eq.rs diff --git a/tests/coverage/simple_loop.cov-map b/tests/coverage/iffy/simple_loop.cov-map similarity index 100% rename from tests/coverage/simple_loop.cov-map rename to tests/coverage/iffy/simple_loop.cov-map diff --git a/tests/coverage/simple_loop.coverage b/tests/coverage/iffy/simple_loop.coverage similarity index 100% rename from tests/coverage/simple_loop.coverage rename to tests/coverage/iffy/simple_loop.coverage diff --git a/tests/coverage/simple_loop.rs b/tests/coverage/iffy/simple_loop.rs similarity index 100% rename from tests/coverage/simple_loop.rs rename to tests/coverage/iffy/simple_loop.rs diff --git a/tests/coverage/simple_match.cov-map b/tests/coverage/iffy/simple_match.cov-map similarity index 100% rename from tests/coverage/simple_match.cov-map rename to tests/coverage/iffy/simple_match.cov-map diff --git a/tests/coverage/simple_match.coverage b/tests/coverage/iffy/simple_match.coverage similarity index 100% rename from tests/coverage/simple_match.coverage rename to tests/coverage/iffy/simple_match.coverage diff --git a/tests/coverage/simple_match.rs b/tests/coverage/iffy/simple_match.rs similarity index 100% rename from tests/coverage/simple_match.rs rename to tests/coverage/iffy/simple_match.rs diff --git a/tests/coverage/try_error_result.cov-map b/tests/coverage/iffy/try_error_result.cov-map similarity index 100% rename from tests/coverage/try_error_result.cov-map rename to tests/coverage/iffy/try_error_result.cov-map diff --git a/tests/coverage/try_error_result.coverage b/tests/coverage/iffy/try_error_result.coverage similarity index 100% rename from tests/coverage/try_error_result.coverage rename to tests/coverage/iffy/try_error_result.coverage diff --git a/tests/coverage/try_error_result.rs b/tests/coverage/iffy/try_error_result.rs similarity index 100% rename from tests/coverage/try_error_result.rs rename to tests/coverage/iffy/try_error_result.rs diff --git a/tests/coverage/uses_crate.cov-map b/tests/coverage/iffy/uses_crate.cov-map similarity index 100% rename from tests/coverage/uses_crate.cov-map rename to tests/coverage/iffy/uses_crate.cov-map diff --git a/tests/coverage/uses_crate.coverage b/tests/coverage/iffy/uses_crate.coverage similarity index 100% rename from tests/coverage/uses_crate.coverage rename to tests/coverage/iffy/uses_crate.coverage diff --git a/tests/coverage/uses_crate.rs b/tests/coverage/iffy/uses_crate.rs similarity index 100% rename from tests/coverage/uses_crate.rs rename to tests/coverage/iffy/uses_crate.rs diff --git a/tests/coverage/uses_inline_crate.cov-map b/tests/coverage/iffy/uses_inline_crate.cov-map similarity index 100% rename from tests/coverage/uses_inline_crate.cov-map rename to tests/coverage/iffy/uses_inline_crate.cov-map diff --git a/tests/coverage/uses_inline_crate.coverage b/tests/coverage/iffy/uses_inline_crate.coverage similarity index 100% rename from tests/coverage/uses_inline_crate.coverage rename to tests/coverage/iffy/uses_inline_crate.coverage diff --git a/tests/coverage/uses_inline_crate.rs b/tests/coverage/iffy/uses_inline_crate.rs similarity index 100% rename from tests/coverage/uses_inline_crate.rs rename to tests/coverage/iffy/uses_inline_crate.rs diff --git a/tests/coverage/iffy/while.cov-map b/tests/coverage/iffy/while.cov-map new file mode 100644 index 0000000000000..c4183e18e021d --- /dev/null +++ b/tests/coverage/iffy/while.cov-map @@ -0,0 +1,14 @@ +Function name: while::main +Raw bytes (34): 0x[01, 01, 00, 06, 01, 01, 01, 00, 0a, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 10, 01, 01, 0b, 00, 14, 00, 00, 15, 02, 06, 01, 03, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/while.rs +Number of expressions: 0 +Number of file 0 mappings: 6 +- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 10) +- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 12) +- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16) +- Code(Counter(0)) at (prev + 1, 11) to (start + 0, 20) +- Code(Zero) at (prev + 0, 21) to (start + 2, 6) +- Code(Counter(0)) at (prev + 3, 1) to (start + 0, 2) +Highest counter ID seen: c0 + diff --git a/tests/coverage/iffy/while.coverage b/tests/coverage/iffy/while.coverage new file mode 100644 index 0000000000000..90c16288d668c --- /dev/null +++ b/tests/coverage/iffy/while.coverage @@ -0,0 +1,7 @@ + LL| 1|fn main() { + LL| 1| let num = 9; + LL| 1| while num >= 10 { + LL| 0| // loop body + LL| 0| } + LL| 1|} + diff --git a/tests/coverage/iffy/while.rs b/tests/coverage/iffy/while.rs new file mode 100644 index 0000000000000..d60916a979818 --- /dev/null +++ b/tests/coverage/iffy/while.rs @@ -0,0 +1,6 @@ +fn main() { + let num = 9; + while num >= 10 { + // loop body + } +} diff --git a/tests/coverage/while_early_ret.cov-map b/tests/coverage/iffy/while_early_ret.cov-map similarity index 100% rename from tests/coverage/while_early_ret.cov-map rename to tests/coverage/iffy/while_early_ret.cov-map diff --git a/tests/coverage/while_early_ret.coverage b/tests/coverage/iffy/while_early_ret.coverage similarity index 100% rename from tests/coverage/while_early_ret.coverage rename to tests/coverage/iffy/while_early_ret.coverage diff --git a/tests/coverage/while_early_ret.rs b/tests/coverage/iffy/while_early_ret.rs similarity index 100% rename from tests/coverage/while_early_ret.rs rename to tests/coverage/iffy/while_early_ret.rs diff --git a/tests/coverage/yield.cov-map b/tests/coverage/iffy/yield.cov-map similarity index 100% rename from tests/coverage/yield.cov-map rename to tests/coverage/iffy/yield.cov-map diff --git a/tests/coverage/yield.coverage b/tests/coverage/iffy/yield.coverage similarity index 100% rename from tests/coverage/yield.coverage rename to tests/coverage/iffy/yield.coverage diff --git a/tests/coverage/yield.rs b/tests/coverage/iffy/yield.rs similarity index 100% rename from tests/coverage/yield.rs rename to tests/coverage/iffy/yield.rs diff --git a/tests/coverage/let-else.none.cov-map b/tests/coverage/let-else.none.cov-map new file mode 100644 index 0000000000000..af5b34cb36f79 --- /dev/null +++ b/tests/coverage/let-else.none.cov-map @@ -0,0 +1,38 @@ +Function name: let_else::let_else_no_semi +Raw bytes (41): 0x[01, 01, 01, 01, 05, 07, 01, 10, 01, 00, 2b, 02, 01, 0e, 00, 11, 01, 00, 15, 00, 1c, 05, 01, 09, 00, 0f, 02, 02, 05, 00, 08, 02, 00, 09, 00, 0c, 01, 01, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/let-else.rs +Number of expressions: 1 +- expression 0 operands: lhs = Counter(0), rhs = Counter(1) +Number of file 0 mappings: 7 +- Code(Counter(0)) at (prev + 16, 1) to (start + 0, 43) +- Code(Expression(0, Sub)) at (prev + 1, 14) to (start + 0, 17) + = (c0 - c1) +- Code(Counter(0)) at (prev + 0, 21) to (start + 0, 28) +- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 15) +- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 8) + = (c0 - c1) +- Code(Expression(0, Sub)) at (prev + 0, 9) to (start + 0, 12) + = (c0 - c1) +- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c1 + +Function name: let_else::let_else_semi +Raw bytes (41): 0x[01, 01, 01, 01, 05, 07, 01, 08, 01, 00, 28, 02, 01, 0e, 00, 11, 01, 00, 15, 00, 1c, 05, 01, 09, 00, 0f, 02, 02, 05, 00, 08, 02, 00, 09, 00, 0c, 01, 01, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/let-else.rs +Number of expressions: 1 +- expression 0 operands: lhs = Counter(0), rhs = Counter(1) +Number of file 0 mappings: 7 +- Code(Counter(0)) at (prev + 8, 1) to (start + 0, 40) +- Code(Expression(0, Sub)) at (prev + 1, 14) to (start + 0, 17) + = (c0 - c1) +- Code(Counter(0)) at (prev + 0, 21) to (start + 0, 28) +- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 15) +- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 8) + = (c0 - c1) +- Code(Expression(0, Sub)) at (prev + 0, 9) to (start + 0, 12) + = (c0 - c1) +- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c1 + diff --git a/tests/coverage/let-else.none.coverage b/tests/coverage/let-else.none.coverage new file mode 100644 index 0000000000000..a24877eb90a03 --- /dev/null +++ b/tests/coverage/let-else.none.coverage @@ -0,0 +1,39 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ revisions: none some + LL| |//@[some] ignore-coverage-map + LL| | + LL| |// Basic test for let-else statements. + LL| | + LL| 1|fn let_else_semi(opt_msg: Option<&str>) { + LL| 1| let Some(msg) = opt_msg else { + ^0 + LL| 1| return; + LL| | }; + LL| 0| say(msg); + LL| 1|} + LL| | + LL| |#[rustfmt::skip] + LL| 1|fn let_else_no_semi(opt_msg: Option<&str>) { + LL| 1| let Some(msg) = opt_msg else { + ^0 + LL| 1| return + LL| | }; + LL| 0| say(msg); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let opt_msg = cfg_select!( + LL| | some => Some("hello"), + LL| | none => None, + LL| | ); + LL| | let_else_semi(opt_msg); + LL| | let_else_no_semi(opt_msg); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/let-else.rs b/tests/coverage/let-else.rs new file mode 100644 index 0000000000000..0ebef52d649c7 --- /dev/null +++ b/tests/coverage/let-else.rs @@ -0,0 +1,36 @@ +#![feature(coverage_attribute)] +//@ edition: 2024 +//@ revisions: none some +//@[some] ignore-coverage-map + +// Basic test for let-else statements. + +fn let_else_semi(opt_msg: Option<&str>) { + let Some(msg) = opt_msg else { + return; + }; + say(msg); +} + +#[rustfmt::skip] +fn let_else_no_semi(opt_msg: Option<&str>) { + let Some(msg) = opt_msg else { + return + }; + say(msg); +} + +#[coverage(off)] +fn main() { + let opt_msg = cfg_select!( + some => Some("hello"), + none => None, + ); + let_else_semi(opt_msg); + let_else_no_semi(opt_msg); +} + +#[coverage(off)] +fn say(msg: &str) { + println!("{msg}"); +} diff --git a/tests/coverage/let-else.some.coverage b/tests/coverage/let-else.some.coverage new file mode 100644 index 0000000000000..828731b199f95 --- /dev/null +++ b/tests/coverage/let-else.some.coverage @@ -0,0 +1,37 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| |//@ revisions: none some + LL| |//@[some] ignore-coverage-map + LL| | + LL| |// Basic test for let-else statements. + LL| | + LL| 1|fn let_else_semi(opt_msg: Option<&str>) { + LL| 1| let Some(msg) = opt_msg else { + LL| 0| return; + LL| | }; + LL| 1| say(msg); + LL| 1|} + LL| | + LL| |#[rustfmt::skip] + LL| 1|fn let_else_no_semi(opt_msg: Option<&str>) { + LL| 1| let Some(msg) = opt_msg else { + LL| 0| return + LL| | }; + LL| 1| say(msg); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | let opt_msg = cfg_select!( + LL| | some => Some("hello"), + LL| | none => None, + LL| | ); + LL| | let_else_semi(opt_msg); + LL| | let_else_no_semi(opt_msg); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/match.cov-map b/tests/coverage/match.cov-map new file mode 100644 index 0000000000000..ac9433fda2dcb --- /dev/null +++ b/tests/coverage/match.cov-map @@ -0,0 +1,49 @@ +Function name: match::match_expr +Raw bytes (131): 0x[01, 01, 0b, 1d, 07, 0b, 19, 0f, 15, 05, 0d, 0d, 11, 0d, 11, 05, 09, 05, 09, 05, 09, 01, 1d, 01, 1d, 15, 01, 06, 01, 00, 2a, 0d, 01, 0b, 00, 0c, 02, 01, 14, 00, 17, 02, 00, 18, 00, 1e, 19, 03, 0d, 00, 10, 19, 00, 11, 00, 16, 15, 02, 14, 02, 0a, 11, 03, 17, 00, 18, 11, 00, 1c, 02, 0a, 16, 03, 14, 00, 17, 16, 00, 18, 00, 1f, 09, 01, 0e, 00, 13, 05, 00, 18, 00, 1d, 09, 00, 21, 00, 22, 09, 00, 26, 02, 0a, 22, 03, 0e, 00, 13, 22, 00, 18, 00, 1b, 22, 00, 1c, 00, 23, 2a, 01, 11, 00, 14, 2a, 00, 15, 00, 1b, 01, 02, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/match.rs +Number of expressions: 11 +- expression 0 operands: lhs = Counter(7), rhs = Expression(1, Add) +- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(6) +- expression 2 operands: lhs = Expression(3, Add), rhs = Counter(5) +- expression 3 operands: lhs = Counter(1), rhs = Counter(3) +- expression 4 operands: lhs = Counter(3), rhs = Counter(4) +- expression 5 operands: lhs = Counter(3), rhs = Counter(4) +- expression 6 operands: lhs = Counter(1), rhs = Counter(2) +- expression 7 operands: lhs = Counter(1), rhs = Counter(2) +- expression 8 operands: lhs = Counter(1), rhs = Counter(2) +- expression 9 operands: lhs = Counter(0), rhs = Counter(7) +- expression 10 operands: lhs = Counter(0), rhs = Counter(7) +Number of file 0 mappings: 21 +- Code(Counter(0)) at (prev + 6, 1) to (start + 0, 42) +- Code(Counter(3)) at (prev + 1, 11) to (start + 0, 12) +- Code(Expression(0, Sub)) at (prev + 1, 20) to (start + 0, 23) + = (c7 - (((c1 + c3) + c5) + c6)) +- Code(Expression(0, Sub)) at (prev + 0, 24) to (start + 0, 30) + = (c7 - (((c1 + c3) + c5) + c6)) +- Code(Counter(6)) at (prev + 3, 13) to (start + 0, 16) +- Code(Counter(6)) at (prev + 0, 17) to (start + 0, 22) +- Code(Counter(5)) at (prev + 2, 20) to (start + 2, 10) +- Code(Counter(4)) at (prev + 3, 23) to (start + 0, 24) +- Code(Counter(4)) at (prev + 0, 28) to (start + 2, 10) +- Code(Expression(5, Sub)) at (prev + 3, 20) to (start + 0, 23) + = (c3 - c4) +- Code(Expression(5, Sub)) at (prev + 0, 24) to (start + 0, 31) + = (c3 - c4) +- Code(Counter(2)) at (prev + 1, 14) to (start + 0, 19) +- Code(Counter(1)) at (prev + 0, 24) to (start + 0, 29) +- Code(Counter(2)) at (prev + 0, 33) to (start + 0, 34) +- Code(Counter(2)) at (prev + 0, 38) to (start + 2, 10) +- Code(Expression(8, Sub)) at (prev + 3, 14) to (start + 0, 19) + = (c1 - c2) +- Code(Expression(8, Sub)) at (prev + 0, 24) to (start + 0, 27) + = (c1 - c2) +- Code(Expression(8, Sub)) at (prev + 0, 28) to (start + 0, 35) + = (c1 - c2) +- Code(Expression(10, Sub)) at (prev + 1, 17) to (start + 0, 20) + = (c0 - c7) +- Code(Expression(10, Sub)) at (prev + 0, 21) to (start + 0, 27) + = (c0 - c7) +- Code(Counter(0)) at (prev + 2, 1) to (start + 0, 2) +Highest counter ID seen: c6 + diff --git a/tests/coverage/match.coverage b/tests/coverage/match.coverage new file mode 100644 index 0000000000000..a69a8652b3c75 --- /dev/null +++ b/tests/coverage/match.coverage @@ -0,0 +1,43 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| | + LL| |// Basic test for `match` expressions with various kinds of arms and guards. + LL| | + LL| 16|fn match_expr(x: Option, cond: bool) { + LL| 3| match x { + LL| 0| Some(0) => say("zero"), + LL| | Some(1) => { + LL| | // (block with a trailing expression) + LL| 1| say("one") + LL| | } + LL| 2| Some(2) => { + LL| 2| say("two"); + LL| 2| } + LL| 0| Some(3) if cond => { + LL| 0| say("three-cond"); + LL| 0| } + LL| 3| Some(3) => say("three"), + LL| 9| Some(other) if other == 4 => { + ^4 ^4 + LL| 4| say("four"); + LL| 4| } + LL| 5| Some(other) => say("other"), + LL| 1| None => say("none"), + LL| | } + LL| 16|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | for i in 0..=5 { + LL| | for _ in 0..i { + LL| | match_expr(Some(i), false); + LL| | } + LL| | } + LL| | match_expr(None, true); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} + diff --git a/tests/coverage/match.rs b/tests/coverage/match.rs new file mode 100644 index 0000000000000..c9d4fd75bdc18 --- /dev/null +++ b/tests/coverage/match.rs @@ -0,0 +1,41 @@ +#![feature(coverage_attribute)] +//@ edition: 2024 + +// Basic test for `match` expressions with various kinds of arms and guards. + +fn match_expr(x: Option, cond: bool) { + match x { + Some(0) => say("zero"), + Some(1) => { + // (block with a trailing expression) + say("one") + } + Some(2) => { + say("two"); + } + Some(3) if cond => { + say("three-cond"); + } + Some(3) => say("three"), + Some(other) if other == 4 => { + say("four"); + } + Some(other) => say("other"), + None => say("none"), + } +} + +#[coverage(off)] +fn main() { + for i in 0..=5 { + for _ in 0..i { + match_expr(Some(i), false); + } + } + match_expr(None, true); +} + +#[coverage(off)] +fn say(msg: &str) { + println!("{msg}"); +} diff --git a/tests/coverage/while.cov-map b/tests/coverage/while.cov-map index c4183e18e021d..52bef0a80dfb1 100644 --- a/tests/coverage/while.cov-map +++ b/tests/coverage/while.cov-map @@ -1,14 +1,42 @@ -Function name: while::main -Raw bytes (34): 0x[01, 01, 00, 06, 01, 01, 01, 00, 0a, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 10, 01, 01, 0b, 00, 14, 00, 00, 15, 02, 06, 01, 03, 01, 00, 02] +Function name: while::while_with_tail_expr +Raw bytes (56): 0x[01, 01, 01, 05, 01, 0a, 01, 06, 01, 00, 1a, 01, 01, 09, 00, 0e, 01, 00, 11, 00, 12, 05, 01, 0b, 00, 10, 02, 01, 09, 00, 0f, 02, 01, 09, 00, 0c, 02, 00, 0d, 00, 1a, 01, 02, 05, 00, 08, 01, 00, 09, 00, 12, 01, 01, 01, 00, 02] Number of files: 1 - file 0 => $DIR/while.rs -Number of expressions: 0 -Number of file 0 mappings: 6 -- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 10) -- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 12) -- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16) -- Code(Counter(0)) at (prev + 1, 11) to (start + 0, 20) -- Code(Zero) at (prev + 0, 21) to (start + 2, 6) -- Code(Counter(0)) at (prev + 3, 1) to (start + 0, 2) -Highest counter ID seen: c0 +Number of expressions: 1 +- expression 0 operands: lhs = Counter(1), rhs = Counter(0) +Number of file 0 mappings: 10 +- Code(Counter(0)) at (prev + 6, 1) to (start + 0, 26) +- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 14) +- Code(Counter(0)) at (prev + 0, 17) to (start + 0, 18) +- Code(Counter(1)) at (prev + 1, 11) to (start + 0, 16) +- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 15) + = (c1 - c0) +- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 12) + = (c1 - c0) +- Code(Expression(0, Sub)) at (prev + 0, 13) to (start + 0, 26) + = (c1 - c0) +- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 8) +- Code(Counter(0)) at (prev + 0, 9) to (start + 0, 18) +- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c1 + +Function name: while::while_with_tail_stmt +Raw bytes (51): 0x[01, 01, 01, 05, 01, 09, 01, 0f, 01, 00, 1a, 01, 01, 09, 00, 0e, 01, 00, 11, 00, 12, 05, 01, 0b, 00, 10, 02, 00, 11, 03, 06, 02, 01, 09, 00, 0f, 01, 03, 05, 00, 08, 01, 00, 09, 00, 12, 01, 01, 01, 00, 02] +Number of files: 1 +- file 0 => $DIR/while.rs +Number of expressions: 1 +- expression 0 operands: lhs = Counter(1), rhs = Counter(0) +Number of file 0 mappings: 9 +- Code(Counter(0)) at (prev + 15, 1) to (start + 0, 26) +- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 14) +- Code(Counter(0)) at (prev + 0, 17) to (start + 0, 18) +- Code(Counter(1)) at (prev + 1, 11) to (start + 0, 16) +- Code(Expression(0, Sub)) at (prev + 0, 17) to (start + 3, 6) + = (c1 - c0) +- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 15) + = (c1 - c0) +- Code(Counter(0)) at (prev + 3, 5) to (start + 0, 8) +- Code(Counter(0)) at (prev + 0, 9) to (start + 0, 18) +- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2) +Highest counter ID seen: c1 diff --git a/tests/coverage/while.coverage b/tests/coverage/while.coverage index 90c16288d668c..a83198bbc675e 100644 --- a/tests/coverage/while.coverage +++ b/tests/coverage/while.coverage @@ -1,7 +1,34 @@ - LL| 1|fn main() { - LL| 1| let num = 9; - LL| 1| while num >= 10 { - LL| 0| // loop body - LL| 0| } + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| | + LL| |// Basic test for `while` expressions. + LL| | + LL| 1|fn while_with_tail_expr() { + LL| 1| let mut x = 5; + LL| 6| while x > 0 { + LL| 5| x -= 1; + LL| 5| say("decreased x") + LL| | } + LL| 1| say("goodbye"); LL| 1|} + LL| | + LL| 1|fn while_with_tail_stmt() { + LL| 1| let mut x = 5; + LL| 6| while x > 0 { + LL| 5| x -= 1; + LL| 5| say("decreased x"); + LL| 5| } + LL| 1| say("goodbye"); + LL| 1|} + LL| | + LL| |#[coverage(off)] + LL| |fn main() { + LL| | while_with_tail_expr(); + LL| | while_with_tail_stmt(); + LL| |} + LL| | + LL| |#[coverage(off)] + LL| |fn say(msg: &str) { + LL| | println!("{msg}"); + LL| |} diff --git a/tests/coverage/while.rs b/tests/coverage/while.rs index d60916a979818..77ef50d09a6ac 100644 --- a/tests/coverage/while.rs +++ b/tests/coverage/while.rs @@ -1,6 +1,33 @@ -fn main() { - let num = 9; - while num >= 10 { - // loop body +#![feature(coverage_attribute)] +//@ edition: 2024 + +// Basic test for `while` expressions. + +fn while_with_tail_expr() { + let mut x = 5; + while x > 0 { + x -= 1; + say("decreased x") + } + say("goodbye"); +} + +fn while_with_tail_stmt() { + let mut x = 5; + while x > 0 { + x -= 1; + say("decreased x"); } + say("goodbye"); +} + +#[coverage(off)] +fn main() { + while_with_tail_expr(); + while_with_tail_stmt(); +} + +#[coverage(off)] +fn say(msg: &str) { + println!("{msg}"); }