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