assertables/assert_abs_diff/assert_abs_diff_ge_x.rs
1//! Assert an absolute difference is greater than or equal to an expression.
2//!
3//! Pseudocode:<br>
4//! |Δ| ≥ x
5//!
6//! # Example
7//!
8//! ```rust
9//! use assertables::*;
10//!
11//! let a = 10;
12//! let b = 13;
13//! let x = 2;
14//! assert_abs_diff_ge_x!(a, b, x);
15//! ```
16//!
17//! # Module macros
18//!
19//! * [`assert_abs_diff_ge_x`](macro@crate::assert_abs_diff_ge_x)
20//! * [`assert_abs_diff_ge_x_as_result`](macro@crate::assert_abs_diff_ge_x_as_result)
21//! * [`debug_assert_abs_diff_ge_x`](macro@crate::debug_assert_abs_diff_ge_x)
22
23/// Assert an absolute difference is greater than or equal to an expression.
24///
25/// Pseudocode:<br>
26/// |Δ| ≥ x
27///
28/// * If true, return `Ok((lhs, rhs))`.
29///
30/// * Otherwise, return [`Err`] with a message and the values of the
31/// expressions with their debug representations.
32///
33/// This macro is useful for runtime checks, such as checking parameters,
34/// or sanitizing inputs, or handling different results in different ways.
35///
36/// # Module macros
37///
38/// * [`assert_abs_diff_ge_x`](macro@crate::assert_abs_diff_ge_x)
39/// * [`assert_abs_diff_ge_x_as_result`](macro@crate::assert_abs_diff_ge_x_as_result)
40/// * [`debug_assert_abs_diff_ge_x`](macro@crate::debug_assert_abs_diff_ge_x)
41///
42#[macro_export]
43macro_rules! assert_abs_diff_ge_x_as_result {
44 ($a:expr, $b:expr, $x:expr $(,)?) => {
45 match (&$a, &$b, &$x) {
46 (a, b, x) => {
47 match ::std::panic::catch_unwind(|| if (a >= b) { a - b } else { b - a }) {
48 Ok(abs_diff) => {
49 if abs_diff >= *x {
50 Ok((abs_diff, *x))
51 } else {
52 Err(
53 format!(
54 concat!(
55 "assertion failed: `assert_abs_diff_ge_x!(a, b, x)`\n",
56 "https://docs.rs/assertables/9.5.6/assertables/macro.assert_abs_diff_ge_x.html\n",
57 " a label: `{}`,\n",
58 " a debug: `{:?}`,\n",
59 " b label: `{}`,\n",
60 " b debug: `{:?}`,\n",
61 " x label: `{}`,\n",
62 " x debug: `{:?}`,\n",
63 " |Δ|: `{:?}`,\n",
64 " |Δ| ≥ x: {}"
65 ),
66 stringify!($a),
67 a,
68 stringify!($b),
69 b,
70 stringify!($x),
71 x,
72 abs_diff,
73 false
74 )
75 )
76 }
77 },
78 Err(_err) => {
79 Err(
80 format!(
81 concat!(
82 "assertion failed: `assert_abs_diff_ge_x!(a, b, x)`\n",
83 "https://docs.rs/assertables/9.5.6/assertables/macro.assert_abs_diff_ge_x.html\n",
84 " a label: `{}`,\n",
85 " a debug: `{:?}`,\n",
86 " b label: `{}`,\n",
87 " b debug: `{:?}`,\n",
88 " x label: `{}`,\n",
89 " x debug: `{:?}`,\n",
90 " |Δ|: panic", //TODO add the panic message
91 ),
92 stringify!($a),
93 a,
94 stringify!($b),
95 b,
96 stringify!($x),
97 x
98 )
99 )
100 }
101 }
102 }
103 }
104 };
105}
106
107#[cfg(test)]
108mod test_assert_abs_diff_ge_x_as_result {
109 use std::sync::Once;
110
111 #[test]
112 fn gt() {
113 let a: i8 = 10;
114 let b: i8 = 13;
115 let x: i8 = 2;
116 let actual = assert_abs_diff_ge_x_as_result!(a, b, x);
117 assert_eq!(actual.unwrap(), (3, 2));
118 }
119
120 #[test]
121 fn gt_once() {
122
123 static A: Once = Once::new();
124 fn a() -> i8 {
125 if A.is_completed() { panic!("A.is_completed()") } else { A.call_once(|| {}) }
126 10
127 }
128
129 static B: Once = Once::new();
130 fn b() -> i8 {
131 if B.is_completed() { panic!("B.is_completed()") } else { B.call_once(|| {}) }
132 13
133 }
134
135 static X: Once = Once::new();
136 fn x() -> i8 {
137 if X.is_completed() { panic!("X.is_completed()") } else { X.call_once(|| {}) }
138 2
139 }
140
141 assert_eq!(A.is_completed(), false);
142 assert_eq!(B.is_completed(), false);
143 assert_eq!(X.is_completed(), false);
144 let result = assert_abs_diff_ge_x_as_result!(a(), b(), x());
145 assert!(result.is_ok());
146 assert_eq!(A.is_completed(), true);
147 assert_eq!(B.is_completed(), true);
148 assert_eq!(X.is_completed(), true);
149
150 }
151
152 #[test]
153 fn eq() {
154 let a: i8 = 10;
155 let b: i8 = 13;
156 let x: i8 = 3;
157 let actual = assert_abs_diff_ge_x_as_result!(a, b, x);
158 assert_eq!(actual.unwrap(), (3, 3));
159 }
160
161 #[test]
162 fn eq_once() {
163
164 static A: Once = Once::new();
165 fn a() -> i8 {
166 if A.is_completed() { panic!("A.is_completed()") } else { A.call_once(|| {}) }
167 10
168 }
169
170 static B: Once = Once::new();
171 fn b() -> i8 {
172 if B.is_completed() { panic!("B.is_completed()") } else { B.call_once(|| {}) }
173 13
174 }
175
176 static X: Once = Once::new();
177 fn x() -> i8 {
178 if X.is_completed() { panic!("X.is_completed()") } else { X.call_once(|| {}) }
179 3
180 }
181
182 assert_eq!(A.is_completed(), false);
183 assert_eq!(B.is_completed(), false);
184 assert_eq!(X.is_completed(), false);
185 let result = assert_abs_diff_ge_x_as_result!(a(), b(), x());
186 assert!(result.is_ok());
187 assert_eq!(A.is_completed(), true);
188 assert_eq!(B.is_completed(), true);
189 assert_eq!(X.is_completed(), true);
190
191 }
192 #[test]
193 fn lt() {
194 let a: i8 = 10;
195 let b: i8 = 13;
196 let x: i8 = 4;
197 let actual = assert_abs_diff_ge_x_as_result!(a, b, x);
198 let message = concat!(
199 "assertion failed: `assert_abs_diff_ge_x!(a, b, x)`\n",
200 "https://docs.rs/assertables/9.5.6/assertables/macro.assert_abs_diff_ge_x.html\n",
201 " a label: `a`,\n",
202 " a debug: `10`,\n",
203 " b label: `b`,\n",
204 " b debug: `13`,\n",
205 " x label: `x`,\n",
206 " x debug: `4`,\n",
207 " |Δ|: `3`,\n",
208 " |Δ| ≥ x: false"
209 );
210 assert_eq!(actual.unwrap_err(), message);
211 }
212
213 #[test]
214 fn overflow() {
215 let a: i8 = i8::MAX;
216 let b: i8 = i8::MIN;
217 let x: i8 = 0;
218 let actual = assert_abs_diff_ge_x_as_result!(a, b, x);
219 let message = format!(
220 concat!(
221 "assertion failed: `assert_abs_diff_ge_x!(a, b, x)`\n",
222 "https://docs.rs/assertables/9.5.6/assertables/macro.assert_abs_diff_ge_x.html\n",
223 " a label: `a`,\n",
224 " a debug: `{}`,\n",
225 " b label: `b`,\n",
226 " b debug: `{}`,\n",
227 " x label: `x`,\n",
228 " x debug: `{}`,\n",
229 " |Δ|: panic"
230 ),
231 a, b, x
232 );
233 assert_eq!(actual.unwrap_err(), message);
234 }
235
236}
237
238/// Assert an absolute difference is greater than or equal to an expression.
239///
240/// Pseudocode:<br>
241/// |Δ| ≥ x
242///
243/// * If true, return `(lhs, rhs)`.
244///
245/// * Otherwise, call [`panic!`] with a message and the values of the
246/// expressions with their debug representations.
247///
248/// # Examples
249///
250/// ```rust
251/// use assertables::*;
252/// # use std::panic;
253///
254/// # fn main() {
255/// let a = 10;
256/// let b = 13;
257/// let x = 2;
258/// assert_abs_diff_ge_x!(a, b, x);
259///
260/// # let result = panic::catch_unwind(|| {
261/// // This will panic
262/// let a = 10;
263/// let b = 13;
264/// let x = 4;
265/// assert_abs_diff_ge_x!(a, b, x);
266/// # });
267/// // assertion failed: `assert_abs_diff_ge_x!(a, b)`
268/// // https://docs.rs/assertables/9.5.6/assertables/macro.assert_abs_diff_ge_x.html
269/// // a label: `a`,
270/// // a debug: `10`,
271/// // b label: `b`,
272/// // b debug: `13`,
273/// // x label: `x`,
274/// // x debug: `4`,
275/// // |Δ|: `3`,
276/// // |Δ| ≥ x: false
277/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
278/// # let message = concat!(
279/// # "assertion failed: `assert_abs_diff_ge_x!(a, b, x)`\n",
280/// # "https://docs.rs/assertables/9.5.6/assertables/macro.assert_abs_diff_ge_x.html\n",
281/// # " a label: `a`,\n",
282/// # " a debug: `10`,\n",
283/// # " b label: `b`,\n",
284/// # " b debug: `13`,\n",
285/// # " x label: `x`,\n",
286/// # " x debug: `4`,\n",
287/// # " |Δ|: `3`,\n",
288/// # " |Δ| ≥ x: false"
289/// # );
290/// # assert_eq!(actual, message);
291/// # }
292/// ```
293///
294/// # Module macros
295///
296/// * [`assert_abs_diff_ge_x`](macro@crate::assert_abs_diff_ge_x)
297/// * [`assert_abs_diff_ge_x_as_result`](macro@crate::assert_abs_diff_ge_x_as_result)
298/// * [`debug_assert_abs_diff_ge_x`](macro@crate::debug_assert_abs_diff_ge_x)
299///
300#[macro_export]
301macro_rules! assert_abs_diff_ge_x {
302 ($a:expr, $b:expr, $x:expr $(,)?) => {{
303 match $crate::assert_abs_diff_ge_x_as_result!($a, $b, $x) {
304 Ok(x) => x,
305 Err(err) => panic!("{}", err),
306 }
307 }};
308 ($a:expr, $b:expr, $x:expr, $($message:tt)+) => {{
309 match $crate::assert_abs_diff_ge_x_as_result!($a, $b, $x) {
310 Ok(x) => x,
311 Err(err) => panic!("{}\n{}", format_args!($($message)+), err),
312 }
313 }};
314}
315
316#[cfg(test)]
317mod test_assert_abs_diff_ge_x {
318 use std::panic;
319
320 #[test]
321 fn gt() {
322 let a = 10;
323 let b = 13;
324 let x = 2;
325 let actual = assert_abs_diff_ge_x!(a, b, x);
326 assert_eq!(actual, (3, 2));
327 }
328
329 #[test]
330 fn eq() {
331 let a = 10;
332 let b = 13;
333 let x = 3;
334 let actual = assert_abs_diff_ge_x!(a, b, x);
335 assert_eq!(actual, (3, 3));
336 }
337
338 #[test]
339 fn lt() {
340 let result = panic::catch_unwind(|| {
341 let a = 10;
342 let b = 13;
343 let x = 4;
344 let _actual = assert_abs_diff_ge_x!(a, b, x);
345 });
346 let message = concat!(
347 "assertion failed: `assert_abs_diff_ge_x!(a, b, x)`\n",
348 "https://docs.rs/assertables/9.5.6/assertables/macro.assert_abs_diff_ge_x.html\n",
349 " a label: `a`,\n",
350 " a debug: `10`,\n",
351 " b label: `b`,\n",
352 " b debug: `13`,\n",
353 " x label: `x`,\n",
354 " x debug: `4`,\n",
355 " |Δ|: `3`,\n",
356 " |Δ| ≥ x: false"
357 );
358 assert_eq!(
359 result
360 .unwrap_err()
361 .downcast::<String>()
362 .unwrap()
363 .to_string(),
364 message
365 );
366 }
367
368 #[test]
369 fn overflow() {
370 let a: i8 = i8::MAX;
371 let b: i8 = i8::MIN;
372 let x: i8 = 0;
373 let result = panic::catch_unwind(|| {
374 let _actual = assert_abs_diff_ge_x!(a, b, x);
375 });
376 let message = format!(
377 concat!(
378 "assertion failed: `assert_abs_diff_ge_x!(a, b, x)`\n",
379 "https://docs.rs/assertables/9.5.6/assertables/macro.assert_abs_diff_ge_x.html\n",
380 " a label: `a`,\n",
381 " a debug: `{}`,\n",
382 " b label: `b`,\n",
383 " b debug: `{}`,\n",
384 " x label: `x`,\n",
385 " x debug: `{}`,\n",
386 " |Δ|: panic"
387 ),
388 a, b, x
389 );
390 assert_eq!(
391 result
392 .unwrap_err()
393 .downcast::<String>()
394 .unwrap()
395 .to_string(),
396 message
397 );
398 }
399}
400
401/// Assert an absolute difference is greater than or equal to an expression.
402///
403/// Pseudocode:<br>
404/// |Δ| ≥ c
405///
406/// This macro provides the same statements as [`assert_abs_diff_ge_x`](macro.assert_abs_diff_ge_x.html),
407/// except this macro's statements are only enabled in non-optimized
408/// builds by default. An optimized build will not execute this macro's
409/// statements unless `-x debug-assertions` is passed to the compiler.
410///
411/// This macro is useful for checks that are too expensive to be present
412/// in a release build but may be helpful during development.
413///
414/// The result of expanding this macro is always type checked.
415///
416/// An unchecked assertion allows a program in an inconsistent state to
417/// keep running, which might have unexpected consequences but does not
418/// introduce unsafety as long as this only happens in safe code. The
419/// performance cost of assertions, however, is not measurable in general.
420/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
421/// after thorough profiling, and more importantly, only in safe code!
422///
423/// This macro is intended to work in a similar way to
424/// [`::std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
425///
426/// # Module macros
427///
428/// * [`assert_abs_diff_ge_x`](macro@crate::assert_abs_diff_ge_x)
429/// * [`assert_abs_diff_ge_x`](macro@crate::assert_abs_diff_ge_x)
430/// * [`debug_assert_abs_diff_ge_x`](macro@crate::debug_assert_abs_diff_ge_x)
431///
432#[macro_export]
433macro_rules! debug_assert_abs_diff_ge_x {
434 ($($arg:tt)*) => {
435 if $crate::cfg!(debug_assertions) {
436 $crate::assert_abs_diff_ge_x!($($arg)*);
437 }
438 };
439}