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