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