Crate assertables

Assertables: Rust crate of assert macros for testing

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/
• Contact: joel@joelparkerhenderson.com

Introduction

The Rust programming language provides a few built-in assert macros to test code:

The Rust programming language provides assert macros to test code:

• assert!()
• assert_eq!(a, b) // equal
• assert_ne!(a, b) // not equal

The assertables crate provides many more, so you can write smarter tests.

Examples:

• assert_lt!(1, 2) // compare less than
• assert_approx_eq!(1.0000001, 1.0000002) // compare floats
• assert_len_eq!("hello", "world") // compare lengths
• assert_starts_with!("hello world", "hello") // compare strings
• assert_fs_read_to_string_eq!("a.txt", "b.txt") // compare files

Top 3 benefits:

1. You can write better tests to improve reliability and maintainability.
2. You can handle more corner cases without needing to write custom code.
3. You can troubleshoot faster because error messages show specifics.

Top 3 features:

1. Easy to use: everything is well-documented with runnable examples.
2. Runtime savvy: all the assertables macros have runtime versions.
3. Zero overhead: if you don’t use a macro, then it’s never compiled.

To use this crate, add it to your Cargo.toml file:

[dev-dependencies]
assertables = "8.13.0"

Assert macros

For values:

• assert_lt!(a, b) // less than
• assert_le!(a, b) // less than or equal to
• assert_gt!(a, b) // greater than
• assert_ge!(a, b) // greater than or equal to

For approximation:

• assert_approx_eq!(a, b)
• assert_approx_ne!(a, b)

For strings:

• assert_starts_with!(a, b)
• assert_ends_with!(a, b)

For matching:

• assert_contains!(a, b)
• assert_is_match!(a, b)
• assert_len_eq!(a, b) & more

For infix operators:

• assert_infix!(a == b)
• assert_infix!(a && b)

For nearness:

• assert_in_delta!(a, b, delta)
• assert_in_epsilon!(a, b, epsilon)

For Result Ok/Err:

• assert_ok!(a) & lt, gt, etc.
• assert_err!(a) & lt, gt, etc.

For Option Some/None:

• assert_some!(a) & lt, gt, etc.
• assert_none!(a)

For Poll Ready/Pending:

• assert_ready!(a) & lt, gt, etc.
• assert_pending!(a)

For collections such as arrays, vectors, iterators, sets, bags:

• assert_iter_eq!(collection1, collection2) & lt, gt, etc.
• assert_set_eq!(collection1, collection2) & eq, ne, subset, etc.
• assert_bag_eq!(collection1, collection2) & eq, ne, subbag, etc.

For file system paths and input/output readers:

• assert_fs_read_to_string_eq!(path1, path2)
• assert_io_read_to_string_eq!(reader1, reader2)

For command capture of standard output and standard error:

• assert_command_stdout_eq!(command1, command2)
• assert_program_args_stdout_eq!(program1, args1, program2, args2);

There are many more macros that are grouped into modules.

Modules for collections, such as arrays, vectors, lists, maps:

• assert_iter for iterator collections.
• assert_set for set collections.
• assert_bag for bag collections.

Modules for variants:

• assert_ok,assert_err for Result::{Ok,Err}.
• assert_some,assert_none for Option::{Some,None}.
• assert_ready,assert_pending for Poll::{Ready,Pending}.

Modules for functions:

• assert_fn for functions in general.
• assert_fn_ok for functions that return Result::Ok.
• assert_fn_err for functions that return Result::Err.

Modules for readers:

• assert_fs_read_to_string for file system path contents.
• assert_io_read_to_string for input/output reader streams.

Modules for external calls:

• assert_command for commands and their stdout & stderr.
• assert_program_args for programs with args and their stdout & stderr.

Forms

All assertables macros have forms for different outcomes:

• assert_gt!(a, b) // panic during typical test
• assert_gt_as_result!(a, b) // return Ok or Err
• debug_assert_gt!(a, b) // panic when in debug mode

All assertables macros have forms for an optional message:

• assert_gt!(a, b) // automatic message
• assert_gt!(a, b, "Your text") // custom message

Many assertables macros have forms for comparing left hand side (LHS) and right hand side (RHS) as the same type or as an expression:

• assert_ok_eq!(a, b) // Ok(…) = Ok(…)
• assert_ok_eq_expr!(a, b) // Ok(…) = expression

Tracking

• Package: assertables-rust-crate
• Version: 8.13.0
• Created: 2021-03-30T15:47:49Z
• Updated: 2024-10-03T16:03:50Z
• 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)

Modules

• assert
  Assert a condition is true.
• assert_approx_eq
  Assert a number is approximately equal to another number.
• assert_approx_ne
  Assert a number is approximately not equal to another number.
• assert_bag
  Assert macros for comparing bag collections.
• assert_command
  Assert macros for comparing commands and their stdout & stderr.
• assert_contains
  Assert a container is a match for an expression.
• assert_ends_with
  Assert an expression (such as a string) ends with an expression (such as a string).
• assert_eq
  Assert an expression is equal to another expression.
• assert_err
  Assert macros for Err(_) items.
• assert_fn
  Assert macros for comparing functions.
• assert_fn_err
  Assert macros for comparing functions that return errors.
• assert_fn_ok
  Assert macros for comparing functions that return Result::Ok.
• assert_fs_read_to_string
  Assert macros for comparing file system path contents.
• assert_ge
  Assert an expression is greater than or equal to another expression.
• assert_gt
  Assert an expression is greater than another expression.
• assert_in_delta
  Assert a number is within delta of another number.
• assert_in_epsilon
  Assert a number is within epsilon of another number.
• assert_infix
  Assert a infix operator, such as assert_infix!(a == b).
• assert_io_read_to_string
  Assert macros for comparing input/output reader streams.
• assert_is_match
  Assert a matcher is a match for an expression.
• assert_iter
  Assert macros for comparing iter collections.
• assert_le
  Assert an expression is less than or equal to another expression.
• assert_len
  Assert macros for comparing lengths.
• assert_lt
  Assert an expression is less than another expression.
• assert_ne
  Assert an expression is not equal to another expression.
• assert_none
  Assert macro for None items.
• assert_not_contains
  Assert an expression (such as a string) does not contain an expression (such as a substring).
• assert_not_ends_with
  Assert an expression (such as a string) does not end with an expression (such as a string).
• assert_not_match
  Assert an expression (such as a regex) is not a match for an expression (such as a string).
• assert_not_starts_with
  Assert an expression (such as a string) does not start with an expression (such as a string).
• assert_ok
  Assert macros for Ok(_) items.
• assert_option
  Assert macros for Option {Some, None}
• assert_pending
  Assert macro for Pending items.
• assert_poll
  Assert macros for Poll {Ready, Pending}
• assert_program_args
  Assert macros for comparing programs with arguments.
• assert_ready
  Assert macros for Ready(_) items.
• assert_result
  Assert macros for Result {Ok, Err}
• assert_set
  Assert macros for comparing set collections.
