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