assertables/assert_program_args/assert_program_args_stderr_ge.rs
1//! Assert a command (built with program and args) stderr is greater than or 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", "aa"];
15//! assert_program_args_stderr_ge!(a_program, a_args, b_program, b_args);
16//! ```
17//!
18//! /// # Module macros
19//!
20//! * [`assert_program_args_stderr_ge`](macro@crate::assert_program_args_stderr_ge)
21//! * [`assert_program_args_stderr_ge_as_result`](macro@crate::assert_program_args_stderr_ge_as_result)
22//! * [`debug_assert_program_args_stderr_ge`](macro@crate::debug_assert_program_args_stderr_ge)
23
24/// Assert a command (built with program and args) stderr is greater than or 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_ge`](macro@crate::assert_program_args_stderr_ge)
39/// * [`assert_program_args_stderr_ge_as_result`](macro@crate::assert_program_args_stderr_ge_as_result)
40/// * [`debug_assert_program_args_stderr_ge`](macro@crate::debug_assert_program_args_stderr_ge)
41///
42#[macro_export]
43macro_rules! assert_program_args_stderr_ge_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.ge(&b) {
55 Ok((a, b))
56 } else {
57 Err(
58 format!(
59 concat!(
60 "assertion failed: `assert_program_args_stderr_ge!(a_program, a_args, b_program, b_args)`\n",
61 "https://docs.rs/assertables/9.8.1/assertables/macro.assert_program_args_stderr_ge.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_ge!(a_program, a_args, b_program, b_args)`\n",
92 "https://docs.rs/assertables/9.8.1/assertables/macro.assert_program_args_stderr_ge.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_ge_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 = assert_program_args_stderr_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-stderr"
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-stderr"
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_stderr_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-stderr";
198 let a_args = ["%s", "alfa"];
199 let b_program = "bin/printf-stderr";
200 let b_args = ["%s", "alfa"];
201 let actual = assert_program_args_stderr_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-stderr"
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-stderr"
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_stderr_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-stderr";
265 let a_args = ["%s", "alfa"];
266 let b_program = "bin/printf-stderr";
267 let b_args = ["%s", "zz"];
268 let actual = assert_program_args_stderr_ge_as_result!(a_program, a_args, b_program, b_args);
269 let message = concat!(
270 "assertion failed: `assert_program_args_stderr_ge!(a_program, a_args, b_program, b_args)`\n",
271 "https://docs.rs/assertables/9.8.1/assertables/macro.assert_program_args_stderr_ge.html\n",
272 " a_program label: `a_program`,\n",
273 " a_program debug: `\"bin/printf-stderr\"`,\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-stderr\"`,\n",
278 " b_args label: `b_args`,\n",
279 " b_args debug: `[\"%s\", \"zz\"]`,\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) stderr is greater than or equal to another.
288///
289/// Pseudocode:<br>
290/// (a_program + a_args ⇒ command ⇒ stderr) ≥ (b_program + b_args ⇒ command ⇒ stderr)
291///
292/// * If true, return `()`.
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-stderr";
305/// let a_args = ["%s", "alfa"];
306/// let b_program = "bin/printf-stderr";
307/// let b_args = ["%s", "aa"];
308/// assert_program_args_stderr_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-stderr";
313/// let a_args = ["%s", "alfa"];
314/// let b_program = "bin/printf-stderr";
315/// let b_args = ["%s", "zz"];
316/// assert_program_args_stderr_ge!(a_program, a_args, b_program, b_args);
317/// # });
318/// // assertion failed: `assert_program_args_stderr_ge!(a_program, a_args, b_program, b_args)`
319/// // https://docs.rs/assertables/…/assertables/macro.assert_program_args_stderr_ge.html
320/// // a_program label: `a_program`,
321/// // a_program debug: `\"bin/printf-stderr\"`,
322/// // a_args label: `a_args`,
323/// // a_args debug: `[\"%s\", \"alfa\"]`,
324/// // b_program label: `b_program`,
325/// // b_program debug: `\"bin/printf-stderr\"`,
326/// // b_args label: `b_args`,
327/// // b_args debug: `[\"%s\", \"zz\"]`,
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_stderr_ge!(a_program, a_args, b_program, b_args)`\n",
333/// # "https://docs.rs/assertables/9.8.1/assertables/macro.assert_program_args_stderr_ge.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!(actual, message);
346/// # }
347/// ```
348///
349/// /// # Module macros
350///
351/// * [`assert_program_args_stderr_ge`](macro@crate::assert_program_args_stderr_ge)
352/// * [`assert_program_args_stderr_ge_as_result`](macro@crate::assert_program_args_stderr_ge_as_result)
353/// * [`debug_assert_program_args_stderr_ge`](macro@crate::debug_assert_program_args_stderr_ge)
354///
355#[macro_export]
356macro_rules! assert_program_args_stderr_ge {
357 ($a_program:expr, $a_args:expr, $b_program:expr, $b_args:expr $(,)?) => {
358 match $crate::assert_program_args_stderr_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_stderr_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_stderr_ge {
373 use std::panic;
374
375 #[test]
376 fn gt() {
377 let a_program = "bin/printf-stderr";
378 let a_args = ["%s", "alfa"];
379 let b_program = "bin/printf-stderr";
380 let b_args = ["%s", "aa"];
381 for _ in 0..1 {
382 let actual = assert_program_args_stderr_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-stderr";
390 let a_args = ["%s", "alfa"];
391 let b_program = "bin/printf-stderr";
392 let b_args = ["%s", "alfa"];
393 let actual = assert_program_args_stderr_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-stderr";
403 let a_args = ["%s", "alfa"];
404 let b_program = "bin/printf-stderr";
405 let b_args = ["%s", "zz"];
406 let result = panic::catch_unwind(|| {
407 let _actual = assert_program_args_stderr_ge!(a_program, a_args, b_program, b_args);
408 });
409 let message = concat!(
410 "assertion failed: `assert_program_args_stderr_ge!(a_program, a_args, b_program, b_args)`\n",
411 "https://docs.rs/assertables/9.8.1/assertables/macro.assert_program_args_stderr_ge.html\n",
412 " a_program label: `a_program`,\n",
413 " a_program debug: `\"bin/printf-stderr\"`,\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-stderr\"`,\n",
418 " b_args label: `b_args`,\n",
419 " b_args debug: `[\"%s\", \"zz\"]`,\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) stderr greater than or equal to another.
435///
436/// Pseudocode:<br>
437/// (a_program + a_args ⇒ command ⇒ stderr) ≥ (b_program + b_args ⇒ command ⇒ stderr)
438///
439/// This macro provides the same statements as [`assert_program_args_stderr_ge`](macro.assert_program_args_stderr_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_stderr_ge`](macro@crate::assert_program_args_stderr_ge)
462/// * [`assert_program_args_stderr_ge`](macro@crate::assert_program_args_stderr_ge)
463/// * [`debug_assert_program_args_stderr_ge`](macro@crate::debug_assert_program_args_stderr_ge)
464///
465#[macro_export]
466macro_rules! debug_assert_program_args_stderr_ge {
467 ($($arg:tt)*) => {
468 if $crate::cfg!(debug_assertions) {
469 $crate::assert_program_args_stderr_ge!($($arg)*);
470 }
471 };
472}