tests/run-make/coverage/try_error_result.rs

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