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