validit/macros.rs
1//! Defines macros for validation check, such as `less!(smaller, greater)`.
2
3use std::fmt::Arguments;
4
5pub fn make_err(fmt: Arguments) -> anyerror::AnyError {
6 anyerror::AnyError::error(format!("{fmt}"))
7}
8
9/// Assert that function call `call(a,b,...)`(up to 8 arguments) to return true, otherwise it return
10/// an error.
11///
12/// For example:
13/// ```
14/// # use std::error::Error;
15/// # use validit::be_true;
16/// fn expect_true(a: u64, b:u64) -> Result<(), Box<dyn Error + 'static>> {
17/// fn le(a: u64, b: u64) -> bool { a <= b }
18/// be_true!(le(a,b));
19/// Ok(())
20/// }
21/// assert!(expect_true(1,2).is_ok());
22/// assert!(expect_true(3,2).unwrap_err().to_string().starts_with("expect to be true: le(a(3), b(2)) at "));
23/// ```
24///
25/// Another example with 3 arguments:
26/// ```
27/// # use std::error::Error;
28/// # use validit::be_true;
29/// fn expect_true3(a: u64, b:u64) -> Result<(), Box<dyn Error + 'static>> {
30/// fn mid(l: u64, x: u64, r: u64) -> bool { l <= x && x <= r }
31/// be_true!(mid(a,5,b));
32/// Ok(())
33/// }
34/// assert!(expect_true3(1,10).is_ok());
35/// assert!(expect_true3(6,10).unwrap_err().to_string().starts_with("expect to be true: mid(a(6), 5(5), b(10)) at "));
36/// ```
37#[macro_export]
38macro_rules! be_true {
39 // 0 args
40 ($($call: ident).+()) => {{
41 let __result = $($call).+();
42 if __result {
43 // Ok
44 } else {
45 Err($crate::macros::make_err(format_args!(
46 "expect to be true: {}() at {}:{}",
47 stringify!($($call).+),
48 file!(), line!(),
49 )))?;
50 }
51 }};
52
53 // 1 args
54 ($($call: ident).+($a: expr)) => {{
55 let __a = $a;
56 let __result = $($call).+(__a);
57 if __result {
58 // Ok
59 } else {
60 Err($crate::macros::make_err(format_args!(
61 "expect to be true: {}({}({:?})) at {}:{}",
62 stringify!($($call).+),
63 stringify!($a),
64 __a,
65 file!(), line!(),
66 )))?;
67 }
68 }};
69
70 // 2 args
71 ($($call: ident).+($a: expr, $b: expr)) => {{
72 let __a = $a;
73 let __b = $b;
74 let __result = $($call).+(__a, __b);
75 if __result {
76 // Ok
77 } else {
78 Err($crate::macros::make_err(format_args!(
79 "expect to be true: {}({}({:?}), {}({:?})) at {}:{}",
80 stringify!($($call).+),
81 stringify!($a),
82 __a,
83 stringify!($b),
84 __b,
85 file!(), line!(),
86 )))?;
87 }
88 }};
89
90 // 3 args
91 ($($call: ident).+($a: expr, $b: expr, $c: expr)) => {{
92 let __a = $a;
93 let __b = $b;
94 let __c = $c;
95 let __result = $($call).+(__a, __b, __c);
96 if __result {
97 // Ok
98 } else {
99 Err($crate::macros::make_err(format_args!(
100 "expect to be true: {}({}({:?}), {}({:?}), {}({:?})) at {}:{}",
101 stringify!($($call).+),
102 stringify!($a),
103 __a,
104 stringify!($b),
105 __b,
106 stringify!($c),
107 __c,
108 file!(), line!(),
109 )))?;
110 }
111 }};
112
113 // 4 args
114 ($($call: ident).+($a: expr, $b: expr, $c: expr, $d: expr)) => {{
115 let __a = $a;
116 let __b = $b;
117 let __c = $c;
118 let __d = $d;
119 let __result = $($call).+(__a, __b, __c, __d);
120 if __result {
121 // Ok
122 } else {
123 Err($crate::macros::make_err(format_args!(
124 "expect to be true: {}({}({:?}), {}({:?}), {}({:?}), {}({:?})) at {}:{}",
125 stringify!($($call).+),
126 stringify!($a),
127 __a,
128 stringify!($b),
129 __b,
130 stringify!($c),
131 __c,
132 stringify!($d),
133 __d,
134 file!(), line!(),
135 )))?;
136 }
137 }};
138
139 // 5 args
140 ($($call: ident).+($a: expr, $b: expr, $c: expr, $d: expr, $e: expr)) => {{
141 let __a = $a;
142 let __b = $b;
143 let __c = $c;
144 let __d = $d;
145 let __e = $e;
146 let __result = $($call).+(__a, __b, __c, __d, __e);
147 if __result {
148 // Ok
149 } else {
150 Err($crate::macros::make_err(format_args!(
151 "expect to be true: {}({}({:?}), {}({:?}), {}({:?}), {}({:?}), {}({:?})) at {}:{}",
152 stringify!($($call).+),
153 stringify!($a),
154 __a,
155 stringify!($b),
156 __b,
157 stringify!($c),
158 __c,
159 stringify!($d),
160 __d,
161 stringify!($e),
162 __e,
163 file!(), line!(),
164 )))?;
165 }
166 }};
167
168 // 6 args
169 ($($call: ident).+($a: expr, $b: expr, $c: expr, $d: expr, $e: expr, $f: expr)) => {{
170 let __a = $a;
171 let __b = $b;
172 let __c = $c;
173 let __d = $d;
174 let __e = $e;
175 let __f = $f;
176 let __result = $($call).+(__a, __b, __c, __d, __e, __f);
177 if __result {
178 // Ok
179 } else {
180 Err($crate::macros::make_err(format_args!(
181 "expect to be true: {}({}({:?}), {}({:?}), {}({:?}), {}({:?}), {}({:?}), {}({:?})) at {}:{}",
182 stringify!($($call).+),
183 stringify!($a),
184 __a,
185 stringify!($b),
186 __b,
187 stringify!($c),
188 __c,
189 stringify!($d),
190 __d,
191 stringify!($e),
192 __e,
193 stringify!($f),
194 __f,
195 file!(), line!(),
196 )))?;
197 }
198 }};
199
200 // 7 args
201 ($($call: ident).+($a: expr, $b: expr, $c: expr, $d: expr, $e: expr, $f: expr, $g: expr)) => {{
202 let __a = $a;
203 let __b = $b;
204 let __c = $c;
205 let __d = $d;
206 let __e = $e;
207 let __f = $f;
208 let __g = $g;
209 let __result = $($call).+(__a, __b, __c, __d, __e, __f, __g);
210 if __result {
211 // Ok
212 } else {
213 Err($crate::macros::make_err(format_args!(
214 "expect to be true: {}({}({:?}), {}({:?}), {}({:?}), {}({:?}), {}({:?}), {}({:?}), {}({:?})) at {}:{}",
215 stringify!($($call).+),
216 stringify!($a),
217 __a,
218 stringify!($b),
219 __b,
220 stringify!($c),
221 __c,
222 stringify!($d),
223 __d,
224 stringify!($e),
225 __e,
226 stringify!($f),
227 __f,
228 stringify!($g),
229 __g,
230 file!(), line!(),
231 )))?;
232 }
233 }};
234
235 // 8 args
236 ($($call: ident).+($a: expr, $b: expr, $c: expr, $d: expr, $e: expr, $f: expr, $g: expr, $h: expr)) => {{
237 let __a = $a;
238 let __b = $b;
239 let __c = $c;
240 let __d = $d;
241 let __e = $e;
242 let __f = $f;
243 let __g = $g;
244 let __h = $h;
245 let __result = $($call).+(__a, __b, __c, __d, __e, __f, __g, __h);
246 if __result {
247 // Ok
248 } else {
249 Err($crate::macros::make_err(format_args!(
250 "expect to be true: {}({}({:?}), {}({:?}), {}({:?}), {}({:?}), {}({:?}), {}({:?}), {}({:?}), {}({:?})) at {}:{}",
251 stringify!($($call).+),
252 stringify!($a),
253 __a,
254 stringify!($b),
255 __b,
256 stringify!($c),
257 __c,
258 stringify!($d),
259 __d,
260 stringify!($e),
261 __e,
262 stringify!($f),
263 __f,
264 stringify!($g),
265 __g,
266 stringify!($h),
267 __h,
268 file!(), line!(),
269 )))?;
270 }
271 }};
272}
273
274/// Assert that `a` is less than `b`, otherwise it return an error.
275///
276/// For example:
277/// ```
278/// # use std::error::Error;
279/// # use validit::less;
280/// fn expect_less(a: u64, b:u64) -> Result<(), Box<dyn Error + 'static>> {
281/// less!(a,b);
282/// Ok(())
283/// }
284/// assert!(expect_less(1,2).is_ok());
285/// assert!(expect_less(2,2).unwrap_err().to_string().starts_with("expect: a(2) < b(2) at "));
286/// ```
287#[macro_export]
288macro_rules! less {
289 ($a: expr, $b: expr) => {{
290 let a = $a;
291 let b = $b;
292 if (a < b) {
293 // Ok
294 } else {
295 Err($crate::macros::make_err(format_args!(
296 "expect: {}({:?}) < {}({:?}) at {}:{}",
297 stringify!($a),
298 a,
299 stringify!($b),
300 b,
301 file!(),
302 line!(),
303 )))?;
304 }
305 }};
306}
307
308/// Assert that `a` is greater than `b`, otherwise it return an error.
309///
310/// For example:
311/// ```
312/// # use std::error::Error;
313/// # use validit::greater;
314/// fn expect_greater(a: u64, b:u64) -> Result<(), Box<dyn Error + 'static>> {
315/// greater!(a,b);
316/// Ok(())
317/// }
318/// assert!(expect_greater(2,1).is_ok());
319/// assert!(expect_greater(2,2).unwrap_err().to_string().starts_with("expect: a(2) > b(2) at "));
320/// ```
321#[macro_export]
322macro_rules! greater {
323 ($a: expr, $b: expr) => {{
324 let a = $a;
325 let b = $b;
326 if (a > b) {
327 // Ok
328 } else {
329 Err($crate::macros::make_err(format_args!(
330 "expect: {}({:?}) > {}({:?}) at {}:{}",
331 stringify!($a),
332 a,
333 stringify!($b),
334 b,
335 file!(),
336 line!(),
337 )))?;
338 }
339 }};
340}
341
342/// Assert that `a` is less than or equal to `b`, otherwise it return an error.
343///
344/// For example:
345/// ```
346/// # use std::error::Error;
347/// # use validit::less_equal;
348/// fn expect_less_equal(a: u64, b:u64) -> Result<(), Box<dyn Error + 'static>> {
349/// less_equal!(a,b);
350/// Ok(())
351/// }
352/// assert!(expect_less_equal(2,2).is_ok());
353/// assert!(expect_less_equal(3,2).unwrap_err().to_string().starts_with("expect: a(3) <= b(2) at "));
354/// ```
355#[macro_export]
356macro_rules! less_equal {
357 ($a: expr, $b: expr) => {{
358 let a = $a;
359 let b = $b;
360 if (a <= b) {
361 // Ok
362 } else {
363 Err($crate::macros::make_err(format_args!(
364 "expect: {}({:?}) <= {}({:?}) at {}:{}",
365 stringify!($a),
366 a,
367 stringify!($b),
368 b,
369 file!(),
370 line!(),
371 )))?;
372 }
373 }};
374}
375
376/// Assert that `a` is greater than or equal to `b`, otherwise it return an error.
377///
378/// For example:
379/// ```
380/// # use std::error::Error;
381/// # use validit::greater_equal;
382/// fn expect_greater_equal(a: u64, b:u64) -> Result<(), Box<dyn Error + 'static>> {
383/// greater_equal!(a,b);
384/// Ok(())
385/// }
386/// assert!(expect_greater_equal(2,2).is_ok());
387/// assert!(expect_greater_equal(2,3).unwrap_err().to_string().starts_with("expect: a(2) >= b(3) at "));
388/// ```
389#[macro_export]
390macro_rules! greater_equal {
391 ($a: expr, $b: expr) => {{
392 let a = $a;
393 let b = $b;
394 if (a >= b) {
395 // Ok
396 } else {
397 Err($crate::macros::make_err(format_args!(
398 "expect: {}({:?}) >= {}({:?}) at {}:{}",
399 stringify!($a),
400 a,
401 stringify!($b),
402 b,
403 file!(),
404 line!(),
405 )))?;
406 }
407 }};
408}
409
410/// Assert that `a` equal to `b`, otherwise it return an error.
411///
412/// For example:
413/// ```
414/// # use std::error::Error;
415/// # use validit::equal;
416/// fn expect_equal(a: u64, b:u64) -> Result<(), Box<dyn Error + 'static>> {
417/// equal!(a,b);
418/// Ok(())
419/// }
420/// assert!(expect_equal(2,2).is_ok());
421/// assert!(expect_equal(3,2).unwrap_err().to_string().starts_with("expect: a(3) == b(2) at "));
422/// ```
423#[macro_export]
424macro_rules! equal {
425 ($a: expr, $b: expr) => {{
426 let a = $a;
427 let b = $b;
428 if (a == b) {
429 // Ok
430 } else {
431 Err($crate::macros::make_err(format_args!(
432 "expect: {}({:?}) == {}({:?}) at {}:{}",
433 stringify!($a),
434 a,
435 stringify!($b),
436 b,
437 file!(),
438 line!(),
439 )))?;
440 }
441 }};
442}