• assert_some
  Assert macros for Some(_) items.
• assert_starts_with
  Assert an expression (such as a string) starts with an expression (such as a string).

Macros

• assert_approx_eq
  Assert a number is approximately equal to another number.
• assert_approx_eq_as_result
  Assert a number is approximately equal to another number.
• assert_approx_ne
  Assert a number is approximately not equal to another number.
• assert_approx_ne_as_result
  Assert a number is approximately not equal to another number.
• assert_as_result
  Assert a condition is true.
• assert_bag_eq
  Assert a bag is equal to another.
• assert_bag_eq_as_result
  Assert a bag is equal to another.
• assert_bag_impl_prep
• assert_bag_ne
  Assert a bag is not equal to another.
• assert_bag_ne_as_result
  Assert a bag is not equal to another.
• assert_bag_subbag
  Assert a bag is a subbag of another.
• assert_bag_subbag_as_result
  Assert a bag is a subbag of another.
• assert_bag_superbag
  Assert a bag is a superbag of another.
• assert_bag_superbag_as_result
  Assert a bag is a superbag of another.
• assert_command_stderr_contains
  Assert a command stderr string contains a given containee.
• assert_command_stderr_contains_as_result
  Assert a command stderr string contains a given containee.
• assert_command_stderr_eq
  Assert a command stderr string is equal to another.
• assert_command_stderr_eq_as_result
  Assert a command stderr string is equal to another.
• assert_command_stderr_eq_expr
  Assert a command stderr string is equal to an expression.
• assert_command_stderr_eq_expr_as_result
  Assert a command stderr string is equal to an expression.
• assert_command_stderr_is_match
  Assert a command stderr string is a match to a regex.
• assert_command_stderr_is_match_as_result
  Assert a command stderr string is a match to a regex.
• assert_command_stdout_contains
  Assert a command stdout string contains a given containee.
• assert_command_stdout_contains_as_result
  Assert a command stdout string contains a given containee.
• assert_command_stdout_eq
  Assert a command stdout string is equal to another.
• assert_command_stdout_eq_as_result
  Assert a command stdout string is equal to another.
• assert_command_stdout_eq_expr
  Assert a command stdout string is equal to an expression.
• assert_command_stdout_eq_expr_as_result
  Assert a command stdout string is equal to an expression.
• assert_command_stdout_is_match
  Assert command stdout string is a match to a regex.
• assert_command_stdout_is_match_as_result
  Assert command stdout string is a match to a regex.
• assert_contains
  Assert a container is a match for an expression.
• assert_contains_as_result
  Assert an expression (such as a string) contains an expression (such as a substring).
• assert_ends_with
  Assert an expression (such as a string) ends with an expression (such as a string).
• assert_ends_with_as_result
  Assert an expression (such as a string) ends with an expression (such as a substring).
• assert_eq_as_result
  Assert an expression is equal to another expression.
• assert_err
  Assert expression is Err(_).
• assert_err_as_result
  Assert expression is Err(_).
• assert_err_eq
  Assert two expressions are Err(_) and their values are equal.
• assert_err_eq_as_result
  Assert two expressions are Err(_) and their values are equal.
• assert_err_eq_expr
  Assert an expression is Err(_) and its value is equal to an expression.
• assert_err_eq_expr_as_result
  Assert an expression is Err(_) and its value is equal to an expression.
• assert_err_ne
  Assert two expressions are Err(_) and their values are not equal.
• assert_err_ne_as_result
  Assert two expressions are Err(_) and their values are not equal.
• assert_err_ne_expr
  Assert an expression is Err(_) and its value is equal to an expression.
• assert_err_ne_expr_as_result
  Assert an expression is Err(_) and its value is equal to an expression.
• assert_fn_eq
  Assert a function output is equal to another function output.
• assert_fn_eq_as_result
  Assert a function output is equal to another function output.
• assert_fn_eq_expr
  Assert a function output is equal to an expression.
• assert_fn_eq_expr_as_result
  Assert a function output is equal to an expression.
• assert_fn_err_eq
  Assert a function error is equal to another.
• assert_fn_err_eq_as_result
  Assert a function error is equal to another.
• assert_fn_err_eq_expr
  Assert a function error is equal to an expression.
• assert_fn_err_eq_expr_as_result
  Assert a function error is equal to an expression.
• assert_fn_err_ge
  Assert a function error is greater than or equal to another.
• assert_fn_err_ge_as_result
  Assert a function error is greater than or equal to another.
• assert_fn_err_ge_expr
  Assert a function error is greater than or equal to an expression.
• assert_fn_err_ge_expr_as_result
  Assert a function error is greater than or equal to an expression.
• assert_fn_err_gt
  Assert a function error is greater than another.
• assert_fn_err_gt_as_result
  Assert a function error is greater than another.
• assert_fn_err_gt_expr
  Assert a function error is greater than an expression.
• assert_fn_err_gt_expr_as_result
  Assert a function error is greater than an expression.
• assert_fn_err_le
  Assert a function error is less than or equal to another.
• assert_fn_err_le_as_result
  Assert a function error is less than or equal to another.
• assert_fn_err_le_expr
  Assert a function error is less than or equal to an expression.
• assert_fn_err_le_expr_as_result
  Assert a function error is less than or equal to an expression.
• assert_fn_err_lt
  Assert a function error is less than another.
• assert_fn_err_lt_as_result
  Assert a function error is less than another.
• assert_fn_err_lt_expr
  Assert a function error is less than an expression.
• assert_fn_err_lt_expr_as_result
  Assert a function error is less than an expression.
• assert_fn_err_ne
  Assert a function error is not equal to another.
• assert_fn_err_ne_as_result
  Assert a function error is not equal to another.
• assert_fn_err_ne_expr
  Assert a function error is not equal to an expression.
• assert_fn_err_ne_expr_as_result
  Assert a function error is not equal to an expression.
• assert_fn_ge
  Assert a function output is greater than or equal to another.
• assert_fn_ge_as_result
  Assert a function output is greater than or equal to another.
• assert_fn_ge_expr
  Assert a function output is greater than or equal to an expression.
• assert_fn_ge_expr_as_result
  Assert a function output is greater than or equal to an expression.
• assert_fn_gt
  Assert a function output is greater than another.
• assert_fn_gt_as_result
  Assert a function output is greater than another.
• assert_fn_gt_expr
  Assert a function output is greater than an expression.
• assert_fn_gt_expr_as_result
  Assert a function output is greater than an expression.
• assert_fn_le
  Assert a function output is less than or equal to another.
• assert_fn_le_as_result
  Assert a function output is less than or equal to another.
• assert_fn_le_expr
  Assert a function output is less than or equal to an expression.
• assert_fn_le_expr_as_result
  Assert a function output is less than or equal to an expression.
• assert_fn_lt
  Assert a function output is less than another.
• assert_fn_lt_as_result
  Assert a function output is less than another.
• assert_fn_lt_expr
  Assert a function output is less than an expression.
• assert_fn_lt_expr_as_result
  Assert a function output is less than an expression.
