assertables/assert_fn_err/assert_fn_err_gt_x.rs
1//! Assert a function Err(…) is greater than an expression.
2//!
3//! Pseudocode:<br>
4//! (function(param) ⇒ Err(a) ⇒ a) > expr
5//!
6//! # Example
7//!
8//! ```rust
9//! use assertables::*;
10//! fn f(i: i8) -> Result<String, String> {
11//! match i {
12//! 0..=9 => Ok(format!("{}", i)),
13//! _ => Err(format!("{:?} is out of range", i)),
14//! }
15//! }
16//!
17//! let a: i8 = 20;
18//! let b = String::from("10 is out of range");
19//! assert_fn_err_gt_x!(f, a, b);
20//! ```
21//!
22//! # Module macros
23//!
24//! * [`assert_fn_err_gt_x`](macro@crate::assert_fn_err_gt_x)
25//! * [`assert_fn_err_gt_x_as_result`](macro@crate::assert_fn_err_gt_x_as_result)
26//! * [`debug_assert_fn_err_gt_x`](macro@crate::debug_assert_fn_err_gt_x)
27
28/// Assert a function error is greater than an expression.
29///
30/// Pseudocode:<br>
31/// (function(param) ⇒ Err(a) ⇒ a) > expr
32///
33/// * If true, return Result `Ok(a)`.
34///
35/// * Otherwise, return Result `Err(message)`.
36///
37/// This macro is useful for runtime checks, such as checking parameters,
38/// or sanitizing inputs, or handling different results in different ways.
39///
40/// # Module macros
41///
42/// * [`assert_fn_err_gt_x`](macro@crate::assert_fn_err_gt_x)
43/// * [`assert_fn_err_gt_x_as_result`](macro@crate::assert_fn_err_gt_x_as_result)
44/// * [`debug_assert_fn_err_gt_x`](macro@crate::debug_assert_fn_err_gt_x)
45///
46#[macro_export]
47macro_rules! assert_fn_err_gt_x_as_result {
48
49 //// Arity 1
50
51 ($a_function:path, $a_param:expr, $b_expr:expr $(,)?) => {
52 match (&$a_function, &$a_param, &$b_expr) {
53 (_a_function, a_param, b_expr) => {
54 match ($a_function($a_param)) {
55 Err(a) => {
56 if a > $b_expr {
57 Ok(a)
58 } else {
59 Err(
60 format!(
61 concat!(
62 "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
63 "https://docs.rs/assertables/", env!("CARGO_PKG_VERSION"), "/assertables/macro.assert_fn_err_gt_x.html\n",
64 " a_function label: `{}`,\n",
65 " a_param label: `{}`,\n",
66 " a_param debug: `{:?}`,\n",
67 " b_expr label: `{}`,\n",
68 " b_expr debug: `{:?}`,\n",
69 " a: `{:?}`,\n",
70 " b: `{:?}`",
71 ),
72 stringify!($a_function),
73 stringify!($a_param),
74 a_param,
75 stringify!($b_expr),
76 b_expr,
77 a,
78 $b_expr
79 )
80 )
81 }
82 },
83 a => {
84 Err(
85 format!(
86 concat!(
87 "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
88 "https://docs.rs/assertables/", env!("CARGO_PKG_VERSION"), "/assertables/macro.assert_fn_err_gt_x.html\n",
89 " a_function label: `{}`,\n",
90 " a_param label: `{}`,\n",
91 " a_param debug: `{:?}`,\n",
92 " b_expr label: `{}`,\n",
93 " b_expr debug: `{:?}`,\n",
94 " a: `{:?}`",
95 ),
96 stringify!($a_function),
97 stringify!($a_param),
98 a_param,
99 stringify!($b_expr),
100 b_expr,
101 a
102 )
103 )
104 }
105 }
106 }
107 }
108 };
109
110 //// Arity 0
111
112 ($a_function:path, $b_expr:expr $(,)?) => {
113 match (&$a_function, &$b_expr) {
114 (_a_function, b_expr) => {
115 match ($a_function()) {
116 Err(a) => {
117 if a > $b_expr {
118 Ok(a)
119 } else {
120 Err(
121 format!(
122 concat!(
123 "assertion failed: `assert_fn_err_gt_x!(a_function, b_expr)`\n",
124 "https://docs.rs/assertables/", env!("CARGO_PKG_VERSION"), "/assertables/macro.assert_fn_err_gt_x.html\n",
125 " a_function label: `{}`,\n",
126 " b_expr label: `{}`,\n",
127 " b_expr debug: `{:?}`,\n",
128 " a: `{:?}`,\n",
129 " b: `{:?}`",
130 ),
131 stringify!($a_function),
132 stringify!($b_expr),
133 b_expr,
134 a,
135 $b_expr
136 )
137 )
138 }
139 },
140 a => {
141 Err(
142 format!(
143 concat!(
144 "assertion failed: `assert_fn_err_gt_x!(a_function, b_expr)`\n",
145 "https://docs.rs/assertables/", env!("CARGO_PKG_VERSION"), "/assertables/macro.assert_fn_err_gt_x.html\n",
146 " a_function label: `{}`,\n",
147 " b_expr label: `{}`,\n",
148 " b_expr debug: `{:?}`,\n",
149 " a: `{:?}`",
150 ),
151 stringify!($a_function),
152 stringify!($b_expr),
153 b_expr,
154 a
155 )
156 )
157 }
158 }
159 }
160 }
161 };
162
163}
164
165#[cfg(test)]
166mod test_assert_fn_err_gt_x_as_result {
167 // use std::sync::Once;
168
169 mod arity_1 {
170
171 fn f(i: i8) -> Result<i8, i8> {
172 Err(i)
173 }
174
175 #[test]
176 fn gt() {
177 let a: i8 = 2;
178 let b: i8 = 1;
179 for _ in 0..1 {
180 let actual = assert_fn_err_gt_x_as_result!(f, a, b);
181 assert_eq!(actual.unwrap(), 2);
182 }
183 }
184
185 #[test]
186 fn eq() {
187 let a: i8 = 1;
188 let b: i8 = 1;
189 let actual = assert_fn_err_gt_x_as_result!(f, a, b);
190 let message = concat!(
191 "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
192 "https://docs.rs/assertables/",
193 env!("CARGO_PKG_VERSION"),
194 "/assertables/macro.assert_fn_err_gt_x.html\n",
195 " a_function label: `f`,\n",
196 " a_param label: `a`,\n",
197 " a_param debug: `1`,\n",
198 " b_expr label: `b`,\n",
199 " b_expr debug: `1`,\n",
200 " a: `1`,\n",
201 " b: `1`"
202 );
203 assert_eq!(actual.unwrap_err(), message);
204 }
205
206 #[test]
207 fn lt() {
208 let a: i8 = 1;
209 let b: i8 = 2;
210 let actual = assert_fn_err_gt_x_as_result!(f, a, b);
211 let message = concat!(
212 "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
213 "https://docs.rs/assertables/",
214 env!("CARGO_PKG_VERSION"),
215 "/assertables/macro.assert_fn_err_gt_x.html\n",
216 " a_function label: `f`,\n",
217 " a_param label: `a`,\n",
218 " a_param debug: `1`,\n",
219 " b_expr label: `b`,\n",
220 " b_expr debug: `2`,\n",
221 " a: `1`,\n",
222 " b: `2`"
223 );
224 assert_eq!(actual.unwrap_err(), message);
225 }
226 }
227
228 mod arity_0 {
229
230 fn f() -> Result<i8, i8> {
231 Err(1)
232 }
233
234 #[test]
235 fn gt() {
236 let b: i8 = 0;
237 for _ in 0..1 {
238 let actual = assert_fn_err_gt_x_as_result!(f, b);
239 assert_eq!(actual.unwrap(), 1);
240 }
241 }
242
243 #[test]
244 fn eq() {
245 let b: i8 = 1;
246 let actual = assert_fn_err_gt_x_as_result!(f, b);
247 let message = concat!(
248 "assertion failed: `assert_fn_err_gt_x!(a_function, b_expr)`\n",
249 "https://docs.rs/assertables/",
250 env!("CARGO_PKG_VERSION"),
251 "/assertables/macro.assert_fn_err_gt_x.html\n",
252 " a_function label: `f`,\n",
253 " b_expr label: `b`,\n",
254 " b_expr debug: `1`,\n",
255 " a: `1`,\n",
256 " b: `1`"
257 );
258 assert_eq!(actual.unwrap_err(), message);
259 }
260
261 #[test]
262 fn lt() {
263 let b: i8 = 2;
264 let actual = assert_fn_err_gt_x_as_result!(f, b);
265 let message = concat!(
266 "assertion failed: `assert_fn_err_gt_x!(a_function, b_expr)`\n",
267 "https://docs.rs/assertables/",
268 env!("CARGO_PKG_VERSION"),
269 "/assertables/macro.assert_fn_err_gt_x.html\n",
270 " a_function label: `f`,\n",
271 " b_expr label: `b`,\n",
272 " b_expr debug: `2`,\n",
273 " a: `1`,\n",
274 " b: `2`"
275 );
276 assert_eq!(actual.unwrap_err(), message);
277 }
278 }
279}
280
281/// Assert a function error is greater than an expression.
282///
283/// Pseudocode:<br>
284/// (function(param) ⇒ Err(a) ⇒ a) > expr
285///
286/// * If true, return `a`.
287///
288/// * Otherwise, call [`panic!`] with a message and the values of the
289/// expressions with their debug representations.
290///
291/// # Examples
292///
293/// ```rust
294/// use assertables::*;
295/// # use std::panic;
296/// fn f(i: i8) -> Result<String, String> {
297/// match i {
298/// 0..=9 => Ok(format!("{}", i)),
299/// _ => Err(format!("{:?} is out of range", i)),
300/// }
301/// }
302///
303/// # fn main() {
304/// let a: i8 = 20;
305/// let b = String::from("10 is out of range");
306/// assert_fn_err_gt_x!(f, a, b);
307///
308/// # let result = panic::catch_unwind(|| {
309/// // This will panic
310/// let a: i8 = 10;
311/// let b = String::from("20 is out of range");
312/// assert_fn_err_gt_x!(f, a, b);
313/// # });
314/// // assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`
315/// // https://docs.rs/assertables/9.7.0/assertables/macro.assert_fn_err_gt_x.html
316/// // a_function label: `f`,
317/// // a_param label: `a`,
318/// // a_param debug: `10`,
319/// // b_expr label: `b`,
320/// // b_expr debug: `\"20 is out of range\"`,
321/// // a: `\"10 is out of range\"`,
322/// // b: `\"20 is out of range\"`
323/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
324/// # let message = concat!(
325/// # "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
326/// # "https://docs.rs/assertables/", env!("CARGO_PKG_VERSION"), "/assertables/macro.assert_fn_err_gt_x.html\n",
327/// # " a_function label: `f`,\n",
328/// # " a_param label: `a`,\n",
329/// # " a_param debug: `10`,\n",
330/// # " b_expr label: `b`,\n",
331/// # " b_expr debug: `\"20 is out of range\"`,\n",
332/// # " a: `\"10 is out of range\"`,\n",
333/// # " b: `\"20 is out of range\"`"
334/// # );
335/// # assert_eq!(actual, message);
336/// # }
337/// ```
338///
339/// # Module macros
340///
341/// * [`assert_fn_err_gt_x`](macro@crate::assert_fn_err_gt_x)
342/// * [`assert_fn_err_gt_x_as_result`](macro@crate::assert_fn_err_gt_x_as_result)
343/// * [`debug_assert_fn_err_gt_x`](macro@crate::debug_assert_fn_err_gt_x)
344///
345#[macro_export]
346macro_rules! assert_fn_err_gt_x {
347
348 //// Arity 1
349
350 ($a_function:path, $a_param:expr, $b_expr:expr $(,)?) => {
351 match $crate::assert_fn_err_gt_x_as_result!($a_function, $a_param, $b_expr) {
352 Ok(x) => x,
353 Err(err) => panic!("{}", err),
354 }
355 };
356
357 ($a_function:path, $a_param:expr, $b_expr:expr, $($message:tt)+) => {
358 match $crate::assert_fn_err_gt_x_as_result!($a_function, $a_param, $b_expr) {
359 Ok(x) => x,
360 Err(err) => panic!("{}\n{}", format_args!($($message)+), err),
361 }
362 };
363
364 //// Arity 0
365
366 ($a_function:path, $b_expr:expr $(,)?) => {
367 match $crate::assert_fn_err_gt_x_as_result!($a_function, $b_expr) {
368 Ok(x) => x,
369 Err(err) => panic!("{}", err),
370 }
371 };
372
373 ($a_function:path, $b_expr:expr, $($message:tt)+) => {
374 match $crate::assert_fn_err_gt_x_as_result!($a_function, $b_expr) {
375 Ok(x) => x,
376 Err(err) => panic!("{}\n{}", format_args!($($message)+), err),
377 }
378 };
379}
380
381#[cfg(test)]
382mod test_assert_fn_err_gt_x {
383 use std::panic;
384
385 mod arity_1 {
386 use super::*;
387
388 fn f(i: i8) -> Result<i8, i8> {
389 Err(i)
390 }
391
392 #[test]
393 fn gt() {
394 let a: i8 = 2;
395 let b: i8 = 1;
396 for _ in 0..1 {
397 let actual = assert_fn_err_gt_x!(f, a, b);
398 assert_eq!(actual, 2);
399 }
400 }
401
402 #[test]
403 fn eq() {
404 let result = panic::catch_unwind(|| {
405 let a: i8 = 1;
406 let b: i8 = 1;
407 let _actual = assert_fn_err_gt_x!(f, a, b);
408 });
409 let message = concat!(
410 "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
411 "https://docs.rs/assertables/",
412 env!("CARGO_PKG_VERSION"),
413 "/assertables/macro.assert_fn_err_gt_x.html\n",
414 " a_function label: `f`,\n",
415 " a_param label: `a`,\n",
416 " a_param debug: `1`,\n",
417 " b_expr label: `b`,\n",
418 " b_expr debug: `1`,\n",
419 " a: `1`,\n",
420 " b: `1`"
421 );
422 assert_eq!(
423 result
424 .unwrap_err()
425 .downcast::<String>()
426 .unwrap()
427 .to_string(),
428 message
429 );
430 }
431
432 #[test]
433 fn lt() {
434 let result = panic::catch_unwind(|| {
435 let a: i8 = 1;
436 let b: i8 = 2;
437 let _actual = assert_fn_err_gt_x!(f, a, b);
438 });
439 let message = concat!(
440 "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
441 "https://docs.rs/assertables/",
442 env!("CARGO_PKG_VERSION"),
443 "/assertables/macro.assert_fn_err_gt_x.html\n",
444 " a_function label: `f`,\n",
445 " a_param label: `a`,\n",
446 " a_param debug: `1`,\n",
447 " b_expr label: `b`,\n",
448 " b_expr debug: `2`,\n",
449 " a: `1`,\n",
450 " b: `2`"
451 );
452 assert_eq!(
453 result
454 .unwrap_err()
455 .downcast::<String>()
456 .unwrap()
457 .to_string(),
458 message
459 );
460 }
461 }
462
463 mod arity_0 {
464 use super::*;
465
466 fn f() -> Result<i8, i8> {
467 Err(1)
468 }
469
470 #[test]
471 fn gt() {
472 let b: i8 = 0;
473 for _ in 0..1 {
474 let actual = assert_fn_err_gt_x!(f, b);
475 assert_eq!(actual, 1);
476 }
477 }
478
479 #[test]
480 fn eq() {
481 let result = panic::catch_unwind(|| {
482 let b: i8 = 1;
483 let _actual = assert_fn_err_gt_x!(f, b);
484 });
485 let message = concat!(
486 "assertion failed: `assert_fn_err_gt_x!(a_function, b_expr)`\n",
487 "https://docs.rs/assertables/",
488 env!("CARGO_PKG_VERSION"),
489 "/assertables/macro.assert_fn_err_gt_x.html\n",
490 " a_function label: `f`,\n",
491 " b_expr label: `b`,\n",
492 " b_expr debug: `1`,\n",
493 " a: `1`,\n",
494 " b: `1`"
495 );
496 assert_eq!(
497 result
498 .unwrap_err()
499 .downcast::<String>()
500 .unwrap()
501 .to_string(),
502 message
503 );
504 }
505
506 #[test]
507 fn lt() {
508 let result = panic::catch_unwind(|| {
509 let b: i8 = 2;
510 let _actual = assert_fn_err_gt_x!(f, b);
511 });
512 let message = concat!(
513 "assertion failed: `assert_fn_err_gt_x!(a_function, b_expr)`\n",
514 "https://docs.rs/assertables/",
515 env!("CARGO_PKG_VERSION"),
516 "/assertables/macro.assert_fn_err_gt_x.html\n",
517 " a_function label: `f`,\n",
518 " b_expr label: `b`,\n",
519 " b_expr debug: `2`,\n",
520 " a: `1`,\n",
521 " b: `2`"
522 );
523 assert_eq!(
524 result
525 .unwrap_err()
526 .downcast::<String>()
527 .unwrap()
528 .to_string(),
529 message
530 );
531 }
532 }
533}
534
535/// Assert a function error is greater than an expression.
536///
537/// Pseudocode:<br>
538/// (function(param) ⇒ Err(a) ⇒ a) > expr
539///
540/// This macro provides the same statements as [`assert_fn_err_gt_x`](macro.assert_fn_err_gt_x.html),
541/// except this macro's statements are only enabled in non-optimized
542/// builds by default. An optimized build will not execute this macro's
543/// statements unless `-C debug-assertions` is passed to the compiler.
544///
545/// This macro is useful for checks that are too expensive to be present
546/// in a release build but may be helpful during development.
547///
548/// The result of expanding this macro is always type checked.
549///
550/// An unchecked assertion allows a program in an inconsistent state to
551/// keep running, which might have unexpected consequences but does not
552/// introduce unsafety as long as this only happens in safe code. The
553/// performance cost of assertions, however, is not measurable in general.
554/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
555/// after thorough profiling, and more importantly, only in safe code!
556///
557/// This macro is intended to work in a similar way to
558/// [`::std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
559///
560/// # Module macros
561///
562/// * [`assert_fn_err_gt_x`](macro@crate::assert_fn_err_gt_x)
563/// * [`assert_fn_err_gt_x`](macro@crate::assert_fn_err_gt_x)
564/// * [`debug_assert_fn_err_gt_x`](macro@crate::debug_assert_fn_err_gt_x)
565///
566#[macro_export]
567macro_rules! debug_assert_fn_err_gt_x {
568 ($($arg:tt)*) => {
569 if $crate::cfg!(debug_assertions) {
570 $crate::assert_fn_err_gt_x!($($arg)*);
571 }
572 };
573}