From 40c04ee8390ffccf67c67e7f2bb70d77175d4c35 Mon Sep 17 00:00:00 2001 From: Zalathar Date: Wed, 2 Sep 2026 14:15:19 +1000 Subject: [PATCH 1/3] Move async tests into `tests/coverage/async` --- tests/coverage/{ => async}/async.cov-map | 0 tests/coverage/{ => async}/async.coverage | 0 tests/coverage/{ => async}/async.rs | 0 tests/coverage/{ => async}/async2.cov-map | 0 tests/coverage/{ => async}/async2.coverage | 0 tests/coverage/{ => async}/async2.rs | 0 tests/coverage/{ => async}/async_block.cov-map | 0 tests/coverage/{ => async}/async_block.coverage | 0 tests/coverage/{ => async}/async_block.rs | 0 tests/coverage/{ => async}/async_closure.cov-map | 0 tests/coverage/{ => async}/async_closure.coverage | 0 tests/coverage/{ => async}/async_closure.rs | 0 tests/coverage/{ => async}/async_closure2.cov-map | 0 tests/coverage/{ => async}/async_closure2.coverage | 0 tests/coverage/{ => async}/async_closure2.rs | 0 tests/coverage/{ => async}/auxiliary/executor.rs | 0 tests/coverage/{ => async}/await_ready.cov-map | 0 tests/coverage/{ => async}/await_ready.coverage | 0 tests/coverage/{ => async}/await_ready.rs | 0 tests/coverage/{ => async}/closure_macro_async.cov-map | 0 tests/coverage/{ => async}/closure_macro_async.coverage | 0 tests/coverage/{ => async}/closure_macro_async.rs | 0 22 files changed, 0 insertions(+), 0 deletions(-) rename tests/coverage/{ => async}/async.cov-map (100%) rename tests/coverage/{ => async}/async.coverage (100%) rename tests/coverage/{ => async}/async.rs (100%) rename tests/coverage/{ => async}/async2.cov-map (100%) rename tests/coverage/{ => async}/async2.coverage (100%) rename tests/coverage/{ => async}/async2.rs (100%) rename tests/coverage/{ => async}/async_block.cov-map (100%) rename tests/coverage/{ => async}/async_block.coverage (100%) rename tests/coverage/{ => async}/async_block.rs (100%) rename tests/coverage/{ => async}/async_closure.cov-map (100%) rename tests/coverage/{ => async}/async_closure.coverage (100%) rename tests/coverage/{ => async}/async_closure.rs (100%) rename tests/coverage/{ => async}/async_closure2.cov-map (100%) rename tests/coverage/{ => async}/async_closure2.coverage (100%) rename tests/coverage/{ => async}/async_closure2.rs (100%) rename tests/coverage/{ => async}/auxiliary/executor.rs (100%) rename tests/coverage/{ => async}/await_ready.cov-map (100%) rename tests/coverage/{ => async}/await_ready.coverage (100%) rename tests/coverage/{ => async}/await_ready.rs (100%) rename tests/coverage/{ => async}/closure_macro_async.cov-map (100%) rename tests/coverage/{ => async}/closure_macro_async.coverage (100%) rename tests/coverage/{ => async}/closure_macro_async.rs (100%) 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 From c7c0eeaa3a4be33afc4770974f34983963bd0a5f Mon Sep 17 00:00:00 2001 From: Zalathar Date: Wed, 2 Sep 2026 14:15:19 +1000 Subject: [PATCH 2/3] Move some less-useful tests into `tests/coverage/iffy` These tests are of limited value for investigating specific problems, but still have some worth in detecting regressions by adding variety to the test corpus. (The boundary is a bit fuzzy, but it's easy enough to move tests back out if appropriate.) --- tests/coverage/iffy/README.md | 4 ++++ tests/coverage/{ => iffy}/abort.cov-map | 0 tests/coverage/{ => iffy}/abort.coverage | 0 tests/coverage/{ => iffy}/abort.rs | 0 tests/coverage/{ => iffy}/assert.cov-map | 0 tests/coverage/{ => iffy}/assert.coverage | 0 tests/coverage/{ => iffy}/assert.rs | 0 .../{ => iffy}/auxiliary/inline_always_with_dead_code.rs | 0 tests/coverage/{ => iffy}/auxiliary/used_crate.rs | 0 tests/coverage/{ => iffy}/auxiliary/used_inline_crate.rs | 0 tests/coverage/{ => iffy}/closure.cov-map | 0 tests/coverage/{ => iffy}/closure.coverage | 0 tests/coverage/{ => iffy}/closure.rs | 0 tests/coverage/{ => iffy}/closure_macro.cov-map | 0 tests/coverage/{ => iffy}/closure_macro.coverage | 0 tests/coverage/{ => iffy}/closure_macro.rs | 0 tests/coverage/{ => iffy}/conditions.cov-map | 0 tests/coverage/{ => iffy}/conditions.coverage | 0 tests/coverage/{ => iffy}/conditions.rs | 0 tests/coverage/{ => iffy}/continue.cov-map | 0 tests/coverage/{ => iffy}/continue.coverage | 0 tests/coverage/{ => iffy}/continue.rs | 0 tests/coverage/{ => iffy}/coroutine.cov-map | 0 tests/coverage/{ => iffy}/coroutine.coverage | 0 tests/coverage/{ => iffy}/coroutine.rs | 0 tests/coverage/{ => iffy}/drop_trait.cov-map | 0 tests/coverage/{ => iffy}/drop_trait.coverage | 0 tests/coverage/{ => iffy}/drop_trait.rs | 0 tests/coverage/{ => iffy}/generics.cov-map | 0 tests/coverage/{ => iffy}/generics.coverage | 0 tests/coverage/{ => iffy}/generics.rs | 0 tests/coverage/{ => iffy}/if.cov-map | 0 tests/coverage/{ => iffy}/if.coverage | 0 tests/coverage/{ => iffy}/if.rs | 0 tests/coverage/{ => iffy}/if_else.cov-map | 0 tests/coverage/{ => iffy}/if_else.coverage | 0 tests/coverage/{ => iffy}/if_else.rs | 0 tests/coverage/{ => iffy}/inline-dead.cov-map | 0 tests/coverage/{ => iffy}/inline-dead.coverage | 0 tests/coverage/{ => iffy}/inline-dead.rs | 0 tests/coverage/{ => iffy}/inline.cov-map | 0 tests/coverage/{ => iffy}/inline.coverage | 0 tests/coverage/{ => iffy}/inline.rs | 0 tests/coverage/{ => iffy}/inner_items.cov-map | 0 tests/coverage/{ => iffy}/inner_items.coverage | 0 tests/coverage/{ => iffy}/inner_items.rs | 0 tests/coverage/{ => iffy}/issue-83601.cov-map | 0 tests/coverage/{ => iffy}/issue-83601.coverage | 0 tests/coverage/{ => iffy}/issue-83601.rs | 0 tests/coverage/{ => iffy}/issue-84561.cov-map | 0 tests/coverage/{ => iffy}/issue-84561.coverage | 0 tests/coverage/{ => iffy}/issue-84561.rs | 0 tests/coverage/{ => iffy}/issue-85461.cov-map | 0 tests/coverage/{ => iffy}/issue-85461.coverage | 0 tests/coverage/{ => iffy}/issue-85461.rs | 0 tests/coverage/{ => iffy}/issue-93054.cov-map | 0 tests/coverage/{ => iffy}/issue-93054.coverage | 0 tests/coverage/{ => iffy}/issue-93054.rs | 0 tests/coverage/{ => iffy}/lazy_boolean.cov-map | 0 tests/coverage/{ => iffy}/lazy_boolean.coverage | 0 tests/coverage/{ => iffy}/lazy_boolean.rs | 0 tests/coverage/{ => iffy}/loops_branches.cov-map | 0 tests/coverage/{ => iffy}/loops_branches.coverage | 0 tests/coverage/{ => iffy}/loops_branches.rs | 0 tests/coverage/{ => iffy}/match_or_pattern.cov-map | 0 tests/coverage/{ => iffy}/match_or_pattern.coverage | 0 tests/coverage/{ => iffy}/match_or_pattern.rs | 0 tests/coverage/{ => iffy}/nested_loops.cov-map | 0 tests/coverage/{ => iffy}/nested_loops.coverage | 0 tests/coverage/{ => iffy}/nested_loops.rs | 0 tests/coverage/{ => iffy}/no_cov_crate.cov-map | 0 tests/coverage/{ => iffy}/no_cov_crate.coverage | 0 tests/coverage/{ => iffy}/no_cov_crate.rs | 0 tests/coverage/{ => iffy}/overflow.cov-map | 0 tests/coverage/{ => iffy}/overflow.coverage | 0 tests/coverage/{ => iffy}/overflow.rs | 0 tests/coverage/{ => iffy}/panic_unwind.cov-map | 0 tests/coverage/{ => iffy}/panic_unwind.coverage | 0 tests/coverage/{ => iffy}/panic_unwind.rs | 0 tests/coverage/{ => iffy}/partial_eq.cov-map | 0 tests/coverage/{ => iffy}/partial_eq.coverage | 0 tests/coverage/{ => iffy}/partial_eq.rs | 0 tests/coverage/{ => iffy}/simple_loop.cov-map | 0 tests/coverage/{ => iffy}/simple_loop.coverage | 0 tests/coverage/{ => iffy}/simple_loop.rs | 0 tests/coverage/{ => iffy}/simple_match.cov-map | 0 tests/coverage/{ => iffy}/simple_match.coverage | 0 tests/coverage/{ => iffy}/simple_match.rs | 0 tests/coverage/{ => iffy}/try_error_result.cov-map | 0 tests/coverage/{ => iffy}/try_error_result.coverage | 0 tests/coverage/{ => iffy}/try_error_result.rs | 0 tests/coverage/{ => iffy}/uses_crate.cov-map | 0 tests/coverage/{ => iffy}/uses_crate.coverage | 0 tests/coverage/{ => iffy}/uses_crate.rs | 0 tests/coverage/{ => iffy}/uses_inline_crate.cov-map | 0 tests/coverage/{ => iffy}/uses_inline_crate.coverage | 0 tests/coverage/{ => iffy}/uses_inline_crate.rs | 0 tests/coverage/{ => iffy}/while.cov-map | 0 tests/coverage/{ => iffy}/while.coverage | 0 tests/coverage/{ => iffy}/while.rs | 0 tests/coverage/{ => iffy}/while_early_ret.cov-map | 0 tests/coverage/{ => iffy}/while_early_ret.coverage | 0 tests/coverage/{ => iffy}/while_early_ret.rs | 0 tests/coverage/{ => iffy}/yield.cov-map | 0 tests/coverage/{ => iffy}/yield.coverage | 0 tests/coverage/{ => iffy}/yield.rs | 0 106 files changed, 4 insertions(+) create mode 100644 tests/coverage/iffy/README.md rename tests/coverage/{ => iffy}/abort.cov-map (100%) rename tests/coverage/{ => iffy}/abort.coverage (100%) rename tests/coverage/{ => iffy}/abort.rs (100%) rename tests/coverage/{ => iffy}/assert.cov-map (100%) rename tests/coverage/{ => iffy}/assert.coverage (100%) rename tests/coverage/{ => iffy}/assert.rs (100%) rename tests/coverage/{ => iffy}/auxiliary/inline_always_with_dead_code.rs (100%) rename tests/coverage/{ => iffy}/auxiliary/used_crate.rs (100%) rename tests/coverage/{ => iffy}/auxiliary/used_inline_crate.rs (100%) rename tests/coverage/{ => iffy}/closure.cov-map (100%) rename tests/coverage/{ => iffy}/closure.coverage (100%) rename tests/coverage/{ => iffy}/closure.rs (100%) rename tests/coverage/{ => iffy}/closure_macro.cov-map (100%) rename tests/coverage/{ => iffy}/closure_macro.coverage (100%) rename tests/coverage/{ => iffy}/closure_macro.rs (100%) rename tests/coverage/{ => iffy}/conditions.cov-map (100%) rename tests/coverage/{ => iffy}/conditions.coverage (100%) rename tests/coverage/{ => iffy}/conditions.rs (100%) rename tests/coverage/{ => iffy}/continue.cov-map (100%) rename tests/coverage/{ => iffy}/continue.coverage (100%) rename tests/coverage/{ => iffy}/continue.rs (100%) rename tests/coverage/{ => iffy}/coroutine.cov-map (100%) rename tests/coverage/{ => iffy}/coroutine.coverage (100%) rename tests/coverage/{ => iffy}/coroutine.rs (100%) rename tests/coverage/{ => iffy}/drop_trait.cov-map (100%) rename tests/coverage/{ => iffy}/drop_trait.coverage (100%) rename tests/coverage/{ => iffy}/drop_trait.rs (100%) rename tests/coverage/{ => iffy}/generics.cov-map (100%) rename tests/coverage/{ => iffy}/generics.coverage (100%) rename tests/coverage/{ => iffy}/generics.rs (100%) rename tests/coverage/{ => iffy}/if.cov-map (100%) rename tests/coverage/{ => iffy}/if.coverage (100%) rename tests/coverage/{ => iffy}/if.rs (100%) rename tests/coverage/{ => iffy}/if_else.cov-map (100%) rename tests/coverage/{ => iffy}/if_else.coverage (100%) rename tests/coverage/{ => iffy}/if_else.rs (100%) rename tests/coverage/{ => iffy}/inline-dead.cov-map (100%) rename tests/coverage/{ => iffy}/inline-dead.coverage (100%) rename tests/coverage/{ => iffy}/inline-dead.rs (100%) rename tests/coverage/{ => iffy}/inline.cov-map (100%) rename tests/coverage/{ => iffy}/inline.coverage (100%) rename tests/coverage/{ => iffy}/inline.rs (100%) rename tests/coverage/{ => iffy}/inner_items.cov-map (100%) rename tests/coverage/{ => iffy}/inner_items.coverage (100%) rename tests/coverage/{ => iffy}/inner_items.rs (100%) rename tests/coverage/{ => iffy}/issue-83601.cov-map (100%) rename tests/coverage/{ => iffy}/issue-83601.coverage (100%) rename tests/coverage/{ => iffy}/issue-83601.rs (100%) rename tests/coverage/{ => iffy}/issue-84561.cov-map (100%) rename tests/coverage/{ => iffy}/issue-84561.coverage (100%) rename tests/coverage/{ => iffy}/issue-84561.rs (100%) rename tests/coverage/{ => iffy}/issue-85461.cov-map (100%) rename tests/coverage/{ => iffy}/issue-85461.coverage (100%) rename tests/coverage/{ => iffy}/issue-85461.rs (100%) rename tests/coverage/{ => iffy}/issue-93054.cov-map (100%) rename tests/coverage/{ => iffy}/issue-93054.coverage (100%) rename tests/coverage/{ => iffy}/issue-93054.rs (100%) rename tests/coverage/{ => iffy}/lazy_boolean.cov-map (100%) rename tests/coverage/{ => iffy}/lazy_boolean.coverage (100%) rename tests/coverage/{ => iffy}/lazy_boolean.rs (100%) rename tests/coverage/{ => iffy}/loops_branches.cov-map (100%) rename tests/coverage/{ => iffy}/loops_branches.coverage (100%) rename tests/coverage/{ => iffy}/loops_branches.rs (100%) rename tests/coverage/{ => iffy}/match_or_pattern.cov-map (100%) rename tests/coverage/{ => iffy}/match_or_pattern.coverage (100%) rename tests/coverage/{ => iffy}/match_or_pattern.rs (100%) rename tests/coverage/{ => iffy}/nested_loops.cov-map (100%) rename tests/coverage/{ => iffy}/nested_loops.coverage (100%) rename tests/coverage/{ => iffy}/nested_loops.rs (100%) rename tests/coverage/{ => iffy}/no_cov_crate.cov-map (100%) rename tests/coverage/{ => iffy}/no_cov_crate.coverage (100%) rename tests/coverage/{ => iffy}/no_cov_crate.rs (100%) rename tests/coverage/{ => iffy}/overflow.cov-map (100%) rename tests/coverage/{ => iffy}/overflow.coverage (100%) rename tests/coverage/{ => iffy}/overflow.rs (100%) rename tests/coverage/{ => iffy}/panic_unwind.cov-map (100%) rename tests/coverage/{ => iffy}/panic_unwind.coverage (100%) rename tests/coverage/{ => iffy}/panic_unwind.rs (100%) rename tests/coverage/{ => iffy}/partial_eq.cov-map (100%) rename tests/coverage/{ => iffy}/partial_eq.coverage (100%) rename tests/coverage/{ => iffy}/partial_eq.rs (100%) rename tests/coverage/{ => iffy}/simple_loop.cov-map (100%) rename tests/coverage/{ => iffy}/simple_loop.coverage (100%) rename tests/coverage/{ => iffy}/simple_loop.rs (100%) rename tests/coverage/{ => iffy}/simple_match.cov-map (100%) rename tests/coverage/{ => iffy}/simple_match.coverage (100%) rename tests/coverage/{ => iffy}/simple_match.rs (100%) rename tests/coverage/{ => iffy}/try_error_result.cov-map (100%) rename tests/coverage/{ => iffy}/try_error_result.coverage (100%) rename tests/coverage/{ => iffy}/try_error_result.rs (100%) rename tests/coverage/{ => iffy}/uses_crate.cov-map (100%) rename tests/coverage/{ => iffy}/uses_crate.coverage (100%) rename tests/coverage/{ => iffy}/uses_crate.rs (100%) rename tests/coverage/{ => iffy}/uses_inline_crate.cov-map (100%) rename tests/coverage/{ => iffy}/uses_inline_crate.coverage (100%) rename tests/coverage/{ => iffy}/uses_inline_crate.rs (100%) rename tests/coverage/{ => iffy}/while.cov-map (100%) rename tests/coverage/{ => iffy}/while.coverage (100%) rename tests/coverage/{ => iffy}/while.rs (100%) rename tests/coverage/{ => iffy}/while_early_ret.cov-map (100%) rename tests/coverage/{ => iffy}/while_early_ret.coverage (100%) rename tests/coverage/{ => iffy}/while_early_ret.rs (100%) rename tests/coverage/{ => iffy}/yield.cov-map (100%) rename tests/coverage/{ => iffy}/yield.coverage (100%) rename tests/coverage/{ => iffy}/yield.rs (100%) 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/assert.cov-map b/tests/coverage/iffy/assert.cov-map similarity index 100% rename from tests/coverage/assert.cov-map rename to tests/coverage/iffy/assert.cov-map diff --git a/tests/coverage/assert.coverage b/tests/coverage/iffy/assert.coverage similarity index 100% rename from tests/coverage/assert.coverage rename to tests/coverage/iffy/assert.coverage diff --git a/tests/coverage/assert.rs b/tests/coverage/iffy/assert.rs similarity index 100% rename from tests/coverage/assert.rs rename to tests/coverage/iffy/assert.rs 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/while.cov-map b/tests/coverage/iffy/while.cov-map similarity index 100% rename from tests/coverage/while.cov-map rename to tests/coverage/iffy/while.cov-map diff --git a/tests/coverage/while.coverage b/tests/coverage/iffy/while.coverage similarity index 100% rename from tests/coverage/while.coverage rename to tests/coverage/iffy/while.coverage diff --git a/tests/coverage/while.rs b/tests/coverage/iffy/while.rs similarity index 100% rename from tests/coverage/while.rs rename to tests/coverage/iffy/while.rs 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 From 492fff70b80241545a29377b0480824a718d22a7 Mon Sep 17 00:00:00 2001 From: Zalathar Date: Wed, 2 Sep 2026 14:15:19 +1000 Subject: [PATCH 3/3] Add some simple coverage tests for common constructs --- tests/coverage/assert.cov-map | 72 +++++++++++++++++++++++ tests/coverage/assert.coverage | 42 +++++++++++++ tests/coverage/assert.rs | 41 +++++++++++++ tests/coverage/call-method.cov-map | 19 ++++++ tests/coverage/call-method.coverage | 46 +++++++++++++++ tests/coverage/call-method.rs | 45 ++++++++++++++ tests/coverage/for.many.coverage | 39 ++++++++++++ tests/coverage/for.one.coverage | 37 ++++++++++++ tests/coverage/for.rs | 36 ++++++++++++ tests/coverage/for.zero.cov-map | 30 ++++++++++ tests/coverage/for.zero.coverage | 39 ++++++++++++ tests/coverage/if-let-chain.none.cov-map | 40 +++++++++++++ tests/coverage/if-let-chain.none.coverage | 41 +++++++++++++ tests/coverage/if-let-chain.one.coverage | 41 +++++++++++++ tests/coverage/if-let-chain.rs | 38 ++++++++++++ tests/coverage/if-let-chain.two.coverage | 40 +++++++++++++ tests/coverage/if-tail-expr.no.cov-map | 45 ++++++++++++++ tests/coverage/if-tail-expr.no.coverage | 46 +++++++++++++++ tests/coverage/if-tail-expr.rs | 45 ++++++++++++++ tests/coverage/if-tail-expr.yes.coverage | 46 +++++++++++++++ tests/coverage/if-tail-stmt.no.cov-map | 34 +++++++++++ tests/coverage/if-tail-stmt.no.coverage | 46 +++++++++++++++ tests/coverage/if-tail-stmt.rs | 45 ++++++++++++++ tests/coverage/if-tail-stmt.yes.coverage | 48 +++++++++++++++ tests/coverage/let-else.none.cov-map | 38 ++++++++++++ tests/coverage/let-else.none.coverage | 39 ++++++++++++ tests/coverage/let-else.rs | 36 ++++++++++++ tests/coverage/let-else.some.coverage | 37 ++++++++++++ tests/coverage/match.cov-map | 49 +++++++++++++++ tests/coverage/match.coverage | 43 ++++++++++++++ tests/coverage/match.rs | 41 +++++++++++++ tests/coverage/while.cov-map | 42 +++++++++++++ tests/coverage/while.coverage | 34 +++++++++++ tests/coverage/while.rs | 33 +++++++++++ 34 files changed, 1393 insertions(+) create mode 100644 tests/coverage/assert.cov-map create mode 100644 tests/coverage/assert.coverage create mode 100644 tests/coverage/assert.rs create mode 100644 tests/coverage/call-method.cov-map create mode 100644 tests/coverage/call-method.coverage create mode 100644 tests/coverage/call-method.rs create mode 100644 tests/coverage/for.many.coverage create mode 100644 tests/coverage/for.one.coverage create mode 100644 tests/coverage/for.rs create mode 100644 tests/coverage/for.zero.cov-map create mode 100644 tests/coverage/for.zero.coverage create mode 100644 tests/coverage/if-let-chain.none.cov-map create mode 100644 tests/coverage/if-let-chain.none.coverage create mode 100644 tests/coverage/if-let-chain.one.coverage create mode 100644 tests/coverage/if-let-chain.rs create mode 100644 tests/coverage/if-let-chain.two.coverage create mode 100644 tests/coverage/if-tail-expr.no.cov-map create mode 100644 tests/coverage/if-tail-expr.no.coverage create mode 100644 tests/coverage/if-tail-expr.rs create mode 100644 tests/coverage/if-tail-expr.yes.coverage create mode 100644 tests/coverage/if-tail-stmt.no.cov-map create mode 100644 tests/coverage/if-tail-stmt.no.coverage create mode 100644 tests/coverage/if-tail-stmt.rs create mode 100644 tests/coverage/if-tail-stmt.yes.coverage create mode 100644 tests/coverage/let-else.none.cov-map create mode 100644 tests/coverage/let-else.none.coverage create mode 100644 tests/coverage/let-else.rs create mode 100644 tests/coverage/let-else.some.coverage create mode 100644 tests/coverage/match.cov-map create mode 100644 tests/coverage/match.coverage create mode 100644 tests/coverage/match.rs create mode 100644 tests/coverage/while.cov-map create mode 100644 tests/coverage/while.coverage create mode 100644 tests/coverage/while.rs diff --git a/tests/coverage/assert.cov-map b/tests/coverage/assert.cov-map new file mode 100644 index 0000000000000..4500eab355739 --- /dev/null +++ b/tests/coverage/assert.cov-map @@ -0,0 +1,72 @@ +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: 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::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: 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 new file mode 100644 index 0000000000000..d9171fd705c99 --- /dev/null +++ b/tests/coverage/assert.coverage @@ -0,0 +1,42 @@ + LL| |#![feature(coverage_attribute)] + LL| |//@ edition: 2024 + LL| | + LL| |use core::assert_matches; + LL| | + 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| 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 new file mode 100644 index 0000000000000..9c3151ba4ce17 --- /dev/null +++ b/tests/coverage/assert.rs @@ -0,0 +1,41 @@ +#![feature(coverage_attribute)] +//@ edition: 2024 + +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 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}"); +} + +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/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/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 new file mode 100644 index 0000000000000..52bef0a80dfb1 --- /dev/null +++ b/tests/coverage/while.cov-map @@ -0,0 +1,42 @@ +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: 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 new file mode 100644 index 0000000000000..a83198bbc675e --- /dev/null +++ b/tests/coverage/while.coverage @@ -0,0 +1,34 @@ + 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 new file mode 100644 index 0000000000000..77ef50d09a6ac --- /dev/null +++ b/tests/coverage/while.rs @@ -0,0 +1,33 @@ +#![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}"); +}