assertables/
assert_ne.rs

1//! Assert an expression is not equal to another.
2//!
3//! Pseudocode:<br>
4//! a ≠ b
5//!
6//! # Module macro
7//!
8//! * [`assert_ne_as_result`](macro@crate::assert_ne_as_result)
9//!
10//! # Rust standard macros
11//!
12//! * [`assert_ne`](https://doc.rust-lang.org/std/macro.assert_ne.html)
13//! * [`debug_assert_ne`](https://doc.rust-lang.org/std/macro.debug_assert_ne.html)
14
15/// Assert an expression is not equal to another.
16///
17/// Pseudocode:<br>
18/// a ≠ b
19///
20/// * If true, return Result `Ok(())`.
21///
22/// * When false, return [`Err`] with a message and the values of the
23///   expressions with their debug representations.
24///
25/// This macro is useful for runtime checks, such as checking parameters,
26/// or sanitizing inputs, or handling different results in different ways.
27///
28/// # Module macro
29///
30/// * [`assert_ne_as_result`](macro@crate::assert_ne_as_result)
31///
32/// # Rust standard macros
33///
34/// * [`assert_ne`](https://doc.rust-lang.org/std/macro.assert_ne.html)
35/// * [`debug_assert_ne`](https://doc.rust-lang.org/std/macro.debug_assert_ne.html)
36///
37#[macro_export]
38macro_rules! assert_ne_as_result {
39    ($a:expr, $b:expr $(,)?) => {
40        match (&$a, &$b) {
41            (a, b) => {
42                if a != b {
43                    Ok(())
44                } else {
45                    Err(format!(
46                        concat!(
47                            "assertion failed: `assert_ne!(a, b)`\n",
48                            "https://docs.rs/assertables/9.8.2/assertables/macro.assert_ne.html\n",
49                            " a label: `{}`,\n",
50                            " a debug: `{:?}`,\n",
51                            " b label: `{}`,\n",
52                            " b debug: `{:?}`"
53                        ),
54                        stringify!($a),
55                        a,
56                        stringify!($b),
57                        b
58                    ))
59                }
60            }
61        }
62    };
63}
64
65#[cfg(test)]
66mod test_assert_ne_as_result {
67    use std::sync::Once;
68
69    mod integer {
70        use super::*;
71
72        #[test]
73        fn lt() {
74            let a: i8 = 1;
75            let b: i8 = 2;
76            for _ in 0..1 {
77                let actual = assert_ne_as_result!(a, b);
78                assert_eq!(actual.unwrap(), ());
79            }
80        }
81
82        #[test]
83        fn lt_once() {
84            static A: Once = Once::new();
85            fn a() -> i8 {
86                if A.is_completed() {
87                    panic!("A.is_completed()")
88                } else {
89                    A.call_once(|| {})
90                }
91                1
92            }
93
94            static B: Once = Once::new();
95            fn b() -> i8 {
96                if B.is_completed() {
97                    panic!("B.is_completed()")
98                } else {
99                    B.call_once(|| {})
100                }
101                2
102            }
103
104            assert_eq!(A.is_completed(), false);
105            assert_eq!(B.is_completed(), false);
106            let result = assert_ne_as_result!(a(), b());
107            assert!(result.is_ok());
108            assert_eq!(A.is_completed(), true);
109            assert_eq!(B.is_completed(), true);
110        }
111
112        #[test]
113        fn gt() {
114            let a: i8 = 2;
115            let b: i8 = 1;
116            for _ in 0..1 {
117                let actual = assert_ne_as_result!(a, b);
118                assert_eq!(actual.unwrap(), ());
119            }
120        }
121
122        #[test]
123        fn gt_once() {
124            static A: Once = Once::new();
125            fn a() -> i8 {
126                if A.is_completed() {
127                    panic!("A.is_completed()")
128                } else {
129                    A.call_once(|| {})
130                }
131                2
132            }
133
134            static B: Once = Once::new();
135            fn b() -> i8 {
136                if B.is_completed() {
137                    panic!("B.is_completed()")
138                } else {
139                    B.call_once(|| {})
140                }
141                1
142            }
143
144            assert_eq!(A.is_completed(), false);
145            assert_eq!(B.is_completed(), false);
146            let result = assert_ne_as_result!(a(), b());
147            assert!(result.is_ok());
148            assert_eq!(A.is_completed(), true);
149            assert_eq!(B.is_completed(), true);
150        }
151
152        #[test]
153        fn eq() {
154            let a: i8 = 1;
155            let b: i8 = 1;
156            let actual = assert_ne_as_result!(a, b);
157            let message = concat!(
158                "assertion failed: `assert_ne!(a, b)`\n",
159                "https://docs.rs/assertables/9.8.2/assertables/macro.assert_ne.html\n",
160                " a label: `a`,\n",
161                " a debug: `1`,\n",
162                " b label: `b`,\n",
163                " b debug: `1`",
164            );
165            assert_eq!(actual.unwrap_err(), message);
166        }
167    }
168
169    mod string {
170        use super::*;
171
172        #[test]
173        fn lt() {
174            let a: String = String::from("1");
175            let b: String = String::from("2");
176            for _ in 0..1 {
177                let actual = assert_ne_as_result!(a, b);
178                assert_eq!(actual.unwrap(), ());
179            }
180        }
181
182        #[test]
183        fn lt_once() {
184            static A: Once = Once::new();
185            fn a() -> String {
186                if A.is_completed() {
187                    panic!("A.is_completed()")
188                } else {
189                    A.call_once(|| {})
190                }
191                String::from("1")
192            }
193
194            static B: Once = Once::new();
195            fn b() -> String {
196                if B.is_completed() {
197                    panic!("B.is_completed()")
198                } else {
199                    B.call_once(|| {})
200                }
201                String::from("2")
202            }
203
204            assert_eq!(A.is_completed(), false);
205            assert_eq!(B.is_completed(), false);
206            let result = assert_ne_as_result!(a(), b());
207            assert!(result.is_ok());
208            assert_eq!(A.is_completed(), true);
209            assert_eq!(B.is_completed(), true);
210        }
211
212        #[test]
213        fn gt() {
214            let a: String = String::from("2");
215            let b: String = String::from("1");
216            for _ in 0..1 {
217                let actual = assert_ne_as_result!(a, b);
218                assert_eq!(actual.unwrap(), ());
219            }
220        }
221
222        #[test]
223        fn gt_once() {
224            static A: Once = Once::new();
225            fn a() -> String {
226                if A.is_completed() {
227                    panic!("A.is_completed()")
228                } else {
229                    A.call_once(|| {})
230                }
231                String::from("2")
232            }
233
234            static B: Once = Once::new();
235            fn b() -> String {
236                if B.is_completed() {
237                    panic!("B.is_completed()")
238                } else {
239                    B.call_once(|| {})
240                }
241                String::from("1")
242            }
243
244            assert_eq!(A.is_completed(), false);
245            assert_eq!(B.is_completed(), false);
246            let result = assert_ne_as_result!(a(), b());
247            assert!(result.is_ok());
248            assert_eq!(A.is_completed(), true);
249            assert_eq!(B.is_completed(), true);
250        }
251
252        #[test]
253        fn eq() {
254            let a: String = String::from("1");
255            let b: String = String::from("1");
256            let actual = assert_ne_as_result!(a, b);
257            let message = concat!(
258                "assertion failed: `assert_ne!(a, b)`\n",
259                "https://docs.rs/assertables/9.8.2/assertables/macro.assert_ne.html\n",
260                " a label: `a`,\n",
261                " a debug: `\"1\"`,\n",
262                " b label: `b`,\n",
263                " b debug: `\"1\"`",
264            );
265            assert_eq!(actual.unwrap_err(), message);
266        }
267    }
268}
assertables/assert_ne.rs

assertables/
assert_ne.rs
