Crate assertables

source ·

Expand description

Assertables: Rust crate of assert macros for testing

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/

Highlights

Macros for values such as:

assert_gt!(value1, value2); // value1 > value2

Macros for arrays, vectors, sets, bags, etc., such as:

assert_set_subset_other!(set1, set2); // set1 is a subset of set2

Macros for functions such as:

assert_fn_eq!(function, input, output); // function(input) == output

Macros for readers such as:

assert_read_to_string_eq!(reader, string); // reader read to string == string

Macros for commands such as:

assert_command_stdout_eq!(command, expr); // command standard output == expression

Naming conventions

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 which has key counts.

Forms for panic! versus Err()

The macros have forms for immediate interrupts versus returning results:

assert_gt!(a, b); // return () or panic!(…)

assert_gt_as_result!(a, b); // return Result Ok(()) or Err(…)

Forms for default messages versus custom messages

The macros have forms for default messages versus custom messages.

Examples with panics:

assert_gt!(1, 2); // panic!("assertion failed: assert_gt(1, 2)…")
 
assert_gt!(1, 2, "message"); // panic!("message")

Examples with errors:

assert_gt_as_result!(1, 2); // return Err("assertion failed: assert_gt(1, 2)…")

assert_gt_as_result!(1, 2, "message"); // return Err("message")

Forms for comparing an expression versus an equivalent

Some macros have forms for comparing to an expression (expr) versus an equivalent (other):

assert_read_to_string_eq!(reader, expr); // reader.read_to_string() == expr

assert_read_to_string_eq_other!(reader1, reader2); // reader1.read_to_string() == reader2.read_to_string()

assert_* for values

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

assert_set_* for set collection comparisons

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

assert_bag_* for bag collection comparisons

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.