The assertables
Rust crate provides many assert macros to improve your
compile-time tests and run-time reliability.
Crate: https://crates.io/crates/assertables
Docs: https://docs.rs/assertables/
Repo: https://github.com/sixarm/assertables-rust-crate/
When you write Rust tests, then you can use Rust assert macros, such as:
assert_eq!(value1, value2)
The assertables Rust crate provides many more assert macros for values, strings, vectors, paths, readers, commands, and more, such as:
// value1 greater than value2
assert_gt!(value1, value2);
// string1 starts with string2
assert_starts_with!(string1, string2);
// regex is match of string
assert_is_match!(regex, string);
// vector1 as set ⊆ vector2 as set
assert_set_subset!(vector1, vector2);
// function1 ok = function2 ok
assert_fn_ok_eq!(function1, function2);
// path1 to string = path2 to string
assert_fs_read_to_string_eq!(path1, path2);
// reader1 to string = reader2 to string
assert_io_read_to_string_eq!(reader1, reader2);
// command1 standard output = command2 standard output
assert_command_stdout_eq!(command1, command2);
See below for the complete list of all the assert macros.
-
Your tests are more purposeful and powerful, which helps your code be more reliable.
-
Your assert failures provide more information, which helps you troubleshoot faster.
-
You gain runtime asserts, which helps you with validations and verifications.
-
Easy to use: each macro is well-documented with runnable examples and tests.
-
Zero overhead: if you don't use a macro, then it's never compiled into your code.
-
Three forms:
assert_*
for development,debug_assert_*
for debugging, andassert_*_as_result
for production.
Compare values:
-
assert_eq!(a, b)
≈ a = b -
assert_ne!(a, b)
≈ a ≠ b -
assert_ge!(a, b)
≈ a ≥ b -
assert_gt!(a, b)
≈ a > b -
assert_le!(a, b)
≈ a ≤ b -
assert_lt!(a, b)
≈ a < b
Compare values by using nearness:
-
assert_in_delta!(a, b, delta)
≈ | a - b | ≤ delta -
assert_in_epsilon(a, b, epsilon)
≈ | a - b | ≤ epsilon * min(a, b)
These macros help with strings and also other structures that provide
matchers such as starts_with
, ends_width
, contains
, and is_match
.
-
assert_starts_with(a, b)
≈ a.starts_with(b) -
assert_not_starts_with(a, b)
≈ !a.starts_with(b) -
assert_ends_with(a, b)
≈ a.ends_with(b) -
assert_not_ends_with(a, b)
≈ !a.ends_with(b) -
assert_contains(container, containee)
≈ container.contains(containee) -
assert_not_contains(container, containee)
≈ !container.contains(containee) -
assert_is_match(matcher, matchee)
≈ matcher.is_match(matchee) -
assert_not_match(matcher, matchee)
≈ !matcher.is_match(matchee)
-
assert_ok(a)
≈ a.is_ok() -
assert_ok_eq(a, b)
≈ a.ok() = b.ok() (TODO) -
assert_ok_eq_expr(a, b)
≈ a.ok() = b (TODO) -
assert_err(a)
≈ a.is_err()
-
assert_some(a)
≈ a.is_some() -
assert_some_eq(a, b)
≈ a.some() = b.some() (TODO) -
assert_some_eq_expr(a, b)
≈ a.some() = b (TODO) -
assert_none(a)
≈ a.is_none()
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. These macros convert their inputs into HashSet iterators.
-
assert_set_eq!(a, b)
≈ set a = set b -
assert_set_ne!(a, b)
≈ set a ≠ set b -
assert_set_subset!(a, b)
≈ set a ⊆ set b -
assert_set_superset!(a, b)
≈ set a ⊇ set b -
assert_set_joint!(a, b)
≈ set a ∩ set b ≠ ∅ -
assert_set_disjoint!(a, b)
≈ set a ∩ 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. These macros convert their inputs into HashMap iterators.
-
assert_bag_eq(a, b)
≈ bag a = bag b -
assert_bag_ne(a, b)
≈ bag a ≠ bag b -
assert_bag_subbag(a, b)
≈ bag a ⊆ bag b -
assert_bag_superbag(a, b)
≈ bag a ⊇ bag b
Compare a function with another function:
-
assert_fn_eq!(function1, function2)
≈ function1() = function2() -
assert_fn_ne!(function1, function2)
≈ function1() ≠ function2() -
assert_fn_ge!(function1, function2)
≈ function1() ≥ function2() -
assert_fn_gt!(function1, function2)
≈ function1() > function2() -
assert_fn_le!(function1, function2)
≈ function1() ≤ function2() -
assert_fn_lt!(function1, function2)
≈ function1() < function2()
Compare a function with an expression:
-
assert_fn_eq_expr!(function, expr)
≈ function() = expr -
assert_fn_ne_expr!(function, expr)
≈ function() ≠ expr -
assert_fn_ge_expr!(function, expr)
≈ function() ≥ expr -
assert_fn_gt_expr!(function, expr)
≈ function() > expr -
assert_fn_le_expr!(function, expr)
≈ function() ≤ expr -
assert_fn_lt_expr!(function, expr)
≈ function() < expr
Compare a function Ok() with another function Ok():
-
assert_fn_ok_eq!(function1, function2)
≈ function1().ok().unwrap() = function2().ok().unwrap() -
assert_fn_ok_ne!(function1, function2)
≈ function1().ok().unwrap() ≠ function2().ok().unwrap() -
assert_fn_ok_ge!(function1, function2)
≈ function1().ok().unwrap() ≥ function2().ok().unwrap() -
assert_fn_ok_gt!(function1, function2)
≈ function1().ok().unwrap() > function2().ok().unwrap() -
assert_fn_ok_le!(function1, function2)
≈ function1().ok().unwrap() ≤ function2().ok().unwrap() -
assert_fn_ok_lt!(function1, function2)
≈ function1().ok().unwrap() < function2().ok().unwrap()
Compare a function Ok() with an expression:
-
assert_fn_ok_eq_expr!(function, expr)
≈ function().ok().unwrap() = expr -
assert_fn_ok_ne_expr!(function, expr)
≈ function().ok().unwrap() ≠ expr -
assert_fn_ok_ge_expr!(function, expr)
≈ function().ok().unwrap() ≥ expr -
assert_fn_ok_gt_expr!(function, expr)
≈ function().ok().unwrap() > expr -
assert_fn_ok_le_expr!(function, expr)
≈ function().ok().unwrap() ≤ expr -
assert_fn_ok_lt_expr!(function, expr)
≈ function().ok().unwrap() < expr
Compare a function Err() with another function Err():
-
assert_fn_err_eq!(function1, function2)
≈ function1().unwrap_err() = function2().unwrap_err() -
assert_fn_err_ne!(function1, function2)
≈ function1().unwrap_err() ≠ function2().unwrap_err() -
assert_fn_err_ge!(function1, function2)
≈ function1().unwrap_err() ≥ function2().unwrap_err() -
assert_fn_err_gt!(function1, function2)
≈ function1().unwrap_err() > function2().unwrap_err() -
assert_fn_err_le!(function1, function2)
≈ function1().unwrap_err() ≤ function2().unwrap_err() -
assert_fn_err_lt!(function1, function2)
≈ function1().unwrap_err() < function2().unwrap_err()
Compare a function Err() with an expression:
-
assert_fn_err_eq!(function, expr)
≈ function().unwrap_err() = expr -
assert_fn_err_ne!(function, expr)
≈ function().unwrap_err() ≠ expr -
assert_fn_err_ge!(function, expr)
≈ function().unwrap_err() ≥ expr -
assert_fn_err_gt!(function, expr)
≈ function().unwrap_err() > expr -
assert_fn_err_le!(function, expr)
≈ function().unwrap_err() ≤ expr -
assert_fn_err_lt!(function, expr)
≈ function().unwrap_err() < expr
These macros help with file system paths, such as disk files, Path
, PathBuf
,
the trait AsRef<Path>
, and anything that is readable via
std::fs::read_to_string(…)
.
Compare a path with another path:
-
assert_fs_read_to_string_eq!(path1, path2)
≈ std::fs::read_to_string(path1) = std::fs::read_to_string(path2) -
assert_fs_read_to_string_ne!(path1, path2)
≈ std::fs::read_to_string(path1) ≠ std::fs::read_to_string(path2) -
assert_fs_read_to_string_ge!(path1, path2)
≈ std::fs::read_to_string(path1) ≥ std::fs::read_to_string(path2) -
assert_fs_read_to_string_gt!(path1, path2)
≈ std::fs::read_to_string(path1) > std::fs::read_to_string(path2) -
assert_fs_read_to_string_le!(path1, path2)
≈ std::fs::read_to_string(path1) ≤ std::fs::read_to_string(path2) -
assert_fs_read_to_string_lt!(path1, path2)
≈ std::fs::read_to_string(path1) < std::fs::read_to_string(path2)
Compare a path with an expression:
-
assert_fs_read_to_string_eq_expr(path, expr)
≈ std::fs::read_to_string(path) = expr -
assert_fs_read_to_string_ne_expr(path, expr)
≈ std::fs::read_to_string(path) ≠ expr -
assert_fs_read_to_string_ge_expr(path, expr)
≈ std::fs::read_to_string(path) ≥ expr -
assert_fs_read_to_string_gt_expr(path, expr)
≈ std::fs::read_to_string(path) > expr -
assert_fs_read_to_string_le_expr(path, expr)
≈ std::fs::read_to_string(path) ≤ expr -
assert_fs_read_to_string_lt_expr(path, expr)
≈ std::fs::read_to_string(path) < expr
Compare a path with its contents:
-
assert_fs_read_to_string_contains(path, containee)
≈ std::fs::read_to_string(path).contains(containee) -
assert_fs_read_to_string_matches(path, matcher)
≈ matcher.is_match(std::fs::read_to_string(path))
These macros help with input/output readers, such as file handles, byte arrays,
input streams, the trait std::io::Read
, and anything that implements the
method read_to_string()
.
Compare a reader with another reader:
-
assert_io_read_to_string_eq!(reader1, reader2)
≈ reader1.read_to_string() = reader2.read_to_string() -
assert_io_read_to_string_ne!(reader1, reader2)
≈ reader1.read_to_string() ≠ reader2.read_to_string() -
assert_io_read_to_string_ge!(reader1, reader2)
≈ reader1.read_to_string() ≥ reader2.read_to_string() -
assert_io_read_to_string_gt!(reader1, reader2)
≈ reader1.read_to_string() > reader2.read_to_string() -
assert_io_read_to_string_le!(reader1, reader2)
≈ reader1.read_to_string() ≤ reader2.read_to_string() -
assert_io_read_to_string_lt!(reader1, reader2)
≈ reader1.read_to_string() < reader2.read_to_string()
Compare a reader with an expression:
-
assert_io_read_to_string_eq_expr(reader, expr)
≈ reader.read_to_string() = expr -
assert_io_read_to_string_ne_expr(reader, expr)
≈ reader.read_to_string() ≠ expr -
assert_io_read_to_string_ge_expr(reader, expr)
≈ reader.read_to_string() ≥ expr -
assert_io_read_to_string_gt_expr(reader, expr)
≈ reader.read_to_string() > expr -
assert_io_read_to_string_le_expr(reader, expr)
≈ reader.read_to_string() ≤ expr -
assert_io_read_to_string_lt_expr(reader, expr)
≈ reader.read_to_string() < expr
Compare a reader with its contents:
-
assert_io_read_to_string_contains(reader, containee)
≈ reader.read_to_string().contains(containee) -
assert_io_read_to_string_matches(reader, matcher)
≈ matcher.is_match(reader.read_to_string())
Compare command standard output string:
-
assert_command_stdout_eq!(command1, command2)
≈ command1 stdout = command2 stdout -
assert_command_stdout_eq_expr!(command, expr)
≈ command stdout = expr -
assert_command_stdout_contains!(command, containee)
≈ command stdout contains containee -
assert_command_stdout_is_match!(command, matcher)
≈ command stdout is a matcher match
Compare command standard error string:
-
assert_command_stderr_eq!(command1, command2)
≈ command1 stderr = command2 stderr -
assert_command_stderr_eq_expr!(command, expr)
≈ command stderr = expr -
assert_command_stderr_contains!(command, containee)
≈ command stderr contains containee -
assert_command_stderr_is_match!(command, matcher)
≈ command stderr is a matcher match
Compare command using program and arguments to standard output:
-
assert_program_args_stdout_eq!(program1, args1, program2, args2)
≈ command using program1 and args1 to stdout = command2 with program2 and args2 to stdout -
assert_program_args_stdout_eq_expr!(program, args, expr)
≈ command using program and args to stdout = expr -
assert_program_args_stdout_contains!(program, args, containee)
≈ command using program and args to stdout contains containee -
assert_program_args_stdout_is_match!(program, args, matcher)
≈ matcher is match with command using program and args
Compare command using program and arguments to standard output:
-
assert_program_args_stderr_eq!(program1, args1, program2, args2)
≈ command using program1 and args1 to stderr = command2 with program2 and args2 to stderr -
assert_program_args_stderr_eq_expr!(program, args, expr)
≈ command using program and args to stderr = expr -
assert_program_args_stderr_contains!(program, args, containee)
≈ command using program and args to stderr contains containee -
assert_program_args_stderr_is_match!(program, args, matcher)
≈ matcher is match with command using program and args
Abbreviations:
-
eq
≈ equal -
ne
≈ not equal. -
ge
≈ greater than or equal. -
gt
≈ greater than -
le
≈ less than or equal. -
lt
≈ less than
Shorthands:
-
path
≈ implementsAsRef<Path>
such asstd::path::PathBuf
. -
reader
≈ implements method.read_to_string()
such asstd::io::Read
. -
matcher
≈ implements.is_match(…)
such asregex::Regex
. -
containee
≈ usable inside.contains(…)
such as astd::string::String
substring. -
set
≈ a collection such as::std::collections::BTreeSet
. -
bag
≈ a collection such as::std::collections::BTreeMap
which has key counts.
The assert macros have three forms that you can use depending on your goals:
assert_gt!(a, b); // return () or panic!(…), for typical compile-time testing
debug_assert_gt!(a, b); // return () or panic!(…), for a non-optimized runtime
assert_gt_as_result!(a, b); // return Result Ok(()) or Err(…), for any runtime
The assert macros have forms for default messages versus custom messages.
assert_gt!(1, 2); // panic!("assertion failed: assert_gt(1, 2)…")
assert_gt!(1, 2, "message"); // panic!("message")
Some assert macros have forms for comparing an other versus an expression:
assert_io_read_to_string_eq!(reader1, reader2); // reader1.read_to_string() = reader2.read_to_string()
assert_io_read_to_string_eq_expr!(reader, expr); // reader1.read_to_string() = expr
-
Add
assert_fs_read_to_string_*
macros for comparing files. -
Rename
assert_read_to_string_*
macros toassert_io_read_to_string_*
. If you use these macros, then please update your code to use the new naming convention. -
Add
rustdoc
documentation for all modules.
-
Add
assert_in_delta
,assert_in_epsilon
. -
Add
assert_fn_*
macros with multiple arities. -
Add
cargo release
for optimized tagged releases.
-
Add
assert_starts_with
,assert_ends_with
,assert_contains
,assert_is_match
. -
Add
debug_assert_*
macros everywhere. -
Add
GPL-3.0
license.
- Package: assertables-rust-crate
- Version: 8.1.0
- Created: 2021-03-30T15:47:49Z
- Updated: 2024-09-03T21:12:07Z
- License: MIT or Apache-2.0 or GPL-2.0 or GPL-3.0 or contact us for more
- Contact: Joel Parker Henderson (joel@sixarm.com)