assertables/assert_command/
assert_command_stderr_eq.rs

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

assertables/assert_command/
assert_command_stderr_eq.rs
