Debian Codegraph @

.cargo/vendor/anyhow/tests/test_ensure.rs

raw
1 #![allow(
2 clippy::bool_to_int_with_if,
3 clippy::char_lit_as_u8,
4 clippy::deref_addrof,
5 clippy::diverging_sub_expression,
6 clippy::erasing_op,
7 clippy::extra_unused_type_parameters,
8 clippy::if_same_then_else,
9 clippy::ifs_same_cond,
10 clippy::ignored_unit_patterns,
11 clippy::items_after_statements,
12 clippy::let_and_return,
13 clippy::let_underscore_untyped,
14 clippy::literal_string_with_formatting_args,
15 clippy::match_bool,
16 clippy::needless_else,
17 clippy::never_loop,
18 clippy::overly_complex_bool_expr,
19 clippy::redundant_closure_call,
20 clippy::redundant_pattern_matching,
21 clippy::too_many_lines,
22 clippy::unit_arg,
23 clippy::unnecessary_cast,
24 clippy::while_immutable_condition,
25 clippy::zero_ptr,
26 irrefutable_let_patterns
27 )]
28
29 use self::Enum::Generic;
30 use anyhow::{anyhow, ensure, Chain, Error, Result};
31 use std::fmt::{self, Debug};
32 use std::iter;
33 use std::marker::{PhantomData, PhantomData as P};
34 use std::mem;
35 use std::ops::Add;
36 use std::ptr;
37
38 struct S;
39
40 impl<T> Add<T> for S {
41 type Output = bool;
42 fn add(self, rhs: T) -> Self::Output {
43 let _ = rhs;
44 false
45 }
46 }
47
48 trait Trait: Sized {
49 const V: usize = 0;
50 fn t(self, i: i32) -> i32 {
51 i
52 }
53 }
54
55 impl<T> Trait for T {}
56
57 enum Enum<T: ?Sized> {
58 #[allow(dead_code)]
59 Thing(PhantomData<T>),
60 Generic,
61 }
62
63 impl<T: ?Sized> PartialEq for Enum<T> {
64 fn eq(&self, rhs: &Self) -> bool {
65 mem::discriminant(self) == mem::discriminant(rhs)
66 }
67 }
68
69 impl<T: ?Sized> Debug for Enum<T> {
70 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
71 formatter.write_str("Generic")
72 }
73 }
74
75 #[track_caller]
76 fn assert_err<T: Debug>(result: impl FnOnce() -> Result<T>, expected: &'static str) {
77 let actual = result().unwrap_err().to_string();
78
79 // In general different rustc versions will format the interpolated lhs and
80 // rhs $:expr fragment with insignificant differences in whitespace or
81 // punctuation, so we check the message in full against nightly and do just
82 // a cursory test on older toolchains.
83 if rustversion::cfg!(nightly) && !cfg!(miri) {
84 assert_eq!(actual, expected);
85 } else {
86 assert_eq!(actual.contains(" vs "), expected.contains(" vs "));
87 }
88 }
89
90 #[test]
91 fn test_recursion() {
92 // Must not blow the default #[recursion_limit], which is 128.
93 #[rustfmt::skip]
94 let test = || Ok(ensure!(
95 false | false | false | false | false | false | false | false | false |
96 false | false | false | false | false | false | false | false | false |
97 false | false | false | false | false | false | false | false | false |
98 false | false | false | false | false | false | false | false | false |
99 false | false | false | false | false | false | false | false | false |
100 false | false | false | false | false | false | false | false | false |
101 false | false | false | false | false | false | false | false | false
102 ));
103
104 test().unwrap_err();
105 }
106
107 #[test]
108 fn test_low_precedence_control_flow() {
109 #[allow(unreachable_code)]
110 let test = || {
111 let val = loop {
112 // Break has lower precedence than the comparison operators so the
113 // expression here is `S + (break (1 == 1))`. It would be bad if the
114 // ensure macro partitioned this input into `(S + break 1) == (1)`
115 // because that means a different thing than what was written.
116 ensure!(S + break 1 == 1);
117 };
118 Ok(val)
119 };
120
121 assert!(test().unwrap());
122 }
123
124 #[test]
125 fn test_low_precedence_binary_operator() {
126 // Must not partition as `false == (true && false)`.
127 let test = || Ok(ensure!(false == true && false));
128 assert_err(test, "Condition failed: `false == true && false`");
129
130 // But outside the root level, it is fine.
131 let test = || Ok(ensure!(while false == true && false {} < ()));
132 assert_err(
133 test,
134 "Condition failed: `while false == true && false {} < ()` (() vs ())",
135 );
136
137 let a = 15;
138 let b = 3;
139 let test = || Ok(ensure!(a <= b || a - b <= 10));
140 assert_err(test, "Condition failed: `a <= b || a - b <= 10`");
141 }
142
143 #[test]
144 fn test_high_precedence_binary_operator() {
145 let a = 15;
146 let b = 3;
147 let test = || Ok(ensure!(a - b <= 10));
148 assert_err(test, "Condition failed: `a - b <= 10` (12 vs 10)");
149 }
150
151 #[test]
152 fn test_closure() {
153 // Must not partition as `(S + move) || (1 == 1)` by treating move as an
154 // identifier, nor as `(S + move || 1) == (1)` by misinterpreting the
155 // closure precedence.
156 let test = || Ok(ensure!(S + move || 1 == 1));
157 assert_err(test, "Condition failed: `S + move || 1 == 1`");
158
159 let test = || Ok(ensure!(S + || 1 == 1));
160 assert_err(test, "Condition failed: `S + || 1 == 1`");
161
162 // Must not partition as `S + ((move | ()) | 1) == 1` by treating those
163 // pipes as bitwise-or.
164 let test = || Ok(ensure!(S + move |()| 1 == 1));
165 assert_err(test, "Condition failed: `S + move |()| 1 == 1`");
166
167 let test = || Ok(ensure!(S + |()| 1 == 1));
168 assert_err(test, "Condition failed: `S + |()| 1 == 1`");
169 }
170
171 #[test]
172 fn test_unary() {
173 let mut x = &1;
174 let test = || Ok(ensure!(*x == 2));
175 assert_err(test, "Condition failed: `*x == 2` (1 vs 2)");
176
177 let test = || Ok(ensure!(!x == 1));
178 assert_err(test, "Condition failed: `!x == 1` (-2 vs 1)");
179
180 let test = || Ok(ensure!(-x == 1));
181 assert_err(test, "Condition failed: `-x == 1` (-1 vs 1)");
182
183 let test = || Ok(ensure!(&x == &&2));
184 assert_err(test, "Condition failed: `&x == &&2` (1 vs 2)");
185
186 let test = || Ok(ensure!(&mut x == *&&mut &2));
187 assert_err(test, "Condition failed: `&mut x == *&&mut &2` (1 vs 2)");
188 }
189
190 #[rustversion::since(1.82)]
191 #[test]
192 fn test_raw_addr() {
193 let mut x = 1;
194 let test = || Ok(ensure!(S + &raw const x != S + &raw mut x));
195 assert_err(
196 test,
197 "Condition failed: `S + &raw const x != S + &raw mut x` (false vs false)",
198 );
199 }
200
201 #[test]
202 fn test_if() {
203 #[rustfmt::skip]
204 let test = || Ok(ensure!(if false {}.t(1) == 2));
205 assert_err(test, "Condition failed: `if false {}.t(1) == 2` (1 vs 2)");
206
207 #[rustfmt::skip]
208 let test = || Ok(ensure!(if false {} else {}.t(1) == 2));
209 assert_err(
210 test,
211 "Condition failed: `if false {} else {}.t(1) == 2` (1 vs 2)",
212 );
213
214 #[rustfmt::skip]
215 let test = || Ok(ensure!(if false {} else if false {}.t(1) == 2));
216 assert_err(
217 test,
218 "Condition failed: `if false {} else if false {}.t(1) == 2` (1 vs 2)",
219 );
220
221 #[rustfmt::skip]
222 let test = || Ok(ensure!(if let 1 = 2 {}.t(1) == 2));
223 assert_err(
224 test,
225 "Condition failed: `if let 1 = 2 {}.t(1) == 2` (1 vs 2)",
226 );
227
228 #[rustfmt::skip]
229 let test = || Ok(ensure!(if let 1 | 2 = 2 {}.t(1) == 2));
230 assert_err(
231 test,
232 "Condition failed: `if let 1 | 2 = 2 {}.t(1) == 2` (1 vs 2)",
233 );
234
235 #[rustfmt::skip]
236 let test = || Ok(ensure!(if let | 1 | 2 = 2 {}.t(1) == 2));
237 assert_err(
238 test,
239 "Condition failed: `if let | 1 | 2 = 2 {}.t(1) == 2` (1 vs 2)",
240 );
241 }
242
243 #[test]
244 fn test_loop() {
245 #[rustfmt::skip]
246 let test = || Ok(ensure!(1 + loop { break 1 } == 1));
247 assert_err(
248 test,
249 "Condition failed: `1 + loop { break 1 } == 1` (2 vs 1)",
250 );
251
252 #[rustfmt::skip]
253 let test = || Ok(ensure!(1 + 'a: loop { break 'a 1 } == 1));
254 assert_err(
255 test,
256 "Condition failed: `1 + 'a: loop { break 'a 1 } == 1` (2 vs 1)",
257 );
258
259 #[rustfmt::skip]
260 let test = || Ok(ensure!(while false {}.t(1) == 2));
261 assert_err(
262 test,
263 "Condition failed: `while false {}.t(1) == 2` (1 vs 2)",
264 );
265
266 #[rustfmt::skip]
267 let test = || Ok(ensure!(while let None = Some(1) {}.t(1) == 2));
268 assert_err(
269 test,
270 "Condition failed: `while let None = Some(1) {}.t(1) == 2` (1 vs 2)",
271 );
272
273 #[rustfmt::skip]
274 let test = || Ok(ensure!(for _x in iter::once(0) {}.t(1) == 2));
275 assert_err(
276 test,
277 "Condition failed: `for _x in iter::once(0) {}.t(1) == 2` (1 vs 2)",
278 );
279
280 #[rustfmt::skip]
281 let test = || Ok(ensure!(for | _x in iter::once(0) {}.t(1) == 2));
282 assert_err(
283 test,
284 "Condition failed: `for | _x in iter::once(0) {}.t(1) == 2` (1 vs 2)",
285 );
286
287 #[rustfmt::skip]
288 let test = || Ok(ensure!(for true | false in iter::empty() {}.t(1) == 2));
289 assert_err(
290 test,
291 "Condition failed: `for true | false in iter::empty() {}.t(1) == 2` (1 vs 2)",
292 );
293 }
294
295 #[test]
296 fn test_match() {
297 #[rustfmt::skip]
298 let test = || Ok(ensure!(match 1 == 1 { true => 1, false => 0 } == 2));
299 assert_err(
300 test,
301 "Condition failed: `match 1 == 1 { true => 1, false => 0 } == 2` (1 vs 2)",
302 );
303 }
304
305 #[test]
306 fn test_atom() {
307 let test = || Ok(ensure!([false, false].len() > 3));
308 assert_err(
309 test,
310 "Condition failed: `[false, false].len() > 3` (2 vs 3)",
311 );
312
313 #[rustfmt::skip]
314 let test = || Ok(ensure!({ let x = 1; x } >= 3));
315 assert_err(test, "Condition failed: `{ let x = 1; x } >= 3` (1 vs 3)");
316
317 let test = || Ok(ensure!(S + async { 1 } == true));
318 assert_err(
319 test,
320 "Condition failed: `S + async { 1 } == true` (false vs true)",
321 );
322
323 let test = || Ok(ensure!(S + async move { 1 } == true));
324 assert_err(
325 test,
326 "Condition failed: `S + async move { 1 } == true` (false vs true)",
327 );
328
329 let x = &1;
330 let test = || Ok(ensure!(S + unsafe { ptr::read(x) } == true));
331 assert_err(
332 test,
333 "Condition failed: `S + unsafe { ptr::read(x) } == true` (false vs true)",
334 );
335 }
336
337 #[test]
338 fn test_path() {
339 let test = || Ok(ensure!(crate::S.t(1) == 2));
340 assert_err(test, "Condition failed: `crate::S.t(1) == 2` (1 vs 2)");
341
342 let test = || Ok(ensure!(::anyhow::Error::root_cause.t(1) == 2));
343 assert_err(
344 test,
345 "Condition failed: `::anyhow::Error::root_cause.t(1) == 2` (1 vs 2)",
346 );
347
348 let test = || Ok(ensure!(Error::msg::<&str>.t(1) == 2));
349 assert_err(
350 test,
351 "Condition failed: `Error::msg::<&str>.t(1) == 2` (1 vs 2)",
352 );
353
354 #[rustfmt::skip]
355 let test = || Ok(ensure!(Error::msg::<&str,>.t(1) == 2));
356 assert_err(
357 test,
358 "Condition failed: `Error::msg::<&str,>.t(1) == 2` (1 vs 2)",
359 );
360
361 let test = || Ok(ensure!(Error::msg::<<str as ToOwned>::Owned>.t(1) == 2));
362 assert_err(
363 test,
364 "Condition failed: `Error::msg::<<str as ToOwned>::Owned>.t(1) == 2` (1 vs 2)",
365 );
366
367 let test = || Ok(ensure!(Chain::<'static>::new.t(1) == 2));
368 assert_err(
369 test,
370 "Condition failed: `Chain::<'static>::new.t(1) == 2` (1 vs 2)",
371 );
372
373 #[rustfmt::skip]
374 let test = || Ok(ensure!(Chain::<'static,>::new.t(1) == 2));
375 assert_err(
376 test,
377 "Condition failed: `Chain::<'static,>::new.t(1) == 2` (1 vs 2)",
378 );
379
380 fn f<const I: isize>() {}
381 let test = || Ok(ensure!(f::<1>() != ()));
382 assert_err(test, "Condition failed: `f::<1>() != ()` (() vs ())");
383 let test = || Ok(ensure!(f::<-1>() != ()));
384 assert_err(test, "Condition failed: `f::<-1>() != ()` (() vs ())");
385
386 fn g<T, const I: isize>() {}
387 let test = || Ok(ensure!(g::<u8, 1>() != ()));
388 assert_err(test, "Condition failed: `g::<u8, 1>() != ()` (() vs ())");
389 let test = || Ok(ensure!(g::<u8, -1>() != ()));
390 assert_err(test, "Condition failed: `g::<u8, -1>() != ()` (() vs ())");
391
392 #[derive(PartialOrd, PartialEq, Debug)]
393 enum E<'a, T> {
394 #[allow(dead_code)]
395 T(&'a T),
396 U,
397 }
398
399 #[rustfmt::skip]
400 let test = || Ok(ensure!(E::U::<>>E::U::<u8>));
401 assert_err(test, "Condition failed: `E::U::<> > E::U::<u8>` (U vs U)");
402
403 #[rustfmt::skip]
404 let test = || Ok(ensure!(E::U::<u8>>E::U));
405 assert_err(test, "Condition failed: `E::U::<u8> > E::U` (U vs U)");
406
407 #[rustfmt::skip]
408 let test = || Ok(ensure!(E::U::<u8,>>E::U));
409 assert_err(test, "Condition failed: `E::U::<u8,> > E::U` (U vs U)");
410
411 let test = || Ok(ensure!(Generic::<dyn Debug + Sync> != Generic));
412 assert_err(
413 test,
414 "Condition failed: `Generic::<dyn Debug + Sync> != Generic` (Generic vs Generic)",
415 );
416
417 let test = || Ok(ensure!(Generic::<dyn Fn() + Sync> != Generic));
418 assert_err(
419 test,
420 "Condition failed: `Generic::<dyn Fn() + Sync> != Generic` (Generic vs Generic)",
421 );
422
423 #[rustfmt::skip]
424 let test = || {
425 Ok(ensure!(
426 Generic::<dyn Fn::() + ::std::marker::Sync> != Generic
427 ))
428 };
429 assert_err(
430 test,
431 "Condition failed: `Generic::<dyn Fn::() + ::std::marker::Sync> != Generic` (Generic vs Generic)",
432 );
433 }
434
435 #[test]
436 fn test_macro() {
437 let test = || Ok(ensure!(anyhow!("...").to_string().len() <= 1));
438 assert_err(
439 test,
440 "Condition failed: `anyhow!(\"...\").to_string().len() <= 1` (3 vs 1)",
441 );
442
443 let test = || Ok(ensure!(vec![1].len() < 1));
444 assert_err(test, "Condition failed: `vec![1].len() < 1` (1 vs 1)");
445
446 let test = || Ok(ensure!(stringify! {} != ""));
447 assert_err(
448 test,
449 "Condition failed: `stringify! {} != \"\"` (\"\" vs \"\")",
450 );
451 }
452
453 #[test]
454 fn test_trailer() {
455 let test = || Ok(ensure!((|| 1)() == 2));
456 assert_err(test, "Condition failed: `(|| 1)() == 2` (1 vs 2)");
457
458 let test = || Ok(ensure!(b"hmm"[1] == b'c'));
459 assert_err(test, "Condition failed: `b\"hmm\"[1] == b'c'` (109 vs 99)");
460
461 let test = || Ok(ensure!(PhantomData::<u8> {} != PhantomData));
462 assert_err(
463 test,
464 "Condition failed: `PhantomData::<u8> {} != PhantomData` (PhantomData<u8> vs PhantomData<u8>)",
465 );
466
467 let result = Ok::<_, Error>(1);
468 let test = || Ok(ensure!(result? == 2));
469 assert_err(test, "Condition failed: `result? == 2` (1 vs 2)");
470
471 let test = || Ok(ensure!((2, 3).1 == 2));
472 assert_err(test, "Condition failed: `(2, 3).1 == 2` (3 vs 2)");
473
474 #[rustfmt::skip]
475 let test = || Ok(ensure!((2, (3, 4)). 1.1 == 2));
476 assert_err(test, "Condition failed: `(2, (3, 4)).1.1 == 2` (4 vs 2)");
477
478 let err = anyhow!("");
479 let test = || Ok(ensure!(err.is::<&str>() == false));
480 assert_err(
481 test,
482 "Condition failed: `err.is::<&str>() == false` (true vs false)",
483 );
484
485 let test = || Ok(ensure!(err.is::<<str as ToOwned>::Owned>() == true));
486 assert_err(
487 test,
488 "Condition failed: `err.is::<<str as ToOwned>::Owned>() == true` (false vs true)",
489 );
490 }
491
492 #[test]
493 fn test_whitespace() {
494 #[derive(Debug)]
495 pub struct Point {
496 #[allow(dead_code)]
497 pub x: i32,
498 #[allow(dead_code)]
499 pub y: i32,
500 }
501
502 let point = Point { x: 0, y: 0 };
503 let test = || Ok(ensure!("" == format!("{:#?}", point)));
504 assert_err(
505 test,
506 "Condition failed: `\"\" == format!(\"{:#?}\", point)`",
507 );
508 }
509
510 #[test]
511 fn test_too_long() {
512 let test = || Ok(ensure!("" == "x".repeat(10)));
513 assert_err(
514 test,
515 "Condition failed: `\"\" == \"x\".repeat(10)` (\"\" vs \"xxxxxxxxxx\")",
516 );
517
518 let test = || Ok(ensure!("" == "x".repeat(80)));
519 assert_err(test, "Condition failed: `\"\" == \"x\".repeat(80)`");
520 }
521
522 #[test]
523 fn test_as() {
524 let test = || Ok(ensure!('\0' as u8 > 1));
525 assert_err(test, "Condition failed: `'\\0' as u8 > 1` (0 vs 1)");
526
527 let test = || Ok(ensure!('\0' as ::std::primitive::u8 > 1));
528 assert_err(
529 test,
530 "Condition failed: `'\\0' as ::std::primitive::u8 > 1` (0 vs 1)",
531 );
532
533 let test = || Ok(ensure!(&[0] as &[i32] == [1]));
534 assert_err(
535 test,
536 "Condition failed: `&[0] as &[i32] == [1]` ([0] vs [1])",
537 );
538
539 let test = || Ok(ensure!(0 as *const () as *mut _ == 1 as *mut ()));
540 assert_err(
541 test,
542 "Condition failed: `0 as *const () as *mut _ == 1 as *mut ()` (0x0 vs 0x1)",
543 );
544
545 let s = "";
546 let test = || Ok(ensure!(s as &str != s));
547 assert_err(test, "Condition failed: `s as &str != s` (\"\" vs \"\")");
548
549 let test = || Ok(ensure!(&s as &&str != &s));
550 assert_err(test, "Condition failed: `&s as &&str != &s` (\"\" vs \"\")");
551
552 let test = || Ok(ensure!(s as &'static str != s));
553 assert_err(
554 test,
555 "Condition failed: `s as &'static str != s` (\"\" vs \"\")",
556 );
557
558 let test = || Ok(ensure!(&s as &&'static str != &s));
559 assert_err(
560 test,
561 "Condition failed: `&s as &&'static str != &s` (\"\" vs \"\")",
562 );
563
564 let m: &mut str = Default::default();
565 let test = || Ok(ensure!(m as &mut str != s));
566 assert_err(
567 test,
568 "Condition failed: `m as &mut str != s` (\"\" vs \"\")",
569 );
570
571 let test = || Ok(ensure!(&m as &&mut str != &s));
572 assert_err(
573 test,
574 "Condition failed: `&m as &&mut str != &s` (\"\" vs \"\")",
575 );
576
577 let test = || Ok(ensure!(&m as &&'static mut str != &s));
578 assert_err(
579 test,
580 "Condition failed: `&m as &&'static mut str != &s` (\"\" vs \"\")",
581 );
582
583 let f = || {};
584 let test = || Ok(ensure!(f as fn() as usize * 0 != 0));
585 assert_err(
586 test,
587 "Condition failed: `f as fn() as usize * 0 != 0` (0 vs 0)",
588 );
589
590 let test = || Ok(ensure!(f as fn() -> () as usize * 0 != 0));
591 assert_err(
592 test,
593 "Condition failed: `f as fn() -> () as usize * 0 != 0` (0 vs 0)",
594 );
595
596 let test = || Ok(ensure!(f as for<'a> fn() as usize * 0 != 0));
597 assert_err(
598 test,
599 "Condition failed: `f as for<'a> fn() as usize * 0 != 0` (0 vs 0)",
600 );
601
602 let test = || Ok(ensure!(f as unsafe fn() as usize * 0 != 0));
603 assert_err(
604 test,
605 "Condition failed: `f as unsafe fn() as usize * 0 != 0` (0 vs 0)",
606 );
607
608 #[rustfmt::skip]
609 let test = || Ok(ensure!(f as extern "Rust" fn() as usize * 0 != 0));
610 assert_err(
611 test,
612 "Condition failed: `f as extern \"Rust\" fn() as usize * 0 != 0` (0 vs 0)",
613 );
614
615 extern "C" fn extern_fn() {}
616 #[rustfmt::skip]
617 #[allow(missing_abi)]
618 let test = || Ok(ensure!(extern_fn as extern fn() as usize * 0 != 0));
619 assert_err(
620 test,
621 "Condition failed: `extern_fn as extern fn() as usize * 0 != 0` (0 vs 0)",
622 );
623
624 let f = || -> ! { panic!() };
625 let test = || Ok(ensure!(f as fn() -> ! as usize * 0 != 0));
626 assert_err(
627 test,
628 "Condition failed: `f as fn() -> ! as usize * 0 != 0` (0 vs 0)",
629 );
630
631 trait EqDebug<T>: PartialEq<T> + Debug {
632 type Assoc;
633 }
634
635 impl<S, T> EqDebug<T> for S
636 where
637 S: PartialEq<T> + Debug,
638 {
639 type Assoc = bool;
640 }
641
642 let test = || Ok(ensure!(&0 as &dyn EqDebug<i32, Assoc = bool> != &0));
643 assert_err(
644 test,
645 "Condition failed: `&0 as &dyn EqDebug<i32, Assoc = bool> != &0` (0 vs 0)",
646 );
647
648 let test = || {
649 Ok(ensure!(
650 PhantomData as PhantomData<<i32 as ToOwned>::Owned> != PhantomData
651 ))
652 };
653 assert_err(
654 test,
655 "Condition failed: `PhantomData as PhantomData<<i32 as ToOwned>::Owned> != PhantomData` (PhantomData<i32> vs PhantomData<i32>)",
656 );
657
658 macro_rules! int {
659 (...) => {
660 u8
661 };
662 }
663
664 let test = || Ok(ensure!(0 as int!(...) != 0));
665 assert_err(test, "Condition failed: `0 as int!(...) != 0` (0 vs 0)");
666
667 let test = || Ok(ensure!(0 as int![...] != 0));
668 assert_err(test, "Condition failed: `0 as int![...] != 0` (0 vs 0)");
669
670 let test = || Ok(ensure!(0 as int! {...} != 0));
671 assert_err(test, "Condition failed: `0 as int! {...} != 0` (0 vs 0)");
672 }
673
674 #[test]
675 fn test_pat() {
676 let test = || Ok(ensure!(if let ref mut _x @ 0 = 0 { 0 } else { 1 } == 1));
677 assert_err(
678 test,
679 "Condition failed: `if let ref mut _x @ 0 = 0 { 0 } else { 1 } == 1` (0 vs 1)",
680 );
681
682 let test = || Ok(ensure!(if let -1..=1 = 0 { 0 } else { 1 } == 1));
683 assert_err(
684 test,
685 "Condition failed: `if let -1..=1 = 0 { 0 } else { 1 } == 1` (0 vs 1)",
686 );
687
688 let test = || Ok(ensure!(if let &0 = &0 { 0 } else { 1 } == 1));
689 assert_err(
690 test,
691 "Condition failed: `if let &0 = &0 { 0 } else { 1 } == 1` (0 vs 1)",
692 );
693
694 let test = || Ok(ensure!(if let &&0 = &&0 { 0 } else { 1 } == 1));
695 assert_err(
696 test,
697 "Condition failed: `if let &&0 = &&0 { 0 } else { 1 } == 1` (0 vs 1)",
698 );
699
700 let test = || Ok(ensure!(if let &mut 0 = &mut 0 { 0 } else { 1 } == 1));
701 assert_err(
702 test,
703 "Condition failed: `if let &mut 0 = &mut 0 { 0 } else { 1 } == 1` (0 vs 1)",
704 );
705
706 let test = || Ok(ensure!(if let &&mut 0 = &&mut 0 { 0 } else { 1 } == 1));
707 assert_err(
708 test,
709 "Condition failed: `if let &&mut 0 = &&mut 0 { 0 } else { 1 } == 1` (0 vs 1)",
710 );
711
712 let test = || Ok(ensure!(if let (0, 1) = (0, 1) { 0 } else { 1 } == 1));
713 assert_err(
714 test,
715 "Condition failed: `if let (0, 1) = (0, 1) { 0 } else { 1 } == 1` (0 vs 1)",
716 );
717
718 let test = || Ok(ensure!(if let [0] = b"\0" { 0 } else { 1 } == 1));
719 assert_err(
720 test,
721 "Condition failed: `if let [0] = b\"\\0\" { 0 } else { 1 } == 1` (0 vs 1)",
722 );
723
724 let p = PhantomData::<u8>;
725 let test = || Ok(ensure!(if let P::<u8> {} = p { 0 } else { 1 } == 1));
726 assert_err(
727 test,
728 "Condition failed: `if let P::<u8> {} = p { 0 } else { 1 } == 1` (0 vs 1)",
729 );
730
731 let test = || Ok(ensure!(if let ::std::marker::PhantomData = p {} != ()));
732 assert_err(
733 test,
734 "Condition failed: `if let ::std::marker::PhantomData = p {} != ()` (() vs ())",
735 );
736
737 let test = || Ok(ensure!(if let <S as Trait>::V = 0 { 0 } else { 1 } == 1));
738 assert_err(
739 test,
740 "Condition failed: `if let <S as Trait>::V = 0 { 0 } else { 1 } == 1` (0 vs 1)",
741 );
742
743 let test = || Ok(ensure!(for _ in iter::once(()) {} != ()));
744 assert_err(
745 test,
746 "Condition failed: `for _ in iter::once(()) {} != ()` (() vs ())",
747 );
748
749 let test = || Ok(ensure!(if let stringify!(x) = "x" { 0 } else { 1 } == 1));
750 assert_err(
751 test,
752 "Condition failed: `if let stringify!(x) = \"x\" { 0 } else { 1 } == 1` (0 vs 1)",
753 );
754 }