The assertables Rust crate provides many "assert" macros
to help with compile-time testing and run-time reliability
Crate: https://crates.io/crates/assertables
Docs: https://docs.rs/assertables/
Repo: https://github.com/sixarm/assertables-rust-crate/
Value macros such as:
assert_gt!(value1, value2); // value1 > value2
Set macros such as:
assert_set_subset_other!(set1, set2); // set1 is a subset of set2
Function macros such as:
assert_fn_eq!(function, input, output); // function(input) == output
Reader macros such as:
assert_read_to_string_eq!(reader, string); // reader read to string == string
Command macros such as:
assert_command_stdout_eq!(command, string); // command standard output == string
Abbreviations:
eq means equal; ne means not equal.
lt means less than; le means less than or equal.
gt means greater than; ge means greater than or equal.
Shorthands:
reader means implements .read_to_string(…) such as std::io::Read.
matcher means implements .is_match(…) such as regex::Regex.
containee means usable inside .contains(…) such as a std::string::String substring.
set means a collection such as ::std::collections::BTreeSet.
bag means a collection such as ::std::collections::BTreeMap with key counts.
The macros have forms for immediate interrupts or returning results:
``` assert_gt!(a, b); // return () or panic!(…)
assertgtas_result!(a, b); // return Result Ok(()) or Err(…) ```
The macros have forms for default messages or custom messages.
``
assert_gt!(1, 2); // panic!("assertion failed:assert_gt(1, 2)`…")
assert_gt!(1, 2, "message"); // panic!("message") ```
Some macros have forms for comparing to an expression (expr) versus an equivalent (other):
``` assertreadtostringeq!(reader, expr); // reader.readtostring() == expr
assertreadtostringeqother!(reader1, reader2); // reader1.readtostring() == reader2.readto_string() ```
Compare values.
assert_eq!(a, b) ~ a == b
assert_ne!(a, b) ~ a != b
assert_lt!(a, b) ~ a < b
assert_le!(a, b) ~ a <= b
assert_gt!(a, b) ~ a > b
assert_ge!(a, b) ~ a >= b
These macros help with comparison of set parameters, such as two arrays or two vectors. where the item order does not matter, and the item count does not matter. The macros convert inputs into HashSet iterators.
assert_set_eq_other!(a, b) ~ set a == set b
assert_set_ne_other!(a, b) ~ set a != set b
assert_set_subset_other!(a, b) ~ set a ⊆ set b
assert_set_superset_other!(a, b) ~ set a ⊇ set b
assert_set_joint!(a, b) ~ set a is joint with set b
assert_set_disjoint!(a, b) ~ set a is disjoint with set b
These macros help with comparison of bag parameters, such as comparison of two arrays or two vectors, where the item order does not matter, and the item count does matter. The macros convert inputs into HashMap iterators.
assert_bag_eq_other(a, b) ~ bag a == bag b
assert_bag_ne_other(a, b) ~ bag a != bag b
assert_bag_subbag(a, b) ~ bag a ⊆ bag b
assert_bag_superbag(a, b) ~ bag a ⊇ bag b
assert_fn_eq!(f, a, b) ~ f(a) == b
assert_fn_eq_other!(f, a, b) ~ f(a) == f(b)
assert_fn_ne!(f, a, b) ~ f(a) != b
assert_fn_ne_other!(f, a, b) ~ f(a) != f(b)
assert_fn_lt!(f, a, b) ~ f(a) < v
assert_fn_lt_other!(f, a, b) ~ f(a) < f(b)
assert_fn_le!(f, a, b) ~ f(a) <= b
assert_fn_le_other!(f, a, b) ~ f(a) <= f(b)
assert_fn_gt!(f, a, b) ~ f(a) > b
assert_fn_gt_other!(f, a, b) ~ f(a) > f(b)
assert_fn_ge!(f, a, b) ~ f(a) >= b
assert_fn_ge_other!(f, a, b) ~ f(a) >= f(b)
assert_fn_ok_eq!(f, a, b) ~ f(a).unwrap() == b
assert_fn_ok_eq_other!(f, a, b) ~ f(a).unwrap() == f(b).unwrap()
assert_fn_ok_ne!(f, a, b) ~ f(a).unwrap() != b
assert_fn_ok_ne_other!(f, a, b) ~ f(a).unwrap() != f(b).unwrap()
assert_fn_ok_lt!(f, a, b) ~ f(a).unwrap() < b
assert_fn_ok_lt_other!(f, a, b) ~ f(a).unwrap() < f(b).unwrap()
assert_fn_ok_le!(f, a, b) ~ f(a).unwrap() <= b
assert_fn_ok_le_other!(f, a, b) ~ f(a).unwrap() <= f(b).unwrap()
assert_fn_ok_gt!(f, a, b) ~ f(a).unwrap() > b
assert_fn_ok_gt_other!(f, a, b) ~ f(a).unwrap() > f(b).unwrap()
assert_fn_ok_gt!(f, a, b) ~ f(a).unwrap() > b
assert_fn_ok_gt_other!(f, a, b) ~ f(a).unwrap() > f(b).unwrap()
assert_fn_err_eq!(f, a, b) ~ f(a).unwrap_err() == b
assert_fn_err_eq_other!(f, a, b) ~ f(a).unwraperr() == f(b).unwraperr()
assert_fn_err_ne!(f, a, b) ~ f(a).unwrap_err() != b
assert_fn_err_ne_other!(f, a, b) ~ f(a).unwraperr() != f(b).unwraperr()
assert_fn_err_lt!(f, a, b) ~ f(a).unwrap_err() < b
assert_fn_err_lt_other!(f, a, b) ~ f(a).unwraperr() < f(b).unwraperr()
assert_fn_err_le!(f, a, b) ~ f(a).unwrap_err() <= b
assert_fn_err_le_other!(f, a, b) ~ f(a).unwraperr() <= f(b).unwraperr()
assert_fn_err_gt!(f, a, b) ~ f(a).unwrap_err() > b
assert_fn_err_gt_other!(f, a, b) ~ f(a).unwraperr() > f(b).unwraperr()
assert_fn_err_ge!(f, a, b)~ f(a).unwrap_err() >= b
assert_fn_err_ge_other!(f, a, b)~ f(a).unwraperr() >= f(b).unwraperr()
These macros help with readers, such as file handles, byte arrays, input streams, and the trait std::io::Read.
assert_read_to_string_eq!(a, b) ~ a.readtostring() == b
assert_read_to_string_eq_other!(a, b) ~ a.readtostring() == b.readtostring()
assert_read_to_string_ne!(a, b) ~ a.readtostring() != b
assert_read_to_string_ne_other!(a, b) ~ a.readtostring() != b.readtostring()
assert_read_to_string_lt!(a, b) ~ a.readtostring() < b
assert_read_to_string_lt_other!(a, b) ~ a.readtostring() < b.readtostring()
assert_read_to_string_le!(a, b) ~ a.readtostring() <= b
assert_read_to_string_le_other!(a, b) ~ a.readtostring() <= b.readtostring()
assert_read_to_string_gt!(a, b) ~ a.readtostring() > b
assert_read_to_string_gt_other!(a, b) ~ a.readtostring() > b.readtostring()
assert_read_to_string_ge!(a, b) ~ a.readtostring() >= b
assert_read_to_string_ge_other!(a, b) ~ a.readtostring() >= b.readtostring()
Using standard output a.k.a. stdout:
assert_command_stdout_eq!(command, value) ~ String::from_utf8(command.output().unwrap().stdout).unwrap() == value
assert_command_stdout_eq_other!(command, command) ~ String::fromutf8(command.output().unwrap().stdout).unwrap() == ng::fromutf8(command.output().unwrap().stdout).unwrap()
assert_command_stdout_contains!(command, containee) ~ String::from_utf8(command.output().unwrap().stdout).unwrap().contains(containee)
assert_command_stdout_matches!(command, matcher) ~ regex.ismatch(String::fromutf8(command.output().unwrap().stdout).ap())
Using standard error a.k.a. stderr:
assert_command_stderr_eq!(command, value) ~ String::from_utf8(command.output().unwrap().stderr).unwrap() == value
assert_command_stderr_eq_other!(command, command) ~ String::fromutf8(command.output().unwrap().stderr).unwrap() == ng::fromutf8(command.output().unwrap().stdout).unwrap()
assert_command_stderr_contains!(command, containee) ~ String::from_utf8(command.output().unwrap().stderr).unwrap().contains(containee)
assert_command_stderr_matches!(command, matcher) ~ regex.ismatch(String::fromutf8(command.output().unwrap().stderr).ap())
Using standard output a.k.a. stdout:
assert_program_args_stdout_eq!(program, args, value) ~ String::from_utf8(command.output().unwrap().stdout).unwrap() == value
assert_program_args_stdout_eq_other!(program, args, program, args) ~ String::fromutf8(command.output().unwrap().stdout).unwrap() == String::fromutf8(command.output().unwrap().stdout).unwrap()
assert_program_args_stdout_contains!(program, args, containee) ~ String::from_utf8(command.output().unwrap().stdout).unwrap().contains(containee)
assert_program_args_stdout_matches!(program, args, matcher) ~ regex.ismatch(String::fromutf8(command.output().unwrap().stdout).unwrap())
Using standard error a.k.a. stderr:
assert_program_args_stderr_eq!(program, args, value) ~ String::from_utf8(command.output().unwrap().stderr).unwrap() == value
assert_program_args_stderr_eq_other!(program, args, program, args) ~ String::fromutf8(command.output().unwrap().stderr).unwrap() == String::fromutf8(command.output().unwrap().stdout).unwrap()
assert_program_args_stderr_contains!(program, args, containee) ~ String::from_utf8(command.output().unwrap().stderr).unwrap().contains(containee)
assert_program_args_stderr_matches!(program, args, matcher) ~ regex.ismatch(String::fromutf8(command.output().unwrap().stderr).unwrap())