assertables/assert_program_args/assert_program_args_stdout_ge.rs
1//! Assert a command (built with program and args) stdout is greater than or 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", "a", "a"];
15//! assert_program_args_stdout_ge!(a_program, a_args, b_program, b_args);
16//! ```
17//!
18//! # Module macros
19//!
20//! * [`assert_program_args_stdout_ge`](macro@crate::assert_program_args_stdout_ge)
21//! * [`assert_program_args_stdout_ge_as_result`](macro@crate::assert_program_args_stdout_ge_as_result)
22//! * [`debug_assert_program_args_stdout_ge`](macro@crate::debug_assert_program_args_stdout_ge)
23
24/// Assert a command (built with program and args) stdout is greater than or 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_ge`](macro@crate::assert_program_args_stdout_ge)
40/// * [`assert_program_args_stdout_ge_as_result`](macro@crate::assert_program_args_stdout_ge_as_result)
41/// * [`debug_assert_program_args_stdout_ge`](macro@crate::debug_assert_program_args_stdout_ge)
42///
43#[macro_export]
44macro_rules! assert_program_args_stdout_ge_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.ge(&b) {
56 Ok((a, b))
57 } else {
58 Err(
59 format!(
60 concat!(
61 "assertion failed: `assert_program_args_stdout_ge!(a_program, a_args, b_program, b_args)`\n",
62 "https://docs.rs/assertables/9.8.2/assertables/macro.assert_program_args_stdout_ge.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_ge!(a_program, a_args, b_program, b_args)`\n",
93 "https://docs.rs/assertables/9.8.2/assertables/macro.assert_program_args_stdout_ge.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 output: `{:?}`,\n",
103 " b output: `{:?}`"
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_ge_as_result {
126 use std::sync::Once;
127
128 #[test]
129 fn gt() {
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", "a", "a"];
134 let actual = assert_program_args_stdout_ge_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'a'])
138 );
139 }
140
141 #[test]
142 fn gt_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", "aa"]
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_ge_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 eq() {
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%s%s", "a", "l", "f", "a"];
201 let actual = assert_program_args_stdout_ge_as_result!(a_program, a_args, b_program, b_args);
202 assert_eq!(
203 actual.unwrap(),
204 (vec![b'a', b'l', b'f', b'a'], vec![b'a', b'l', b'f', b'a'])
205 );
206 }
207
208 #[test]
209 fn eq_once() {
210 static A: Once = Once::new();
211 fn a() -> &'static str {
212 if A.is_completed() {
213 panic!("A.is_completed()")
214 } else {
215 A.call_once(|| {})
216 }
217 "bin/printf-stdout"
218 }
219
220 static A_ARGS: Once = Once::new();
221 fn a_args() -> [&'static str; 2] {
222 if A_ARGS.is_completed() {
223 panic!("A_ARGS.is_completed()")
224 } else {
225 A_ARGS.call_once(|| {})
226 }
227 ["%s", "alfa"]
228 }
229
230 static B: Once = Once::new();
231 fn b() -> &'static str {
232 if B.is_completed() {
233 panic!("B.is_completed()")
234 } else {
235 B.call_once(|| {})
236 }
237 "bin/printf-stdout"
238 }
239
240 static B_ARGS: Once = Once::new();
241 fn b_args() -> [&'static str; 2] {
242 if B_ARGS.is_completed() {
243 panic!("B_ARGS.is_completed()")
244 } else {
245 B_ARGS.call_once(|| {})
246 }
247 ["%s", "alfa"]
248 }
249
250 assert_eq!(A.is_completed(), false);
251 assert_eq!(A_ARGS.is_completed(), false);
252 assert_eq!(B.is_completed(), false);
253 assert_eq!(B_ARGS.is_completed(), false);
254 let result = assert_program_args_stdout_ge_as_result!(a(), a_args(), b(), b_args());
255 assert!(result.is_ok());
256 assert_eq!(A.is_completed(), true);
257 assert_eq!(A_ARGS.is_completed(), true);
258 assert_eq!(B.is_completed(), true);
259 assert_eq!(B_ARGS.is_completed(), true);
260 }
261
262 #[test]
263 fn lt() {
264 let a_program = "bin/printf-stdout";
265 let a_args = ["%s", "alfa"];
266 let b_program = "bin/printf-stdout";
267 let b_args = ["%s%s", "z", "z"];
268 let actual = assert_program_args_stdout_ge_as_result!(a_program, a_args, b_program, b_args);
269 let message: &str = concat!(
270 "assertion failed: `assert_program_args_stdout_ge!(a_program, a_args, b_program, b_args)`\n",
271 "https://docs.rs/assertables/9.8.2/assertables/macro.assert_program_args_stdout_ge.html\n",
272 " a_program label: `a_program`,\n",
273 " a_program debug: `\"bin/printf-stdout\"`,\n",
274 " a_args label: `a_args`,\n",
275 " a_args debug: `[\"%s\", \"alfa\"]`,\n",
276 " b_program label: `b_program`,\n",
277 " b_program debug: `\"bin/printf-stdout\"`,\n",
278 " b_args label: `b_args`,\n",
279 " b_args debug: `[\"%s%s\", \"z\", \"z\"]`,\n",
280 " a: `[97, 108, 102, 97]`,\n",
281 " b: `[122, 122]`"
282 );
283 assert_eq!(actual.unwrap_err(), message);
284 }
285}
286
287/// Assert a command (built with program and args) stdout is greater than or equal to another.
288///
289/// Pseudocode:<br>
290/// (a_program + a_args ⇒ command ⇒ stdout) ≥ (b_program + b_args ⇒ command ⇒ stdout)
291///
292/// * If true, return `(a_stdout, b_stdout)`.
293///
294/// * Otherwise, call [`panic!`] with a message and the values of the
295/// expressions with their debug representations.
296///
297/// # Examples
298///
299/// ```rust
300/// use assertables::*;
301/// # use std::panic;
302///
303/// # fn main() {
304/// let a_program = "bin/printf-stdout";
305/// let a_args = ["%s", "alfa"];
306/// let b_program = "bin/printf-stdout";
307/// let b_args = ["%s%s", "a", "a"];
308/// assert_program_args_stdout_ge!(a_program, a_args, b_program, b_args);
309///
310/// # let result = panic::catch_unwind(|| {
311/// // This will panic
312/// let a_program = "bin/printf-stdout";
313/// let a_args = ["%s", "alfa"];
314/// let b_program = "bin/printf-stdout";
315/// let b_args = ["%s%s", "z", "z"];
316/// assert_program_args_stdout_ge!(a_program, a_args, b_program, b_args);
317/// # });
318/// // assertion failed: `assert_program_args_stdout_ge!(a_program, a_args, b_program, b_args)`
319/// // https://docs.rs/assertables/…/assertables/macro.assert_program_args_stdout_ge.html
320/// // a_program label: `a_program`,
321/// // a_program debug: `\"bin/printf-stdout\"`,
322/// // a_args label: `a_args`,
323/// // a_args debug: `[\"%s\", \"alfa\"]`,
324/// // b_program label: `b_program`,
325/// // b_program debug: `\"bin/printf-stdout\"`,
326/// // b_args label: `b_args`,
327/// // b_args debug: `[\"%s%s\", \"z\", \"z\"]`,
328/// // a: `[97, 108, 102, 97]`,
329/// // b: `[122, 122]`
330/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
331/// # let message = concat!(
332/// # "assertion failed: `assert_program_args_stdout_ge!(a_program, a_args, b_program, b_args)`\n",
333/// # "https://docs.rs/assertables/9.8.2/assertables/macro.assert_program_args_stdout_ge.html\n",
334/// # " a_program label: `a_program`,\n",
335/// # " a_program debug: `\"bin/printf-stdout\"`,\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-stdout\"`,\n",
340/// # " b_args label: `b_args`,\n",
341/// # " b_args debug: `[\"%s%s\", \"z\", \"z\"]`,\n",
342/// # " a: `[97, 108, 102, 97]`,\n",
343/// # " b: `[122, 122]`"
344/// # );
345/// # assert_eq!(actual, message);
346/// # }
347/// ```
348///
349/// # Module macros
350///
351/// * [`assert_program_args_stdout_ge`](macro@crate::assert_program_args_stdout_ge)
352/// * [`assert_program_args_stdout_ge_as_result`](macro@crate::assert_program_args_stdout_ge_as_result)
353/// * [`debug_assert_program_args_stdout_ge`](macro@crate::debug_assert_program_args_stdout_ge)
354///
355#[macro_export]
356macro_rules! assert_program_args_stdout_ge {
357 ($a_program:expr, $a_args:expr, $b_program:expr, $b_args:expr $(,)?) => {
358 match $crate::assert_program_args_stdout_ge_as_result!($a_program, $a_args, $b_program, $b_args) {
359 Ok(x) => x,
360 Err(err) => panic!("{}", err),
361 }
362 };
363 ($a_program:expr, $a_args:expr, $b_program:expr, $($message:tt)+) => {
364 match $crate::assert_program_args_stdout_ge_as_result!($a_program, $a_args, $b_program, $b_args) {
365 Ok(x) => x,
366 Err(err) => panic!("{}\n{}", format_args!($($message)+), err),
367 }
368 };
369}
370
371#[cfg(test)]
372mod test_assert_program_args_stdout_ge {
373 use std::panic;
374
375 #[test]
376 fn gt() {
377 let a_program = "bin/printf-stdout";
378 let a_args = ["%s", "alfa"];
379 let b_program = "bin/printf-stdout";
380 let b_args = ["%s%s", "a", "a"];
381 for _ in 0..1 {
382 let actual = assert_program_args_stdout_ge!(a_program, a_args, b_program, b_args);
383 assert_eq!(actual, (vec![b'a', b'l', b'f', b'a'], vec![b'a', b'a']));
384 }
385 }
386
387 #[test]
388 fn eq() {
389 let a_program = "bin/printf-stdout";
390 let a_args = ["%s", "alfa"];
391 let b_program = "bin/printf-stdout";
392 let b_args = ["%s%s%s%s", "a", "l", "f", "a"];
393 let actual = assert_program_args_stdout_ge!(a_program, a_args, b_program, b_args);
394 assert_eq!(
395 actual,
396 (vec![b'a', b'l', b'f', b'a'], vec![b'a', b'l', b'f', b'a'])
397 );
398 }
399
400 #[test]
401 fn lt() {
402 let a_program = "bin/printf-stdout";
403 let a_args = ["%s", "alfa"];
404 let b_program = "bin/printf-stdout";
405 let b_args = ["%s%s", "z", "z"];
406 let result = panic::catch_unwind(|| {
407 let _actual = assert_program_args_stdout_ge!(a_program, a_args, b_program, b_args);
408 });
409 let message: &str = concat!(
410 "assertion failed: `assert_program_args_stdout_ge!(a_program, a_args, b_program, b_args)`\n",
411 "https://docs.rs/assertables/9.8.2/assertables/macro.assert_program_args_stdout_ge.html\n",
412 " a_program label: `a_program`,\n",
413 " a_program debug: `\"bin/printf-stdout\"`,\n",
414 " a_args label: `a_args`,\n",
415 " a_args debug: `[\"%s\", \"alfa\"]`,\n",
416 " b_program label: `b_program`,\n",
417 " b_program debug: `\"bin/printf-stdout\"`,\n",
418 " b_args label: `b_args`,\n",
419 " b_args debug: `[\"%s%s\", \"z\", \"z\"]`,\n",
420 " a: `[97, 108, 102, 97]`,\n",
421 " b: `[122, 122]`"
422 );
423 assert_eq!(
424 result
425 .unwrap_err()
426 .downcast::<String>()
427 .unwrap()
428 .to_string(),
429 message
430 );
431 }
432}
433
434/// Assert a command (built with program and args) stdout is greater than or equal to another.
435///
436/// Pseudocode:<br>
437/// (a_program + a_args ⇒ command ⇒ stdout) ≥ (b_program + b_args ⇒ command ⇒ stdout)
438///
439/// This macro provides the same statements as [`assert_program_args_stdout_ge`](macro.assert_program_args_stdout_ge.html),
440/// except this macro's statements are only enabled in non-optimized
441/// builds by default. An optimized build will not execute this macro's
442/// statements unless `-C debug-assertions` is passed to the compiler.
443///
444/// This macro is useful for checks that are too expensive to be present
445/// in a release build but may be helpful during development.
446///
447/// The result of expanding this macro is always type checked.
448///
449/// An unchecked assertion allows a program in an inconsistent state to
450/// keep running, which might have unexpected consequences but does not
451/// introduce unsafety as long as this only happens in safe code. The
452/// performance cost of assertions, however, is not measurable in general.
453/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
454/// after thorough profiling, and more importantly, only in safe code!
455///
456/// This macro is intended to work in a similar way to
457/// [`::std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
458///
459/// # Module macros
460///
461/// * [`assert_program_args_stdout_ge`](macro@crate::assert_program_args_stdout_ge)
462/// * [`assert_program_args_stdout_ge`](macro@crate::assert_program_args_stdout_ge)
463/// * [`debug_assert_program_args_stdout_ge`](macro@crate::debug_assert_program_args_stdout_ge)
464///
465#[macro_export]
466macro_rules! debug_assert_program_args_stdout_ge {
467 ($($arg:tt)*) => {
468 if $crate::cfg!(debug_assertions) {
469 $crate::assert_program_args_stdout_ge!($($arg)*);
470 }
471 };
472}