• assert_fn_ne
  Assert a function output is not equal to another.
• assert_fn_ne_as_result
  Assert a function output is not equal to another.
• assert_fn_ne_expr
  Assert a function output is not equal to an expression.
• assert_fn_ne_expr_as_result
  Assert a function output is not equal to an expression.
• assert_fn_ok_eq
  Assert a function Ok(…) is equal to another.
• assert_fn_ok_eq_as_result
  Assert a function Ok(…) is equal to another.
• assert_fn_ok_eq_expr
  Assert a function Ok(…) is equal to an expression.
• assert_fn_ok_eq_expr_as_result
  Assert a function Ok(…) is equal to an expression.
• assert_fn_ok_ge
  Assert a function Ok(…) is greater than or equal to another.
• assert_fn_ok_ge_as_result
  Assert a function Ok(…) is greater than or equal to another.
• assert_fn_ok_ge_expr
  Assert a function Ok(…) is greater than or equal to an expression.
• assert_fn_ok_ge_expr_as_result
  Assert a function Ok(…) is greater than or equal to an expression.
• assert_fn_ok_gt
  Assert a function Ok(…) is greater than another.
• assert_fn_ok_gt_as_result
  Assert a function Ok(…) is greater than another.
• assert_fn_ok_gt_expr
  Assert a function Ok(…) is greater than an expression.
• assert_fn_ok_gt_expr_as_result
  Assert a function Ok(…) is greater than an expression.
• assert_fn_ok_le
  Assert a function Ok(…) is less than or equal to another.
• assert_fn_ok_le_as_result
  Assert a function Ok(…) is less than or equal to another.
• assert_fn_ok_le_expr
  Assert a function Ok(…) is less than or equal to an expression.
• assert_fn_ok_le_expr_as_result
  Assert a function Ok(…) is less than or equal to an expression.
• assert_fn_ok_lt
  Assert a function Ok(…) is less than another.
• assert_fn_ok_lt_as_result
  Assert a function Ok(…) is less than another.
• assert_fn_ok_lt_expr
  Assert a function Ok(…) is less than an expression.
• assert_fn_ok_lt_expr_as_result
  Assert a function Ok(…) is less than an expression.
• assert_fn_ok_ne
  Assert a function Ok(…) is not equal to another.
• assert_fn_ok_ne_as_result
  Assert a function Ok(…) is not equal to another.
• assert_fn_ok_ne_expr
  Assert a function Ok(…) is not equal to an expression.
• assert_fn_ok_ne_expr_as_result
  Assert a function Ok(…) is not equal to an expression.
• assert_fs_read_to_string_contains
  Assert a std::fs::read_to_string(path) contains a pattern.
• assert_fs_read_to_string_contains_as_result
  Assert a std::fs::read_to_string(path) contains a pattern.
• assert_fs_read_to_string_eq
  Assert a std::fs::read_to_string(path) value is equal to another.
• assert_fs_read_to_string_eq_as_result
  Assert a std::fs::read_to_string(path) is equal to another.
• assert_fs_read_to_string_eq_expr
  Assert a std::fs::read_to_string(path) value is equal to an expression.
• assert_fs_read_to_string_eq_expr_as_result
  Assert a std::fs::read_to_string(path) value is equal to an expression.
• assert_fs_read_to_string_ge
  Assert a std::fs::read_to_string(path) value is greater than or equal to another.
• assert_fs_read_to_string_ge_as_result
  Assert a std::fs::read_to_string(path) value is greater than or equal to another.
• assert_fs_read_to_string_ge_expr
  Assert a std::fs::read_to_string(path) value is greater than or equal to an expression.
• assert_fs_read_to_string_ge_expr_as_result
  Assert a std::fs::read_to_string(path) value is greater than or equal to an expression.
• assert_fs_read_to_string_gt
  Assert a std::fs::read_to_string(path) value is greater than another.
• assert_fs_read_to_string_gt_as_result
  Assert a std::fs::read_to_string(path) value is greater than another.
• assert_fs_read_to_string_gt_expr
  Assert a std::fs::read_to_string(path) value is greater than an expression.
• assert_fs_read_to_string_gt_expr_as_result
  Assert a std::fs::read_to_string(path) value is greater than an expression.
• assert_fs_read_to_string_le
  Assert a std::fs::read_to_string(path) value is less than or equal to another.
• assert_fs_read_to_string_le_as_result
  Assert a std::fs::read_to_string(path) value is less than or equal to another.
• assert_fs_read_to_string_le_expr
  Assert a std::fs::read_to_string(path) value is less than or equal to an expression.
• assert_fs_read_to_string_le_expr_as_result
  Assert a std::fs::read_to_string(path) value is less than or equal to an expression.
• assert_fs_read_to_string_lt
  Assert a std::fs::read_to_string(path) value is less than another.
• assert_fs_read_to_string_lt_as_result
  Assert a std::fs::read_to_string(path) value is less than another.
• assert_fs_read_to_string_lt_expr
  Assert a std::fs::read_to_string(path) value is less than an expression.
• assert_fs_read_to_string_lt_expr_as_result
  Assert a std::fs::read_to_string(path) value is less than an expression.
• assert_fs_read_to_string_matches
  Assert a std::fs::read_to_string(path) is a match to a regex.
• assert_fs_read_to_string_matches_as_result
  Assert a std::fs::read_to_string(path) is a match to a regex.
• assert_fs_read_to_string_ne
  Assert a std::fs::read_to_string(path) is not equal to another.
• assert_fs_read_to_string_ne_as_result
  Assert a std::fs::read_to_string(path) is not equal to another.
• assert_fs_read_to_string_ne_expr
  Assert a std::fs::read_to_string(path) is not equal to an expression.
• assert_fs_read_to_string_ne_expr_as_result
  Assert a std::fs::read_to_string(path) is not equal to an expression.
• assert_ge
  Assert an expression is greater than or equal to another expression.
• assert_ge_as_result
  Assert an expression is greater than or equal to another expression.
• assert_gt
  Assert an expression is greater than another expression.
• assert_gt_as_result
  Assert an expression is greater than another expression.
• assert_in_delta
  Assert a number is within delta of another number.
• assert_in_delta_as_result
  Assert a number is within delta of another number.
• assert_in_epsilon
  Assert a number is within epsilon of another number.
• assert_in_epsilon_as_result
  Assert a number is within epsilon of another number.
• assert_infix
  Assert a infix operator, such as assert_infix!(a == b).
• assert_infix_as_result
  Assert a infix operator, such as assert_infix!(a == b).
• assert_io_read_to_string_contains
  Assert a std::io::Read read_to_string() contains a pattern.
• assert_io_read_to_string_contains_as_result
  Assert a std::io::Read read_to_string() contains a pattern.
• assert_io_read_to_string_eq
  Assert a std::io::Read read_to_string() value is equal to another.
• assert_io_read_to_string_eq_as_result
  Assert a std::io::Read read_to_string() is equal to another.
