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.6/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.6/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.6/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.6/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.6/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            let expect = (vec![b'a', b'l', b'f', b'a'], vec![b'a', b'l', b'f', b'a']);
281            assert_eq!(actual, expect);
282        }
283    }
284
285    #[test]
286    fn lt() {
287        let result = panic::catch_unwind(|| {
288            let mut a = Command::new("bin/printf-stderr");
289            a.args(["%s", "alfa"]);
290            let mut b = Command::new("bin/printf-stderr");
291            b.args(["%s", "zz"]);
292            let _actual = assert_command_stderr_eq!(a, b);
293        });
294        let message = concat!(
295            "assertion failed: `assert_command_stderr_eq!(a_command, b_command)`\n",
296            "https://docs.rs/assertables/9.8.6/assertables/macro.assert_command_stderr_eq.html\n",
297            " a label: `a`,\n",
298            " a debug: `\"bin/printf-stderr\" \"%s\" \"alfa\"`,\n",
299            " a value: `[97, 108, 102, 97]`,\n",
300            " b label: `b`,\n",
301            " b debug: `\"bin/printf-stderr\" \"%s\" \"zz\"`,\n",
302            " b value: `[122, 122]`"
303        );
304        assert_eq!(
305            result
306                .unwrap_err()
307                .downcast::<String>()
308                .unwrap()
309                .to_string(),
310            message
311        );
312    }
313
314    #[test]
315    fn gt() {
316        let result = panic::catch_unwind(|| {
317            let mut a = Command::new("bin/printf-stderr");
318            a.args(["%s", "alfa"]);
319            let mut b = Command::new("bin/printf-stderr");
320            b.args(["%s", "aa"]);
321            let _actual = assert_command_stderr_eq!(a, b);
322        });
323        let message = concat!(
324            "assertion failed: `assert_command_stderr_eq!(a_command, b_command)`\n",
325            "https://docs.rs/assertables/9.8.6/assertables/macro.assert_command_stderr_eq.html\n",
326            " a label: `a`,\n",
327            " a debug: `\"bin/printf-stderr\" \"%s\" \"alfa\"`,\n",
328            " a value: `[97, 108, 102, 97]`,\n",
329            " b label: `b`,\n",
330            " b debug: `\"bin/printf-stderr\" \"%s\" \"aa\"`,\n",
331            " b value: `[97, 97]`"
332        );
333        assert_eq!(
334            result
335                .unwrap_err()
336                .downcast::<String>()
337                .unwrap()
338                .to_string(),
339            message
340        );
341    }
342}
343
344/// Assert a command stderr string is equal to another.
345///
346/// This macro provides the same statements as [`assert_command_stderr_eq {`](macro.assert_command_stderr_eq {.html),
347/// except this macro's statements are only enabled in non-optimized
348/// builds by default. An optimized build will not execute this macro's
349/// statements unless `-C debug-assertions` is passed to the compiler.
350///
351/// This macro is useful for checks that are too expensive to be present
352/// in a release build but may be helpful during development.
353///
354/// The result of expanding this macro is always type checked.
355///
356/// An unchecked assertion allows a program in an inconsistent state to
357/// keep running, which might have unexpected consequences but does not
358/// introduce unsafety as long as this only happens in safe code. The
359/// performance cost of assertions, however, is not measurable in general.
360/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
361/// after thorough profiling, and more importantly, only in safe code!
362///
363/// This macro is intended to work in a similar way to
364/// [`::std::debug_assert`](https://doc.-lang.org/std/macro.debug_assert.html).
365///
366/// # Module macros
367///
368/// * [`assert_command_stderr_eq {`](macro@crate::assert_command_stderr_eq {)
369/// * [`assert_command_stderr_eq {`](macro@crate::assert_command_stderr_eq {)
370/// * [`debug_assert_command_stderr_eq {`](macro@crate::debug_assert_command_stderr_eq {)
371///
372#[macro_export]
373macro_rules! debug_assert_command_stderr_eq {
374    ($($arg:tt)*) => {
375        if cfg!(debug_assertions) {
376            $crate::assert_command_stderr_eq!($($arg)*);
377        }
378    };
379}
380
381#[cfg(test)]
382mod test_debug_assert_command_stderr_eq {
383    use std::panic;
384    use std::process::Command;
385
386    #[test]
387    fn eq() {
388        let mut a = Command::new("bin/printf-stderr");
389        a.args(["%s", "alfa"]);
390        let mut b = Command::new("bin/printf-stderr");
391        b.args(["%s", "alfa"]);
392        for _ in 0..1 {
393            let _actual = debug_assert_command_stderr_eq!(a, b);
394            let _expect = (vec![b'a', b'l', b'f', b'a'], vec![b'a', b'l', b'f', b'a']);
395            // assert_eq!(actual, expect);
396        }
397    }
398
399    #[test]
400    fn lt() {
401        let result = panic::catch_unwind(|| {
402            let mut a = Command::new("bin/printf-stderr");
403            a.args(["%s", "alfa"]);
404            let mut b = Command::new("bin/printf-stderr");
405            b.args(["%s", "zz"]);
406            let _actual = debug_assert_command_stderr_eq!(a, b);
407        });
408        let message = concat!(
409            "assertion failed: `assert_command_stderr_eq!(a_command, b_command)`\n",
410            "https://docs.rs/assertables/9.8.6/assertables/macro.assert_command_stderr_eq.html\n",
411            " a label: `a`,\n",
412            " a debug: `\"bin/printf-stderr\" \"%s\" \"alfa\"`,\n",
413            " a value: `[97, 108, 102, 97]`,\n",
414            " b label: `b`,\n",
415            " b debug: `\"bin/printf-stderr\" \"%s\" \"zz\"`,\n",
416            " b value: `[122, 122]`"
417        );
418        assert_eq!(
419            result
420                .unwrap_err()
421                .downcast::<String>()
422                .unwrap()
423                .to_string(),
424            message
425        );
426    }
427
428    #[test]
429    fn gt() {
430        let result = panic::catch_unwind(|| {
431            let mut a = Command::new("bin/printf-stderr");
432            a.args(["%s", "alfa"]);
433            let mut b = Command::new("bin/printf-stderr");
434            b.args(["%s", "aa"]);
435            let _actual = debug_assert_command_stderr_eq!(a, b);
436        });
437        let message = concat!(
438            "assertion failed: `assert_command_stderr_eq!(a_command, b_command)`\n",
439            "https://docs.rs/assertables/9.8.6/assertables/macro.assert_command_stderr_eq.html\n",
440            " a label: `a`,\n",
441            " a debug: `\"bin/printf-stderr\" \"%s\" \"alfa\"`,\n",
442            " a value: `[97, 108, 102, 97]`,\n",
443            " b label: `b`,\n",
444            " b debug: `\"bin/printf-stderr\" \"%s\" \"aa\"`,\n",
445            " b value: `[97, 97]`"
446        );
447        assert_eq!(
448            result
449                .unwrap_err()
450                .downcast::<String>()
451                .unwrap()
452                .to_string(),
453            message
454        );
455    }
456}
assertables/assert_command/assert_command_stderr_eq.rs

assertables/assert_command/
assert_command_stderr_eq.rs
