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