Add assert_abs_diff*

Author: joelparkerhenderson

CHANGES.md

@@ -3,18 +3,20 @@
 Changes highlights for recent major versions.
 
 
-## Version 9.0.0
+## Version 9.0
 
-* Add returns to many macros.
+* 9.1.0: Add absolute difference macros: `assert_abs_diff*`.
 
-* Breaking change: rename macros from `assert_*_eq` into `assert_*_eq2`, then from `assert_*_eq_expr` into `assert_*_eq`.
+* 9.0.0: Breaking change: many macros now return data upon success.
+
+* 9.0.0: Breaking change: rename macros from `assert_*_expr` into `assert_*_x`.
 
 
 ## Version 8.x
 
 * Add matches macros: `assert_matches`, `assert_not_matches`.
 
-* Add Iterator macros: `assert_iter_all`, `assert_iter_any`, `assert_iter_eq2`, etc.
+* Add Iterator macros: `assert_iter_all`, `assert_iter_any`, `assert_iter_eq`, etc.
 
 * Add Result macros: `assert_ok`, `assert_err`, etc.
 

Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "assertables"
-version = "9.0.0"
+version = "9.1.0"
 authors = ["Joel Parker Henderson <[email protected]>"]
 edition = "2021"
 description = "Assertables: assert macros for better testing, debugging, quality assurance, and runtime reliability."
 readme = "README.md"
 repository = "https://github.com/sixarm/assertables-rust-crate/"
-license = "MIT OR Apache-2.0 OR GPL-2.0 OR GPL-3.0 or BSD-3-Clause"
+license = "MIT OR Apache-2.0 OR GPL-2.0 OR GPL-3.0 OR BSD-3-Clause"
 keywords = ["assert", "assertable", "assertion", "macro", "test"]
 categories = ["development-tools", "development-tools::testing", "rust-patterns"]
 

README.md

@@ -41,16 +41,16 @@ let output2 = function2(input2);
 assert_eq!(output1, output2);
 ```
 
-Rust `assertables` provides the macro `assert_fn_eq2!` that does the same kind of processing, by automatically calling functions with inputs, then comparing the outputs:
+Rust `assertables` provides the macro `assert_fn_eq!` that does the same kind of processing, by automatically calling functions with inputs, then comparing the outputs:
 
 ```rust
-assert_fn_eq2!(function1, input1, function2, input2);
+assert_fn_eq!(function1, input1, function2, input2);
 ```
 
 The `assertables` message looks like:
 
 ```text
-assertion failed: `assert_fn_eq2!(left_function, left_input, right_function, right_input)`,
+assertion failed: `assert_fn_eq!(left_function, left_input, right_function, right_input)`,
   left_function label: `function1`,
      left_input label: `input1`,
      left_input debug: `…`,
@@ -63,27 +63,27 @@ assertion failed: `assert_fn_eq2!(left_function, left_input, right_function, rig
 
 Rust `assertables` provides these macros for functions:
 
-* `assert_fn_eq2!`
+* `assert_fn_eq!`
 
 * `assert_fn_eq_other!`
 
-* `assert_fn_ge2!`
+* `assert_fn_ge!`
 
 * `assert_fn_ge_other!`
 
-* `assert_fn_gt2!`
+* `assert_fn_gt!`
 
 * `assert_fn_gt_other!`
 
-* `assert_fn_le2!`
+* `assert_fn_le!`
 
 * `assert_fn_le_other!`
 
-* `assert_fn_lt2!`
+* `assert_fn_lt!`
 
 * `assert_fn_lt_other!`
 
-* `assert_fn_ne2!`
+* `assert_fn_ne!`
 
 * `assert_fn_ne_other!`
 
@@ -96,20 +96,20 @@ TODO
 
 let a = 1;
 let b = String::from("1");
-assert_fn_ok_eq2!(example_digit_to_string, a, b);
+assert_fn_ok_eq!(example_digit_to_string, a, b);
 //-> ()
 
 let a = 1;
 let b = String::from("2");
 // Panic with error message
 let result = panic::catch_unwind(|| {
-assert_fn_ok_eq2!(example_digit_to_string, a, b);
+assert_fn_ok_eq!(example_digit_to_string, a, b);
 //-> panic!
 });
 assert!(result.is_err());
 
 ```text