• assert_io_read_to_string_eq_expr
  Assert a std::io::Read read_to_string() value is equal to an expression.
• assert_io_read_to_string_eq_expr_as_result
  Assert a std::io::Read read_to_string() value is equal to an expression.
• assert_io_read_to_string_ge
  Assert a std::io::Read read_to_string() value is greater than or equal to another.
• assert_io_read_to_string_ge_as_result
  Assert a std::io::Read read_to_string() value is greater than or equal to another.
• assert_io_read_to_string_ge_expr
  Assert a std::io::Read read_to_string() value is greater than or equal to an expression.
• assert_io_read_to_string_ge_expr_as_result
  Assert a std::io::Read read_to_string() value is greater than or equal to an expression.
• assert_io_read_to_string_gt
  Assert a std::io::Read read_to_string() value is greater than another.
• assert_io_read_to_string_gt_as_result
  Assert a std::io::Read read_to_string() value is greater than another.
• assert_io_read_to_string_gt_expr
  Assert a std::io::Read read_to_string() value is greater than an expression.
• assert_io_read_to_string_gt_expr_as_result
  Assert a std::io::Read read_to_string() value is greater than an expression.
• assert_io_read_to_string_le
  Assert a std::io::Read read_to_string() value is less than or equal to another.
• assert_io_read_to_string_le_as_result
  Assert a std::io::Read read_to_string() value is less than or equal to another.
• assert_io_read_to_string_le_expr
  Assert a std::io::Read read_to_string() value is less than or equal to an expression.
• assert_io_read_to_string_le_expr_as_result
  Assert a std::io::Read read_to_string() value is less than or equal to an expression.
• assert_io_read_to_string_lt
  Assert a std::io::Read read_to_string() value is less than another.
• assert_io_read_to_string_lt_as_result
  Assert a std::io::Read read_to_string() value is less than another.
• assert_io_read_to_string_lt_expr
  Assert a std::io::Read read_to_string() value is less than an expression.
• assert_io_read_to_string_lt_expr_as_result
  Assert a std::io::Read read_to_string() value is less than an expression.
• assert_io_read_to_string_matches
  Assert a std::io::Read read_to_string() is a match to a regex.
• assert_io_read_to_string_matches_as_result
  Assert a std::io::Read read_to_string() is a match to a regex.
• assert_io_read_to_string_ne
  Assert a std::io::Read read_to_string() is not equal to another.
• assert_io_read_to_string_ne_as_result
  Assert a std::io::Read read_to_string() is not equal to another.
• assert_io_read_to_string_ne_expr
  Assert a std::io::Read read_to_string() is not equal to an expression.
• assert_io_read_to_string_ne_expr_as_result
  Assert a std::io::Read read_to_string() is not equal to an expression.
• assert_is_match
  Assert a matcher is a match for an expression.
• assert_is_match_as_result
  Assert an expression (such as a regex) is a match for an expression (such as a string).
• assert_iter_eq
  Assert an iterable is equal to another.
• assert_iter_eq_as_result
  Assert an iterable is equal to another.
• assert_iter_ge
  Assert an iterable is greater than or equal to another.
• assert_iter_ge_as_result
  Assert an iterable is greater than or equal to another.
• assert_iter_gt
  Assert an iterable is greater than another.
• assert_iter_gt_as_result
  Assert an iterable is greater than another.
• assert_iter_le
  Assert an iterable is less than or equal to another.
• assert_iter_le_as_result
  Assert an iterable is less than or equal to another.
• assert_iter_lt
  Assert an iterable is less than another.
• assert_iter_lt_as_result
  Assert an iterable is less than another.
• assert_iter_ne
  Assert an iterable is not equal to another.
• assert_iter_ne_as_result
  Assert an iterable is not equal to another.
• assert_le
  Assert an expression is less than or equal to another expression.
• assert_le_as_result
  Assert an expression is less than or equal to another expression.
• assert_len_eq
  Assert a length is equal to another length.
• assert_len_eq_as_result
  Assert a length is equal to another length.
• assert_len_eq_expr
  Assert a length is equal to an expression.
• assert_len_eq_expr_as_result
  Assert a length is equal to an expression.
• assert_len_ge
  Assert a length is greater than or equal to another length.
• assert_len_ge_as_result
  Assert a length is greater than or equal to another length.
• assert_len_ge_expr
  Assert a length is greater than or equal to an expression.
• assert_len_ge_expr_as_result
  Assert a length is greater than or equal to an expression.
• assert_len_gt
  Assert a length is greater than another length.
• assert_len_gt_as_result
  Assert a length is greater than another length.
• assert_len_gt_expr
  Assert a length is greater than an expression.
• assert_len_gt_expr_as_result
  Assert a length is greater than an expression.
• assert_len_le
  Assert a length is less than or equal to another length.
• assert_len_le_as_result
  Assert a length is less than or equal to another length.
• assert_len_le_expr
  Assert a length is less than or equal to an expression.
• assert_len_le_expr_as_result
  Assert a length is less than or equal to an expression.
• assert_len_lt
  Assert a length is less than another length.
• assert_len_lt_as_result
  Assert a length is less than another length.
• assert_len_lt_expr
  Assert a length is less than an expression.
• assert_len_lt_expr_as_result
  Assert a length is less than an expression.
• assert_len_ne
  Assert a length is equal to another length.
• assert_len_ne_as_result
  Assert a length is equal to another length.
• assert_len_ne_expr
  Assert a length is equal to an expression.
• assert_len_ne_expr_as_result
  Assert a length is equal to an expression.
• assert_lt
  Assert an expression is less than another expression.
• assert_lt_as_result
  Assert an expression is less than another expression.
• assert_ne_as_result
  Assert an expression is not equal to another expression.
• assert_none
  Assert expression is None.
• assert_none_as_result
  Assert an expression.is_none() is true.
• assert_not_contains
  Assert an expression (such as a string) does not contain an expression (such as a substring).
• assert_not_contains_as_result
  Assert an expression (such as a string) does not contain an expression (such as a substring).
• assert_not_ends_with
  Assert an expression (such as a string) does not end with an expression (such as a string).
• assert_not_ends_with_as_result
  Assert an expression (such as a string) does not end with an expression (such as a substring).
• assert_not_match
  Assert an expression (such as a regex) is not a match for an expression (such as a string).
• assert_not_match_as_result
  Assert an expression (such as a regex) is not a match for an expression (such as a string).
• assert_not_starts_with
  Assert an expression (such as a string) does not start with an expression (such as a string).
• assert_not_starts_with_as_result
  Assert an expression (such as a string) does not start with an expression (such as a substring).
• assert_ok
  Assert expression is Ok(_).
• assert_ok_as_result
  Assert expression is Ok(_).
• assert_ok_eq
  Assert two expressions are Ok(_) and their values are equal.
• assert_ok_eq_as_result
  Assert two expressions are Ok(_) and their values are equal.
• assert_ok_eq_expr
  Assert an expression is Ok(_) and its value is equal to an expression.
• assert_ok_eq_expr_as_result
  Assert an expression is Ok(_) and its value is equal to an expression.
