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