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

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