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