src/test/run-make-fulldeps/coverage-reports/expected_show_coverage.try_error_result.txt

   1     1|       |#![allow(unused_assignments)]
   2     2|       |// expect-exit-status-1
   3     3|       |
   4     4|      6|fn call(return_error: bool) -> Result<(),()> {
   5     5|      6|    if return_error {
   6     6|      1|        Err(())
   7     7|       |    } else {
   8     8|      5|        Ok(())
   9     9|       |    }
  10    10|      6|}
  11    11|       |
  12    12|      1|fn test1() -> Result<(),()> {
  13    13|      1|    let mut
  14    14|      1|        countdown = 10
  15    15|       |    ;
  16    16|       |    for
  17    17|      6|        _
  18    18|       |    in
  19    19|      6|        0..10
  20    20|       |    {
  21    21|      6|        countdown
  22    22|      6|            -= 1
  23    23|      6|        ;
  24    24|      6|        if
  25    25|      6|            countdown < 5
  26    26|       |        {
  27    27|      1|            call(/*return_error=*/ true)?;
  28    28|      0|            call(/*return_error=*/ false)?;
  29    29|       |        }
  30    30|       |        else
  31    31|       |        {
  32    32|      5|            call(/*return_error=*/ false)?;
  33                                                        ^0
  34    33|       |        }
  35    34|       |    }
  36    35|      0|    Ok(())
  37    36|      1|}
  38    37|       |
  39    38|       |struct Thing1;
  40    39|       |impl Thing1 {
  41    40|     18|    fn get_thing_2(&self, return_error: bool) -> Result<Thing2,()> {
  42    41|     18|        if return_error {
  43    42|      1|            Err(())
  44    43|       |        } else {
  45    44|     17|            Ok(Thing2{})
  46    45|       |        }
  47    46|     18|    }
  48    47|       |}
  49    48|       |
  50    49|       |struct Thing2;
  51    50|       |impl Thing2 {
  52    51|     17|    fn call(&self, return_error: bool) -> Result<u32,()> {
  53    52|     17|        if return_error {
  54    53|      2|            Err(())
  55    54|       |        } else {
  56    55|     15|            Ok(57)
  57    56|       |        }
  58    57|     17|    }
  59    58|       |}
  60    59|       |
  61    60|      1|fn test2() -> Result<(),()> {
  62    61|      1|    let thing1 = Thing1{};
  63    62|      1|    let mut
  64    63|      1|        countdown = 10
  65    64|       |    ;
  66    65|       |    for
  67    66|      6|        _
  68    67|       |    in
  69    68|      6|        0..10
  70    69|       |    {
  71    70|      6|        countdown
  72    71|      6|            -= 1
  73    72|      6|        ;
  74    73|      6|        if
  75    74|      6|            countdown < 5
  76    75|       |        {
  77    76|      1|            thing1.get_thing_2(/*err=*/ false)?.call(/*err=*/ true).expect_err("call should fail");
  78                                                             ^0
  79    77|      1|            thing1
  80    78|      1|                .
  81    79|      1|                get_thing_2(/*return_error=*/ false)
  82    80|      0|                ?
  83    81|       |                .
  84    82|      1|                call(/*return_error=*/ true)
  85    83|      1|                .
  86    84|      1|                expect_err(
  87    85|      1|                    "call should fail"
  88    86|      1|                );
  89    87|      1|            let val = thing1.get_thing_2(/*return_error=*/ true)?.call(/*return_error=*/ true)?;
  90                               ^0                                                ^0                          ^0
  91    88|      0|            assert_eq!(val, 57);
  92    89|      0|            let val = thing1.get_thing_2(/*return_error=*/ true)?.call(/*return_error=*/ false)?;
  93    90|      0|            assert_eq!(val, 57);
  94    91|       |        }
  95    92|       |        else
  96    93|       |        {
  97    94|      5|            let val = thing1.get_thing_2(/*return_error=*/ false)?.call(/*return_error=*/ false)?;
  98                                                                                ^0                             ^0
  99    95|      5|            assert_eq!(val, 57);
 100    96|      5|            let val = thing1
 101    97|      5|                .get_thing_2(/*return_error=*/ false)?
 102                                                                    ^0
 103    98|      5|                .call(/*return_error=*/ false)?;
 104                                                             ^0
 105    99|      5|            assert_eq!(val, 57);
 106   100|      5|            let val = thing1
 107   101|      5|                .get_thing_2(/*return_error=*/ false)
 108   102|      0|                ?
 109   103|      5|                .call(/*return_error=*/ false)
 110   104|      0|                ?
 111   105|       |                ;
 112   106|      5|            assert_eq!(val, 57);
 113   107|       |        }
 114   108|       |    }
 115   109|      0|    Ok(())
 116   110|      1|}
 117   111|       |
 118   112|      1|fn main() -> Result<(),()> {
 119   113|      1|    test1().expect_err("test1 should fail");
 120   114|      1|    test2()
 121   115|      1|    ?
 122   116|       |    ;
 123   117|      0|    Ok(())
 124   118|      1|}
 125