assertables/assert_program_args/assert_program_args_stderr_gt_x.rs
1//! Assert a command (built with program and args) stderr is greater than an expression.
2//!
3//! Pseudocode:<br>
4//! (a_program + a_args ⇒ command ⇒ stderr) > (expr into string)
5//!
6//! # Example
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_gt_x!(program, args, bytes);
15//! ```
16//!
17//! # Module macros
18//!
19//! * [`assert_program_args_stderr_gt_x`](macro@crate::assert_program_args_stderr_gt_x)
20//! * [`assert_program_args_stderr_gt_x_as_result`](macro@crate::assert_program_args_stderr_gt_x_as_result)
21//! * [`debug_assert_program_args_stderr_gt_x`](macro@crate::debug_assert_program_args_stderr_gt_x)
22
23/// Assert a command (built with program and args) stderr is greater than 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_gt_x`](macro@crate::assert_program_args_stderr_gt_x)
38/// * [`assert_program_args_stderr_gt_x_as_result`](macro@crate::assert_program_args_stderr_gt_x_as_result)
39/// * [`debug_assert_program_args_stderr_gt_x`](macro@crate::debug_assert_program_args_stderr_gt_x)
40///
41#[macro_export]
42macro_rules! assert_program_args_stderr_gt_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.gt(b_expr) {
50 Ok(a)
51 } else {
52 Err(
53 format!(
54 concat!(
55 "assertion failed: `assert_program_args_stderr_gt_x!(a_program, a_args, b_expr)`\n",
56 "https://docs.rs/assertables/", env!("CARGO_PKG_VERSION"), "/assertables/macro.assert_program_args_stderr_gt_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_gt_x!(a_program, a_args, b_expr)`\n",
83 "https://docs.rs/assertables/", env!("CARGO_PKG_VERSION"), "/assertables/macro.assert_program_args_stderr_gt_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_gt_x_as_result {
110 use std::sync::Once;
111
112 #[test]
113 fn gt() {
114 let a_program = "bin/printf-stderr";
115 let a_args = ["%s", "alfa"];
116 let b = vec![b'a', b'a'];
117 for _ in 0..1 {
118 let actual = assert_program_args_stderr_gt_x_as_result!(a_program, a_args, b);
119 assert_eq!(actual.unwrap(), vec![b'a', b'l', b'f', b'a']);
120 }
121 }
122
123 #[test]
124 fn gt_once() {
125 static A: Once = Once::new();
126 fn a() -> &'static str {
127 if A.is_completed() {
128 panic!("A.is_completed()")
129 } else {
130 A.call_once(|| {})
131 }
132 "bin/printf-stderr"
133 }
134
135 static A_ARGS: Once = Once::new();
136 fn a_args() -> [&'static str; 2] {
137 if A_ARGS.is_completed() {
138 panic!("A_ARGS.is_completed()")
139 } else {
140 A_ARGS.call_once(|| {})
141 }
142 ["%s", "alfa"]
143 }
144
145 static B: Once = Once::new();
146 fn b() -> Vec<u8> {
147 if B.is_completed() {
148 panic!("B.is_completed()")
149 } else {
150 B.call_once(|| {})
151 }
152 vec![b'a', b'a']
153 }
154
155 assert_eq!(A.is_completed(), false);
156 assert_eq!(A_ARGS.is_completed(), false);
157 assert_eq!(B.is_completed(), false);
158 let result = assert_program_args_stderr_gt_x_as_result!(a(), a_args(), b());
159 assert!(result.is_ok());
160 assert_eq!(A.is_completed(), true);
161 assert_eq!(A_ARGS.is_completed(), true);
162 assert_eq!(B.is_completed(), true);
163 }
164
165 #[test]
166 fn eq() {
167 let a_program = "bin/printf-stderr";
168 let a_args = ["%s", "alfa"];
169 let b = vec![b'a', b'l', b'f', b'a'];
170 let actual = assert_program_args_stderr_gt_x_as_result!(a_program, a_args, b);
171 let message = concat!(
172 "assertion failed: `assert_program_args_stderr_gt_x!(a_program, a_args, b_expr)`\n",
173 "https://docs.rs/assertables/",
174 env!("CARGO_PKG_VERSION"),
175 "/assertables/macro.assert_program_args_stderr_gt_x.html\n",
176 " a_program label: `a_program`,\n",
177 " a_program debug: `\"bin/printf-stderr\"`,\n",
178 " a_args label: `a_args`,\n",
179 " a_args debug: `[\"%s\", \"alfa\"]`,\n",
180 " b_expr label: `b`,\n",
181 " b_expr debug: `[97, 108, 102, 97]`,\n",
182 " a: `[97, 108, 102, 97]`,\n",
183 " b: `[97, 108, 102, 97]`"
184 );
185 assert_eq!(actual.unwrap_err(), message);
186 }
187
188 #[test]
189 fn lt() {
190 let a_program = "bin/printf-stderr";
191 let a_args = ["%s", "alfa"];
192 let b = vec![b'z', b'z'];
193 let actual = assert_program_args_stderr_gt_x_as_result!(a_program, a_args, b);
194 let message = concat!(
195 "assertion failed: `assert_program_args_stderr_gt_x!(a_program, a_args, b_expr)`\n",
196 "https://docs.rs/assertables/",
197 env!("CARGO_PKG_VERSION"),
198 "/assertables/macro.assert_program_args_stderr_gt_x.html\n",
199 " a_program label: `a_program`,\n",
200 " a_program debug: `\"bin/printf-stderr\"`,\n",
201 " a_args label: `a_args`,\n",
202 " a_args debug: `[\"%s\", \"alfa\"]`,\n",
203 " b_expr label: `b`,\n",
204 " b_expr debug: `[122, 122]`,\n",
205 " a: `[97, 108, 102, 97]`,\n",
206 " b: `[122, 122]`"
207 );
208 assert_eq!(actual.unwrap_err(), message);
209 }
210}
211
212/// Assert a command (built with program and args) stderr is greater than an expression.
213///
214/// Pseudocode:<br>
215/// (a_program + a_args ⇒ command ⇒ stderr) > (expr into string)
216///
217/// * If true, return `()`.
218///
219/// * Otherwise, call [`panic!`] with a message and the values of the
220/// expressions with their debug representations.
221///
222/// # Examples
223///
224/// ```rust
225/// use assertables::*;
226/// # use std::panic;
227///
228/// # fn main() {
229/// let program = "bin/printf-stderr";
230/// let args = ["%s", "alfa"];
231/// let bytes = vec![b'a', b'a'];
232/// assert_program_args_stderr_gt_x!(program, args, bytes);
233///
234/// # let result = panic::catch_unwind(|| {
235/// // This will panic
236/// let program = "bin/printf-stderr";
237/// let args = ["%s", "alfa"];
238/// let bytes = vec![b'z', b'z'];
239/// assert_program_args_stderr_gt_x!(program, args, bytes);
240/// # });
241/// // assertion failed: `assert_program_args_stderr_gt_x!(a_program, a_args, b_expr)`
242/// // https://docs.rs/assertables/9.7.0/assertables/macro.assert_program_args_stderr_gt_x.html
243/// // a_program label: `program`,
244/// // a_program debug: `\"bin/printf-stderr\"`,
245/// // a_args label: `args`,
246/// // a_args debug: `[\"%s\", \"alfa\"]`,
247/// // b_expr label: `bytes`,
248/// // b_expr debug: `[122, 122]`,
249/// // a: `[97, 108, 102, 97]`,
250/// // b: `[122, 122]`
251/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
252/// # let message = concat!(
253/// # "assertion failed: `assert_program_args_stderr_gt_x!(a_program, a_args, b_expr)`\n",
254/// # "https://docs.rs/assertables/", env!("CARGO_PKG_VERSION"), "/assertables/macro.assert_program_args_stderr_gt_x.html\n",
255/// # " a_program label: `program`,\n",
256/// # " a_program debug: `\"bin/printf-stderr\"`,\n",
257/// # " a_args label: `args`,\n",
258/// # " a_args debug: `[\"%s\", \"alfa\"]`,\n",
259/// # " b_expr label: `bytes`,\n",
260/// # " b_expr debug: `[122, 122]`,\n",
261/// # " a: `[97, 108, 102, 97]`,\n",
262/// # " b: `[122, 122]`"
263/// # );
264/// # assert_eq!(actual, message);
265/// # }
266/// ```
267///
268/// # Module macros
269///
270/// * [`assert_program_args_stderr_gt_x`](macro@crate::assert_program_args_stderr_gt_x)
271/// * [`assert_program_args_stderr_gt_x_as_result`](macro@crate::assert_program_args_stderr_gt_x_as_result)
272/// * [`debug_assert_program_args_stderr_gt_x`](macro@crate::debug_assert_program_args_stderr_gt_x)
273///
274#[macro_export]
275macro_rules! assert_program_args_stderr_gt_x {
276 ($a_program:expr, $a_args:expr, $b_expr:expr $(,)?) => {
277 match $crate::assert_program_args_stderr_gt_x_as_result!($a_program, $a_args, $b_expr) {
278 Ok(x) => x,
279 Err(err) => panic!("{}", err),
280 }
281 };
282 ($a_program:expr, $a_args:expr, $b_expr:expr, $($message:tt)+) => {
283 match $crate::assert_program_args_stderr_gt_x_as_result!($a_program, $a_args, $b_expr) {
284 Ok(x) => x,
285 Err(err) => panic!("{}\n{}", format_args!($($message)+), err),
286 }
287 };
288}
289
290#[cfg(test)]
291mod test_assert_program_args_stderr_gt_x {
292 use std::panic;
293
294 #[test]
295 fn gt() {
296 let a_program = "bin/printf-stderr";
297 let a_args = ["%s", "alfa"];
298 let b = vec![b'a', b'a'];
299 for _ in 0..1 {
300 let actual = assert_program_args_stderr_gt_x!(a_program, a_args, b);
301 assert_eq!(actual, vec![b'a', b'l', b'f', b'a']);
302 }
303 }
304
305 #[test]
306 fn eq() {
307 let a_program = "bin/printf-stderr";
308 let a_args = ["%s", "alfa"];
309 let b = vec![b'a', b'l', b'f', b'a'];
310 let result = panic::catch_unwind(|| {
311 let _actual = assert_program_args_stderr_gt_x!(a_program, a_args, b);
312 });
313 let message = concat!(
314 "assertion failed: `assert_program_args_stderr_gt_x!(a_program, a_args, b_expr)`\n",
315 "https://docs.rs/assertables/",
316 env!("CARGO_PKG_VERSION"),
317 "/assertables/macro.assert_program_args_stderr_gt_x.html\n",
318 " a_program label: `a_program`,\n",
319 " a_program debug: `\"bin/printf-stderr\"`,\n",
320 " a_args label: `a_args`,\n",
321 " a_args debug: `[\"%s\", \"alfa\"]`,\n",
322 " b_expr label: `b`,\n",
323 " b_expr debug: `[97, 108, 102, 97]`,\n",
324 " a: `[97, 108, 102, 97]`,\n",
325 " b: `[97, 108, 102, 97]`"
326 );
327 assert_eq!(
328 result
329 .unwrap_err()
330 .downcast::<String>()
331 .unwrap()
332 .to_string(),
333 message
334 );
335 }
336
337 #[test]
338 fn lt() {
339 let a_program = "bin/printf-stderr";
340 let a_args = ["%s", "alfa"];
341 let b = vec![b'z', b'z'];
342 let result = panic::catch_unwind(|| {
343 let _actual = assert_program_args_stderr_gt_x!(a_program, a_args, b);
344 });
345 let message = concat!(
346 "assertion failed: `assert_program_args_stderr_gt_x!(a_program, a_args, b_expr)`\n",
347 "https://docs.rs/assertables/",
348 env!("CARGO_PKG_VERSION"),
349 "/assertables/macro.assert_program_args_stderr_gt_x.html\n",
350 " a_program label: `a_program`,\n",
351 " a_program debug: `\"bin/printf-stderr\"`,\n",
352 " a_args label: `a_args`,\n",
353 " a_args debug: `[\"%s\", \"alfa\"]`,\n",
354 " b_expr label: `b`,\n",
355 " b_expr debug: `[122, 122]`,\n",
356 " a: `[97, 108, 102, 97]`,\n",
357 " b: `[122, 122]`"
358 );
359 assert_eq!(
360 result
361 .unwrap_err()
362 .downcast::<String>()
363 .unwrap()
364 .to_string(),
365 message
366 );
367 }
368}
369
370/// Assert a command (built with program and args) stderr is greater than an expression.
371///
372/// Pseudocode:<br>
373/// (a_program + a_args ⇒ command ⇒ stderr) > (expr into string)
374///
375/// This macro provides the same statements as [`assert_program_args_stderr_gt_x`](macro.assert_program_args_stderr_gt_x.html),
376/// except this macro's statements are only enabled in non-optimized
377/// builds by default. An optimized build will not execute this macro's
378/// statements unless `-C debug-assertions` is passed to the compiler.
379///
380/// This macro is useful for checks that are too expensive to be present
381/// in a release build but may be helpful during development.
382///
383/// The result of expanding this macro is always type checked.
384///
385/// An unchecked assertion allows a program in an inconsistent state to
386/// keep running, which might have unexpected consequences but does not
387/// introduce unsafety as long as this only happens in safe code. The
388/// performance cost of assertions, however, is not measurable in general.
389/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
390/// after thorough profiling, and more importantly, only in safe code!
391///
392/// This macro is intended to work in a similar way to
393/// [`::std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
394///
395/// # Module macros
396///
397/// * [`assert_program_args_stderr_gt_x`](macro@crate::assert_program_args_stderr_gt_x)
398/// * [`assert_program_args_stderr_gt_x`](macro@crate::assert_program_args_stderr_gt_x)
399/// * [`debug_assert_program_args_stderr_gt_x`](macro@crate::debug_assert_program_args_stderr_gt_x)
400///
401#[macro_export]
402macro_rules! debug_assert_program_args_stderr_gt_x {
403 ($($arg:tt)*) => {
404 if $crate::cfg!(debug_assertions) {
405 $crate::assert_program_args_stderr_gt_x!($($arg)*);
406 }
407 };
408}