Assertables is a Rust crate of assert macros to improve you 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/
- Contact: joel@joelparkerhenderson.com
The Assertables Rust crate provides many assert macros that can help you develop, test, and debug.
- Test values with assert_lt, assert_gt, assert_in, …
- Test groups with assert_all, assert_any, assert_iter, …
- Test wrappers with assert_ok, assert_some, assert_ready, …
- Test matching with assert_matches, assert_is_match, …
- Test nearness with assert_approx, assert_abs_diff, …
- Test programs with assert_command, assert_status, …
- Many more below.
To use this crate, add it to your file Cargo.toml
:
assertables = "9.5.0"
Benefits:
- You can write better tests to improve reliability and maintainability.
- You can handle more corner cases without needing to write custom code.
- You can troubleshoot faster because error messages show more detail.
Learning: FAQ, docs, examples, changes, upgrades, developing.
Comparisons: more_asserts, cool_asserts, assert2, claims, etc.
Examples with numbers:
let i = 10;
assert_lt!(i, 11);
assert_in_range!(i, 1..100);
assert_abs_diff_eq!(i, 12, 2);
Examples with strings:
let s = "hello";
assert_starts_with!(s, "h");
assert_contains!(s, "e");
assert_is_match!(Regex::new(r"h.*o").unwrap(), s);
Examples with arrays:
let a = [1, 2, 3];
assert_not_empty!(a);
assert_len_eq_x!(a, 3);
assert_all!(a.into_iter(), |i: i32| i < 4);
Values:
assert_eq!(a, b)
≈ a = b ≈ equal toassert_ne!(a, b)
≈ a ≠ b ≈ not equal toassert_lt!(a, b)
≈ a < b ≈ less thanassert_le!(a, b)
≈ a ≤ b ≈ less than or equal toassert_gt!(a, b)
≈ a > b ≈ greater thanassert_ge!(a, b)
≈ a ≥ b ≈ greater than or equal to
Approximations:
assert_approx_eq!(a, b)
≈ |a-b| ≤ 1e-6assert_diff_eq_x!(a, b, x)
≈ (b-a) = xassert_abs_diff_eq_x!(a, b, x)
≈ |b-a| = xassert_in_delta!(a, b, delta)
≈ |a-b| ≤ Δassert_in_epsilon!(a, b, epsilon)
≈ |a-b| ≤ ε min(a,b)assert_in_range!(a, range)
≈ a ∈ range
Groups:
assert_all!(group, predicate)
≈ group.all(predicate)assert_any!(group, predicate)
≈ group.any(predicate)assert_is_empty!(group)
≈ a.is_empty()assert_len_eq!(a, b)
≈ a.len() = b.len()assert_count_eq!(a, b)
≈ a.count() = b.count()
Matching:
assert_starts_with!(sequence, x)
≈ sequence.starts_with(x)assert_ends_with!(sequence, x)
≈ sequence.ends_with(x)assert_contains!(container, x)
≈ container.contains(x)assert_is_match!(matcher, x)
≈ matcher.is_match(x)assert_matches!(expr, pattern)
≈ matches!(expr, pattern)
Results:
assert_ok!(a)
≈ a is Okassert_err!(a)
≈ a is Errassert_ok_eq_x!(a, x)
≈ a is Ok ⇒ unwrap = x
Options:
assert_some!(a)
≈ a is Someassert_none!(a)
≈ a is Noneassert_some_eq_x!(a, x)
≈ a is Some ⇒ unwrap = x
Polls:
assert_ready!(a)
≈ a is Readyassert_pending!(a)
≈ a is Pendingassert_ready_eq_x!(a, x)
≈ a is Ready ⇒ unwrap = x
Readers:
assert_fs_read_to_string_eq_x!(path, x
≈ path ⇒ file ⇒ string = xassert_io_read_to_string_eq_x!(reader, x)
≈ reader ⇒ bytes ⇒ string = x
Collections:
assert_iter_eq!(a, b)
≈ a into iter = b into iterassert_set_eq!(a, b)
≈ a into set = b into setassert_bag_eq!(a, b)
≈ a into bag = b into bag
Commands:
assert_command_stdout_eq_x!(command, x)
≈ command ⇒ stdout == xassert_program_args_stdout_eq_x!(program, args, x)
≈ program.args ⇒ stdout = x
Status:
assert_status_success!(a)
≈ a.status().success()assert_status_code_value_eq_x!(a, x)
≈ a.status().code().unwrap() = x
Infix:
assert_infix!(a == b)
≈ order operators == != < <= > >=assert_infix!(a && b)
≈ logic operators && || ^ & |
For a complete list of modules and macros, see the docs.
All the macros have forms for an optional message:
assert_gt!(a, b)
≈ default messageassert_gt!(a, b, "your text")
≈ custom message
All the macros have forms for different outcomes:
assert_gt!(1, 2)
≈ panicassert_gt_as_result!(1, 2)
≈ Result Errdebug_assert_gt!(a, b)
≈ panic in debug mode
Many of the macros have a form "compare left item to right item" that compares items of the same kind, and a form "compare left item to right expression" that compares one item to any arbitrary expression:
assert_len_eq!(a, b)
≈ a.len() = b.len()assert_len_eq_x!(a, x)
≈ a.len() = x
Many of the macros has a "success return", which means the macro returns data that you can optionally use for more testing.
let inner = assert_ok!(result)
let string = assert_fs_read_to_string_ne!("alfa.txt", "")
let stdout = assert_command_stdout_gt!("ls", vec![b' '])
- Package: assertables-rust-crate
- Version: 9.5.0
- Created: 2021-03-30T15:47:49Z
- Updated: 2024-11-05T16:40:19Z
- License: MIT or Apache-2.0 or GPL-2.0 or GPL-3.0 or contact us for more
- Contact: Joel Parker Henderson (joel@joelparkerhenderson.com)