vendor/derive_more/tests/error/nightly/derives_for_structs_with_backtrace.rs

   1 use super::*;
   2
   3 #[test]
   4 fn unit() {
   5     assert!(SimpleErr.backtrace().is_none());
   6 }
   7
   8 #[test]
   9 fn named_implicit_no_backtrace() {
  10     derive_display!(TestErr);
  11     #[derive(Default, Debug, Error)]
  12     struct TestErr {
  13         field: i32,
  14     }
  15
  16     assert!(TestErr::default().backtrace().is_none());
  17 }
  18
  19 #[test]
  20 fn named_implicit_backtrace_by_field_name() {
  21     derive_display!(TestErr);
  22     #[derive(Debug, Error)]
  23     struct TestErr {
  24         backtrace: MyBacktrace,
  25         field: i32,
  26     }
  27
  28     type MyBacktrace = Backtrace;
  29
  30     let err = TestErr {
  31         backtrace: Backtrace::force_capture(),
  32         field: 0,
  33     };
  34     assert!(err.backtrace().is_some());
  35     assert_bt!(==, err);
  36 }
  37
  38 #[test]
  39 fn named_implicit_backtrace_by_field_type() {
  40     derive_display!(TestErr);
  41     #[derive(Debug, Error)]
  42     struct TestErr {
  43         implicit_backtrace: Backtrace,
  44         field: i32,
  45     }
  46
  47     let err = TestErr {
  48         implicit_backtrace: Backtrace::force_capture(),
  49         field: 0,
  50     };
  51     assert!(err.backtrace().is_some());
  52     assert_bt!(==, err, implicit_backtrace);
  53 }
  54
  55 #[test]
  56 fn named_explicit_no_backtrace_by_field_name() {
  57     derive_display!(TestErr);
  58     #[derive(Debug, Error)]
  59     struct TestErr {
  60         #[error(not(backtrace))]
  61         backtrace: MyBacktrace,
  62         field: i32,
  63     }
  64
  65     type MyBacktrace = Backtrace;
  66
  67     assert!(TestErr {
  68         backtrace: Backtrace::force_capture(),
  69         field: 0
  70     }
  71     .backtrace()
  72     .is_none());
  73 }
  74
  75 #[test]
  76 fn named_explicit_no_backtrace_by_field_type() {
  77     derive_display!(TestErr);
  78     #[derive(Debug, Error)]
  79     struct TestErr {
  80         #[error(not(backtrace))]
  81         implicit_backtrace: Backtrace,
  82         field: i32,
  83     }
  84
  85     assert!(TestErr {
  86         implicit_backtrace: Backtrace::force_capture(),
  87         field: 0
  88     }
  89     .backtrace()
  90     .is_none());
  91 }
  92
  93 #[test]
  94 fn named_explicit_backtrace() {
  95     derive_display!(TestErr);
  96     #[derive(Debug, Error)]
  97     struct TestErr {
  98         #[error(backtrace)]
  99         explicit_backtrace: MyBacktrace,
 100         field: i32,
 101     }
 102
 103     type MyBacktrace = Backtrace;
 104
 105     let err = TestErr {
 106         explicit_backtrace: Backtrace::force_capture(),
 107         field: 0,
 108     };
 109     assert!(err.backtrace().is_some());
 110     assert_bt!(==, err, explicit_backtrace);
 111 }
 112
 113 #[test]
 114 fn named_explicit_no_backtrace_redundant() {
 115     derive_display!(TestErr);
 116     #[derive(Debug, Error)]
 117     struct TestErr {
 118         #[error(not(backtrace))]
 119         not_backtrace: MyBacktrace,
 120         #[error(not(backtrace))]
 121         field: i32,
 122     }
 123
 124     type MyBacktrace = Backtrace;
 125
 126     assert!(TestErr {
 127         not_backtrace: Backtrace::force_capture(),
 128         field: 0
 129     }
 130     .backtrace()
 131     .is_none());
 132 }
 133
 134 #[test]
 135 fn named_explicit_backtrace_by_field_name_redundant() {
 136     derive_display!(TestErr);
 137     #[derive(Debug, Error)]
 138     struct TestErr {
 139         #[error(backtrace)]
 140         backtrace: MyBacktrace,
 141         field: i32,
 142     }
 143
 144     type MyBacktrace = Backtrace;
 145
 146     let err = TestErr {
 147         backtrace: Backtrace::force_capture(),
 148         field: 0,
 149     };
 150     assert!(err.backtrace().is_some());
 151     assert_bt!(==, err);
 152 }
 153
 154 #[test]
 155 fn named_explicit_backtrace_by_field_type_redundant() {
 156     derive_display!(TestErr);
 157     #[derive(Debug, Error)]
 158     struct TestErr {
 159         #[error(backtrace)]
 160         implicit_backtrace: Backtrace,
 161         field: i32,
 162     }
 163
 164     let err = TestErr {
 165         implicit_backtrace: Backtrace::force_capture(),
 166         field: 0,
 167     };
 168     assert!(err.backtrace().is_some());
 169     assert_bt!(==, err, implicit_backtrace);
 170 }
 171
 172 #[test]
 173 fn named_explicit_supresses_implicit() {
 174     derive_display!(TestErr);
 175     #[derive(Debug, Error)]
 176     struct TestErr {
 177         #[error(backtrace)]
 178         not_backtrace: MyBacktrace,
 179         backtrace: Backtrace,
 180         field: i32,
 181     }
 182
 183     type MyBacktrace = Backtrace;
 184
 185     let err = TestErr {
 186         not_backtrace: Backtrace::force_capture(),
 187         backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
 188         field: 0,
 189     };
 190
 191     assert!(err.backtrace().is_some());
 192     assert_bt!(==, err, not_backtrace);
 193     assert_bt!(!=, err);
 194 }
 195
 196 #[test]
 197 fn unnamed_implicit_no_backtrace() {
 198     derive_display!(TestErr);
 199     #[derive(Default, Debug, Error)]
 200     struct TestErr(i32, i32);
 201
 202     assert!(TestErr::default().backtrace().is_none());
 203 }
 204
 205 #[test]
 206 fn unnamed_implicit_backtrace() {
 207     derive_display!(TestErr);
 208     #[derive(Debug, Error)]
 209     struct TestErr(Backtrace, i32, i32);
 210
 211     let err = TestErr(Backtrace::force_capture(), 0, 0);
 212     assert!(err.backtrace().is_some());
 213     assert_bt!(==, err, 0);
 214 }
 215
 216 #[test]
 217 fn unnamed_explicit_no_backtrace() {
 218     derive_display!(TestErr);
 219     #[derive(Debug, Error)]
 220     struct TestErr(#[error(not(backtrace))] Backtrace, i32);
 221
 222     assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none());
 223 }
 224
 225 #[test]
 226 fn unnamed_explicit_backtrace() {
 227     derive_display!(TestErr);
 228     #[derive(Debug, Error)]
 229     struct TestErr(#[error(backtrace)] MyBacktrace, i32, i32);
 230
 231     type MyBacktrace = Backtrace;
 232
 233     let err = TestErr(Backtrace::force_capture(), 0, 0);
 234     assert!(err.backtrace().is_some());
 235     assert_bt!(==, err, 0);
 236 }
 237
 238 #[test]
 239 fn unnamed_explicit_no_backtrace_redundant() {
 240     derive_display!(TestErr);
 241     #[derive(Debug, Error)]
 242     struct TestErr(
 243         #[error(not(backtrace))] MyBacktrace,
 244         #[error(not(backtrace))] i32,
 245     );
 246
 247     type MyBacktrace = Backtrace;
 248
 249     assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none());
 250 }
 251
 252 #[test]
 253 fn unnamed_explicit_backtrace_redundant() {
 254     derive_display!(TestErr);
 255     #[derive(Debug, Error)]
 256     struct TestErr(#[error(backtrace)] Backtrace, i32, i32);
 257
 258     let err = TestErr(Backtrace::force_capture(), 0, 0);
 259     assert!(err.backtrace().is_some());
 260     assert_bt!(==, err, 0);
 261 }
 262
 263 #[test]
 264 fn unnamed_explicit_supresses_implicit() {
 265     derive_display!(TestErr);
 266     #[derive(Debug, Error)]
 267     struct TestErr(#[error(backtrace)] MyBacktrace, Backtrace, i32);
 268
 269     type MyBacktrace = Backtrace;
 270
 271     let err = TestErr(
 272         Backtrace::force_capture(),
 273         (|| Backtrace::force_capture())(), // ensure backtraces are different
 274         0,
 275     );
 276
 277     assert!(err.backtrace().is_some());
 278     assert_bt!(==, err, 0);
 279     assert_bt!(!=, err, 1);
 280 }