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/9.8.6/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/9.8.6/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/9.8.6/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/9.8.6/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/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
193 " a_function label: `f`,\n",
194 " a_param label: `a`,\n",
195 " a_param debug: `1`,\n",
196 " b_expr label: `b`,\n",
197 " b_expr debug: `1`,\n",
198 " a: `1`,\n",
199 " b: `1`"
200 );
201 assert_eq!(actual.unwrap_err(), message);
202 }
203
204 #[test]
205 fn lt() {
206 let a: i8 = 1;
207 let b: i8 = 2;
208 let actual = assert_fn_err_gt_x_as_result!(f, a, b);
209 let message = concat!(
210 "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
211 "https://docs.rs/assertables/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
212 " a_function label: `f`,\n",
213 " a_param label: `a`,\n",
214 " a_param debug: `1`,\n",
215 " b_expr label: `b`,\n",
216 " b_expr debug: `2`,\n",
217 " a: `1`,\n",
218 " b: `2`"
219 );
220 assert_eq!(actual.unwrap_err(), message);
221 }
222 }
223
224 mod arity_0 {
225
226 fn f() -> Result<i8, i8> {
227 Err(1)
228 }
229
230 #[test]
231 fn gt() {
232 let b: i8 = 0;
233 for _ in 0..1 {
234 let actual = assert_fn_err_gt_x_as_result!(f, b);
235 assert_eq!(actual.unwrap(), 1);
236 }
237 }
238
239 #[test]
240 fn eq() {
241 let b: i8 = 1;
242 let actual = assert_fn_err_gt_x_as_result!(f, b);
243 let message = concat!(
244 "assertion failed: `assert_fn_err_gt_x!(a_function, b_expr)`\n",
245 "https://docs.rs/assertables/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
246 " a_function label: `f`,\n",
247 " b_expr label: `b`,\n",
248 " b_expr debug: `1`,\n",
249 " a: `1`,\n",
250 " b: `1`"
251 );
252 assert_eq!(actual.unwrap_err(), message);
253 }
254
255 #[test]
256 fn lt() {
257 let b: i8 = 2;
258 let actual = assert_fn_err_gt_x_as_result!(f, b);
259 let message = concat!(
260 "assertion failed: `assert_fn_err_gt_x!(a_function, b_expr)`\n",
261 "https://docs.rs/assertables/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
262 " a_function label: `f`,\n",
263 " b_expr label: `b`,\n",
264 " b_expr debug: `2`,\n",
265 " a: `1`,\n",
266 " b: `2`"
267 );
268 assert_eq!(actual.unwrap_err(), message);
269 }
270 }
271}
272
273/// Assert a function error is greater than an expression.
274///
275/// Pseudocode:<br>
276/// (function(param) ⇒ Err(a) ⇒ a) > expr
277///
278/// * If true, return `a`.
279///
280/// * Otherwise, call [`panic!`] with a message and the values of the
281/// expressions with their debug representations.
282///
283/// # Examples
284///
285/// ```rust
286/// use assertables::*;
287/// # use std::panic;
288/// fn f(i: i8) -> Result<String, String> {
289/// match i {
290/// 0..=9 => Ok(format!("{}", i)),
291/// _ => Err(format!("{:?} is out of range", i)),
292/// }
293/// }
294///
295/// # fn main() {
296/// let a: i8 = 20;
297/// let b = String::from("10 is out of range");
298/// assert_fn_err_gt_x!(f, a, b);
299///
300/// # let result = panic::catch_unwind(|| {
301/// // This will panic
302/// let a: i8 = 10;
303/// let b = String::from("20 is out of range");
304/// assert_fn_err_gt_x!(f, a, b);
305/// # });
306/// // assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`
307/// // https://docs.rs/assertables/…/assertables/macro.assert_fn_err_gt_x.html
308/// // a_function label: `f`,
309/// // a_param label: `a`,
310/// // a_param debug: `10`,
311/// // b_expr label: `b`,
312/// // b_expr debug: `\"20 is out of range\"`,
313/// // a: `\"10 is out of range\"`,
314/// // b: `\"20 is out of range\"`
315/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
316/// # let message = concat!(
317/// # "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
318/// # "https://docs.rs/assertables/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
319/// # " a_function label: `f`,\n",
320/// # " a_param label: `a`,\n",
321/// # " a_param debug: `10`,\n",
322/// # " b_expr label: `b`,\n",
323/// # " b_expr debug: `\"20 is out of range\"`,\n",
324/// # " a: `\"10 is out of range\"`,\n",
325/// # " b: `\"20 is out of range\"`"
326/// # );
327/// # assert_eq!(actual, message);
328/// # }
329/// ```
330///
331/// # Module macros
332///
333/// * [`assert_fn_err_gt_x`](macro@crate::assert_fn_err_gt_x)
334/// * [`assert_fn_err_gt_x_as_result`](macro@crate::assert_fn_err_gt_x_as_result)
335/// * [`debug_assert_fn_err_gt_x`](macro@crate::debug_assert_fn_err_gt_x)
336///
337#[macro_export]
338macro_rules! assert_fn_err_gt_x {
339
340 //// Arity 1
341
342 ($a_function:path, $a_param:expr, $b_expr:expr $(,)?) => {
343 match $crate::assert_fn_err_gt_x_as_result!($a_function, $a_param, $b_expr) {
344 Ok(x) => x,
345 Err(err) => panic!("{}", err),
346 }
347 };
348
349 ($a_function:path, $a_param:expr, $b_expr:expr, $($message:tt)+) => {
350 match $crate::assert_fn_err_gt_x_as_result!($a_function, $a_param, $b_expr) {
351 Ok(x) => x,
352 Err(err) => panic!("{}\n{}", format_args!($($message)+), err),
353 }
354 };
355
356 //// Arity 0
357
358 ($a_function:path, $b_expr:expr $(,)?) => {
359 match $crate::assert_fn_err_gt_x_as_result!($a_function, $b_expr) {
360 Ok(x) => x,
361 Err(err) => panic!("{}", err),
362 }
363 };
364
365 ($a_function:path, $b_expr:expr, $($message:tt)+) => {
366 match $crate::assert_fn_err_gt_x_as_result!($a_function, $b_expr) {
367 Ok(x) => x,
368 Err(err) => panic!("{}\n{}", format_args!($($message)+), err),
369 }
370 };
371}
372
373#[cfg(test)]
374mod test_assert_fn_err_gt_x {
375 use std::panic;
376
377 mod arity_1 {
378 use super::*;
379
380 fn f(i: i8) -> Result<i8, i8> {
381 Err(i)
382 }
383
384 #[test]
385 fn gt() {
386 let a: i8 = 2;
387 let b: i8 = 1;
388 for _ in 0..1 {
389 let actual = assert_fn_err_gt_x!(f, a, b);
390 let expect = 2;
391 assert_eq!(actual, expect);
392 }
393 }
394
395 #[test]
396 fn eq() {
397 let result = panic::catch_unwind(|| {
398 let a: i8 = 1;
399 let b: i8 = 1;
400 let _actual = assert_fn_err_gt_x!(f, a, b);
401 });
402 let message = concat!(
403 "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
404 "https://docs.rs/assertables/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
405 " a_function label: `f`,\n",
406 " a_param label: `a`,\n",
407 " a_param debug: `1`,\n",
408 " b_expr label: `b`,\n",
409 " b_expr debug: `1`,\n",
410 " a: `1`,\n",
411 " b: `1`"
412 );
413 assert_eq!(
414 result
415 .unwrap_err()
416 .downcast::<String>()
417 .unwrap()
418 .to_string(),
419 message
420 );
421 }
422
423 #[test]
424 fn lt() {
425 let result = panic::catch_unwind(|| {
426 let a: i8 = 1;
427 let b: i8 = 2;
428 let _actual = assert_fn_err_gt_x!(f, a, b);
429 });
430 let message = concat!(
431 "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
432 "https://docs.rs/assertables/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
433 " a_function label: `f`,\n",
434 " a_param label: `a`,\n",
435 " a_param debug: `1`,\n",
436 " b_expr label: `b`,\n",
437 " b_expr debug: `2`,\n",
438 " a: `1`,\n",
439 " b: `2`"
440 );
441 assert_eq!(
442 result
443 .unwrap_err()
444 .downcast::<String>()
445 .unwrap()
446 .to_string(),
447 message
448 );
449 }
450 }
451
452 mod arity_0 {
453 use super::*;
454
455 fn f() -> Result<i8, i8> {
456 Err(1)
457 }
458
459 #[test]
460 fn gt() {
461 let b: i8 = 0;
462 for _ in 0..1 {
463 let actual = assert_fn_err_gt_x!(f, b);
464 let expect = 1;
465 assert_eq!(actual, expect);
466 }
467 }
468
469 #[test]
470 fn eq() {
471 let result = panic::catch_unwind(|| {
472 let b: i8 = 1;
473 let _actual = assert_fn_err_gt_x!(f, b);
474 });
475 let message = concat!(
476 "assertion failed: `assert_fn_err_gt_x!(a_function, b_expr)`\n",
477 "https://docs.rs/assertables/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
478 " a_function label: `f`,\n",
479 " b_expr label: `b`,\n",
480 " b_expr debug: `1`,\n",
481 " a: `1`,\n",
482 " b: `1`"
483 );
484 assert_eq!(
485 result
486 .unwrap_err()
487 .downcast::<String>()
488 .unwrap()
489 .to_string(),
490 message
491 );
492 }
493
494 #[test]
495 fn lt() {
496 let result = panic::catch_unwind(|| {
497 let b: i8 = 2;
498 let _actual = assert_fn_err_gt_x!(f, b);
499 });
500 let message = concat!(
501 "assertion failed: `assert_fn_err_gt_x!(a_function, b_expr)`\n",
502 "https://docs.rs/assertables/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
503 " a_function label: `f`,\n",
504 " b_expr label: `b`,\n",
505 " b_expr debug: `2`,\n",
506 " a: `1`,\n",
507 " b: `2`"
508 );
509 assert_eq!(
510 result
511 .unwrap_err()
512 .downcast::<String>()
513 .unwrap()
514 .to_string(),
515 message
516 );
517 }
518 }
519}
520
521/// Assert a function error is greater than an expression.
522///
523/// Pseudocode:<br>
524/// (function(param) ⇒ Err(a) ⇒ a) > expr
525///
526/// This macro provides the same statements as [`assert_fn_err_gt_x`](macro.assert_fn_err_gt_x.html),
527/// except this macro's statements are only enabled in non-optimized
528/// builds by default. An optimized build will not execute this macro's
529/// statements unless `-C debug-assertions` is passed to the compiler.
530///
531/// This macro is useful for checks that are too expensive to be present
532/// in a release build but may be helpful during development.
533///
534/// The result of expanding this macro is always type checked.
535///
536/// An unchecked assertion allows a program in an inconsistent state to
537/// keep running, which might have unexpected consequences but does not
538/// introduce unsafety as long as this only happens in safe code. The
539/// performance cost of assertions, however, is not measurable in general.
540/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
541/// after thorough profiling, and more importantly, only in safe code!
542///
543/// This macro is intended to work in a similar way to
544/// [`::std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
545///
546/// # Module macros
547///
548/// * [`assert_fn_err_gt_x`](macro@crate::assert_fn_err_gt_x)
549/// * [`assert_fn_err_gt_x`](macro@crate::assert_fn_err_gt_x)
550/// * [`debug_assert_fn_err_gt_x`](macro@crate::debug_assert_fn_err_gt_x)
551///
552#[macro_export]
553macro_rules! debug_assert_fn_err_gt_x {
554 ($($arg:tt)*) => {
555 if cfg!(debug_assertions) {
556 $crate::assert_fn_err_gt_x!($($arg)*);
557 }
558 };
559}
560
561#[cfg(test)]
562mod test_debug_assert_fn_err_gt_x {
563 use std::panic;
564
565 mod arity_1 {
566 use super::*;
567
568 fn f(i: i8) -> Result<i8, i8> {
569 Err(i)
570 }
571
572 #[test]
573 fn gt() {
574 let a: i8 = 2;
575 let b: i8 = 1;
576 for _ in 0..1 {
577 let _actual = debug_assert_fn_err_gt_x!(f, a, b);
578 let _expect = 2;
579 // assert_eq!(actual, expect);
580 }
581 }
582
583 #[test]
584 fn eq() {
585 let result = panic::catch_unwind(|| {
586 let a: i8 = 1;
587 let b: i8 = 1;
588 let _actual = debug_assert_fn_err_gt_x!(f, a, b);
589 });
590 let message = concat!(
591 "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
592 "https://docs.rs/assertables/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
593 " a_function label: `f`,\n",
594 " a_param label: `a`,\n",
595 " a_param debug: `1`,\n",
596 " b_expr label: `b`,\n",
597 " b_expr debug: `1`,\n",
598 " a: `1`,\n",
599 " b: `1`"
600 );
601 assert_eq!(
602 result
603 .unwrap_err()
604 .downcast::<String>()
605 .unwrap()
606 .to_string(),
607 message
608 );
609 }
610
611 #[test]
612 fn lt() {
613 let result = panic::catch_unwind(|| {
614 let a: i8 = 1;
615 let b: i8 = 2;
616 let _actual = debug_assert_fn_err_gt_x!(f, a, b);
617 });
618 let message = concat!(
619 "assertion failed: `assert_fn_err_gt_x!(a_function, a_param, b_expr)`\n",
620 "https://docs.rs/assertables/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
621 " a_function label: `f`,\n",
622 " a_param label: `a`,\n",
623 " a_param debug: `1`,\n",
624 " b_expr label: `b`,\n",
625 " b_expr debug: `2`,\n",
626 " a: `1`,\n",
627 " b: `2`"
628 );
629 assert_eq!(
630 result
631 .unwrap_err()
632 .downcast::<String>()
633 .unwrap()
634 .to_string(),
635 message
636 );
637 }
638 }
639
640 mod arity_0 {
641 use super::*;
642
643 fn f() -> Result<i8, i8> {
644 Err(1)
645 }
646
647 #[test]
648 fn gt() {
649 let b: i8 = 0;
650 for _ in 0..1 {
651 let _actual = debug_assert_fn_err_gt_x!(f, b);
652 let _expect = 1;
653 // assert_eq!(actual, expect);
654 }
655 }
656
657 #[test]
658 fn eq() {
659 let result = panic::catch_unwind(|| {
660 let b: i8 = 1;
661 let _actual = debug_assert_fn_err_gt_x!(f, b);
662 });
663 let message = concat!(
664 "assertion failed: `assert_fn_err_gt_x!(a_function, b_expr)`\n",
665 "https://docs.rs/assertables/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
666 " a_function label: `f`,\n",
667 " b_expr label: `b`,\n",
668 " b_expr debug: `1`,\n",
669 " a: `1`,\n",
670 " b: `1`"
671 );
672 assert_eq!(
673 result
674 .unwrap_err()
675 .downcast::<String>()
676 .unwrap()
677 .to_string(),
678 message
679 );
680 }
681
682 #[test]
683 fn lt() {
684 let result = panic::catch_unwind(|| {
685 let b: i8 = 2;
686 let _actual = debug_assert_fn_err_gt_x!(f, b);
687 });
688 let message = concat!(
689 "assertion failed: `assert_fn_err_gt_x!(a_function, b_expr)`\n",
690 "https://docs.rs/assertables/9.8.6/assertables/macro.assert_fn_err_gt_x.html\n",
691 " a_function label: `f`,\n",
692 " b_expr label: `b`,\n",
693 " b_expr debug: `2`,\n",
694 " a: `1`,\n",
695 " b: `2`"
696 );
697 assert_eq!(
698 result
699 .unwrap_err()
700 .downcast::<String>()
701 .unwrap()
702 .to_string(),
703 message
704 );
705 }
706 }
707}