• assert_ok_ne
  Assert two expressions are Ok(_) and their values are not equal.
• assert_ok_ne_as_result
  Assert two expressions are Ok(_) and their values are not equal.
• assert_ok_ne_expr
  Assert an expression is Ok(_) and its value is equal to an expression.
• assert_ok_ne_expr_as_result
  Assert an expression is Ok(_) and its value is equal to an expression.
• assert_option_noneDeprecated
  Assert expression is None.
• assert_option_none_as_resultDeprecated
  Assert an expression.is_none() is true.
• assert_option_someDeprecated
  Assert expression is Some(_).
• assert_option_some_as_resultDeprecated
  Assert an expression.is_some() is true.
• assert_option_some_eqDeprecated
  Assert two expressions are Some(_) and their values are equal.
• assert_option_some_eq_as_resultDeprecated
  Assert a.is_some() and a.unwrap() are equal to another.
• assert_option_some_neDeprecated
  Assert two expressions are Some(_) and their values are not equal.
• assert_option_some_ne_as_resultDeprecated
  Assert two expressions are Some(_) and their values are not equal.
• assert_pending
  Assert an expression is Pending.
• assert_pending_as_result
  Assert an expression.is_pending() is true.
• assert_poll_pendingDeprecated
  Assert an expression is Pending.
• assert_poll_pending_as_resultDeprecated
  Assert an expression.is_pending() is true.
• assert_poll_readyDeprecated
  Assert an expression is Ready(_).
• assert_poll_ready_as_resultDeprecated
  Assert an expression is Ready(_).
• assert_poll_ready_eqDeprecated
  Assert two expressions are Ready(_) and their values are equal.
• assert_poll_ready_eq_as_resultDeprecated
  Assert two expressions are Ready(_) and their values are equal.
• assert_poll_ready_neDeprecated
  Assert two expressions are Ready(_) and their values are not equal.
• assert_poll_ready_ne_as_resultDeprecated
  Assert two expressions are Ready(_) and their values are not equal.
• assert_program_args_impl_prep
• assert_program_args_stderr_contains
  Assert a command (built with program and args) stderr string contains a given containee.
• assert_program_args_stderr_contains_as_result
  Assert a command (built with program and args) stderr string contains a given containee.
• assert_program_args_stderr_eq
  Assert a command (built with program and args) stderr string is equal to another.
• assert_program_args_stderr_eq_as_result
  Assert a command (built with program and args) stderr string is equal to another.
• assert_program_args_stderr_eq_expr
  Assert a command (built with program and args) stderr string is equal to an expression.
• assert_program_args_stderr_eq_expr_as_result
  Assert a command (built with program and args) stderr string is equal to an expression.
• assert_program_args_stderr_ge
  Assert a command (built with program and args) stderr string is greater than or equal to another.
• assert_program_args_stderr_ge_as_result
  Assert a command (built with program and args) stderr string is greater than or equal to another.
• assert_program_args_stderr_ge_expr
  Assert a command (built with program and args) stderr string is greater than or equal to an expression.
• assert_program_args_stderr_ge_expr_as_result
  Assert a command (built with program and args) stderr string is greater than or equal to an expression.
• assert_program_args_stderr_gt
  Assert a command (built with program and args) stderr string is greater than to another.
• assert_program_args_stderr_gt_as_result
  Assert a command (built with program and args) stderr string is greater than another.
• assert_program_args_stderr_gt_expr
  Assert a command (built with program and args) stderr string is greater than an expression.
• assert_program_args_stderr_gt_expr_as_result
  Assert a command (built with program and args) stderr string is greater than an expression.
• assert_program_args_stderr_is_match
  Assert a command (built with program and args) stderr string is a match to a regex.
• assert_program_args_stderr_is_match_as_result
  Assert a command (built with program and args) stderr string is a match to a regex.
• assert_program_args_stderr_le
  Assert a command (built with program and args) stderr string is less than or equal to another.
• assert_program_args_stderr_le_as_result
  Assert a command (built with program and args) stderr string is less than or equal to another.
• assert_program_args_stderr_le_expr
  Assert a command (built with program and args) stderr string is less than or equal to an expression.
• assert_program_args_stderr_le_expr_as_result
  Assert a command (built with program and args) stderr string is less than or equal to an expression.
• assert_program_args_stderr_lt
  Assert a command (built with program and args) stderr string is less than another.
• assert_program_args_stderr_lt_as_result
  Assert a command (built with program and args) stderr string is less than another.
• assert_program_args_stderr_lt_expr
  Assert a command (built with program and args) stderr string is less than an expression.
• assert_program_args_stderr_lt_expr_as_result
  Assert a command (built with program and args) stderr string is less than an expression.
• assert_program_args_stderr_ne
  Assert a command (built with program and args) stderr string is not equal to another.
• assert_program_args_stderr_ne_as_result
  Assert a command (built with program and args) stderr string is not equal to another.
• assert_program_args_stderr_ne_expr
  Assert a command (built with program and args) stderr string is not equal to an expression.
• assert_program_args_stderr_ne_expr_as_result
  Assert a command (built with program and args) stderr string is not equal to an expression.
• assert_program_args_stdout_contains
  Assert a command (built with program and args) stdout string contains a given containee.
• assert_program_args_stdout_contains_as_result
  Assert a command (built with program and args) stdout string contains a given containee.
• assert_program_args_stdout_eq
  Assert a command (built with program and args) stdout string is equal to another.
• assert_program_args_stdout_eq_as_result
  Assert a command (built with program and args) stdout string is equal to another.
• assert_program_args_stdout_eq_expr
  Assert a command (built with program and args) stdout string is equal to an expression.
• assert_program_args_stdout_eq_expr_as_result
  Assert a command (built with program and args) stdout string is equal to an expression.
• assert_program_args_stdout_ge
  Assert a command (built with program and args) stdout string is greater than or equal to another.
• assert_program_args_stdout_ge_as_result
  Assert a command (built with program and args) stdout string is greater than or equal to another.
• assert_program_args_stdout_ge_expr
  Assert a command (built with program and args) stdout string is greater than or equal to an expression.
• assert_program_args_stdout_ge_expr_as_result
  Assert a command (built with program and args) stdout string is greater than or equal to an expression.
• assert_program_args_stdout_gt
  Assert a command (built with program and args) stdout string is greater than another.
• assert_program_args_stdout_gt_as_result
  Assert a command (built with program and args) stdout string is greater than to another.
• assert_program_args_stdout_gt_expr
  Assert a command (built with program and args) stdout string is greater than an expression.
• assert_program_args_stdout_gt_expr_as_result
  Assert a command (built with program and args) stdout string is greater than an expression.
• assert_program_args_stdout_is_match
  Assert a command (built with program and args) stdout string is a match to a regex.
• assert_program_args_stdout_is_match_as_result
  Assert a command (built with program and args) stdout string is a match to a regex.
• assert_program_args_stdout_le
  Assert a command (built with program and args) stdout string is less than or equal to another.
