assertables/assert_program_args/
assert_program_args_stderr_le_x.rs

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

assertables/assert_program_args/
assert_program_args_stderr_le_x.rs
