Assertables：用于测试的 assert 宏的 Rust crate

《assertables》Rust crate 提供了许多 assert 宏，以改善您的编译时测试和运行时可靠性。

Crate：https://crates.io/crates/assertables

文档：https://docs.rs/assertables/

仓库：https://github.com/sixarm/assertables-rust-crate/

为什么使用这个？

当您编写 Rust 测试时，您可以使用 Rust assert 宏，例如

assert_eq!(value1, value2)

assertables Rust crate 提供了许多更多的 assert 宏，用于值、字符串、向量、读取器、命令等，例如

assert_gt!(value1, value2); // value1 ≥ value2
assert_starts_with!(string1, string2); // string1 starts with string2
assert_is_match!(regex, string); // regex is match of string
assert_set_subset!(vector1, vector2); // vector1 as set ⊆ vector2 as set
assert_fn_ok_eq!(function1, function2); // function1 ok = function2 ok
assert_read_to_string_eq!(reader1, reader2); // reader1 as string = reader2 as string
assert_command_stdout_eq!(command1, command2); // command1 standard output = command2 standard output

以下为所有 assert 宏的完整列表。

优点

• 您的测试更有目的性和强大，这有助于使代码更可靠。

• 您的 assert 失败提供了更多信息，这有助于您更快地调试。

• 您获得了运行时断言，这有助于您进行验证和确认。

功能

• 易于使用：每个宏都有详细的文档和可运行的示例和测试。

• 零开销：如果您不使用宏，则它永远不会编译到您的代码中。

• 三种形式：开发时使用 assert_*，调试时使用 debug_assert_*，生产时使用 assert_*_as_result。

assert 宏的完整列表

用于值的 assert_*

比较值

• 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

通过近似度比较值

• assert_in_delta!(a, b, delta) ≈ | a - b | ≤ delta

• assert_in_epsilon(a, b, epsilon) ≈ | a - b | ≤ epsilon * min(a, b)

字符串和匹配器的assert_*

这些宏帮助处理字符串，以及提供匹配器（如starts_with、ends_width、contains和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_set_*用于集合比较

这些宏帮助比较集合参数，如两个数组或两个向量。其中项目顺序不重要，项目数量也不重要。这些宏将它们的输入转换为HashSet迭代器。

• assert_set_eq!(a, b) ≈ 集合a = 集合b

• assert_set_ne!(a, b) ≈ 集合a ≠ 集合b

• assert_set_subset!(a, b) ≈ 集合a ⊆ 集合b

• assert_set_superset!(a, b) ≈ 集合a ⊇ 集合b

• assert_set_joint!(a, b) ≈ 集合a ∩ 集合b ≠ ∅

• assert_set_disjoint!(a, b) ≈ 集合a ∩ 集合b = ∅

assert_bag_* 用于袋收集比较

这些宏有助于比较袋参数，例如比较两个数组或两个向量，其中项的顺序不重要，而项的数量很重要。这些宏将它们的输入转换为HashMap迭代器。

• 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

assert_fn_* 用于比较函数返回值

比较两个函数

• 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()

比较函数与表达式

• 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

assert_fn_ok_* 用于比较 Result Ok()

比较一个函数 Ok() 与另一个函数 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()

比较函数 Ok() 与表达式

• 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

assert_fn_err_* 用于函数 Err() 比较的函数

比较两个函数 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()

比较函数 Err() 与表达式

• 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

assert_read_to_string_* 用于 std::io::Read 的比较

这些宏帮助处理读取器，如文件句柄、字节数组、输入流和 std::io::Read 特性。

比较两个读取器

• assert_read_to_string_eq!(reader1, reader2) ≈ reader1.read_to_string() = reader2.read_to_string()

• assert_read_to_string_ne!(reader1, reader2) ≈ reader1.read_to_string() ≠ reader2.read_to_string()

• assert_read_to_string_ge!(reader1, reader2) ≈ reader1.read_to_string() ≥ reader2.read_to_string()

• assert_read_to_string_gt!(reader1, reader2) ≈ reader1.read_to_string() > reader2.read_to_string()

• assert_read_to_string_le!(reader1, reader2) ≈ reader1.read_to_string() ≤ reader2.read_to_string()

• assert_read_to_string_lt!(reader1, reader2) ≈ reader1.read_to_string() < reader2.read_to_string()

比较读取器与表达式

• assert_read_to_string_eq_expr(reader, expr) ≈ reader.read_to_string() = expr

• assert_read_to_string_ne_expr(reader, expr) ≈ reader.read_to_string() ≠ expr

• assert_read_to_string_ge_expr(reader, expr) ≈ reader.read_to_string() ≥ expr

• assert_read_to_string_gt_expr(reader, expr) ≈ reader.read_to_string() > expr

• assert_read_to_string_le_expr(reader, expr) ≈ reader.read_to_string() ≤ expr

• assert_read_to_string_lt_expr(reader, expr) ≈ reader.read_to_string() < expr

assert_command_* 用于进程命令的比较

比较命令的标准输出字符串

• 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

比较命令的标准错误字符串

• 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 包含 containee

• assert_command_stderr_is_match!(command, matcher) ≈ command 的 stderr 是 matcher 的匹配

assert_program_args_* 用于通过程序名称和参数迭代器创建的过程命令比较

使用程序和参数比较命令的标准输出

• assert_program_args_stdout_eq!(program1, args1, program2, args2) ≈ 使用 program1 和 args1 的命令输出到 stdout = 使用 program2 和 args2 的命令输出到 stdout

• assert_program_args_stdout_eq_expr!(program, args, expr) ≈ 使用 program 和 args 的命令输出到 stdout = expr

• assert_program_args_stdout_contains!(program, args, containee) ≈ 使用 program 和 args 的命令输出到 stdout 包含 containee

• assert_program_args_stdout_is_match!(program, args, matcher) ≈ matcher 与使用 program 和 args 的命令匹配

使用程序和参数比较命令的标准输出

• assert_program_args_stderr_eq!(program1, args1, program2, args2) ≈ 使用 program1 和 args1 的命令输出到 stderr = 使用 program2 和 args2 的命令输出到 stderr

• assert_program_args_stderr_eq_expr!(program, args, expr) ≈ 使用 program 和 args 的命令输出到 stderr = expr

• assert_program_args_stderr_contains!(program, args, containee) ≈ 使用 program 和 args 的命令输出到 stderr 包含 containee

• assert_program_args_stderr_is_match!(program, args, matcher) ≈ matcher 与使用 program 和 args 的命令匹配

命名约定

缩写

• eq ≈ 等于

• ne ≈ 不等于。

• ge ≈ 大于等于。

• gt ≈ 大于

• le ≈ 小于等于。

• lt ≈ 小于

简称

• reader ≈ 实现 .read_to_string(…)，例如 std::io::Read。

• matcher ≈ 实现 .is_match(…)，例如 regex::Regex。

• containee ≈ 可用于 .contains(…) 内部，例如 std::string::String 子串。

• set ≈ 一种集合，例如 ::std::collections::BTreeSet。

• bag ≈ 一种具有键计数的集合，例如 ::std::collections::BTreeMap。

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

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

assert_gt!(1, 2, "message"); // panic!("message")

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

assert_read_to_string_eq_expr!(reader, expr); // reader1.read_to_string() = expr