• assert_program_args_stdout_le_as_result
  Assert a command (built with program and args) stdout string is less than or equal to another.
• assert_program_args_stdout_le_expr
  Assert a command (built with program and args) stdout string is less than or equal to an expression.
• assert_program_args_stdout_le_expr_as_result
  Assert a command (built with program and args) stdout string is less than or equal to an expression.
• assert_program_args_stdout_lt
  Assert a command (built with program and args) stdout string is less than another.
• assert_program_args_stdout_lt_as_result
  Assert a command (built with program and args) stdout string is less than another.
• assert_program_args_stdout_lt_expr
  Assert a command (built with program and args) stdout string is less than an expression.
• assert_program_args_stdout_lt_expr_as_result
  Assert a command (built with program and args) stdout string is less than an expression.
• assert_program_args_stdout_ne
  Assert a command (built with program and args) stdout string is not equal to another.
• assert_program_args_stdout_ne_as_result
  Assert a command (built with program and args) stdout string is not equal to another.
• assert_program_args_stdout_ne_expr
  Assert a command (built with program and args) stdout string is not equal to an expression.
• assert_program_args_stdout_ne_expr_as_result
  Assert a command (built with program and args) stdout string is not equal to an expression.
• assert_ready
  Assert an expression is Ready(_).
• assert_ready_as_result
  Assert an expression is Ready(_).
• assert_ready_eq
  Assert two expressions are Ready(_) and their values are equal.
• assert_ready_eq_as_result
  Assert two expressions are Ready(_) and their values are equal.
• assert_ready_eq_expr
  Assert an expression is Ready(_) and its value is equal to an expression.
• assert_ready_eq_expr_as_result
  Assert an expression is Ready(_) and its value is equal to an expression.
• assert_ready_ne
  Assert two expressions are Ready(_) and their values are not equal.
• assert_ready_ne_as_result
  Assert two expressions are Ready(_) and their values are not equal.
• assert_ready_ne_expr
  Assert an expression is Ready(_) and its value is not equal to an expression.
• assert_ready_ne_expr_as_result
  Assert an expression is Ready(_) and its value is not equal to an expression.
• assert_result_errDeprecated
  Assert expression is Err(_).
• assert_result_err_as_resultDeprecated
  Assert expression is Err(_).
• assert_result_okDeprecated
  Assert expression is Ok(_).
• assert_result_ok_as_resultDeprecated
  Assert expression is Ok(_).
• assert_result_ok_eqDeprecated
  Assert two expressions are Ok(_) and their values are equal.
• assert_result_ok_eq_as_resultDeprecated
  Assert two expressions are Ok(_) and their values are equal.
• assert_result_ok_neDeprecated
  Assert two expressions are Ok(_) and their values are not equal.
• assert_result_ok_ne_as_resultDeprecated
  Assert two expressions are Ok(_) and their values are not equal.
• assert_set_disjoint
  Assert a set is disjoint with another.
• assert_set_disjoint_as_result
  Assert a set is disjoint with another.
• assert_set_eq
  Assert a set is equal to another.
• assert_set_eq_as_result
  Assert a set is equal to another.
• assert_set_impl_prep
• assert_set_joint
  Assert a set is joint with another.
• assert_set_joint_as_result
  Assert a set is joint with another.
• assert_set_ne
  Assert a set is not equal to another.
• assert_set_ne_as_result
  Assert a set is not equal to another.
• assert_set_subset
  Assert a set is a subset of another.
• assert_set_subset_as_result
  Assert a set is a subset of another.
• assert_set_superset
  Assert a set is a superset of another.
• assert_set_superset_as_result
  Assert a set is a superset of another.
• assert_some
  Assert expression is Some(_).
• assert_some_as_result
  Assert an expression.is_some() is true.
• assert_some_eq
  Assert two expressions are Some(_) and their values are equal.
• assert_some_eq_as_result
  Assert a.is_some() and a.unwrap() are equal to another.
• assert_some_eq_expr
  Assert an expression is Some(_) and its value is equal to an expression.
• assert_some_eq_expr_as_result
  Assert a.is_some() and a.unwrap() are equal to another.
• assert_some_ne
  Assert two expressions are Some(_) and their values are not equal.
• assert_some_ne_as_result
  Assert two expressions are Some(_) and their values are not equal.
• assert_some_ne_expr
  Assert an expression is Some(_) and its value is not equal to an expression.
• assert_some_ne_expr_as_result
  Assert a.is_some() and a.unwrap() are equal to another.
• assert_starts_with
  Assert an expression (such as a string) starts with an expression (such as a string).
• assert_starts_with_as_result
  Assert an expression (such as a string) starts with an expression (such as a substring).
• debug_assert_approx_eq
  Assert a number is approximately equal to another number.
• debug_assert_approx_ne
  Assert a number is approximately not equal to another number.
• debug_assert_bag_eq
  Assert a bag is equal to another.
• debug_assert_bag_ne
  Assert a bag is not equal to another.
• debug_assert_bag_subbag
  Assert a bag is a subbag of another.
• debug_assert_bag_superbag
  Assert a bag is a superbag of another.
• debug_assert_command_stderr_contains
  Assert a command stderr string contains a given containee.
• debug_assert_command_stderr_eq
  Assert a command stderr string is equal to another.
• debug_assert_command_stderr_eq_expr
  Assert a command stderr string is equal to an expression.
• debug_assert_command_stderr_is_match
  Assert a command stderr string is a match to a regex.
• debug_assert_command_stdout_contains
  Assert a command stdout string contains a given containee.
• debug_assert_command_stdout_eq
  Assert a command stdout string is equal to another.
• debug_assert_command_stdout_eq_expr
  Assert a command stdout string is equal to an expression.
• debug_assert_command_stdout_is_match
  Assert command stdout string is a match to a regex.
• debug_assert_contains
  Assert a container is a match for an expression.
• debug_assert_ends_with
  Assert an expression (such as a string) ends with an expression (such as a string).
• debug_assert_err
  Assert expression is Err(_).
• debug_assert_err_eq
  Assert two expressions are Err(_) and their values are equal.
• debug_assert_err_eq_expr
  Assert an expression is Err(_) and its value is equal to an expression.
• debug_assert_err_ne
  Assert two expressions are Err(_) and their values are not equal.
• debug_assert_err_ne_expr
  Assert an expression is Err(_) and its value is equal to an expression.
• debug_assert_fn_eq
  Assert a function output is equal to another function output.
• debug_assert_fn_eq_expr
  Assert a function output is equal to an expression.
• debug_assert_fn_err_eq
  Assert a function error is equal to another.
• debug_assert_fn_err_eq_expr
  Assert a function error is equal to an expression.
• debug_assert_fn_err_ge
  Assert a function error is greater than or equal to another.
• debug_assert_fn_err_ge_expr
  Assert a function error is greater than or equal to an expression.
• debug_assert_fn_err_gt
  Assert a function error is greater than another.
• debug_assert_fn_err_gt_expr
  Assert a function error is greater than an expression.
