vendor/derive_more/tests/error/derives_for_structs_with_source.rs

   1 use super::*;
   2
   3 #[test]
   4 fn unit() {
   5     assert!(SimpleErr.source().is_none());
   6 }
   7
   8 #[test]
   9 fn named_implicit_no_source() {
  10     derive_display!(TestErr);
  11     #[derive(Default, Debug, Error)]
  12     struct TestErr {
  13         field: i32,
  14     }
  15
  16     assert!(TestErr::default().source().is_none());
  17 }
  18
  19 #[test]
  20 fn named_implicit_source() {
  21     derive_display!(TestErr);
  22     #[derive(Default, Debug, Error)]
  23     struct TestErr {
  24         source: SimpleErr,
  25         field: i32,
  26     }
  27
  28     let err = TestErr::default();
  29     assert!(err.source().is_some());
  30     assert!(err.source().unwrap().is::<SimpleErr>());
  31 }
  32
  33 #[test]
  34 fn named_explicit_no_source() {
  35     derive_display!(TestErr);
  36     #[derive(Default, Debug, Error)]
  37     struct TestErr {
  38         #[error(not(source))]
  39         source: SimpleErr,
  40         field: i32,
  41     }
  42
  43     assert!(TestErr::default().source().is_none());
  44 }
  45
  46 #[test]
  47 fn named_explicit_source() {
  48     derive_display!(TestErr);
  49     #[derive(Default, Debug, Error)]
  50     struct TestErr {
  51         #[error(source)]
  52         explicit_source: SimpleErr,
  53         field: i32,
  54     }
  55
  56     let err = TestErr::default();
  57     assert!(err.source().is_some());
  58     assert!(err.source().unwrap().is::<SimpleErr>());
  59 }
  60
  61 #[test]
  62 fn named_explicit_no_source_redundant() {
  63     derive_display!(TestErr);
  64     #[derive(Default, Debug, Error)]
  65     struct TestErr {
  66         #[error(not(source))]
  67         field: i32,
  68     }
  69
  70     assert!(TestErr::default().source().is_none());
  71 }
  72
  73 #[test]
  74 fn named_explicit_source_redundant() {
  75     derive_display!(TestErr);
  76     #[derive(Default, Debug, Error)]
  77     struct TestErr {
  78         #[error(source)]
  79         source: SimpleErr,
  80         field: i32,
  81     }
  82
  83     let err = TestErr::default();
  84     assert!(err.source().is_some());
  85     assert!(err.source().unwrap().is::<SimpleErr>());
  86 }
  87
  88 #[test]
  89 fn named_explicit_suppresses_implicit() {
  90     derive_display!(TestErr);
  91     #[derive(Default, Debug, Error)]
  92     struct TestErr {
  93         source: i32,
  94         #[error(source)]
  95         field: SimpleErr,
  96     }
  97
  98     let err = TestErr::default();
  99     assert!(err.source().is_some());
 100     assert!(err.source().unwrap().is::<SimpleErr>());
 101 }
 102
 103 #[test]
 104 fn unnamed_implicit_no_source() {
 105     derive_display!(TestErr);
 106     #[derive(Default, Debug, Error)]
 107     struct TestErr(i32, i32);
 108
 109     assert!(TestErr::default().source().is_none());
 110 }
 111
 112 #[test]
 113 fn unnamed_implicit_source() {
 114     derive_display!(TestErr);
 115     #[derive(Default, Debug, Error)]
 116     struct TestErr(SimpleErr);
 117
 118     let err = TestErr::default();
 119     assert!(err.source().is_some());
 120     assert!(err.source().unwrap().is::<SimpleErr>());
 121 }
 122
 123 #[test]
 124 fn unnamed_explicit_no_source() {
 125     derive_display!(TestErr);
 126     #[derive(Default, Debug, Error)]
 127     struct TestErr(#[error(not(source))] SimpleErr);
 128
 129     assert!(TestErr::default().source().is_none());
 130 }
 131
 132 #[test]
 133 fn unnamed_explicit_source() {
 134     derive_display!(TestErr);
 135     #[derive(Default, Debug, Error)]
 136     struct TestErr(#[error(source)] SimpleErr, i32);
 137
 138     let err = TestErr::default();
 139     assert!(err.source().is_some());
 140     assert!(err.source().unwrap().is::<SimpleErr>());
 141 }
 142
 143 #[test]
 144 fn unnamed_explicit_no_source_redundant() {
 145     derive_display!(TestErr);
 146     #[derive(Default, Debug, Error)]
 147     struct TestErr(#[error(not(source))] i32, #[error(not(source))] i32);
 148
 149     assert!(TestErr::default().source().is_none());
 150 }
 151
 152 #[test]
 153 fn unnamed_explicit_source_redundant() {
 154     derive_display!(TestErr);
 155     #[derive(Default, Debug, Error)]
 156     struct TestErr(#[error(source)] SimpleErr);
 157
 158     let err = TestErr::default();
 159     assert!(err.source().is_some());
 160     assert!(err.source().unwrap().is::<SimpleErr>());
 161 }
 162
 163 #[test]
 164 fn named_ignore() {
 165     derive_display!(TestErr);
 166     #[derive(Default, Debug, Error)]
 167     struct TestErr {
 168         #[error(ignore)]
 169         source: SimpleErr,
 170         field: i32,
 171     }
 172
 173     assert!(TestErr::default().source().is_none());
 174 }
 175
 176 #[test]
 177 fn unnamed_ignore() {
 178     derive_display!(TestErr);
 179     #[derive(Default, Debug, Error)]
 180     struct TestErr(#[error(ignore)] SimpleErr);
 181
 182     assert!(TestErr::default().source().is_none());
 183 }
 184
 185 #[test]
 186 fn named_ignore_redundant() {
 187     derive_display!(TestErr);
 188     #[derive(Default, Debug, Error)]
 189     struct TestErr {
 190         #[error(ignore)]
 191         field: i32,
 192     }
 193
 194     assert!(TestErr::default().source().is_none());
 195 }
 196
 197 #[test]
 198 fn unnamed_ignore_redundant() {
 199     derive_display!(TestErr);
 200     #[derive(Default, Debug, Error)]
 201     struct TestErr(#[error(ignore)] i32, #[error(ignore)] i32);
 202
 203     assert!(TestErr::default().source().is_none());
 204 }
 205
 206 #[test]
 207 fn named_struct_ignore() {
 208     derive_display!(TestErr);
 209     #[derive(Default, Debug, Error)]
 210     #[error(ignore)]
 211     struct TestErr {
 212         source: SimpleErr,
 213         field: i32,
 214     }
 215
 216     assert!(TestErr::default().source().is_none())
 217 }
 218
 219 #[test]
 220 fn unnamed_struct_ignore() {
 221     derive_display!(TestErr);
 222     #[derive(Default, Debug, Error)]
 223     #[error(ignore)]
 224     struct TestErr(SimpleErr);
 225
 226     assert!(TestErr::default().source().is_none())
 227 }
 228
 229 #[test]
 230 fn named_struct_ignore_redundant() {
 231     derive_display!(TestErr);
 232     #[derive(Default, Debug, Error)]
 233     #[error(ignore)]
 234     struct TestErr {
 235         field: i32,
 236     }
 237
 238     assert!(TestErr::default().source().is_none())
 239 }
 240
 241 #[test]
 242 fn unnamed_struct_ignore_redundant() {
 243     derive_display!(TestErr);
 244     #[derive(Default, Debug, Error)]
 245     #[error(ignore)]
 246     struct TestErr(i32, i32);
 247
 248     assert!(TestErr::default().source().is_none())
 249 }