-assertion failed: `assert_fn_ok_eq2!(left_function, left_input, right_function, right_input)`
+assertion failed: `assert_fn_ok_eq!(left_function, left_input, right_function, right_input)`
   left_function label: `example_digit_to_string`,
      left_input label: `a`,
      left_input debug: `1`,
@@ -125,51 +125,51 @@ assertion failed: `assert_fn_ok_eq2!(left_function, left_input, right_function,
 
 Rust `assertables` provides these macros for functions that return a Result of `Ok`, `Err`:
 
-* `assert_fn_ok_eq2!`
+* `assert_fn_ok_eq!`
 
 * `assert_fn_ok_eq_other!`
 
-* `assert_fn_ok_ge2!`
+* `assert_fn_ok_ge!`
 
 * `assert_fn_ok_ge_other!`
 
-* `assert_fn_ok_gt2!`
+* `assert_fn_ok_gt!`
 
 * `assert_fn_ok_gt_other!`
 
-* `assert_fn_ok_le2!`
+* `assert_fn_ok_le!`
 
 * `assert_fn_ok_le_other!`
 
-* `assert_fn_ok_lt2!`
+* `assert_fn_ok_lt!`
 
 * `assert_fn_ok_lt_other!`
 
-* `assert_fn_ok_ne2!`
+* `assert_fn_ok_ne!`
 
 * `assert_fn_ok_ne_other!`
 
-* `assert_fn_err_eq2!`
+* `assert_fn_err_eq!`
 
 * `assert_fn_err_eq_other!`
 
-* `assert_fn_err_ge2!`
+* `assert_fn_err_ge!`
 
 * `assert_fn_err_ge_other!`
 
-* `assert_fn_err_gt2!`
+* `assert_fn_err_gt!`
 
 * `assert_fn_err_gt_other!`
 
-* `assert_fn_err_le2!`
+* `assert_fn_err_le!`
 
 * `assert_fn_err_le_other!`
 
-* `assert_fn_err_lt2!`
+* `assert_fn_err_lt!`
 
 * `assert_fn_err_lt_other!`
 
-* `assert_fn_err_ne2!`
+* `assert_fn_err_ne!`
 
 * `assert_fn_err_ne_other!`
 
@@ -232,16 +232,16 @@ let set2: std::collections::BTreeSet<_> = array2.into_iter().collect();
 assert_eq!(set1, set2);
 ```
 
-Rust `assertables` provides the macro `assert_set_eq2!` that does the same kind of processing, by automatically converting inputs into sets, then comparing them as sets:
+Rust `assertables` provides the macro `assert_set_eq!` that does the same kind of processing, by automatically converting inputs into sets, then comparing them as sets:
 
 ```rust
-assert_set_eq2!(array1, array2);
+assert_set_eq!(array1, array2);
 ```
 
 The `assertables` message looks like:
 
 ```text
-assertion failed: `assert_set_eq2!(left_set, right_set)`
+assertion failed: `assert_set_eq!(left_set, right_set)`
   left_set label: `&array1`,
   left_set debug: `[1, 2]`,
  right_set label: `&array2`,
@@ -252,9 +252,9 @@ assertion failed: `assert_set_eq2!(left_set, right_set)`
 
 Rust `assertables` provides these macros for sets:
 
-* `assert_set_eq2`
+* `assert_set_eq`
 
-* `assert_set_ne2`
+* `assert_set_ne`
 
 * `assert_set_subset`
 
@@ -327,16 +327,16 @@ for x in array2.into_iter() {
 assert_eq!(bag1, bag2);
 ```
 
