assertables/assert_program_args/
assert_program_args_stdout_eq.rs

1//! Assert a command (built with program and args) stdout is equal to another.
2//!
3//! Pseudocode:<br>
4//! (a_program + a_args ⇒ command ⇒ stdout) = (b_program + b_args ⇒ command ⇒ stdout)
5//!
6//! # Example
7//!
8//! ```rust
9//! use assertables::*;
10//!
11//! let a_program = "bin/printf-stdout";
12//! let a_args = ["%s", "alfa"];
13//! let b_program = "bin/printf-stdout";
14//! let b_args = ["%s%s%s%s", "a", "l", "f", "a"];
15//! assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args);
16//! ```
17//!
18//! # Module macros
19//!
20//! * [`assert_program_args_stdout_eq`](macro@crate::assert_program_args_stdout_eq)
21//! * [`assert_program_args_stdout_eq_as_result`](macro@crate::assert_program_args_stdout_eq_as_result)
22//! * [`debug_assert_program_args_stdout_eq`](macro@crate::debug_assert_program_args_stdout_eq)
23
24/// Assert a command (built with program and args) stdout is equal to another.
25///
26/// Pseudocode:<br>
27/// (a_program + a_args ⇒ command ⇒ stdout) = (b_program + b_args ⇒ command ⇒ stdout)
28///
29/// * If true, return `(a_stdout, b_stdout)`.
30///
31/// * If true, return Result `Err` with a message and the values of the
32///   expressions with their debug representations.
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_program_args_stdout_eq`](macro@crate::assert_program_args_stdout_eq)
40/// * [`assert_program_args_stdout_eq_as_result`](macro@crate::assert_program_args_stdout_eq_as_result)
41/// * [`debug_assert_program_args_stdout_eq`](macro@crate::debug_assert_program_args_stdout_eq)
42///
43#[macro_export]
44macro_rules! assert_program_args_stdout_eq_as_result {
45    ($a_program:expr, $a_args:expr, $b_program:expr, $b_args:expr $(,)?) => {
46        match (&$a_program, &$a_args, &$b_program, &$b_args) {
47            (a_program, a_args, b_program, b_args) => {
48                match (
49                    assert_program_args_impl_prep!(a_program, a_args),
50                    assert_program_args_impl_prep!(b_program, b_args)
51                ) {
52                    (Ok(a_output), Ok(b_output)) => {
53                        let a = a_output.stdout;
54                        let b = b_output.stdout;
55                        if a.eq(&b) {
56                            Ok((a, b))
57                        } else {
58                            Err(
59                                format!(
60                                    concat!(
61                                        "assertion failed: `assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args)`\n",
62                                        "https://docs.rs/assertables/9.8.6/assertables/macro.assert_program_args_stdout_eq.html\n",
63                                        " a_program label: `{}`,\n",
64                                        " a_program debug: `{:?}`,\n",
65                                        "    a_args label: `{}`,\n",
66                                        "    a_args debug: `{:?}`,\n",
67                                        " b_program label: `{}`,\n",
68                                        " b_program debug: `{:?}`,\n",
69                                        "    b_args label: `{}`,\n",
70                                        "    b_args debug: `{:?}`,\n",
71                                        "               a: `{:?}`,\n",
72                                        "               b: `{:?}`"
73                                    ),
74                                    stringify!($a_program),
75                                    a_program,
76                                    stringify!($a_args),
77                                    a_args,
78                                    stringify!($b_program),
79                                    b_program,
80                                    stringify!($b_args),
81                                    b_args,
82                                    a,
83                                    b
84                                )
85                            )
86                        }
87                    },
88                    (a, b) => {
89                        Err(
90                            format!(
91                                concat!(
92                                    "assertion failed: `assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args)`\n",
93                                    "https://docs.rs/assertables/9.8.6/assertables/macro.assert_program_args_stdout_eq.html\n",
94                                    " a_program label: `{}`,\n",
95                                    " a_program debug: `{:?}`,\n",
96                                    "    a_args label: `{}`,\n",
97                                    "    a_args debug: `{:?}`,\n",
98                                    " b_program label: `{}`,\n",
99                                    " b_program debug: `{:?}`,\n",
100                                    "    b_args label: `{}`,\n",
101                                    "    b_args debug: `{:?}`,\n",
102                                    "               a: `{:?}`,\n",
103                                    "               b: `{:?}`"
104                                ),
105                                stringify!($a_program),
106                                a_program,
107                                stringify!($a_args),
108                                a_args,
109                                stringify!($b_program),
110                                b_program,
111                                stringify!($b_args),
112                                b_args,
113                                a,
114                                b
115                            )
116                        )
117                    }
118                }
119            }
120        }
121    };
122}
123
124#[cfg(test)]
125mod test_assert_program_args_stdout_eq_as_result {
126    use std::sync::Once;
127
128    #[test]
129    fn eq() {
130        let a_program = "bin/printf-stdout";
131        let a_args = ["%s", "alfa"];
132        let b_program = "bin/printf-stdout";
133        let b_args = ["%s%s%s%s", "a", "l", "f", "a"];
134        let actual = assert_program_args_stdout_eq_as_result!(a_program, a_args, b_program, b_args);
135        assert_eq!(
136            actual.unwrap(),
137            (vec![b'a', b'l', b'f', b'a'], vec![b'a', b'l', b'f', b'a'])
138        );
139    }
140
141    #[test]
142    fn eq_once() {
143        static A: Once = Once::new();
144        fn a() -> &'static str {
145            if A.is_completed() {
146                panic!("A.is_completed()")
147            } else {
148                A.call_once(|| {})
149            }
150            "bin/printf-stdout"
151        }
152
153        static A_ARGS: Once = Once::new();
154        fn a_args() -> [&'static str; 2] {
155            if A_ARGS.is_completed() {
156                panic!("A_ARGS.is_completed()")
157            } else {
158                A_ARGS.call_once(|| {})
159            }
160            ["%s", "alfa"]
161        }
162
163        static B: Once = Once::new();
164        fn b() -> &'static str {
165            if B.is_completed() {
166                panic!("B.is_completed()")
167            } else {
168                B.call_once(|| {})
169            }
170            "bin/printf-stdout"
171        }
172
173        static B_ARGS: Once = Once::new();
174        fn b_args() -> [&'static str; 2] {
175            if B_ARGS.is_completed() {
176                panic!("B_ARGS.is_completed()")
177            } else {
178                B_ARGS.call_once(|| {})
179            }
180            ["%s", "alfa"]
181        }
182
183        assert_eq!(A.is_completed(), false);
184        assert_eq!(A_ARGS.is_completed(), false);
185        assert_eq!(B.is_completed(), false);
186        assert_eq!(B_ARGS.is_completed(), false);
187        let result = assert_program_args_stdout_eq_as_result!(a(), a_args(), b(), b_args());
188        assert!(result.is_ok());
189        assert_eq!(A.is_completed(), true);
190        assert_eq!(A_ARGS.is_completed(), true);
191        assert_eq!(B.is_completed(), true);
192        assert_eq!(B_ARGS.is_completed(), true);
193    }
194
195    #[test]
196    fn lt() {
197        let a_program = "bin/printf-stdout";
198        let a_args = ["%s", "alfa"];
199        let b_program = "bin/printf-stdout";
200        let b_args = ["%s%s", "z", "z"];
201        let actual = assert_program_args_stdout_eq_as_result!(a_program, a_args, b_program, b_args);
202        let message = concat!(
203            "assertion failed: `assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args)`\n",
204            "https://docs.rs/assertables/9.8.6/assertables/macro.assert_program_args_stdout_eq.html\n",
205            " a_program label: `a_program`,\n",
206            " a_program debug: `\"bin/printf-stdout\"`,\n",
207            "    a_args label: `a_args`,\n",
208            "    a_args debug: `[\"%s\", \"alfa\"]`,\n",
209            " b_program label: `b_program`,\n",
210            " b_program debug: `\"bin/printf-stdout\"`,\n",
211            "    b_args label: `b_args`,\n",
212            "    b_args debug: `[\"%s%s\", \"z\", \"z\"]`,\n",
213            "               a: `[97, 108, 102, 97]`,\n",
214            "               b: `[122, 122]`"
215        );
216        assert_eq!(actual.unwrap_err(), message);
217    }
218
219    #[test]
220    fn gt() {
221        let a_program = "bin/printf-stdout";
222        let a_args = ["%s", "alfa"];
223        let b_program = "bin/printf-stdout";
224        let b_args = ["%s%s", "a", "a"];
225        let actual = assert_program_args_stdout_eq_as_result!(a_program, a_args, b_program, b_args);
226        let message = concat!(
227            "assertion failed: `assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args)`\n",
228            "https://docs.rs/assertables/9.8.6/assertables/macro.assert_program_args_stdout_eq.html\n",
229            " a_program label: `a_program`,\n",
230            " a_program debug: `\"bin/printf-stdout\"`,\n",
231            "    a_args label: `a_args`,\n",
232            "    a_args debug: `[\"%s\", \"alfa\"]`,\n",
233            " b_program label: `b_program`,\n",
234            " b_program debug: `\"bin/printf-stdout\"`,\n",
235            "    b_args label: `b_args`,\n",
236            "    b_args debug: `[\"%s%s\", \"a\", \"a\"]`,\n",
237            "               a: `[97, 108, 102, 97]`,\n",
238            "               b: `[97, 97]`"
239        );
240        assert_eq!(actual.unwrap_err(), message);
241    }
242}
243
244/// Assert a command (built with program and args) stdout is equal to another.
245///
246/// Pseudocode:<br>
247/// (a_program + a_args ⇒ command ⇒ stdout) = (b_program + b_args ⇒ command ⇒ stdout)
248///
249/// * If true, return `(a_stdout, b_stdout)`.
250///
251/// * Otherwise, call [`panic!`] with a message and the values of the
252///   expressions with their debug representations.
253///
254/// # Examples
255///
256/// ```rust
257/// use assertables::*;
258/// # use std::panic;
259///
260/// # fn main() {
261/// let a_program = "bin/printf-stdout";
262/// let a_args = ["%s", "alfa"];
263/// let b_program = "bin/printf-stdout";
264/// let b_args = ["%s%s%s%s", "a", "l", "f", "a"];
265/// assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args);
266///
267/// # let result = panic::catch_unwind(|| {
268/// // This will panic
269/// let a_program = "bin/printf-stdout";
270/// let a_args = ["%s", "alfa"];
271/// let b_program = "bin/printf-stdout";
272/// let b_args = ["%s%s", "z", "z" ];
273/// assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args);
274/// # });
275/// // assertion failed: `assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args)`
276/// // https://docs.rs/assertables/…/assertables/macro.assert_program_args_stdout_eq.html
277/// //  a_program label: `a_program`,
278/// //  a_program debug: `\"bin/printf-stdout\"`,
279/// //     a_args label: `a_args`,
280/// //     a_args debug: `[\"%s\", \"alfa\"]`,
281/// //  b_program label: `b_program`,
282/// //  b_program debug: `\"bin/printf-stdout\"`,
283/// //     b_args label: `b_args`,
284/// //     b_args debug: `[\"%s%s\", \"z\", \"z\"]`,
285/// //                a: `[97, 108, 102, 97]`,
286/// //                b: `[122, 122]`
287/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
288/// # let message = concat!(
289/// #     "assertion failed: `assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args)`\n",
290/// #     "https://docs.rs/assertables/9.8.6/assertables/macro.assert_program_args_stdout_eq.html\n",
291/// #     " a_program label: `a_program`,\n",
292/// #     " a_program debug: `\"bin/printf-stdout\"`,\n",
293/// #     "    a_args label: `a_args`,\n",
294/// #     "    a_args debug: `[\"%s\", \"alfa\"]`,\n",
295/// #     " b_program label: `b_program`,\n",
296/// #     " b_program debug: `\"bin/printf-stdout\"`,\n",
297/// #     "    b_args label: `b_args`,\n",
298/// #     "    b_args debug: `[\"%s%s\", \"z\", \"z\"]`,\n",
299/// #     "               a: `[97, 108, 102, 97]`,\n",
300/// #     "               b: `[122, 122]`"
301/// # );
302/// # assert_eq!(actual, message);
303/// # }
304/// ```
305///
306/// # Module macros
307///
308/// * [`assert_program_args_stdout_eq`](macro@crate::assert_program_args_stdout_eq)
309/// * [`assert_program_args_stdout_eq_as_result`](macro@crate::assert_program_args_stdout_eq_as_result)
310/// * [`debug_assert_program_args_stdout_eq`](macro@crate::debug_assert_program_args_stdout_eq)
311///
312#[macro_export]
313macro_rules! assert_program_args_stdout_eq {
314    ($a_program:expr, $a_args:expr, $b_program:expr, $b_args:expr $(,)?) => {
315        match $crate::assert_program_args_stdout_eq_as_result!($a_program, $a_args, $b_program, $b_args) {
316            Ok(x) => x,
317            Err(err) => panic!("{}", err),
318        }
319    };
320    ($a_program:expr, $a_args:expr, $b_program:expr, $($message:tt)+) => {
321        match $crate::assert_program_args_stdout_eq_as_result!($a_program, $a_args, $b_program, $b_args) {
322            Ok(x) => x,
323            Err(err) => panic!("{}\n{}", format_args!($($message)+), err),
324        }
325    };
326}
327
328#[cfg(test)]
329mod test_assert_program_args_stdout_eq {
330    use std::panic;
331
332    #[test]
333    fn eq() {
334        let a_program = "bin/printf-stdout";
335        let a_args = ["%s", "alfa"];
336        let b_program = "bin/printf-stdout";
337        let b_args = ["%s%s%s%s", "a", "l", "f", "a"];
338        let actual = assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args);
339        assert_eq!(
340            actual,
341            (vec![b'a', b'l', b'f', b'a'], vec![b'a', b'l', b'f', b'a'])
342        );
343    }
344
345    #[test]
346    fn lt() {
347        let a_program = "bin/printf-stdout";
348        let a_args = ["%s", "alfa"];
349        let b_program = "bin/printf-stdout";
350        let b_args = ["%s%s", "z", "z"];
351        let result = panic::catch_unwind(|| {
352            let _actual = assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args);
353        });
354        let message = concat!(
355            "assertion failed: `assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args)`\n",
356            "https://docs.rs/assertables/9.8.6/assertables/macro.assert_program_args_stdout_eq.html\n",
357            " a_program label: `a_program`,\n",
358            " a_program debug: `\"bin/printf-stdout\"`,\n",
359            "    a_args label: `a_args`,\n",
360            "    a_args debug: `[\"%s\", \"alfa\"]`,\n",
361            " b_program label: `b_program`,\n",
362            " b_program debug: `\"bin/printf-stdout\"`,\n",
363            "    b_args label: `b_args`,\n",
364            "    b_args debug: `[\"%s%s\", \"z\", \"z\"]`,\n",
365            "               a: `[97, 108, 102, 97]`,\n",
366            "               b: `[122, 122]`"
367        );
368        assert_eq!(
369            result
370                .unwrap_err()
371                .downcast::<String>()
372                .unwrap()
373                .to_string(),
374            message
375        );
376    }
377
378    #[test]
379    fn gt() {
380        let a_program = "bin/printf-stdout";
381        let a_args = ["%s", "alfa"];
382        let b_program = "bin/printf-stdout";
383        let b_args = ["%s%s", "a", "a"];
384        let result = panic::catch_unwind(|| {
385            let _actual = assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args);
386        });
387        let message = concat!(
388            "assertion failed: `assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args)`\n",
389            "https://docs.rs/assertables/9.8.6/assertables/macro.assert_program_args_stdout_eq.html\n",
390            " a_program label: `a_program`,\n",
391            " a_program debug: `\"bin/printf-stdout\"`,\n",
392            "    a_args label: `a_args`,\n",
393            "    a_args debug: `[\"%s\", \"alfa\"]`,\n",
394            " b_program label: `b_program`,\n",
395            " b_program debug: `\"bin/printf-stdout\"`,\n",
396            "    b_args label: `b_args`,\n",
397            "    b_args debug: `[\"%s%s\", \"a\", \"a\"]`,\n",
398            "               a: `[97, 108, 102, 97]`,\n",
399            "               b: `[97, 97]`"
400        );
401        assert_eq!(
402            result
403                .unwrap_err()
404                .downcast::<String>()
405                .unwrap()
406                .to_string(),
407            message
408        );
409    }
410}
411
412/// Assert a command (built with program and args) stdout is equal to another.
413///
414/// Pseudocode:<br>
415/// (a_program + a_args ⇒ command ⇒ stdout) = (b_program + b_args ⇒ command ⇒ stdout)
416///
417/// This macro provides the same statements as [`assert_program_args_stdout_eq`](macro.assert_program_args_stdout_eq.html),
418/// except this macro's statements are only enabled in non-optimized
419/// builds by default. An optimized build will not execute this macro's
420/// statements unless `-C debug-assertions` is passed to the compiler.
421///
422/// This macro is useful for checks that are too expensive to be present
423/// in a release build but may be helpful during development.
424///
425/// The result of expanding this macro is always type checked.
426///
427/// An unchecked assertion allows a program in an inconsistent state to
428/// keep running, which might have unexpected consequences but does not
429/// introduce unsafety as long as this only happens in safe code. The
430/// performance cost of assertions, however, is not measurable in general.
431/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
432/// after thorough profiling, and more importantly, only in safe code!
433///
434/// This macro is intended to work in a similar way to
435/// [`::std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
436///
437/// # Module macros
438///
439/// * [`assert_program_args_stdout_eq`](macro@crate::assert_program_args_stdout_eq)
440/// * [`assert_program_args_stdout_eq`](macro@crate::assert_program_args_stdout_eq)
441/// * [`debug_assert_program_args_stdout_eq`](macro@crate::debug_assert_program_args_stdout_eq)
442///
443#[macro_export]
444macro_rules! debug_assert_program_args_stdout_eq {
445    ($($arg:tt)*) => {
446        if cfg!(debug_assertions) {
447            $crate::assert_program_args_stdout_eq!($($arg)*);
448        }
449    };
450}
451
452#[cfg(test)]
453mod test_debug_assert_program_args_stdout_eq {
454    use std::panic;
455
456    #[test]
457    fn eq() {
458        let a_program = "bin/printf-stdout";
459        let a_args = ["%s", "alfa"];
460        let b_program = "bin/printf-stdout";
461        let b_args = ["%s%s%s%s", "a", "l", "f", "a"];
462        let _actual = debug_assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args);
463        let _expect = (vec![b'a', b'l', b'f', b'a'], vec![b'a', b'l', b'f', b'a']);
464        // assert_eq!(actual, expect);
465    }
466
467    #[test]
468    fn lt() {
469        let a_program = "bin/printf-stdout";
470        let a_args = ["%s", "alfa"];
471        let b_program = "bin/printf-stdout";
472        let b_args = ["%s%s", "z", "z"];
473        let result = panic::catch_unwind(|| {
474            let _actual =
475                debug_assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args);
476        });
477        let message = concat!(
478            "assertion failed: `assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args)`\n",
479            "https://docs.rs/assertables/9.8.6/assertables/macro.assert_program_args_stdout_eq.html\n",
480            " a_program label: `a_program`,\n",
481            " a_program debug: `\"bin/printf-stdout\"`,\n",
482            "    a_args label: `a_args`,\n",
483            "    a_args debug: `[\"%s\", \"alfa\"]`,\n",
484            " b_program label: `b_program`,\n",
485            " b_program debug: `\"bin/printf-stdout\"`,\n",
486            "    b_args label: `b_args`,\n",
487            "    b_args debug: `[\"%s%s\", \"z\", \"z\"]`,\n",
488            "               a: `[97, 108, 102, 97]`,\n",
489            "               b: `[122, 122]`"
490        );
491        assert_eq!(
492            result
493                .unwrap_err()
494                .downcast::<String>()
495                .unwrap()
496                .to_string(),
497            message
498        );
499    }
500
501    #[test]
502    fn gt() {
503        let a_program = "bin/printf-stdout";
504        let a_args = ["%s", "alfa"];
505        let b_program = "bin/printf-stdout";
506        let b_args = ["%s%s", "a", "a"];
507        let result = panic::catch_unwind(|| {
508            let _actual =
509                debug_assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args);
510        });
511        let message = concat!(
512            "assertion failed: `assert_program_args_stdout_eq!(a_program, a_args, b_program, b_args)`\n",
513            "https://docs.rs/assertables/9.8.6/assertables/macro.assert_program_args_stdout_eq.html\n",
514            " a_program label: `a_program`,\n",
515            " a_program debug: `\"bin/printf-stdout\"`,\n",
516            "    a_args label: `a_args`,\n",
517            "    a_args debug: `[\"%s\", \"alfa\"]`,\n",
518            " b_program label: `b_program`,\n",
519            " b_program debug: `\"bin/printf-stdout\"`,\n",
520            "    b_args label: `b_args`,\n",
521            "    b_args debug: `[\"%s%s\", \"a\", \"a\"]`,\n",
522            "               a: `[97, 108, 102, 97]`,\n",
523            "               b: `[97, 97]`"
524        );
525        assert_eq!(
526            result
527                .unwrap_err()
528                .downcast::<String>()
529                .unwrap()
530                .to_string(),
531            message
532        );
533    }
534}
assertables/assert_program_args/assert_program_args_stdout_eq.rs

assertables/assert_program_args/
assert_program_args_stdout_eq.rs
