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