-Rust `assertables` provides the macro `assert_bag_eq2!` that does the same kind of processing, by automatically converting inputs into sets, then comparing them as bags:
+Rust `assertables` provides the macro `assert_bag_eq!` that does the same kind of processing, by automatically converting inputs into sets, then comparing them as bags:
 
 ```rust
-assert_bag_eq2!(array1, array2);
+assert_bag_eq!(array1, array2);
 ```
 
 The `aasertables` message looks like:
 
 ```text
-assertion failed: `assert_bag_eq2!(left_bag, right_bag)`
+assertion failed: `assert_bag_eq!(left_bag, right_bag)`
   left_bag label: `&array1`,
   left_bag debug: `[1, 1]`,
  right_bag label: `&array2`,
@@ -347,9 +347,9 @@ assertion failed: `assert_bag_eq2!(left_bag, right_bag)`
 
 Rust `assertables` provides these macros for bags:
 
-* `assert_bag_eq2`
+* `assert_bag_eq`
 
-* `assert_bag_ne2`
+* `assert_bag_ne`
 
 * `assert_bag_subbag`
 
@@ -389,35 +389,35 @@ let result2 = reader2.read_to_string(&mut string2);
 assert_eq!(string1, string2);
 ```
 
-Rust `assertables` provides the macro `assert_io_read_to_string_eq2!` that does the same kind of processing, by automatically calling `read_to_string()`, then comparing the outputs as strings:
+Rust `assertables` provides the macro `assert_io_read_to_string_eq!` that does the same kind of processing, by automatically calling `read_to_string()`, then comparing the outputs as strings:
 
 ```rust
-assert_io_read_to_string_eq2!(reader1, reader2);
+assert_io_read_to_string_eq!(reader1, reader2);
 ```
 
 Rust `assertables` provides these macros for readers:
 
-* `assert_io_read_to_string_eq2!`
+* `assert_io_read_to_string_eq!`
 
 * `assert_io_read_to_string_eq_other!`
 
-* `assert_io_read_to_string_ne2!`
+* `assert_io_read_to_string_ne!`
 
 * `assert_io_read_to_string_ne_other!`
 
-* `assert_io_read_to_string_lt2!`
+* `assert_io_read_to_string_lt!`
 
 * `assert_io_read_to_string_lt_other!`
 
-* `assert_io_read_to_string_le2!`
+* `assert_io_read_to_string_le!`
 
 * `assert_io_read_to_string_le_other!`
 
-* `assert_io_read_to_string_gt2!`
+* `assert_io_read_to_string_gt!`
 
 * `assert_io_read_to_string_gt_other!`
 
-* `assert_io_read_to_string_ge2!`
+* `assert_io_read_to_string_ge!`
 
 * `assert_io_read_to_string_ge_other!`
 
@@ -470,22 +470,22 @@ let string2 = String::from_utf8(command2.output().unwrap().stdout).unwrap();
 assert_eq!(string1, string2);
 ```
 
-Rust `assertables` provides the macro `assert_command_stdout_eq2!` that does the same kind of processing, by automatically converting commands into standard outputs, then into UTF-8 strings, then comparing them as strings:
+Rust `assertables` provides the macro `assert_command_stdout_eq!` that does the same kind of processing, by automatically converting commands into standard outputs, then into UTF-8 strings, then comparing them as strings:
 
 ```rust
-assert_command_eq2!(command1, command2);
+assert_command_eq!(command1, command2);
 ```
 
 Rust `assertables` provides these macros for commands and standard output:
 
-* assert_command_stdout_eq2.rs
+* assert_command_stdout_eq.rs
 * assert_command_stdout_eq_other.rs
 * assert_command_stdout_contains.rs
 * assert_command_stdout_is_match.rs
 
 Rust `assertables` provides these macros for commands and standard error:
 
-* assert_command_stderr_eq2.rs
+* assert_command_stderr_eq.rs
 * assert_command_stderr_eq_other.rs
 * assert_command_stderr_contains.rs
 * assert_command_stderr_is_match.rs
@@ -501,26 +501,26 @@ let mut command = Command::new("printf");
 command.args(["%s", "hello"]);
 ```
 
-The previous section showed that Rust `assertables` provides the macro `assert_command_stdout_eq2!` such as:
+The previous section showed that Rust `assertables` provides the macro `assert_command_stdout_eq!` such as:
 
 ```rust
 use std::process::Command;
 let mut command1 = Command::new("printf");
 command1.args(["%s", "hello"]);
 let mut command2 = Command::new("printf");
 command2.args(["%s", "hello"]);
-assert_command_eq2!(string1, string2);
+assert_command_eq!(string1, string2);
 ```
 
