assertables/assert_program_args/assert_program_args_stderr_gt.rs
1//! Assert a command (built with program and args) stderr is greater than 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", "aa"];
15//! assert_program_args_stderr_gt!(&a_program, &a_args, &b_program, &b_args);
16//! ```
17//!
18//! /// # Module macros
19//!
20//! * [`assert_program_args_stderr_gt`](macro@crate::assert_program_args_stderr_gt)
21//! * [`assert_program_args_stderr_gt_as_result`](macro@crate::assert_program_args_stderr_gt_as_result)
22//! * [`debug_assert_program_args_stderr_gt`](macro@crate::debug_assert_program_args_stderr_gt)
23
24/// Assert a command (built with program and args) stderr is greater than 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_gt`](macro@crate::assert_program_args_stderr_gt)
39/// * [`assert_program_args_stderr_gt_as_result`](macro@crate::assert_program_args_stderr_gt_as_result)
40/// * [`debug_assert_program_args_stderr_gt`](macro@crate::debug_assert_program_args_stderr_gt)
41///
42#[macro_export]
43macro_rules! assert_program_args_stderr_gt_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.gt(&b) {
55 Ok((a, b))
56 } else {
57 Err(
58 format!(
59 concat!(
60 "assertion failed: `assert_program_args_stderr_gt!(a_program, a_args, b_program, b_args)`\n",
61 "https://docs.rs/assertables/9.5.5/assertables/macro.assert_program_args_stderr_gt.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_gt!(a_program, a_args, b_program, b_args)`\n",
92 "https://docs.rs/assertables/9.5.5/assertables/macro.assert_program_args_stderr_gt.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_gt_as_result {
125
126 #[test]
127 fn gt() {
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", "aa"];
132 let actual =
133 assert_program_args_stderr_gt_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'a', b'a'])
137 );
138 }
139
140 #[test]
141 fn eq() {
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", "alfa"];
146 let actual =
147 assert_program_args_stderr_gt_as_result!(&a_program, &a_args, &b_program, &b_args);
148 let message = concat!(
149 "assertion failed: `assert_program_args_stderr_gt!(a_program, a_args, b_program, b_args)`\n",
150 "https://docs.rs/assertables/9.5.5/assertables/macro.assert_program_args_stderr_gt.html\n",
151 " a_program label: `&a_program`,\n",
152 " a_program debug: `\"bin/printf-stderr\"`,\n",
153 " a_args label: `&a_args`,\n",
154 " a_args debug: `[\"%s\", \"alfa\"]`,\n",
155 " b_program label: `&b_program`,\n",
156 " b_program debug: `\"bin/printf-stderr\"`,\n",
157 " b_args label: `&b_args`,\n",
158 " b_args debug: `[\"%s\", \"alfa\"]`,\n",
159 " a: `[97, 108, 102, 97]`,\n",
160 " b: `[97, 108, 102, 97]`"
161 );
162 assert_eq!(actual.unwrap_err(), message);
163 }
164
165 #[test]
166 fn lt() {
167 let a_program = "bin/printf-stderr";
168 let a_args = ["%s", "alfa"];
169 let b_program = "bin/printf-stderr";
170 let b_args = ["%s", "zz"];
171 let actual =
172 assert_program_args_stderr_gt_as_result!(&a_program, &a_args, &b_program, &b_args);
173 let message = concat!(
174 "assertion failed: `assert_program_args_stderr_gt!(a_program, a_args, b_program, b_args)`\n",
175 "https://docs.rs/assertables/9.5.5/assertables/macro.assert_program_args_stderr_gt.html\n",
176 " a_program label: `&a_program`,\n",
177 " a_program debug: `\"bin/printf-stderr\"`,\n",
178 " a_args label: `&a_args`,\n",
179 " a_args debug: `[\"%s\", \"alfa\"]`,\n",
180 " b_program label: `&b_program`,\n",
181 " b_program debug: `\"bin/printf-stderr\"`,\n",
182 " b_args label: `&b_args`,\n",
183 " b_args debug: `[\"%s\", \"zz\"]`,\n",
184 " a: `[97, 108, 102, 97]`,\n",
185 " b: `[122, 122]`"
186 );
187 assert_eq!(actual.unwrap_err(), message);
188 }
189}
190
191/// Assert a command (built with program and args) stderr is greater than to another.
192///
193/// Pseudocode:<br>
194/// (a_program + a_args ⇒ command ⇒ stderr) > (b_program + b_args ⇒ command ⇒ stderr)
195///
196/// * If true, return `()`.
197///
198/// * Otherwise, call [`panic!`] with a message and the values of the
199/// expressions with their debug representations.
200///
201/// # Examples
202///
203/// ```rust
204/// use assertables::*;
205/// # use std::panic;
206///
207/// # fn main() {
208/// let a_program = "bin/printf-stderr";
209/// let a_args = ["%s", "alfa"];
210/// let b_program = "bin/printf-stderr";
211/// let b_args = ["%s", "aa"];
212/// assert_program_args_stderr_gt!(&a_program, &a_args, &b_program, &b_args);
213///
214/// # let result = panic::catch_unwind(|| {
215/// // This will panic
216/// let a_program = "bin/printf-stderr";
217/// let a_args = ["%s", "alfa"];
218/// let b_program = "bin/printf-stderr";
219/// let b_args = ["%s", "zz"];
220/// assert_program_args_stderr_gt!(&a_program, &a_args, &b_program, &b_args);
221/// # });
222/// // assertion failed: `assert_program_args_stderr_gt!(a_program, a_args, b_program, b_args)`
223/// // https://docs.rs/assertables/9.5.5/assertables/macro.assert_program_args_stderr_gt.html
224/// // a_program label: `&a_program`,
225/// // a_program debug: `\"bin/printf-stderr\"`,
226/// // a_args label: `&a_args`,
227/// // a_args debug: `[\"%s\", \"alfa\"]`,
228/// // b_program label: `&b_program`,
229/// // b_program debug: `\"bin/printf-stderr\"`,
230/// // b_args label: `&b_args`,
231/// // b_args debug: `[\"%s\", \"zz\"]`,
232/// // a: `[97, 108, 102, 97]`,
233/// // b: `[122, 122]`
234/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
235/// # let message = concat!(
236/// # "assertion failed: `assert_program_args_stderr_gt!(a_program, a_args, b_program, b_args)`\n",
237/// # "https://docs.rs/assertables/9.5.5/assertables/macro.assert_program_args_stderr_gt.html\n",
238/// # " a_program label: `&a_program`,\n",
239/// # " a_program debug: `\"bin/printf-stderr\"`,\n",
240/// # " a_args label: `&a_args`,\n",
241/// # " a_args debug: `[\"%s\", \"alfa\"]`,\n",
242/// # " b_program label: `&b_program`,\n",
243/// # " b_program debug: `\"bin/printf-stderr\"`,\n",
244/// # " b_args label: `&b_args`,\n",
245/// # " b_args debug: `[\"%s\", \"zz\"]`,\n",
246/// # " a: `[97, 108, 102, 97]`,\n",
247/// # " b: `[122, 122]`"
248/// # );
249/// # assert_eq!(actual, message);
250/// # }
251/// ```
252///
253/// /// # Module macros
254///
255/// * [`assert_program_args_stderr_gt`](macro@crate::assert_program_args_stderr_gt)
256/// * [`assert_program_args_stderr_gt_as_result`](macro@crate::assert_program_args_stderr_gt_as_result)
257/// * [`debug_assert_program_args_stderr_gt`](macro@crate::debug_assert_program_args_stderr_gt)
258///
259#[macro_export]
260macro_rules! assert_program_args_stderr_gt {
261 ($a_program:expr, $a_args:expr, $b_program:expr, $b_args:expr $(,)?) => {{
262 match $crate::assert_program_args_stderr_gt_as_result!($a_program, $a_args, $b_program, $b_args) {
263 Ok(x) => x,
264 Err(err) => panic!("{}", err),
265 }
266 }};
267 ($a_program:expr, $a_args:expr, $b_program:expr, $($message:tt)+) => {{
268 match $crate::assert_program_args_stderr_gt_as_result!($a_program, $a_args, $b_program, $b_args) {
269 Ok(x) => x,
270 Err(err) => panic!("{}\n{}", format_args!($($message)+), err),
271 }
272 }};
273}
274
275#[cfg(test)]
276mod test_assert_program_args_stderr_gt {
277 use std::panic;
278
279 #[test]
280 fn gt() {
281 let a_program = "bin/printf-stderr";
282 let a_args = ["%s", "alfa"];
283 let b_program = "bin/printf-stderr";
284 let b_args = ["%s", "aa"];
285 let actual = assert_program_args_stderr_gt!(&a_program, &a_args, &b_program, &b_args);
286 assert_eq!(actual, (vec![b'a', b'l', b'f', b'a'], vec![b'a', b'a']));
287 }
288
289 #[test]
290 fn eq() {
291 let a_program = "bin/printf-stderr";
292 let a_args = ["%s", "alfa"];
293 let b_program = "bin/printf-stderr";
294 let b_args = ["%s", "alfa"];
295 let result = panic::catch_unwind(|| {
296 let _actual = assert_program_args_stderr_gt!(&a_program, &a_args, &b_program, &b_args);
297 });
298 let message = concat!(
299 "assertion failed: `assert_program_args_stderr_gt!(a_program, a_args, b_program, b_args)`\n",
300 "https://docs.rs/assertables/9.5.5/assertables/macro.assert_program_args_stderr_gt.html\n",
301 " a_program label: `&a_program`,\n",
302 " a_program debug: `\"bin/printf-stderr\"`,\n",
303 " a_args label: `&a_args`,\n",
304 " a_args debug: `[\"%s\", \"alfa\"]`,\n",
305 " b_program label: `&b_program`,\n",
306 " b_program debug: `\"bin/printf-stderr\"`,\n",
307 " b_args label: `&b_args`,\n",
308 " b_args debug: `[\"%s\", \"alfa\"]`,\n",
309 " a: `[97, 108, 102, 97]`,\n",
310 " b: `[97, 108, 102, 97]`"
311 );
312 assert_eq!(
313 result
314 .unwrap_err()
315 .downcast::<String>()
316 .unwrap()
317 .to_string(),
318 message
319 );
320 }
321
322 #[test]
323 fn lt() {
324 let a_program = "bin/printf-stderr";
325 let a_args = ["%s", "alfa"];
326 let b_program = "bin/printf-stderr";
327 let b_args = ["%s", "zz"];
328 let result = panic::catch_unwind(|| {
329 let _actual = assert_program_args_stderr_gt!(&a_program, &a_args, &b_program, &b_args);
330 });
331 let message = concat!(
332 "assertion failed: `assert_program_args_stderr_gt!(a_program, a_args, b_program, b_args)`\n",
333 "https://docs.rs/assertables/9.5.5/assertables/macro.assert_program_args_stderr_gt.html\n",
334 " a_program label: `&a_program`,\n",
335 " a_program debug: `\"bin/printf-stderr\"`,\n",
336 " a_args label: `&a_args`,\n",
337 " a_args debug: `[\"%s\", \"alfa\"]`,\n",
338 " b_program label: `&b_program`,\n",
339 " b_program debug: `\"bin/printf-stderr\"`,\n",
340 " b_args label: `&b_args`,\n",
341 " b_args debug: `[\"%s\", \"zz\"]`,\n",
342 " a: `[97, 108, 102, 97]`,\n",
343 " b: `[122, 122]`"
344 );
345 assert_eq!(
346 result
347 .unwrap_err()
348 .downcast::<String>()
349 .unwrap()
350 .to_string(),
351 message
352 );
353 }
354}
355
356/// Assert a command (built with program and args) stderr is greater than another.
357///
358/// Pseudocode:<br>
359/// (a_program + a_args ⇒ command ⇒ stderr) > (b_program + b_args ⇒ command ⇒ stderr)
360///
361/// This macro provides the same statements as [`assert_program_args_stderr_gt`](macro.assert_program_args_stderr_gt.html),
362/// except this macro's statements are only enabled in non-optimized
363/// builds by default. An optimized build will not execute this macro's
364/// statements unless `-C debug-assertions` is passed to the compiler.
365///
366/// This macro is useful for checks that are too expensive to be present
367/// in a release build but may be helpful during development.
368///
369/// The result of expanding this macro is always type checked.
370///
371/// An unchecked assertion allows a program in an inconsistent state to
372/// keep running, which might have unexpected consequences but does not
373/// introduce unsafety as long as this only happens in safe code. The
374/// performance cost of assertions, however, is not measurable in general.
375/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
376/// after thorough profiling, and more importantly, only in safe code!
377///
378/// This macro is intended to work in a similar way to
379/// [`::std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
380///
381/// # Module macros
382///
383/// * [`assert_program_args_stderr_gt`](macro@crate::assert_program_args_stderr_gt)
384/// * [`assert_program_args_stderr_gt`](macro@crate::assert_program_args_stderr_gt)
385/// * [`debug_assert_program_args_stderr_gt`](macro@crate::debug_assert_program_args_stderr_gt)
386///
387#[macro_export]
388macro_rules! debug_assert_program_args_stderr_gt {
389 ($($arg:tt)*) => {
390 if $crate::cfg!(debug_assertions) {
391 $crate::assert_program_args_stderr_gt!($($arg)*);
392 }
393 };
394}