assertables/assert_program_args/assert_program_args_stderr_ge_x.rs
1//! Assert a command (built with program and args) stderr is greater than or equal to an expression.
2//!
3//! Pseudocode:<br>
4//! (a_program + a_args ⇒ command ⇒ stderr) ≥ (expr into string)
5//!
6//! # Examples
7//!
8//! ```rust
9//! use assertables::*;
10//!
11//! let program = "bin/printf-stderr";
12//! let args = ["%s", "alfa"];
13//! let bytes = vec![b'a', b'a'];
14//! assert_program_args_stderr_ge_x!(&program, &args, bytes);
15//! ```
16//!
17//! # Module macros
18//!
19//! * [`assert_program_args_stderr_ge_x`](macro@crate::assert_program_args_stderr_ge_x)
20//! * [`assert_program_args_stderr_ge_x`](macro@crate::assert_program_args_stderr_ge_x)
21//! * [`debug_assert_program_args_stderr_ge_x`](macro@crate::debug_assert_program_args_stderr_ge_x)
22
23/// Assert a command (built with program and args) stderr is greater than or equal to an expression.
24///
25/// Pseudocode:<br>
26/// (a_program + a_args ⇒ command ⇒ stderr) ≥ (expr into string)
27///
28/// * If true, return Result `Ok(stderr)`.
29///
30/// * Otherwise, return Result `Err(message)`.
31///
32/// This macro is useful for runtime checks, such as checking parameters,
33/// or sanitizing inputs, or handling different results in different ways.
34///
35/// # Module macros
36///
37/// * [`assert_program_args_stderr_ge_x`](macro@crate::assert_program_args_stderr_ge_x)
38/// * [`assert_program_args_stderr_ge_x_as_result`](macro@crate::assert_program_args_stderr_ge_x_as_result)
39/// * [`debug_assert_program_args_stderr_ge_x`](macro@crate::debug_assert_program_args_stderr_ge_x)
40///
41#[macro_export]
42macro_rules! assert_program_args_stderr_ge_x_as_result {
43 ($a_program:expr, $a_args:expr, $b_expr:expr $(,)?) => {{
44 match ($a_program, $a_args, &$b_expr) {
45 (a_program, a_args, b_expr) => {
46 match assert_program_args_impl_prep!(a_program, a_args) {
47 Ok(a_output) => {
48 let a = a_output.stderr;
49 if a.ge(&$b_expr) {
50 Ok(a)
51 } else {
52 Err(
53 format!(
54 concat!(
55 "assertion failed: `assert_program_args_stderr_ge_x!(a_program, a_args, b_expr)`\n",
56 "https://docs.rs/assertables/9.5.3/assertables/macro.assert_program_args_stderr_ge_x.html\n",
57 " a_program label: `{}`,\n",
58 " a_program debug: `{:?}`,\n",
59 " a_args label: `{}`,\n",
60 " a_args debug: `{:?}`,\n",
61 " b_expr label: `{}`,\n",
62 " b_expr debug: `{:?}`,\n",
63 " a: `{:?}`,\n",
64 " b: `{:?}`"
65 ),
66 stringify!($a_program),
67 a_program,
68 stringify!($a_args),
69 a_args,
70 stringify!($b_expr),
71 $b_expr,
72 a,
73 b_expr
74 )
75 )
76 }
77 }
78 Err(err) => {
79 Err(
80 format!(
81 concat!(
82 "assertion failed: `assert_program_args_stderr_ge_x!(a_program, a_args, b_expr)`\n",
83 "https://docs.rs/assertables/9.5.3/assertables/macro.assert_program_args_stderr_ge_x.html\n",
84 " a_program label: `{}`,\n",
85 " a_program debug: `{:?}`,\n",
86 " a_args label: `{}`,\n",
87 " a_args debug: `{:?}`,\n",
88 " b_expr label: `{}`,\n",
89 " b_expr debug: `{:?}`,\n",
90 " err: `{:?}`"
91 ),
92 stringify!($a_program),
93 a_program,
94 stringify!($a_args),
95 a_args,
96 stringify!($b_expr),
97 $b_expr,
98 err
99 )
100 )
101 }
102 }
103 }
104 }
105 }};
106}
107
108#[cfg(test)]
109mod test_assert_program_args_stderr_ge_x_as_result {
110
111 #[test]
112 fn gt() {
113 let a_program = "bin/printf-stderr";
114 let a_args = ["%s", "alfa"];
115 let b = vec![b'a', b'a'];
116 let actual = assert_program_args_stderr_ge_x_as_result!(&a_program, &a_args, b);
117 assert_eq!(actual.unwrap(), vec![b'a', b'l', b'f', b'a']);
118 }
119
120 #[test]
121 fn eq() {
122 let a_program = "bin/printf-stderr";
123 let a_args = ["%s", "alfa"];
124 let b = vec![b'a', b'l', b'f', b'a'];
125 let actual = assert_program_args_stderr_ge_x_as_result!(&a_program, &a_args, b);
126 assert_eq!(actual.unwrap(), vec![b'a', b'l', b'f', b'a']);
127 }
128
129 #[test]
130 fn lt() {
131 let a_program = "bin/printf-stderr";
132 let a_args = ["%s", "alfa"];
133 let b = vec![b'z', b'z'];
134 let actual = assert_program_args_stderr_ge_x_as_result!(&a_program, &a_args, b);
135 let message = concat!(
136 "assertion failed: `assert_program_args_stderr_ge_x!(a_program, a_args, b_expr)`\n",
137 "https://docs.rs/assertables/9.5.3/assertables/macro.assert_program_args_stderr_ge_x.html\n",
138 " a_program label: `&a_program`,\n",
139 " a_program debug: `\"bin/printf-stderr\"`,\n",
140 " a_args label: `&a_args`,\n",
141 " a_args debug: `[\"%s\", \"alfa\"]`,\n",
142 " b_expr label: `b`,\n",
143 " b_expr debug: `[122, 122]`,\n",
144 " a: `[97, 108, 102, 97]`,\n",
145 " b: `[122, 122]`"
146 );
147 assert_eq!(actual.unwrap_err(), message);
148 }
149}
150
151/// Assert a command (built with program and args) stderr is greater than or equal to an expression.
152///
153/// Pseudocode:<br>
154/// (a_program + a_args ⇒ command ⇒ stderr) ≥ (expr into string)
155///
156/// * If true, return `()`.
157///
158/// * Otherwise, call [`panic!`] with a message and the values of the
159/// expressions with their debug representations.
160///
161/// # Examples
162///
163/// ```rust
164/// use assertables::*;
165/// # use std::panic;
166///
167/// # fn main() {
168/// let program = "bin/printf-stderr";
169/// let args = ["%s", "alfa"];
170/// let bytes = vec![b'a', b'a'];
171/// assert_program_args_stderr_ge_x!(&program, &args, bytes);
172///
173/// # let result = panic::catch_unwind(|| {
174/// // This will panic
175/// let program = "bin/printf-stderr";
176/// let args = ["%s", "alfa"];
177/// let bytes = vec![b'z', b'z'];
178/// assert_program_args_stderr_ge_x!(&program, &args, bytes);
179/// # });
180/// // assertion failed: `assert_program_args_stderr_ge_x!(a_program, a_args, b_expr)`
181/// // https://docs.rs/assertables/9.5.3/assertables/macro.assert_program_args_stderr_ge_x.html
182/// // a_program label: `&program`,
183/// // a_program debug: `\"bin/printf-stderr\"`,
184/// // a_args label: `&args`,
185/// // a_args debug: `[\"%s\", \"alfa\"]`,
186/// // b_expr label: `bytes`,
187/// // b_expr debug: `[122, 122]`,
188/// // a: `[97, 108, 102, 97]`,
189/// // b: `[122, 122]`
190/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
191/// # let message = concat!(
192/// # "assertion failed: `assert_program_args_stderr_ge_x!(a_program, a_args, b_expr)`\n",
193/// # "https://docs.rs/assertables/9.5.3/assertables/macro.assert_program_args_stderr_ge_x.html\n",
194/// # " a_program label: `&program`,\n",
195/// # " a_program debug: `\"bin/printf-stderr\"`,\n",
196/// # " a_args label: `&args`,\n",
197/// # " a_args debug: `[\"%s\", \"alfa\"]`,\n",
198/// # " b_expr label: `bytes`,\n",
199/// # " b_expr debug: `[122, 122]`,\n",
200/// # " a: `[97, 108, 102, 97]`,\n",
201/// # " b: `[122, 122]`"
202/// # );
203/// # assert_eq!(actual, message);
204/// # }
205/// ```
206///
207/// # Module macros
208///
209/// * [`assert_program_args_stderr_ge_x`](macro@crate::assert_program_args_stderr_ge_x)
210/// * [`assert_program_args_stderr_ge_x_as_result`](macro@crate::assert_program_args_stderr_ge_x_as_result)
211/// * [`debug_assert_program_args_stderr_ge_x`](macro@crate::debug_assert_program_args_stderr_ge_x)
212///
213#[macro_export]
214macro_rules! assert_program_args_stderr_ge_x {
215 ($a_program:expr, $a_args:expr, $b_expr:expr $(,)?) => {{
216 match $crate::assert_program_args_stderr_ge_x_as_result!($a_program, $a_args, $b_expr) {
217 Ok(x) => x,
218 Err(err) => panic!("{}", err),
219 }
220 }};
221 ($a_program:expr, $a_args:expr, $b_expr:expr, $($message:tt)+) => {{
222 match $crate::assert_program_args_stderr_ge_x_as_result!($a_program, $a_args, $b_expr) {
223 Ok(x) => x,
224 Err(err) => panic!("{}\n{}", format_args!($($message)+), err),
225 }
226 }};
227}
228
229#[cfg(test)]
230mod test_assert_program_args_stderr_ge_x {
231 use std::panic;
232
233 #[test]
234 fn gt() {
235 let a_program = "bin/printf-stderr";
236 let a_args = ["%s", "alfa"];
237 let b = vec![b'a', b'a'];
238 let actual = assert_program_args_stderr_ge_x!(&a_program, &a_args, b);
239 assert_eq!(actual, vec![b'a', b'l', b'f', b'a']);
240 }
241
242 #[test]
243 fn eq() {
244 let a_program = "bin/printf-stderr";
245 let a_args = ["%s", "alfa"];
246 let b = vec![b'a', b'l', b'f', b'a'];
247 let actual = assert_program_args_stderr_ge_x!(&a_program, &a_args, b);
248 assert_eq!(actual, vec![b'a', b'l', b'f', b'a']);
249 }
250
251 #[test]
252 fn lt() {
253 let a_program = "bin/printf-stderr";
254 let a_args = ["%s", "alfa"];
255 let b = vec![b'z', b'z'];
256 let result = panic::catch_unwind(|| {
257 let _actual = assert_program_args_stderr_ge_x!(&a_program, &a_args, b);
258 });
259 let message = concat!(
260 "assertion failed: `assert_program_args_stderr_ge_x!(a_program, a_args, b_expr)`\n",
261 "https://docs.rs/assertables/9.5.3/assertables/macro.assert_program_args_stderr_ge_x.html\n",
262 " a_program label: `&a_program`,\n",
263 " a_program debug: `\"bin/printf-stderr\"`,\n",
264 " a_args label: `&a_args`,\n",
265 " a_args debug: `[\"%s\", \"alfa\"]`,\n",
266 " b_expr label: `b`,\n",
267 " b_expr debug: `[122, 122]`,\n",
268 " a: `[97, 108, 102, 97]`,\n",
269 " b: `[122, 122]`"
270 );
271 assert_eq!(
272 result
273 .unwrap_err()
274 .downcast::<String>()
275 .unwrap()
276 .to_string(),
277 message
278 );
279 }
280}
281
282/// Assert a command (built with program and args) stderr is greater than or equal to an expression.
283///
284/// Pseudocode:<br>
285/// (a_program + a_args ⇒ command ⇒ stderr) ≥ (expr into string)
286///
287/// This macro provides the same statements as [`assert_program_args_stderr_ge_x`](macro.assert_program_args_stderr_ge_x.html),
288/// except this macro's statements are only enabled in non-optimized
289/// builds by default. An optimized build will not execute this macro's
290/// statements unless `-C debug-assertions` is passed to the compiler.
291///
292/// This macro is useful for checks that are too expensive to be present
293/// in a release build but may be helpful during development.
294///
295/// The result of expanding this macro is always type checked.
296///
297/// An unchecked assertion allows a program in an inconsistent state to
298/// keep running, which might have unexpected consequences but does not
299/// introduce unsafety as long as this only happens in safe code. The
300/// performance cost of assertions, however, is not measurable in general.
301/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
302/// after thorough profiling, and more importantly, only in safe code!
303///
304/// This macro is intended to work in a similar way to
305/// [`::std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
306///
307/// # Module macros
308///
309/// * [`assert_program_args_stderr_ge_x`](macro@crate::assert_program_args_stderr_ge_x)
310/// * [`assert_program_args_stderr_ge_x`](macro@crate::assert_program_args_stderr_ge_x)
311/// * [`debug_assert_program_args_stderr_ge_x`](macro@crate::debug_assert_program_args_stderr_ge_x)
312///
313#[macro_export]
314macro_rules! debug_assert_program_args_stderr_ge_x {
315 ($($arg:tt)*) => {
316 if $crate::cfg!(debug_assertions) {
317 $crate::assert_program_args_stderr_ge_x!($($arg)*);
318 }
319 };
320}