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