summaryrefslogtreecommitdiffstats
path: root/tests/run-coverage/async.coverage
diff options
context:
space:
mode:
Diffstat (limited to 'tests/run-coverage/async.coverage')
-rw-r--r--tests/run-coverage/async.coverage256
1 files changed, 128 insertions, 128 deletions
diff --git a/tests/run-coverage/async.coverage b/tests/run-coverage/async.coverage
index 93c1535b0..07bc16c2d 100644
--- a/tests/run-coverage/async.coverage
+++ b/tests/run-coverage/async.coverage
@@ -1,139 +1,139 @@
- 1| |#![allow(unused_assignments, dead_code)]
- 2| |
- 3| |// compile-flags: --edition=2018 -C opt-level=1
- 4| |
- 5| 1|async fn c(x: u8) -> u8 {
- 6| 1| if x == 8 {
- 7| 1| 1
- 8| | } else {
- 9| 0| 0
- 10| | }
- 11| 1|}
- 12| |
- 13| 0|async fn d() -> u8 { 1 }
- 14| |
- 15| 0|async fn e() -> u8 { 1 } // unused function; executor does not block on `g()`
- 16| |
- 17| 1|async fn f() -> u8 { 1 }
- 18| |
- 19| 0|async fn foo() -> [bool; 10] { [false; 10] } // unused function; executor does not block on `h()`
- 20| |
- 21| 1|pub async fn g(x: u8) {
- 22| 0| match x {
- 23| 0| y if e().await == y => (),
- 24| 0| y if f().await == y => (),
- 25| 0| _ => (),
- 26| | }
- 27| 0|}
- 28| |
- 29| 1|async fn h(x: usize) { // The function signature is counted when called, but the body is not
- 30| 0| // executed (not awaited) so the open brace has a `0` count (at least when
- 31| 0| // displayed with `llvm-cov show` in color-mode).
- 32| 0| match x {
- 33| 0| y if foo().await[y] => (),
- 34| 0| _ => (),
- 35| | }
- 36| 0|}
- 37| |
- 38| 1|async fn i(x: u8) { // line coverage is 1, but there are 2 regions:
- 39| 1| // (a) the function signature, counted when the function is called; and
- 40| 1| // (b) the open brace for the function body, counted once when the body is
- 41| 1| // executed asynchronously.
- 42| 1| match x {
- 43| 1| y if c(x).await == y + 1 => { d().await; }
+ LL| |#![allow(unused_assignments, dead_code)]
+ LL| |
+ LL| |// compile-flags: --edition=2018 -C opt-level=1
+ LL| |
+ LL| 1|async fn c(x: u8) -> u8 {
+ LL| 1| if x == 8 {
+ LL| 1| 1
+ LL| | } else {
+ LL| 0| 0
+ LL| | }
+ LL| 1|}
+ LL| |
+ LL| 0|async fn d() -> u8 { 1 }
+ LL| |
+ LL| 0|async fn e() -> u8 { 1 } // unused function; executor does not block on `g()`
+ LL| |
+ LL| 1|async fn f() -> u8 { 1 }
+ LL| |
+ LL| 0|async fn foo() -> [bool; 10] { [false; 10] } // unused function; executor does not block on `h()`
+ LL| |
+ LL| 1|pub async fn g(x: u8) {
+ LL| 0| match x {
+ LL| 0| y if e().await == y => (),
+ LL| 0| y if f().await == y => (),
+ LL| 0| _ => (),
+ LL| | }
+ LL| 0|}
+ LL| |
+ LL| 1|async fn h(x: usize) { // The function signature is counted when called, but the body is not
+ LL| 0| // executed (not awaited) so the open brace has a `0` count (at least when
+ LL| 0| // displayed with `llvm-cov show` in color-mode).
+ LL| 0| match x {
+ LL| 0| y if foo().await[y] => (),
+ LL| 0| _ => (),
+ LL| | }
+ LL| 0|}
+ LL| |
+ LL| 1|async fn i(x: u8) { // line coverage is 1, but there are 2 regions:
+ LL| 1| // (a) the function signature, counted when the function is called; and
+ LL| 1| // (b) the open brace for the function body, counted once when the body is
+ LL| 1| // executed asynchronously.
+ LL| 1| match x {
+ LL| 1| y if c(x).await == y + 1 => { d().await; }
^0 ^0 ^0 ^0
- 44| 1| y if f().await == y + 1 => (),
+ LL| 1| y if f().await == y + 1 => (),
^0 ^0 ^0
- 45| 1| _ => (),
- 46| | }
- 47| 1|}
- 48| |
- 49| 1|fn j(x: u8) {
- 50| 1| // non-async versions of `c()`, `d()`, and `f()` to make it similar to async `i()`.
- 51| 1| fn c(x: u8) -> u8 {
- 52| 1| if x == 8 {
- 53| 1| 1 // This line appears covered, but the 1-character expression span covering the `1`
+ LL| 1| _ => (),
+ LL| | }
+ LL| 1|}
+ LL| |
+ LL| 1|fn j(x: u8) {
+ LL| 1| // non-async versions of `c()`, `d()`, and `f()` to make it similar to async `i()`.
+ LL| 1| fn c(x: u8) -> u8 {
+ LL| 1| if x == 8 {
+ LL| 1| 1 // This line appears covered, but the 1-character expression span covering the `1`
^0
- 54| 1| // is not executed. (`llvm-cov show` displays a `^0` below the `1` ). This is because
- 55| 1| // `fn j()` executes the open brace for the function body, followed by the function's
- 56| 1| // first executable statement, `match x`. Inner function declarations are not
- 57| 1| // "visible" to the MIR for `j()`, so the code region counts all lines between the
- 58| 1| // open brace and the first statement as executed, which is, in a sense, true.
- 59| 1| // `llvm-cov show` overcomes this kind of situation by showing the actual counts
- 60| 1| // of the enclosed coverages, (that is, the `1` expression was not executed, and
- 61| 1| // accurately displays a `0`).
- 62| 1| } else {
- 63| 1| 0
- 64| 1| }
- 65| 1| }
- 66| 1| fn d() -> u8 { 1 } // inner function is defined in-line, but the function is not executed
+ LL| 1| // is not executed. (`llvm-cov show` displays a `^0` below the `1` ). This is because
+ LL| 1| // `fn j()` executes the open brace for the function body, followed by the function's
+ LL| 1| // first executable statement, `match x`. Inner function declarations are not
+ LL| 1| // "visible" to the MIR for `j()`, so the code region counts all lines between the
+ LL| 1| // open brace and the first statement as executed, which is, in a sense, true.
+ LL| 1| // `llvm-cov show` overcomes this kind of situation by showing the actual counts
+ LL| 1| // of the enclosed coverages, (that is, the `1` expression was not executed, and
+ LL| 1| // accurately displays a `0`).
+ LL| 1| } else {
+ LL| 1| 0
+ LL| 1| }
+ LL| 1| }
+ LL| 1| fn d() -> u8 { 1 } // inner function is defined in-line, but the function is not executed
^0
- 67| 1| fn f() -> u8 { 1 }
- 68| 1| match x {
- 69| 1| y if c(x) == y + 1 => { d(); }
+ LL| 1| fn f() -> u8 { 1 }
+ LL| 1| match x {
+ LL| 1| y if c(x) == y + 1 => { d(); }
^0 ^0
- 70| 1| y if f() == y + 1 => (),
+ LL| 1| y if f() == y + 1 => (),
^0 ^0
- 71| 1| _ => (),
- 72| | }
- 73| 1|}
- 74| |
- 75| 0|fn k(x: u8) { // unused function
- 76| 0| match x {
- 77| 0| 1 => (),
- 78| 0| 2 => (),
- 79| 0| _ => (),
- 80| | }
- 81| 0|}
- 82| |
- 83| 1|fn l(x: u8) {
- 84| 1| match x {
- 85| 0| 1 => (),
- 86| 0| 2 => (),
- 87| 1| _ => (),
- 88| | }
- 89| 1|}
- 90| |
- 91| 1|async fn m(x: u8) -> u8 { x - 1 }
+ LL| 1| _ => (),
+ LL| | }
+ LL| 1|}
+ LL| |
+ LL| 0|fn k(x: u8) { // unused function
+ LL| 0| match x {
+ LL| 0| 1 => (),
+ LL| 0| 2 => (),
+ LL| 0| _ => (),
+ LL| | }
+ LL| 0|}
+ LL| |
+ LL| 1|fn l(x: u8) {
+ LL| 1| match x {
+ LL| 0| 1 => (),
+ LL| 0| 2 => (),
+ LL| 1| _ => (),
+ LL| | }
+ LL| 1|}
+ LL| |
+ LL| 1|async fn m(x: u8) -> u8 { x - 1 }
^0
- 92| |
- 93| 1|fn main() {
- 94| 1| let _ = g(10);
- 95| 1| let _ = h(9);
- 96| 1| let mut future = Box::pin(i(8));
- 97| 1| j(7);
- 98| 1| l(6);
- 99| 1| let _ = m(5);
- 100| 1| executor::block_on(future.as_mut());
- 101| 1|}
- 102| |
- 103| |mod executor {
- 104| | use core::{
- 105| | future::Future,
- 106| | pin::Pin,
- 107| | task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
- 108| | };
- 109| |
- 110| 1| pub fn block_on<F: Future>(mut future: F) -> F::Output {
- 111| 1| let mut future = unsafe { Pin::new_unchecked(&mut future) };
- 112| 1| use std::hint::unreachable_unchecked;
- 113| 1| static VTABLE: RawWakerVTable = RawWakerVTable::new(
- 114| 1| |_| unsafe { unreachable_unchecked() }, // clone
+ LL| |
+ LL| 1|fn main() {
+ LL| 1| let _ = g(10);
+ LL| 1| let _ = h(9);
+ LL| 1| let mut future = Box::pin(i(8));
+ LL| 1| j(7);
+ LL| 1| l(6);
+ LL| 1| let _ = m(5);
+ LL| 1| executor::block_on(future.as_mut());
+ LL| 1|}
+ LL| |
+ LL| |mod executor {
+ LL| | use core::{
+ LL| | future::Future,
+ LL| | pin::Pin,
+ LL| | task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
+ LL| | };
+ LL| |
+ LL| 1| pub fn block_on<F: Future>(mut future: F) -> F::Output {
+ LL| 1| let mut future = unsafe { Pin::new_unchecked(&mut future) };
+ LL| 1| use std::hint::unreachable_unchecked;
+ LL| 1| static VTABLE: RawWakerVTable = RawWakerVTable::new(
+ LL| 1| |_| unsafe { unreachable_unchecked() }, // clone
^0
- 115| 1| |_| unsafe { unreachable_unchecked() }, // wake
+ LL| 1| |_| unsafe { unreachable_unchecked() }, // wake
^0
- 116| 1| |_| unsafe { unreachable_unchecked() }, // wake_by_ref
+ LL| 1| |_| unsafe { unreachable_unchecked() }, // wake_by_ref
^0
- 117| 1| |_| (),
- 118| 1| );
- 119| 1| let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
- 120| 1| let mut context = Context::from_waker(&waker);
- 121| |
- 122| | loop {
- 123| 1| if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
- 124| 1| break val;
- 125| 0| }
- 126| | }
- 127| 1| }
- 128| |}
+ LL| 1| |_| (),
+ LL| 1| );
+ LL| 1| let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
+ LL| 1| let mut context = Context::from_waker(&waker);
+ LL| |
+ LL| | loop {
+ LL| 1| if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
+ LL| 1| break val;
+ LL| 0| }
+ LL| | }
+ LL| 1| }
+ LL| |}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-04 20:43:01 +0000