| 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 |
} |