coverage: Add test to codify existing behavior

Currently `await` is only counted towards coverage if the containing
function is suspended and resumed at least once. A future commit will
fix this and update the test to reflect the new behavior.

Author: jonathan-conder

tests/coverage/async.cov-map

@@ -262,10 +262,44 @@ Number of file 0 mappings: 1
 - Code(Zero) at (prev + 87, 25) to (start + 0, 34)
 
 Function name: async::main
-Raw bytes (9): 0x[01, 01, 00, 01, 01, 59, 01, 08, 02]
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 61, 01, 09, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 0
 Number of file 0 mappings: 1
-- Code(Counter(0)) at (prev + 89, 1) to (start + 8, 2)
+- Code(Counter(0)) at (prev + 97, 1) to (start + 9, 2)
+
+Function name: async::n
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 59, 01, 00, 14]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 89, 1) to (start + 0, 20)
+
+Function name: async::n::{closure#0}
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 59, 14, 00, 19]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 89, 20) to (start + 0, 25)
+
+Function name: async::o
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 5b, 01, 00, 14]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 91, 1) to (start + 0, 20)
+
+Function name: async::o::{closure#0}
+Raw bytes (19): 0x[01, 01, 00, 03, 01, 5b, 14, 02, 08, 05, 03, 0a, 00, 0f, 09, 01, 01, 00, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 3
+- Code(Counter(0)) at (prev + 91, 20) to (start + 2, 8)
+- Code(Counter(1)) at (prev + 3, 10) to (start + 0, 15)
+- Code(Counter(2)) at (prev + 1, 1) to (start + 0, 2)
 

tests/coverage/async.coverage

@@ -91,6 +91,14 @@
    LL|      1|async fn m(x: u8) -> u8 { x - 1 }
                                       ^0
    LL|       |
+   LL|      1|async fn n() -> u8 { 1 }
+   LL|       |
+   LL|      1|async fn o() -> u8 {
+   LL|      1|    // FIXME(#98712): await is only covered if the function yields
+   LL|      1|    n()
+   LL|      0|        .await
+   LL|      1|}
+   LL|       |
    LL|      1|fn main() {
    LL|      1|    let _ = g(10);
    LL|      1|    let _ = h(9);
@@ -99,6 +107,7 @@
    LL|      1|    l(6);
    LL|      1|    let _ = m(5);
    LL|      1|    executor::block_on(future.as_mut());
+   LL|      1|    executor::block_on(Box::pin(o()).as_mut());
    LL|      1|}
    LL|       |
    LL|       |mod executor {

tests/coverage/async.rs

@@ -86,6 +86,14 @@ fn l(x: u8) {
 
 async fn m(x: u8) -> u8 { x - 1 }
 
+async fn n() -> u8 { 1 }
+
+async fn o() -> u8 {
+    // FIXME(#98712): await is only covered if the function yields
+    n()
+        .await
+}
+
 fn main() {
     let _ = g(10);
     let _ = h(9);
@@ -94,6 +102,7 @@ fn main() {
     l(6);
     let _ = m(5);
     executor::block_on(future.as_mut());
+    executor::block_on(Box::pin(o()).as_mut());
 }
 
 mod executor {