• debug_assert_fn_err_le
  Assert a function error is less than or equal to another.
• debug_assert_fn_err_le_expr
  Assert a function error is less than or equal to an expression.
• debug_assert_fn_err_lt
  Assert a function error is less than another.
• debug_assert_fn_err_lt_expr
  Assert a function error is less than an expression.
• debug_assert_fn_err_ne
  Assert a function error is not equal to another.
• debug_assert_fn_err_ne_expr
  Assert a function error is not equal to an expression.
• debug_assert_fn_ge
  Assert a function output is greater than or equal to another.
• debug_assert_fn_ge_expr
  Assert a function output is greater than or equal to an expression.
• debug_assert_fn_gt
  Assert a function output is greater than another.
• debug_assert_fn_gt_expr
  Assert a function output is greater than an expression.
• debug_assert_fn_le
  Assert a function output is less than or equal to another.
• debug_assert_fn_le_expr
  Assert a function output is less than or equal to an expression.
• debug_assert_fn_lt
  Assert a function output is less than another.
• debug_assert_fn_lt_expr
  Assert a function output is less than an expression.
• debug_assert_fn_ne
  Assert a function output is not equal to another.
• debug_assert_fn_ne_expr
  Assert a function output is not equal to an expression.
• debug_assert_fn_ok_eq
  Assert a function Ok(…) is equal to another.
• debug_assert_fn_ok_eq_expr
  Assert a function Ok(…) is equal to an expression.
• debug_assert_fn_ok_ge
  Assert a function Ok(…) is greater than or equal to another.
• debug_assert_fn_ok_ge_expr
  Assert a function Ok(…) is greater than or equal to an expression.
• debug_assert_fn_ok_gt
  Assert a function Ok(…) is greater than another.
• debug_assert_fn_ok_gt_expr
  Assert a function Ok(…) is greater than an expression.
• debug_assert_fn_ok_le
  Assert a function Ok(…) is less than or equal to another.
• debug_assert_fn_ok_le_expr
  Assert a function Ok(…) is less than or equal to an expression.
• debug_assert_fn_ok_lt
  Assert a function Ok(…) is less than another.
• debug_assert_fn_ok_lt_expr
  Assert a function Ok(…) is less than an expression.
• debug_assert_fn_ok_ne
  Assert a function Ok(…) is not equal to another.
• debug_assert_fn_ok_ne_expr
  Assert a function Ok(…) is not equal to an expression.
• debug_assert_fs_read_to_string_contains
  Assert a std::fs::read_to_string(path) contains a pattern.
• debug_assert_fs_read_to_string_eq
  Assert a std::fs::read_to_string(path) value is equal to another.
• debug_assert_fs_read_to_string_eq_expr
  Assert a std::fs::read_to_string(path) value is equal to an expression.
• debug_assert_fs_read_to_string_ge
  Assert a std::fs::read_to_string(path) value is greater than or equal to another.
• debug_assert_fs_read_to_string_ge_expr
  Assert zzz.
• debug_assert_fs_read_to_string_gt
  Assert a std::fs::read_to_string(path) value is greater than another.
• debug_assert_fs_read_to_string_gt_expr
  Assert a std::fs::read_to_string(path) value is greater than an expression.
• debug_assert_fs_read_to_string_le
  Assert a std::fs::read_to_string(path) value is less than or equal to another.
• debug_assert_fs_read_to_string_le_expr
  Assert a std::fs::read_to_string(path) value is less than or equal to an expression.
• debug_assert_fs_read_to_string_lt
  Assert a std::fs::read_to_string(path) value is less than another.
• debug_assert_fs_read_to_string_lt_expr
  Assert a std::fs::read_to_string(path) value is less than an expression.
• debug_assert_fs_read_to_string_matches
  Assert a std::fs::read_to_string(path) is a match to a regex.
• debug_assert_fs_read_to_string_ne
  Assert a std::fs::read_to_string(path) is not equal to another.
• debug_assert_fs_read_to_string_ne_expr
  Assert a std::fs::read_to_string(path) is not equal to an expression.
• debug_assert_ge
  Assert an expression is greater than or equal to another expression.
• debug_assert_gt
  Assert an expression is greater than another expression.
• debug_assert_in_delta
  Assert a number is within delta of another number.
• debug_assert_in_epsilon
  Assert a number is within epsilon of another number.
• debug_assert_infix
  Assert a infix operator, such as assert_infix!(a == b).
• debug_assert_io_read_to_string_contains
  Assert a std::io::Read read_to_string() contains a pattern.
• debug_assert_io_read_to_string_eq
  Assert a std::io::Read read_to_string() value is equal to another.
• debug_assert_io_read_to_string_eq_expr
  Assert a std::io::Read read_to_string() value is equal to an expression.
• debug_assert_io_read_to_string_ge
  Assert a std::io::Read read_to_string() value is greater than or equal to another.
• debug_assert_io_read_to_string_ge_expr
  Assert zzz.
• debug_assert_io_read_to_string_gt
  Assert a std::io::Read read_to_string() value is greater than another.
• debug_assert_io_read_to_string_gt_expr
  Assert a std::io::Read read_to_string() value is greater than an expression.
• debug_assert_io_read_to_string_le
  Assert a std::io::Read read_to_string() value is less than or equal to another.
• debug_assert_io_read_to_string_le_expr
  Assert a std::io::Read read_to_string() value is less than or equal to an expression.
• debug_assert_io_read_to_string_lt
  Assert a std::io::Read read_to_string() value is less than another.
• debug_assert_io_read_to_string_lt_expr
  Assert a std::io::Read read_to_string() value is less than an expression.
• debug_assert_io_read_to_string_matches
  Assert a std::io::Read read_to_string() is a match to a regex.
• debug_assert_io_read_to_string_ne
  Assert a std::io::Read read_to_string() is not equal to another.
• debug_assert_io_read_to_string_ne_expr
  Assert a std::io::Read read_to_string() is not equal to an expression.
• debug_assert_is_match
  Assert a matcher is a match for an expression.
• debug_assert_iter_eq
  Assert an iterable is equal to another.
• debug_assert_iter_ge
  Assert an iterable is greater than or equal to another.
• debug_assert_iter_gt
  Assert an iterable is greater than another.
• debug_assert_iter_le
  Assert an iterable is less than or equal to another.
• debug_assert_iter_lt
  Assert an iterable is less than another.
• debug_assert_iter_ne
  Assert an iterable is not equal to another.
• debug_assert_le
  Assert an expression is less than or equal to another expression.
• debug_assert_len_eq
  Assert a value is greater than an expression.
• debug_assert_len_eq_expr
  Assert a value is greater than an expression.
• debug_assert_len_ge
  Assert a value is greater than an expression.
• debug_assert_len_ge_expr
  Assert a value is greater than an expression.
• debug_assert_len_gt
  Assert a value is greater than an expression.
• debug_assert_len_gt_expr
  Assert a value is greater than an expression.
• debug_assert_len_le
  Assert a value is greater than an expression.
