commit 0858cccfdf2b69f61a389808e47202f01f3af2fb
parent f17b7613d3ddd9a514d7b2db2e9e33f286b3981d
Author: Zack Newman <zack@philomathiclife.com>
Date: Wed, 15 Apr 2026 08:00:52 -0600
use assert_eq in tests
Diffstat:
| M | src/lib.rs | | | 106 | ++++++++++++++++++++++++++++++++++++++++++------------------------------------- |
1 file changed, 57 insertions(+), 49 deletions(-)
diff --git a/src/lib.rs b/src/lib.rs
@@ -26,7 +26,7 @@
//! input[258] = 209;
//! let mut output = [0; base64url_nopad::encode_len(INPUT_LEN)];
//! assert_eq!(base64url_nopad::encode_buffer(&input, &mut output), ENCODED_VAL);
-//! assert!(base64url_nopad::decode_len(output.len()).is_some_and(|len| len == INPUT_LEN));
+//! assert_eq!(base64url_nopad::decode_len(output.len()), Some(INPUT_LEN));
//! base64url_nopad::decode_buffer(ENCODED_VAL.as_bytes(), &mut output[..INPUT_LEN])?;
//! assert_eq!(input, output[..INPUT_LEN]);
//! # Ok::<_, DecodeErr>(())
@@ -478,7 +478,7 @@ impl Alphabet {
///
/// ```
/// # use base64url_nopad::Alphabet;
- /// assert!(Alphabet::from_u8(25).is_some_and(|val| val == Alphabet::Z));
+ /// assert_eq!(Alphabet::from_u8(25), Some(Alphabet::Z));
/// for i in 0..=63 {
/// assert!(Alphabet::from_u8(i).is_some());
/// }
@@ -921,11 +921,11 @@ pub const MAX_ENCODE_INPUT_LEN: usize = decode_len(usize::MAX).unwrap();
/// # use base64url_nopad::MAX_ENCODE_INPUT_LEN;
/// assert!(base64url_nopad::encode_len_checked(usize::MAX).is_none());
/// assert!(base64url_nopad::encode_len_checked(MAX_ENCODE_INPUT_LEN + 1).is_none());
-/// assert!(base64url_nopad::encode_len_checked(MAX_ENCODE_INPUT_LEN).is_some_and(|len| len == usize::MAX));
-/// assert!(base64url_nopad::encode_len_checked(3).is_some_and(|len| len == 4));
-/// assert!(base64url_nopad::encode_len_checked(2).is_some_and(|len| len == 3));
-/// assert!(base64url_nopad::encode_len_checked(1).is_some_and(|len| len == 2));
-/// assert!(base64url_nopad::encode_len_checked(0).is_some_and(|len| len == 0));
+/// assert_eq!(base64url_nopad::encode_len_checked(MAX_ENCODE_INPUT_LEN), Some(usize::MAX));
+/// assert_eq!(base64url_nopad::encode_len_checked(3), Some(4));
+/// assert_eq!(base64url_nopad::encode_len_checked(2), Some(3));
+/// assert_eq!(base64url_nopad::encode_len_checked(1), Some(2));
+/// assert_eq!(base64url_nopad::encode_len_checked(0), Some(0));
/// ```
#[expect(
clippy::arithmetic_side_effects,
@@ -1027,21 +1027,22 @@ pub const fn encode_len(input_length: usize) -> usize {
/// # Examples
///
/// ```
-/// assert!(
-/// base64url_nopad::encode_buffer_checked([0; 0].as_slice(), [0; 0].as_mut_slice()).is_some_and(|val| val.is_empty())
+/// assert_eq!(
+/// base64url_nopad::encode_buffer_checked([0; 0].as_slice(), [0; 0].as_mut_slice()).as_deref(), Some("")
/// );
-/// assert!(
-/// base64url_nopad::encode_buffer_checked([0; 1].as_slice(), [0; 2].as_mut_slice()).is_some_and(|val| val == "AA")
+/// assert_eq!(
+/// base64url_nopad::encode_buffer_checked([0; 1].as_slice(), [0; 2].as_mut_slice()).as_deref(), Some("AA")
/// );
/// // A larger output buffer than necessary is OK.
-/// assert!(
-/// base64url_nopad::encode_buffer_checked([1; 1].as_slice(), [0; 128].as_mut_slice()).is_some_and(|val| val == "AQ")
+/// assert_eq!(
+/// base64url_nopad::encode_buffer_checked([1; 1].as_slice(), [0; 128].as_mut_slice()).as_deref(), Some("AQ")
/// );
-/// assert!(
+/// assert_eq!(
/// base64url_nopad::encode_buffer_checked(
/// [0xc9; 14].as_slice(),
/// [0; base64url_nopad::encode_len(14)].as_mut_slice()
-/// ).is_some_and(|val| val == "ycnJycnJycnJycnJyck")
+/// ).as_deref(),
+/// Some("ycnJycnJycnJycnJyck")
/// );
/// assert!(base64url_nopad::encode_buffer_checked([0; 1].as_slice(), [0; 1].as_mut_slice()).is_none());
/// ```
@@ -1534,11 +1535,11 @@ pub fn encode_append_only(input: &[u8], s: &mut String) {
/// ```
/// # use base64url_nopad::MAX_ENCODE_INPUT_LEN;
/// assert!(base64url_nopad::decode_len(1).is_none());
-/// assert!(base64url_nopad::decode_len(usize::MAX).is_some_and(|len| len == MAX_ENCODE_INPUT_LEN));
-/// assert!(base64url_nopad::decode_len(4).is_some_and(|len| len == 3));
-/// assert!(base64url_nopad::decode_len(3).is_some_and(|len| len == 2));
-/// assert!(base64url_nopad::decode_len(2).is_some_and(|len| len == 1));
-/// assert!(base64url_nopad::decode_len(0).is_some_and(|len| len == 0));
+/// assert_eq!(base64url_nopad::decode_len(usize::MAX), Some(MAX_ENCODE_INPUT_LEN));
+/// assert_eq!(base64url_nopad::decode_len(4), Some(3));
+/// assert_eq!(base64url_nopad::decode_len(3), Some(2));
+/// assert_eq!(base64url_nopad::decode_len(2), Some(1));
+/// assert_eq!(base64url_nopad::decode_len(0), Some(0));
/// ```
#[expect(
clippy::arithmetic_side_effects,
@@ -1655,17 +1656,17 @@ impl Error for DecodeErr {}
///
/// ```
/// # use base64url_nopad::DecodeErr;
-/// assert_eq!(base64url_nopad::decode_buffer([0; 0].as_slice(), [0; 0].as_mut_slice())?, b"");
+/// assert_eq!(base64url_nopad::decode_buffer(b"", [0; 0].as_mut_slice())?, b"");
/// assert_eq!(
-/// base64url_nopad::decode_buffer([0; 1].as_slice(), [0; 0].as_mut_slice()).unwrap_err(),
+/// base64url_nopad::decode_buffer(b"A", [0; 0].as_mut_slice()).unwrap_err(),
/// DecodeErr::EncodedLen
/// );
/// assert_eq!(
-/// base64url_nopad::decode_buffer([0; 2].as_slice(), [0; 3].as_mut_slice()).unwrap_err(),
+/// base64url_nopad::decode_buffer(b"A+".as_slice(), [0; 3].as_mut_slice()).unwrap_err(),
/// DecodeErr::InvalidByte
/// );
/// assert_eq!(
-/// base64url_nopad::decode_buffer([0; 2].as_slice(), [0; 0].as_mut_slice()).unwrap_err(),
+/// base64url_nopad::decode_buffer(b"AA".as_slice(), [0; 0].as_mut_slice()).unwrap_err(),
/// DecodeErr::BufferLen
/// );
/// assert_eq!(
@@ -1773,11 +1774,11 @@ pub const fn decode_buffer<'a>(
/// # use base64url_nopad::DecodeErr;
/// assert_eq!(base64url_nopad::decode([0; 0].as_slice())?, b"");
/// assert_eq!(
-/// base64url_nopad::decode([0; 1].as_slice()).unwrap_err(),
+/// base64url_nopad::decode(b"A").unwrap_err(),
/// DecodeErr::EncodedLen
/// );
/// assert_eq!(
-/// base64url_nopad::decode([0; 2].as_slice()).unwrap_err(),
+/// base64url_nopad::decode(b"AA==").unwrap_err(),
/// DecodeErr::InvalidByte
/// );
/// assert_eq!(
@@ -1824,13 +1825,13 @@ pub fn decode(input: &[u8]) -> Result<Vec<u8>, DecodeErr> {
///
/// ```
/// # use base64url_nopad::DecodeErr;
-/// base64url_nopad::validate_encoded_data([0; 0].as_slice())?;
+/// base64url_nopad::validate_encoded_data(b"")?;
/// assert_eq!(
-/// base64url_nopad::validate_encoded_data([0; 1].as_slice()).unwrap_err(),
+/// base64url_nopad::validate_encoded_data(b"A").unwrap_err(),
/// DecodeErr::EncodedLen
/// );
/// assert_eq!(
-/// base64url_nopad::validate_encoded_data([0; 2].as_slice()).unwrap_err(),
+/// base64url_nopad::validate_encoded_data(b"A/").unwrap_err(),
/// DecodeErr::InvalidByte
/// );
/// assert_eq!(
@@ -1930,11 +1931,11 @@ pub const fn encode_buffer_exact(input: &[u8], output: &mut [u8]) {
/// ```
/// # use base64url_nopad::DecodeErr;
/// assert_eq!(
-/// base64url_nopad::decode_buffer_exact([0; 1].as_slice(), [0; 0].as_mut_slice()).unwrap_err(),
+/// base64url_nopad::decode_buffer_exact(b"A", [0; 0].as_mut_slice()).unwrap_err(),
/// DecodeErr::EncodedLen
/// );
/// assert_eq!(
-/// base64url_nopad::decode_buffer_exact([0; 2].as_slice(), [0; 1].as_mut_slice()).unwrap_err(),
+/// base64url_nopad::decode_buffer_exact(b"+A", [0; 1].as_mut_slice()).unwrap_err(),
/// DecodeErr::InvalidByte
/// );
/// assert_eq!(
@@ -2008,18 +2009,18 @@ mod test {
#[cfg(target_pointer_width = "64")]
let len = rng.random::<u64>() as usize;
if len <= MAX_ENCODE_INPUT_LEN {
- assert!(
- super::encode_len_checked(len)
- .is_some_and(|l| super::decode_len(l).is_some_and(|orig| orig == len))
+ assert_eq!(
+ super::encode_len_checked(len).map(super::decode_len),
+ Some(Some(len))
);
} else {
assert!(super::encode_len_checked(len).is_none());
}
}
for i in 0..1025 {
- assert!(
- super::encode_len_checked(i)
- .is_some_and(|l| super::decode_len(l).is_some_and(|orig| orig == i))
+ assert_eq!(
+ super::encode_len_checked(i).map(super::decode_len),
+ Some(Some(i))
);
}
#[cfg(target_pointer_width = "16")]
@@ -2031,7 +2032,10 @@ mod test {
assert!(super::encode_len_checked(i).is_none());
}
assert!(super::encode_len_checked(usize::MAX).is_none());
- assert!(super::encode_len_checked(MAX_ENCODE_INPUT_LEN).is_some_and(|l| l == usize::MAX));
+ assert_eq!(
+ super::encode_len_checked(MAX_ENCODE_INPUT_LEN),
+ Some(usize::MAX)
+ );
for _ in 0u32..10_000_000 {
#[cfg(target_pointer_width = "16")]
let len = rng.random::<u16>() as usize;
@@ -2042,10 +2046,9 @@ mod test {
if len & 3 == 1 {
assert!(super::decode_len(len).is_none());
} else {
- assert!(
- super::decode_len(len).is_some_and(
- |l| super::encode_len_checked(l).is_some_and(|orig| orig == len)
- )
+ assert_eq!(
+ super::decode_len(len).map(super::encode_len_checked),
+ Some(Some(len))
);
}
}
@@ -2053,10 +2056,9 @@ mod test {
if i & 3 == 1 {
assert!(super::decode_len(i).is_none());
} else {
- assert!(
- super::decode_len(i).is_some_and(
- |l| super::encode_len_checked(l).is_some_and(|orig| orig == i)
- )
+ assert_eq!(
+ super::decode_len(i).map(super::encode_len_checked),
+ Some(Some(i))
);
}
}
@@ -2065,7 +2067,10 @@ mod test {
if i & 3 == 1 {
assert!(super::decode_len(i).is_none());
} else {
- assert!(super::decode_len(i).is_some_and(|l| super::encode_len_checked(l).is_some_and(|orig| orig == i)));
+ assert_eq!(
+ super::decode_len(i).map(super::encode_len_checked),
+ Some(Some(i))
+ );
}
}
#[cfg(not(target_pointer_width = "16"))]
@@ -2073,10 +2078,13 @@ mod test {
if i & 3 == 1 {
assert!(super::decode_len(i).is_none());
} else {
- assert!(super::decode_len(i).is_some_and(|l| super::encode_len_checked(l).is_some_and(|orig| orig == i)));
+ assert_eq!(
+ super::decode_len(i).map(super::encode_len_checked),
+ Some(Some(i))
+ );
}
}
- assert!(super::decode_len(usize::MAX).is_some_and(|l| l == MAX_ENCODE_INPUT_LEN));
+ assert_eq!(super::decode_len(usize::MAX), Some(MAX_ENCODE_INPUT_LEN));
}
#[expect(clippy::indexing_slicing, reason = "comments justify correctness")]
#[cfg(feature = "alloc")]
