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.2/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.2/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.2/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.2/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.2/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.2/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.2/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 $crate::cfg!(debug_assertions) {
447 $crate::assert_program_args_stdout_eq!($($arg)*);
448 }
449 };
450}