-Rust `assertables` provides the macro `assert_program_args_eq2` that does the same kind of processing, by automatically converting programs and args into commands, then to standard outputs, then into UTF-8 stringss, then comparing them as strings:
+Rust `assertables` provides the macro `assert_program_args_eq` that does the same kind of processing, by automatically converting programs and args into commands, then to standard outputs, then into UTF-8 stringss, then comparing them as strings:
 
 ```rust
-assert_program_args_eq2!("printf", ["%s", "hello"], "printf", ["%s", "hello"]);
+assert_program_args_eq!("printf", ["%s", "hello"], "printf", ["%s", "hello"]);
 ```
 
 Rust `assertables` provides these macros for program args and standard output:
 
-* `assert_program_args_stdout_eq2!`
+* `assert_program_args_stdout_eq!`
 
 * `assert_program_args_stdout_eq_other!`
 
@@ -530,7 +530,7 @@ Rust `assertables` provides these macros for program args and standard output:
 
 Rust `assertables` provides these macros for program args and standard error:
 
-* `assert_program_args_stderr_eq2!`
+* `assert_program_args_stderr_eq!`
 
 * `assert_program_args_stderr_eq_other!`
 

book.md

@@ -0,0 +1,17 @@
+<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Assert an absolute difference is equal to a delta expression."><title>lib::assert_abs_diff::assert_abs_diff_eq - Rust</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-46f98efaafac5295.ttf.woff2,FiraSans-Regular-018c141bf0843ffd.woff2,FiraSans-Medium-8f9a781e4970d388.woff2,SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2,SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2" crossorigin href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-76eba96aa4d2e634.css"><link rel="stylesheet" href="../../../static.files/rustdoc-492a78a4a87dcc01.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="lib" data-themes="" data-resource-suffix="" data-rustdoc-version="1.82.0 (f6e511eec 2024-10-15)" data-channel="1.82.0" data-search-js="search-a99f1315e7cc5121.js" data-settings-js="settings-4313503d2e1961c2.js" ><script src="../../../static.files/storage-118b08c4c78b968e.js"></script><script defer src="../sidebar-items.js"></script><script defer src="../../../static.files/main-921df33f47b8780c.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-3b12f09e550e0385.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-422f7d1d52889060.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-2c020d218678b618.svg"></head><body class="rustdoc mod"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="mobile-topbar"><button class="sidebar-menu-toggle" title="show sidebar"></button></nav><nav class="sidebar"><div class="sidebar-crate"><h2><a href="../../../lib/index.html">lib</a></h2></div><h2 class="location"><a href="#">Module assert_<wbr>abs_<wbr>diff_<wbr>eq</a></h2><div class="sidebar-elems"><h2><a href="../index.html">In lib::<wbr>assert_<wbr>abs_<wbr>diff</a></h2></div></nav><div class="sidebar-resizer"></div><main><div class="width-limiter"><rustdoc-search></rustdoc-search><section id="main-content" class="content"><div class="main-heading"><h1>Module <a href="../../index.html">lib</a>::<wbr><a href="../index.html">assert_abs_diff</a>::<wbr><a class="mod" href="#">assert_abs_diff_eq</a><button id="copy-path" title="Copy item path to clipboard">Copy item path</button></h1><span class="out-of-band"><a class="src" href="../../../src/lib/assert_abs_diff/assert_abs_diff_eq.rs.html#1-261">source</a> · <button id="toggle-all-docs" title="collapse all docs">[<span>&#x2212;</span>]</button></span></div><details class="toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>Assert an absolute difference is equal to a delta expression.</p>
+<p>Pseudocode:<br>
+| a - b | = Δ</p>
+<h2 id="example"><a class="doc-anchor" href="#example">§</a>Example</h2>
+<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>assertables::<span class="kw-2">*</span>;
+
+<span class="kw">let </span>a = <span class="number">10</span>;
+<span class="kw">let </span>b = <span class="number">13</span>;
+<span class="kw">let </span>delta = <span class="number">3</span>;
+<span class="macro">assert_abs_diff_eq!</span>(a, b, delta);</code></pre></div>
+<h2 id="module-macros"><a class="doc-anchor" href="#module-macros">§</a>Module macros</h2>
+<ul>
+<li><a href="../../macro.assert_abs_diff_eq.html" title="macro lib::assert_abs_diff_eq"><code>assert_abs_diff_eq</code></a></li>
+<li><a href="../../macro.assert_abs_diff_eq_as_result.html" title="macro lib::assert_abs_diff_eq_as_result"><code>assert_abs_diff_eq_as_result</code></a></li>
+<li><a href="../../macro.debug_assert_abs_diff_eq.html" title="macro lib::debug_assert_abs_diff_eq"><code>debug_assert_abs_diff_eq</code></a></li>
+</ul>
+</div></details></section></div></main></body></html>

doc/lib/all.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Assert an absolute difference is greater than or equal to a delta expression."><title>lib::assert_abs_diff::assert_abs_diff_ge - Rust</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-46f98efaafac5295.ttf.woff2,FiraSans-Regular-018c141bf0843ffd.woff2,FiraSans-Medium-8f9a781e4970d388.woff2,SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2,SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2" crossorigin href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-76eba96aa4d2e634.css"><link rel="stylesheet" href="../../../static.files/rustdoc-492a78a4a87dcc01.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="lib" data-themes="" data-resource-suffix="" data-rustdoc-version="1.82.0 (f6e511eec 2024-10-15)" data-channel="1.82.0" data-search-js="search-a99f1315e7cc5121.js" data-settings-js="settings-4313503d2e1961c2.js" ><script src="../../../static.files/storage-118b08c4c78b968e.js"></script><script defer src="../sidebar-items.js"></script><script defer src="../../../static.files/main-921df33f47b8780c.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-3b12f09e550e0385.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-422f7d1d52889060.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-2c020d218678b618.svg"></head><body class="rustdoc mod"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="mobile-topbar"><button class="sidebar-menu-toggle" title="show sidebar"></button></nav><nav class="sidebar"><div class="sidebar-crate"><h2><a href="../../../lib/index.html">lib</a></h2></div><h2 class="location"><a href="#">Module assert_<wbr>abs_<wbr>diff_<wbr>ge</a></h2><div class="sidebar-elems"><h2><a href="../index.html">In lib::<wbr>assert_<wbr>abs_<wbr>diff</a></h2></div></nav><div class="sidebar-resizer"></div><main><div class="width-limiter"><rustdoc-search></rustdoc-search><section id="main-content" class="content"><div class="main-heading"><h1>Module <a href="../../index.html">lib</a>::<wbr><a href="../index.html">assert_abs_diff</a>::<wbr><a class="mod" href="#">assert_abs_diff_ge</a><button id="copy-path" title="Copy item path to clipboard">Copy item path</button></h1><span class="out-of-band"><a class="src" href="../../../src/lib/assert_abs_diff/assert_abs_diff_ge.rs.html#1-247">source</a> · <button id="toggle-all-docs" title="collapse all docs">[<span>&#x2212;</span>]</button></span></div><details class="toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>Assert an absolute difference is greater than or equal to a delta expression.</p>
+<p>Pseudocode:<br>
+| a - b | ≥ Δ</p>
+<h2 id="example"><a class="doc-anchor" href="#example">§</a>Example</h2>
+<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>assertables::<span class="kw-2">*</span>;
+
+<span class="kw">let </span>a = <span class="number">10</span>;
+<span class="kw">let </span>b = <span class="number">13</span>;
+<span class="kw">let </span>delta = <span class="number">2</span>;
+<span class="macro">assert_abs_diff_ge!</span>(a, b, delta);</code></pre></div>
+<h2 id="module-macros"><a class="doc-anchor" href="#module-macros">§</a>Module macros</h2>
+<ul>
+<li><a href="../../macro.assert_abs_diff_ge.html" title="macro lib::assert_abs_diff_ge"><code>assert_abs_diff_ge</code></a></li>
+<li><a href="../../macro.assert_abs_diff_ge_as_result.html" title="macro lib::assert_abs_diff_ge_as_result"><code>assert_abs_diff_ge_as_result</code></a></li>
+<li><a href="../../macro.debug_assert_abs_diff_ge.html" title="macro lib::debug_assert_abs_diff_ge"><code>debug_assert_abs_diff_ge</code></a></li>
+</ul>
+</div></details></section></div></main></body></html>