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

assertables/assert_command/
assert_command_stderr_eq.rs