• debug_assert_len_le_expr
  Assert a value is greater than an expression.
• debug_assert_len_lt
  Assert a value is greater than an expression.
• debug_assert_len_lt_expr
  Assert a value is greater than an expression.
• debug_assert_len_ne
  Assert a value is greater than an expression.
• debug_assert_len_ne_expr
  Assert a value is greater than an expression.
• debug_assert_lt
  Assert an expression is less than another expression.
• debug_assert_none
  Assert expression is None.
• debug_assert_not_contains
  Assert an expression (such as a string) does not contain an expression (such as a substring).
• debug_assert_not_ends_with
  Assert an expression (such as a string) does not end with an expression (such as a string).
• debug_assert_not_match
  Assert an expression (such as a regex) is not a match for an expression (such as a string).
• debug_assert_not_starts_with
  Assert an expression (such as a string) does not start with an expression (such as a string).
• debug_assert_ok
  Assert expression is Ok(_).
• debug_assert_ok_eq
  Assert two expressions are Ok(_) and their values are equal.
• debug_assert_ok_eq_expr
  Assert an expression is Ok(_) and its value is equal to an expression.
• debug_assert_ok_ne
  Assert two expressions are Ok(_) and their values are not equal.
• debug_assert_ok_ne_expr
  Assert an expression is Ok(_) and its value is equal to an expression.
• debug_assert_option_noneDeprecated
  Assert expression is None.
• debug_assert_option_someDeprecated
  Assert expression is Some(_).
• debug_assert_option_some_eqDeprecated
  Assert two expressions are Some(_) and their values are equal.
• debug_assert_option_some_neDeprecated
  Assert two expressions are Some(_) and their values are not equal.
• debug_assert_pending
  Assert an expression is Pending.
• debug_assert_poll_pendingDeprecated
  Assert an expression is Pending.
• debug_assert_poll_readyDeprecated
  Assert poll.is_ready() is true.
• debug_assert_poll_ready_eqDeprecated
  Assert two expressions are Ready(_) and their values are equal.
• debug_assert_poll_ready_ne
  Assert two expressions are Ready(_) and their values are not equal.
• debug_assert_program_args_stderr_contains
  Assert a command (built with program and args) stderr string contains a given containee.
• debug_assert_program_args_stderr_eq
  Assert a command (built with program and args) stderr string is equal to another.
• debug_assert_program_args_stderr_eq_expr
  Assert a command (built with program and args) stderr string is equal to an expression.
• debug_assert_program_args_stderr_ge
  Assert a command (built with program and args) stderr string greater than or equal to another.
• debug_assert_program_args_stderr_ge_expr
  Assert a command (built with program and args) stderr string is greater than or equal to an expression.
• debug_assert_program_args_stderr_gt
  Assert a command (built with program and args) stderr string is equal to another.
• debug_assert_program_args_stderr_gt_expr
  Assert a command (built with program and args) stderr string is greater than an expression.
• debug_assert_program_args_stderr_is_match
  Assert a command (built with program and args) stderr string is a match to a regex.
• debug_assert_program_args_stderr_le
  Assert a command (built with program and args) stderr string is less than or equal to another.
• debug_assert_program_args_stderr_le_expr
  Assert a command (built with program and args) stderr string is equal to an expression.
• debug_assert_program_args_stderr_lt
  Assert a command (built with program and args) stderr string is less than another.
• debug_assert_program_args_stderr_lt_expr
  Assert a command (built with program and args) stderr string is less than an expression.
• debug_assert_program_args_stderr_ne
  Assert a command (built with program and args) stderr string is not equal to another.
• debug_assert_program_args_stderr_ne_expr
  Assert a command (built with program and args) stderr string is not equal to an expression.
• debug_assert_program_args_stdout_contains
  Assert a command (built with program and args) stdout string contains a given containee.
• debug_assert_program_args_stdout_eq
  Assert a command (built with program and args) stdout string is equal to another.
• debug_assert_program_args_stdout_eq_expr
  Assert a command (built with program and args) stdout string is equal to an expression.
• debug_assert_program_args_stdout_ge
  Assert a command (built with program and args) stdout string is greater than or equal to another.
• debug_assert_program_args_stdout_ge_expr
  Assert a command (built with program and args) stdout string is greater than or equal to an expression.
• debug_assert_program_args_stdout_gt
  Assert a command (built with program and args) stdout string is greater than another.
• debug_assert_program_args_stdout_gt_expr
  Assert a command (built with program and args) stdout string is greater than an expression.
• debug_assert_program_args_stdout_is_match
  Assert a command (built with program and args) stdout string is a match to a regex.
• debug_assert_program_args_stdout_le
  Assert a command (built with program and args) stdout string is less than or equal to another.
• debug_assert_program_args_stdout_le_expr
  Assert a command (built with program and args) stdout string is less than or equal to an expression.
• debug_assert_program_args_stdout_lt
  Assert a command (built with program and args) stdout string is less than another.
• debug_assert_program_args_stdout_lt_expr
  Assert a command (built with program and args) stdout string is less than an expression.
• debug_assert_program_args_stdout_ne
  Assert a command (built with program and args) stdout string is not equal to another.
• debug_assert_program_args_stdout_ne_expr
  Assert a command (built with program and args) stdout string is not equal to an expression.
• debug_assert_ready
  Assert poll.is_ready() is true.
• debug_assert_ready_eq
  Assert two expressions are Ready(_) and their values are equal.
• debug_assert_ready_eq_expr
  Assert an expression is Ready(_) and its value is equal to an expression.
• debug_assert_ready_ne
  Assert two expressions are Ready(_) and their values are not equal.
• debug_assert_ready_ne_expr
  Assert an expression is Ready(_) and its value is not equal to an expression.
• debug_assert_result_errDeprecated
  Assert expression is Err(_).
• debug_assert_result_okDeprecated
  Assert expression is Ok(_).
• debug_assert_result_ok_eqDeprecated
  Assert two expressions are Ok(_) and their values are equal.
• debug_assert_result_ok_neDeprecated
  Assert two expressions are Ok(_) and their values are not equal.
• debug_assert_set_disjoint
  Assert a set is disjoint with another.
• debug_assert_set_eq
  Assert a set is equal to another.
• debug_assert_set_joint
  Assert a set is joint with another.
• debug_assert_set_ne
  Assert a set is not equal to another.
• debug_assert_set_subset
  Assert a set is a subset of another.
• debug_assert_set_superset
  Assert a set is a superset of another.
• debug_assert_some
  Assert expression is Some(_).
• debug_assert_some_eq
  Assert two expressions are Some(_) and their values are equal.
• debug_assert_some_eq_expr
  Assert an expression is Some(_) and its value is equal to an expression.
• debug_assert_some_ne
  Assert two expressions are Some(_) and their values are not equal.
• debug_assert_some_ne_expr
  Assert an expression is Some(_) and its value is not equal to an expression.
• debug_assert_starts_with
  Assert an expression (such as a string) starts with an expression (such as a string).