Vendor dependencies

notes-service/vendor/lexical-util/tests/algorithm_tests.rs

@@ -0,0 +1,30 @@
+#[cfg(any(feature = "write-floats", feature = "write-integers"))]
+use lexical_util::algorithm;
+
+#[test]
+#[cfg(any(feature = "write-floats", feature = "write-integers"))]
+fn copy_to_dest_test() {
+    let src = b"12345";
+    let mut dst = [b'0'; 16];
+
+    assert_eq!(5, algorithm::copy_to_dst(&mut dst, src));
+    assert_eq!(&dst[..5], src);
+}
+
+#[test]
+#[cfg(any(feature = "write-floats", feature = "write-integers"))]
+fn ltrim_char_test() {
+    let w = "0001";
+    let x = "1010";
+    let y = "1.00";
+    let z = "1e05";
+
+    assert_eq!(algorithm::ltrim_char_count(w.as_bytes(), b'0'), 3);
+    assert_eq!(algorithm::ltrim_char_count(x.as_bytes(), b'0'), 0);
+    assert_eq!(algorithm::ltrim_char_count(x.as_bytes(), b'1'), 1);
+    assert_eq!(algorithm::ltrim_char_count(y.as_bytes(), b'0'), 0);
+    assert_eq!(algorithm::ltrim_char_count(y.as_bytes(), b'1'), 1);
+    assert_eq!(algorithm::ltrim_char_count(z.as_bytes(), b'0'), 0);
+    assert_eq!(algorithm::ltrim_char_count(z.as_bytes(), b'1'), 1);
+    assert_eq!(algorithm::ltrim_char_count(z.as_bytes(), b'5'), 0);
+}

notes-service/vendor/lexical-util/tests/ascii_tests.rs

@@ -0,0 +1,51 @@
+use lexical_util::ascii;
+
+#[test]
+fn is_valid_ascii_test() {
+    assert_eq!(ascii::is_valid_ascii(b'\x00'), false);
+    assert_eq!(ascii::is_valid_ascii(b'\n'), true);
+    assert_eq!(ascii::is_valid_ascii(b'\r'), true);
+    assert_eq!(ascii::is_valid_ascii(b'\x1b'), false);
+    assert_eq!(ascii::is_valid_ascii(b' '), true);
+    assert_eq!(ascii::is_valid_ascii(b'0'), true);
+    assert_eq!(ascii::is_valid_ascii(b'9'), true);
+    assert_eq!(ascii::is_valid_ascii(b':'), true);
+    assert_eq!(ascii::is_valid_ascii(b'A'), true);
+    assert_eq!(ascii::is_valid_ascii(b'Z'), true);
+    assert_eq!(ascii::is_valid_ascii(b']'), true);
+    assert_eq!(ascii::is_valid_ascii(b'a'), true);
+    assert_eq!(ascii::is_valid_ascii(b'z'), true);
+    assert_eq!(ascii::is_valid_ascii(b'~'), true);
+    assert_eq!(ascii::is_valid_ascii(b'\x7f'), false);
+}
+
+#[test]
+fn is_valid_ascii_slice_test() {
+    assert_eq!(ascii::is_valid_ascii_slice(b" 09a"), true);
+    assert_eq!(ascii::is_valid_ascii_slice(b" 09a\x1b"), false);
+}
+
+#[test]
+fn is_valid_letter_test() {
+    assert_eq!(ascii::is_valid_letter(b'\x00'), false);
+    assert_eq!(ascii::is_valid_letter(b'\n'), false);
+    assert_eq!(ascii::is_valid_letter(b'\r'), false);
+    assert_eq!(ascii::is_valid_letter(b'\x1b'), false);
+    assert_eq!(ascii::is_valid_letter(b' '), false);
+    assert_eq!(ascii::is_valid_letter(b'0'), false);
+    assert_eq!(ascii::is_valid_letter(b'9'), false);
+    assert_eq!(ascii::is_valid_letter(b':'), false);
+    assert_eq!(ascii::is_valid_letter(b'A'), true);
+    assert_eq!(ascii::is_valid_letter(b'Z'), true);
+    assert_eq!(ascii::is_valid_letter(b']'), false);
+    assert_eq!(ascii::is_valid_letter(b'a'), true);
+    assert_eq!(ascii::is_valid_letter(b'z'), true);
+    assert_eq!(ascii::is_valid_letter(b'~'), false);
+    assert_eq!(ascii::is_valid_letter(b'\x7f'), false);
+}
+
+#[test]
+fn is_valid_letter_slice_test() {
+    assert_eq!(ascii::is_valid_letter_slice(b" 09a"), false);
+    assert_eq!(ascii::is_valid_letter_slice(b"aZAz"), true);
+}

notes-service/vendor/lexical-util/tests/bf16_tests.rs

@@ -0,0 +1,44 @@
+#![cfg(feature = "f16")]
+
+use lexical_util::bf16::bf16;
+use lexical_util::num::Float;
+
+#[test]
+fn as_f32_test() {
+    assert_eq!(bf16::from_bits(1).as_f32(), 9.18355e-41f32);
+    assert_eq!(bf16::ZERO.as_f32_const(), 0.0f32);
+    assert_eq!(bf16::ZERO.to_bits(), 0);
+    assert_eq!(bf16::ONE.as_f32_const(), 1.0f32);
+    assert_eq!(bf16::ONE.to_bits(), (127 << 7));
+    assert_eq!(bf16::TWO.as_f32_const(), 2.0f32);
+    assert_eq!(bf16::TWO.to_bits(), (128 << 7));
+    assert_eq!(bf16::from_bits(126 << 7).as_f32_const(), 0.5f32);
+    assert!(bf16::NAN.as_f32_const().is_nan());
+    assert!(bf16::INFINITY.as_f32_const().is_inf());
+    assert!(bf16::NEG_INFINITY.as_f32_const().is_inf());
+}
+
+#[test]
+fn from_f32_test() {
+    assert_eq!(bf16::from_f32_const(4.5917e-41f32).to_bits(), 0);
+    assert_eq!(bf16::from_f32_const(4.5918e-41f32).to_bits(), 0);
+    assert_eq!(bf16::from_f32_const(4.5919e-41f32).to_bits(), 1);
+    assert_eq!(bf16::from_f32_const(9.18354e-41f32).to_bits(), 1);
+    assert_eq!(bf16::from_f32_const(9.18355e-41f32).to_bits(), 1);
+    assert_eq!(bf16::from_f32_const(9.18356e-41f32).to_bits(), 1);
+    assert_eq!(bf16::from_f32_const(1.37752e-40f32).to_bits(), 1);
+    assert_eq!(bf16::from_f32_const(1.37753e-40f32).to_bits(), 2);
+    assert_eq!(bf16::from_f32_const(1.37754e-40f32).to_bits(), 2);
+    assert!(bf16::from_f32_const(f32::NAN).is_nan());
+    assert!(bf16::from_f32_const(f32::INFINITY).is_inf());
+    assert!(bf16::from_f32_const(f32::NEG_INFINITY).is_inf());
+}
+
+#[test]
+fn math_tests() {
+    assert_eq!(bf16::ONE + bf16::ONE, bf16::TWO);
+    assert_eq!(bf16::ONE * bf16::ONE, bf16::ONE);
+    assert_eq!(bf16::ONE / bf16::ONE, bf16::ONE);
+    assert_eq!(bf16::ONE - bf16::ONE, bf16::ZERO);
+    assert_eq!(bf16::ONE % bf16::ONE, bf16::ZERO);
+}

notes-service/vendor/lexical-util/tests/digit_tests.rs

@@ -0,0 +1,115 @@
+#![cfg(any(
+    feature = "parse-floats",
+    feature = "parse-integers",
+    feature = "write-floats",
+    feature = "write-integers",
+))]
+
+use lexical_util::digit;
+
+#[cfg(any(feature = "parse-floats", feature = "parse-integers"))]
+fn char_to_digit(c: u8, radix: u32, expected: Option<u32>) {
+    assert_eq!(digit::char_to_digit_const(c, radix), expected);
+    assert_eq!(digit::char_to_digit(c, radix), expected);
+}
+
+#[test]
+#[cfg(any(feature = "parse-floats", feature = "parse-integers"))]
+fn char_to_digit_test() {
+    char_to_digit(b'0', 2, Some(0));
+    char_to_digit(b'1', 2, Some(1));
+    char_to_digit(b'9', 2, None);
+    char_to_digit(b'A', 2, None);
+    char_to_digit(b'Z', 2, None);
+
+    char_to_digit(b'0', 10, Some(0));
+    char_to_digit(b'1', 10, Some(1));
+    char_to_digit(b'9', 10, Some(9));
+    char_to_digit(b'A', 10, None);
+    char_to_digit(b'Z', 10, None);
+
+    char_to_digit(b'0', 16, Some(0));
+    char_to_digit(b'1', 16, Some(1));
+    char_to_digit(b'9', 16, Some(9));
+    char_to_digit(b'A', 16, Some(10));
+    char_to_digit(b'Z', 16, None);
+
+    // char_to_digit doesn't care about the radix.
+    // check some more comprehensive cases.
+    for c in b'0'..=b'9' {
+        char_to_digit(c, 10, Some(c as u32 - b'0' as u32));
+    }
+    char_to_digit(0x29, 10, None);
+    char_to_digit(0x3A, 10, None);
+    char_to_digit(0x59, 10, None);
+
+    for c in b'0'..=b'8' {
+        char_to_digit(c, 9, Some(c as u32 - b'0' as u32));
+    }
+    char_to_digit(0x29, 9, None);
+    char_to_digit(0x39, 9, None);
+    char_to_digit(0x3A, 9, None);
+    char_to_digit(0x59, 9, None);
+
+    for c in b'0'..=b'9' {
+        char_to_digit(c, 16, Some(c as u32 - b'0' as u32));
+    }
+    for c in b'a'..=b'f' {
+        char_to_digit(c, 16, Some(c as u32 - b'a' as u32 + 10));
+    }
+    for c in b'A'..=b'F' {
+        char_to_digit(c, 16, Some(c as u32 - b'A' as u32 + 10));
+    }
+    char_to_digit(0x29, 16, None);
+    char_to_digit(0x40, 16, None);
+    char_to_digit(0x3A, 16, None);
+    char_to_digit(0x59, 16, None);
+    char_to_digit(0x41, 16, Some(10));
+    char_to_digit(0x47, 16, None);
+    char_to_digit(0x5A, 16, None);
+    char_to_digit(0x61, 16, Some(10));
+    char_to_digit(0x67, 16, None);
+    char_to_digit(0x7A, 16, None);
+}
+
+#[cfg(any(feature = "parse-floats", feature = "parse-integers"))]
+fn char_is_digit(c: u8, radix: u32, expected: bool) {
+    assert_eq!(digit::char_is_digit_const(c, radix), expected);
+    assert_eq!(digit::char_is_digit(c, radix), expected);
+}
+
+#[test]
+#[cfg(any(feature = "parse-floats", feature = "parse-integers"))]
+fn char_is_digit_const_test() {
+    char_is_digit(b'0', 2, true);
+    char_is_digit(b'1', 2, true);
+    char_is_digit(b'9', 2, false);
+    char_is_digit(b'A', 2, false);
+    char_is_digit(b'Z', 2, false);
+
+    char_is_digit(b'0', 10, true);
+    char_is_digit(b'1', 10, true);
+    char_is_digit(b'9', 10, true);
+    char_is_digit(b'A', 10, false);
+    char_is_digit(b'Z', 10, false);
+
+    char_is_digit(b'0', 16, true);
+    char_is_digit(b'1', 16, true);
+    char_is_digit(b'9', 16, true);
+    char_is_digit(b'A', 16, true);
+    char_is_digit(b'Z', 16, false);
+}
+
+#[cfg(any(feature = "write-floats", feature = "write-integers"))]
+fn digit_to_char(digit: u32, radix: u32, expected: u8) {
+    assert_eq!(digit::digit_to_char_const(digit, radix), expected);
+    assert_eq!(digit::digit_to_char(digit), expected);
+}
+
+#[test]
+#[cfg(any(feature = "write-floats", feature = "write-integers"))]
+fn digit_to_char_const_test() {
+    digit_to_char(9, 10, b'9');
+    digit_to_char(10, 36, b'A');
+    digit_to_char(11, 36, b'B');
+}

notes-service/vendor/lexical-util/tests/f16_tests.rs

@@ -0,0 +1,41 @@
+#![cfg(feature = "f16")]
+
+use lexical_util::f16::f16;
+use lexical_util::num::Float;
+
+#[test]
+fn as_f32_test() {
+    assert_eq!(f16::from_bits(1).as_f32_const(), 0.000000059604645);
+    assert_eq!(f16::ZERO.as_f32_const(), 0.0f32);
+    assert_eq!(f16::ZERO.to_bits(), 0);
+    assert_eq!(f16::ONE.as_f32_const(), 1.0f32);
+    assert_eq!(f16::ONE.to_bits(), (15 << 10));
+    assert_eq!(f16::TWO.as_f32_const(), 2.0f32);
+    assert_eq!(f16::TWO.to_bits(), (16 << 10));
+    assert_eq!(f16::from_bits(14 << 10).as_f32_const(), 0.5f32);
+    assert!(f16::NAN.as_f32_const().is_nan());
+    assert!(f16::INFINITY.as_f32_const().is_inf());
+    assert!(f16::NEG_INFINITY.as_f32_const().is_inf());
+}
+
+#[test]
+fn from_f32_test() {
+    assert_eq!(f16::from_f32_const(2.980232e-08).to_bits(), 0);
+    assert_eq!(f16::from_f32_const(2.9802322e-08).to_bits(), 0);
+    assert_eq!(f16::from_f32_const(2.9802326e-08).to_bits(), 1);
+    assert_eq!(f16::from_f32_const(5.960464e-08).to_bits(), 1);
+    assert_eq!(f16::from_f32_const(5.9604645e-08).to_bits(), 1);
+    assert_eq!(f16::from_f32_const(5.960465e-08).to_bits(), 1);
+    assert!(f16::from_f32_const(f32::NAN).is_nan());
+    assert!(f16::from_f32_const(f32::INFINITY).is_inf());
+    assert!(f16::from_f32_const(f32::NEG_INFINITY).is_inf());
+}
+
+#[test]
+fn math_tests() {
+    assert_eq!(f16::ONE + f16::ONE, f16::TWO);
+    assert_eq!(f16::ONE * f16::ONE, f16::ONE);
+    assert_eq!(f16::ONE / f16::ONE, f16::ONE);
+    assert_eq!(f16::ONE - f16::ONE, f16::ZERO);
+    assert_eq!(f16::ONE % f16::ONE, f16::ZERO);
+}

notes-service/vendor/lexical-util/tests/feature_format_tests.rs

@@ -0,0 +1,241 @@
+#![cfg(feature = "format")]
+
+use core::num;
+
+use lexical_util::format;
+
+#[test]
+fn ignore_test() {
+    let fmt = format::NumberFormat::<{ format::IGNORE }> {};
+    assert_eq!(fmt.flags(), format::DIGIT_SEPARATOR_FLAG_MASK);
+    assert_eq!(fmt.digit_separator(), b'_');
+    assert_eq!(fmt.required_integer_digits(), false);
+    assert_eq!(fmt.required_fraction_digits(), false);
+    assert_eq!(fmt.required_exponent_digits(), false);
+    assert_eq!(fmt.required_mantissa_digits(), false);
+    assert_eq!(fmt.required_digits(), false);
+    assert_eq!(fmt.no_positive_mantissa_sign(), false);
+    assert_eq!(fmt.required_mantissa_sign(), false);
+    assert_eq!(fmt.no_exponent_notation(), false);
+    assert_eq!(fmt.no_positive_exponent_sign(), false);
+    assert_eq!(fmt.required_exponent_sign(), false);
+    assert_eq!(fmt.no_exponent_without_fraction(), false);
+    assert_eq!(fmt.no_special(), false);
+    assert_eq!(fmt.case_sensitive_special(), false);
+    assert_eq!(fmt.no_integer_leading_zeros(), false);
+    assert_eq!(fmt.no_float_leading_zeros(), false);
+    assert_eq!(fmt.required_exponent_notation(), false);
+    assert_eq!(fmt.case_sensitive_exponent(), false);
+    #[cfg(feature = "power-of-two")]
+    assert_eq!(fmt.case_sensitive_base_prefix(), false);
+    #[cfg(feature = "power-of-two")]
+    assert_eq!(fmt.case_sensitive_base_suffix(), false);
+    assert_eq!(fmt.integer_internal_digit_separator(), true);
+    assert_eq!(fmt.fraction_internal_digit_separator(), true);
+    assert_eq!(fmt.exponent_internal_digit_separator(), true);
+    assert_eq!(fmt.internal_digit_separator(), true);
+    assert_eq!(fmt.integer_leading_digit_separator(), true);
+    assert_eq!(fmt.fraction_leading_digit_separator(), true);
+    assert_eq!(fmt.exponent_leading_digit_separator(), true);
+    assert_eq!(fmt.leading_digit_separator(), true);
+    assert_eq!(fmt.integer_trailing_digit_separator(), true);
+    assert_eq!(fmt.fraction_trailing_digit_separator(), true);
+    assert_eq!(fmt.exponent_trailing_digit_separator(), true);
+    assert_eq!(fmt.trailing_digit_separator(), true);
+    assert_eq!(fmt.integer_consecutive_digit_separator(), true);
+    assert_eq!(fmt.fraction_consecutive_digit_separator(), true);
+    assert_eq!(fmt.exponent_consecutive_digit_separator(), true);
+    assert_eq!(fmt.consecutive_digit_separator(), true);
+    assert_eq!(fmt.special_digit_separator(), true);
+}
+
+fn test_flag<const FORMAT: u128>() {
+    let fmt = format::NumberFormat::<FORMAT> {};
+    assert_eq!(fmt.flags(), FORMAT);
+    assert_eq!(fmt.digit_separator(), 0);
+}
+
+macro_rules! test_flag {
+    ($field:ident, $flag:ident) => {{
+        test_flag::<{ format::$flag }>();
+
+        if format::$flag & format::CONSECUTIVE_DIGIT_SEPARATOR == 0 {
+            const FORMAT: u128 = format::NumberFormatBuilder::new()
+                .digit_separator(num::NonZeroU8::new(b'_'))
+                .$field(true)
+                .build_unchecked();
+            let fmt = format::NumberFormat::<FORMAT> {};
+            assert_eq!(fmt.is_valid(), true);
+            assert_eq!(fmt.$field(), true);
+        } else {
+            const FORMAT: u128 = format::NumberFormatBuilder::new()
+                .digit_separator(num::NonZeroU8::new(b'_'))
+                .internal_digit_separator(true)
+                .leading_digit_separator(true)
+                .trailing_digit_separator(true)
+                .$field(true)
+                .build_unchecked();
+            let fmt = format::NumberFormat::<FORMAT> {};
+            assert_eq!(fmt.is_valid(), true);
+            assert_eq!(fmt.$field(), true);
+        }
+    }};
+}
+
+#[test]
+fn flags_test() {
+    test_flag!(required_integer_digits, REQUIRED_INTEGER_DIGITS);
+    test_flag!(required_fraction_digits, REQUIRED_FRACTION_DIGITS);
+    test_flag!(required_exponent_digits, REQUIRED_EXPONENT_DIGITS);
+    test_flag!(required_mantissa_digits, REQUIRED_MANTISSA_DIGITS);
+    test_flag!(no_positive_mantissa_sign, NO_POSITIVE_MANTISSA_SIGN);
+    test_flag!(required_mantissa_sign, REQUIRED_MANTISSA_SIGN);
+    test_flag!(no_exponent_notation, NO_EXPONENT_NOTATION);
+    test_flag!(no_positive_exponent_sign, NO_POSITIVE_EXPONENT_SIGN);
+    test_flag!(required_exponent_sign, REQUIRED_EXPONENT_SIGN);
+    test_flag!(no_exponent_without_fraction, NO_EXPONENT_WITHOUT_FRACTION);
+    test_flag!(no_special, NO_SPECIAL);
+    test_flag!(case_sensitive_special, CASE_SENSITIVE_SPECIAL);
+    test_flag!(no_integer_leading_zeros, NO_INTEGER_LEADING_ZEROS);
+    test_flag!(no_float_leading_zeros, NO_FLOAT_LEADING_ZEROS);
+    test_flag!(required_exponent_notation, REQUIRED_EXPONENT_NOTATION);
+    test_flag!(case_sensitive_exponent, CASE_SENSITIVE_EXPONENT);
+    #[cfg(feature = "power-of-two")]
+    test_flag!(case_sensitive_base_prefix, CASE_SENSITIVE_BASE_PREFIX);
+    #[cfg(feature = "power-of-two")]
+    test_flag!(case_sensitive_base_suffix, CASE_SENSITIVE_BASE_SUFFIX);
+    test_flag!(integer_internal_digit_separator, INTEGER_INTERNAL_DIGIT_SEPARATOR);
+    test_flag!(fraction_internal_digit_separator, FRACTION_INTERNAL_DIGIT_SEPARATOR);
+    test_flag!(exponent_internal_digit_separator, EXPONENT_INTERNAL_DIGIT_SEPARATOR);
+    test_flag!(integer_leading_digit_separator, INTEGER_LEADING_DIGIT_SEPARATOR);
+    test_flag!(fraction_leading_digit_separator, FRACTION_LEADING_DIGIT_SEPARATOR);
+    test_flag!(exponent_leading_digit_separator, EXPONENT_LEADING_DIGIT_SEPARATOR);
+    test_flag!(integer_trailing_digit_separator, INTEGER_TRAILING_DIGIT_SEPARATOR);
+    test_flag!(fraction_trailing_digit_separator, FRACTION_TRAILING_DIGIT_SEPARATOR);
+    test_flag!(exponent_trailing_digit_separator, EXPONENT_TRAILING_DIGIT_SEPARATOR);
+    test_flag!(integer_consecutive_digit_separator, INTEGER_CONSECUTIVE_DIGIT_SEPARATOR);
+    test_flag!(fraction_consecutive_digit_separator, FRACTION_CONSECUTIVE_DIGIT_SEPARATOR);
+    test_flag!(exponent_consecutive_digit_separator, EXPONENT_CONSECUTIVE_DIGIT_SEPARATOR);
+    test_flag!(special_digit_separator, SPECIAL_DIGIT_SEPARATOR);
+}
+
+#[test]
+fn constants_test() {
+    // Don't check the actual values: just check they're defined.
+    let _: u128 = format::RUST_LITERAL;
+    let _: u128 = format::RUST_STRING;
+    let _: u128 = format::PYTHON_LITERAL;
+    let _: u128 = format::PYTHON_STRING;
+    let _: u128 = format::PYTHON3_LITERAL;
+    let _: u128 = format::PYTHON3_STRING;
+    let _: u128 = format::PYTHON36_LITERAL;
+    let _: u128 = format::PYTHON35_LITERAL;
+    let _: u128 = format::PYTHON2_LITERAL;
+    let _: u128 = format::PYTHON2_STRING;
+    let _: u128 = format::CXX17_LITERAL;
+    let _: u128 = format::CXX17_STRING;
+    let _: u128 = format::CXX14_LITERAL;
+    let _: u128 = format::CXX14_STRING;
+    let _: u128 = format::CXX11_LITERAL;
+    let _: u128 = format::CXX11_STRING;
+    let _: u128 = format::CXX03_LITERAL;
+    let _: u128 = format::CXX03_STRING;
+    let _: u128 = format::CXX98_LITERAL;
+    let _: u128 = format::CXX98_STRING;
+    let _: u128 = format::C18_LITERAL;
+    let _: u128 = format::C18_STRING;
+    let _: u128 = format::C11_LITERAL;
+    let _: u128 = format::C11_STRING;
+    let _: u128 = format::C99_LITERAL;
+    let _: u128 = format::C99_STRING;
+    let _: u128 = format::C90_LITERAL;
+    let _: u128 = format::C90_STRING;
+    let _: u128 = format::C89_LITERAL;
+    let _: u128 = format::C89_STRING;
+    let _: u128 = format::RUBY_LITERAL;
+    let _: u128 = format::RUBY_STRING;
+    let _: u128 = format::SWIFT_LITERAL;
+    let _: u128 = format::SWIFT_STRING;
+    let _: u128 = format::GO_LITERAL;
+    let _: u128 = format::GO_STRING;
+    let _: u128 = format::HASKELL_LITERAL;
+    let _: u128 = format::HASKELL_STRING;
+    let _: u128 = format::JAVASCRIPT_LITERAL;
+    let _: u128 = format::JAVASCRIPT_STRING;
+    let _: u128 = format::PERL_LITERAL;
+    let _: u128 = format::PERL_STRING;
+    let _: u128 = format::PHP_LITERAL;
+    let _: u128 = format::PHP_STRING;
+    let _: u128 = format::JAVA_LITERAL;
+    let _: u128 = format::JAVA_STRING;
+    let _: u128 = format::R_LITERAL;
+    let _: u128 = format::R_STRING;
+    let _: u128 = format::KOTLIN_LITERAL;
+    let _: u128 = format::KOTLIN_STRING;
+    let _: u128 = format::JULIA_LITERAL;
+    let _: u128 = format::JULIA_STRING;
+    let _: u128 = format::CSHARP7_LITERAL;
+    let _: u128 = format::CSHARP7_STRING;
+    let _: u128 = format::CSHARP6_LITERAL;
+    let _: u128 = format::CSHARP6_STRING;
+    let _: u128 = format::CSHARP5_LITERAL;
+    let _: u128 = format::CSHARP5_STRING;
+    let _: u128 = format::CSHARP4_LITERAL;
+    let _: u128 = format::CSHARP4_STRING;
+    let _: u128 = format::CSHARP3_LITERAL;
+    let _: u128 = format::CSHARP3_STRING;
+    let _: u128 = format::CSHARP2_LITERAL;
+    let _: u128 = format::CSHARP2_STRING;
+    let _: u128 = format::CSHARP1_LITERAL;
+    let _: u128 = format::CSHARP1_STRING;
+    let _: u128 = format::KAWA_LITERAL;
+    let _: u128 = format::KAWA_STRING;
+    let _: u128 = format::GAMBITC_LITERAL;
+    let _: u128 = format::GAMBITC_STRING;
+    let _: u128 = format::GUILE_LITERAL;
+    let _: u128 = format::GUILE_STRING;
+    let _: u128 = format::CLOJURE_LITERAL;
+    let _: u128 = format::CLOJURE_STRING;
+    let _: u128 = format::ERLANG_LITERAL;
+    let _: u128 = format::ERLANG_STRING;
+    let _: u128 = format::ELM_LITERAL;
+    let _: u128 = format::ELM_STRING;
+    let _: u128 = format::SCALA_LITERAL;
+    let _: u128 = format::SCALA_STRING;
+    let _: u128 = format::ELIXIR_LITERAL;
+    let _: u128 = format::ELIXIR_STRING;
+    let _: u128 = format::FORTRAN_LITERAL;
+    let _: u128 = format::FORTRAN_STRING;
+    let _: u128 = format::D_LITERAL;
+    let _: u128 = format::D_STRING;
+    let _: u128 = format::COFFEESCRIPT_LITERAL;
+    let _: u128 = format::COFFEESCRIPT_STRING;
+    let _: u128 = format::COBOL_LITERAL;
+    let _: u128 = format::COBOL_STRING;
+    let _: u128 = format::FSHARP_LITERAL;
+    let _: u128 = format::FSHARP_STRING;
+    let _: u128 = format::VB_LITERAL;
+    let _: u128 = format::VB_STRING;
+    let _: u128 = format::OCAML_LITERAL;
+    let _: u128 = format::OCAML_STRING;
+    let _: u128 = format::OBJECTIVEC_LITERAL;
+    let _: u128 = format::OBJECTIVEC_STRING;
+    let _: u128 = format::REASONML_LITERAL;
+    let _: u128 = format::REASONML_STRING;
+    let _: u128 = format::OCTAVE_LITERAL;
+    let _: u128 = format::OCTAVE_STRING;
+    let _: u128 = format::MATLAB_LITERAL;
+    let _: u128 = format::MATLAB_STRING;
+    let _: u128 = format::ZIG_LITERAL;
+    let _: u128 = format::ZIG_STRING;
+    let _: u128 = format::SAGE_LITERAL;
+    let _: u128 = format::SAGE_STRING;
+    let _: u128 = format::JSON;
+    let _: u128 = format::TOML;
+    let _: u128 = format::YAML;
+    let _: u128 = format::XML;
+    let _: u128 = format::SQLITE;
+    let _: u128 = format::POSTGRESQL;
+    let _: u128 = format::MYSQL;
+    let _: u128 = format::MONGODB;
+}

notes-service/vendor/lexical-util/tests/format_builder_tests.rs

@@ -0,0 +1,60 @@
+use lexical_util::format::{NumberFormat, NumberFormatBuilder};
+
+#[test]
+fn decimal_test() {
+    const FORMAT: u128 = NumberFormatBuilder::decimal();
+    let format = NumberFormat::<FORMAT> {};
+    assert!(format.is_valid());
+    assert_eq!(format.radix(), 10);
+    assert_eq!(format.mantissa_radix(), 10);
+    assert_eq!(format.exponent_base(), 10);
+    assert_eq!(format.exponent_radix(), 10);
+}
+
+#[test]
+#[cfg(feature = "power-of-two")]
+fn binary_test() {
+    const FORMAT: u128 = NumberFormatBuilder::binary();
+    let format = NumberFormat::<FORMAT> {};
+    assert!(format.is_valid());
+    assert_eq!(format.radix(), 2);
+    assert_eq!(format.mantissa_radix(), 2);
+    assert_eq!(format.exponent_base(), 2);
+    assert_eq!(format.exponent_radix(), 2);
+}
+
+#[test]
+#[cfg(feature = "power-of-two")]
+fn octal_test() {
+    const FORMAT: u128 = NumberFormatBuilder::octal();
+    let format = NumberFormat::<FORMAT> {};
+    assert!(format.is_valid());
+    assert_eq!(format.radix(), 8);
+    assert_eq!(format.mantissa_radix(), 8);
+    assert_eq!(format.exponent_base(), 8);
+    assert_eq!(format.exponent_radix(), 8);
+}
+
+#[test]
+#[cfg(feature = "power-of-two")]
+fn hexadecimal_test() {
+    const FORMAT: u128 = NumberFormatBuilder::hexadecimal();
+    let format = NumberFormat::<FORMAT> {};
+    assert!(format.is_valid());
+    assert_eq!(format.radix(), 16);
+    assert_eq!(format.mantissa_radix(), 16);
+    assert_eq!(format.exponent_base(), 16);
+    assert_eq!(format.exponent_radix(), 16);
+}
+
+#[test]
+#[cfg(feature = "power-of-two")]
+fn from_radix_test() {
+    const FORMAT: u128 = NumberFormatBuilder::from_radix(32);
+    let format = NumberFormat::<FORMAT> {};
+    assert!(format.is_valid());
+    assert_eq!(format.radix(), 32);
+    assert_eq!(format.mantissa_radix(), 32);
+    assert_eq!(format.exponent_base(), 32);
+    assert_eq!(format.exponent_radix(), 32);
+}

notes-service/vendor/lexical-util/tests/format_flags_tests.rs

@@ -0,0 +1,60 @@
+#[cfg(feature = "format")]
+use core::num;
+
+#[cfg(feature = "format")]
+use lexical_util::format;
+
+#[cfg(feature = "format")]
+const fn from_digit_separator(digit_separator: u8) -> u128 {
+    format::NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(digit_separator))
+        .digit_separator_flags(true)
+        .build_unchecked()
+}
+
+#[cfg(feature = "format")]
+fn is_valid_digit_separator(digit_separator: u8) -> bool {
+    let format = from_digit_separator(digit_separator);
+    format::is_valid_digit_separator(format)
+}
+
+#[test]
+#[cfg(feature = "format")]
+fn test_is_valid_digit_separator() {
+    assert_eq!(is_valid_digit_separator(b'_'), true);
+    assert_eq!(is_valid_digit_separator(b'\''), true);
+    assert_eq!(is_valid_digit_separator(b'.'), true);
+    assert_eq!(is_valid_digit_separator(b'e'), true);
+    assert_eq!(is_valid_digit_separator(b'0'), false);
+    assert_eq!(is_valid_digit_separator(128), false);
+
+    // Try with a custom radix.
+    #[cfg(feature = "radix")]
+    {
+        let format = format::NumberFormat::<{ from_digit_separator(b'e') }>::rebuild()
+            .radix(16)
+            .build_unchecked();
+        assert_eq!(format::is_valid_digit_separator(format), false);
+    }
+}
+
+#[cfg(all(feature = "power-of-two", feature = "format"))]
+fn is_valid_punctuation(digit_separator: u8, base_prefix: u8, base_suffix: u8) -> bool {
+    let fmt = format::NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(digit_separator))
+        .digit_separator_flags(true)
+        .base_prefix(num::NonZeroU8::new(base_prefix))
+        .base_suffix(num::NonZeroU8::new(base_suffix))
+        .build_unchecked();
+    format::is_valid_punctuation(fmt)
+}
+
+#[test]
+#[cfg(all(feature = "power-of-two", feature = "format"))]
+fn test_is_valid_punctuation() {
+    assert_eq!(is_valid_punctuation(b'_', b'h', 0), true);
+    assert_eq!(is_valid_punctuation(b'e', b'h', 0), true);
+    assert_eq!(is_valid_punctuation(b'^', b'h', 0), true);
+    assert_eq!(is_valid_punctuation(b'\'', b'h', 0), true);
+    assert_eq!(is_valid_punctuation(b'\'', b'h', b'h'), false);
+}

notes-service/vendor/lexical-util/tests/iterator_tests.rs

@@ -0,0 +1,115 @@
+#![cfg(any(feature = "parse-floats", feature = "parse-integers"))]
+
+use lexical_util::iterator::{AsBytes, Bytes, DigitsIter, Iter};
+
+#[test]
+#[cfg(not(feature = "format"))]
+fn digits_iterator_test() {
+    use lexical_util::format::STANDARD;
+
+    type Digits<'a> = Bytes<'a, { STANDARD }>;
+    assert!(Digits::IS_CONTIGUOUS);
+
+    let digits = b"12345";
+    let mut byte1 = Digits::new(digits);
+    let mut byte2 = Digits::new(digits);
+    assert!(byte1.integer_iter().eq(byte2.integer_iter()));
+
+    let mut byte = digits.bytes::<{ STANDARD }>();
+    let mut iter = byte.integer_iter();
+    assert_eq!(iter.as_slice(), &digits[..]);
+    assert_eq!(iter.as_ptr(), digits.as_ptr());
+    assert_eq!(iter.is_consumed(), false);
+    assert_eq!(iter.is_buffer_empty(), false);
+    assert_eq!(u32::from_le(iter.peek_u32().unwrap()), 0x34333231);
+    assert_eq!(iter.buffer_length(), 5);
+    assert_eq!(iter.cursor(), 0);
+    assert_eq!(iter.current_count(), 0);
+    unsafe {
+        iter.step_by_unchecked(4);
+    }
+    assert_eq!(iter.buffer_length(), 5);
+    assert_eq!(iter.cursor(), 4);
+    assert_eq!(iter.current_count(), 4);
+    assert_eq!(iter.peek(), Some(&b'5'));
+    assert_eq!(iter.peek(), Some(&b'5'));
+    assert_eq!(iter.next(), Some(&b'5'));
+    assert_eq!(iter.peek(), None);
+    assert_eq!(iter.next(), None);
+
+    let mut byte = digits.bytes::<{ STANDARD }>();
+    let mut iter = byte.integer_iter();
+    assert_eq!(iter.peek_u64(), None);
+    assert_eq!(iter.nth(4).unwrap(), &b'5');
+    assert_eq!(iter.as_slice(), &digits[digits.len()..]);
+    assert_eq!(iter.as_ptr(), digits[digits.len()..].as_ptr());
+
+    let mut byte = digits.bytes::<{ STANDARD }>();
+    let mut iter = byte.integer_iter();
+    assert_eq!(iter.peek(), Some(&b'1'));
+    unsafe {
+        iter.step_unchecked();
+    }
+    assert_eq!(iter.peek(), Some(&b'2'));
+    unsafe {
+        iter.step_unchecked();
+    }
+}
+
+#[test]
+#[cfg(feature = "format")]
+fn skip_iterator_test() {
+    use core::num;
+
+    use lexical_util::format::NumberFormatBuilder;
+
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .digit_separator_flags(true)
+        .build_strict();
+
+    type Digits<'a> = Bytes<'a, { FORMAT }>;
+    assert!(!Digits::IS_CONTIGUOUS);
+
+    let digits = b"123_45";
+    let mut byte1 = Digits::new(digits);
+    let mut byte2 = Digits::new(digits);
+    assert!(byte1.integer_iter().eq(byte2.integer_iter()));
+
+    let mut byte = digits.bytes::<{ FORMAT }>();
+    let mut iter = byte.integer_iter();
+    assert_eq!(iter.as_slice(), &digits[..]);
+    assert_eq!(iter.as_ptr(), digits.as_ptr());
+    assert_eq!(iter.is_consumed(), false);
+    assert_eq!(iter.is_buffer_empty(), false);
+    assert_eq!(iter.buffer_length(), 6);
+    assert_eq!(iter.cursor(), 0);
+    assert_eq!(iter.current_count(), 0);
+    unsafe { iter.step_unchecked() };
+    assert_eq!(iter.cursor(), 1);
+    assert_eq!(iter.current_count(), 0);
+    iter.next();
+    assert_eq!(iter.cursor(), 2);
+    assert_eq!(iter.current_count(), 1);
+
+    let mut byte = digits.bytes::<{ FORMAT }>();
+    let mut iter = byte.integer_iter();
+    assert_eq!(iter.peek(), Some(&b'1'));
+    assert_eq!(iter.peek(), Some(&b'1'));
+    assert_eq!(iter.next(), Some(&b'1'));
+    assert_eq!(iter.next(), Some(&b'2'));
+    assert_eq!(iter.next(), Some(&b'3'));
+    assert_eq!(iter.cursor(), 3);
+    assert_eq!(iter.current_count(), 3);
+    assert_eq!(iter.next(), Some(&b'4'));
+    assert_eq!(iter.cursor(), 5);
+    assert_eq!(iter.current_count(), 4);
+    assert_eq!(iter.next(), Some(&b'5'));
+    assert_eq!(iter.next(), None);
+
+    let mut byte = digits.bytes::<{ FORMAT }>();
+    let mut iter = byte.integer_iter();
+    assert_eq!(iter.nth(4).unwrap(), &b'5');
+    assert_eq!(iter.as_slice(), &digits[digits.len()..]);
+    assert_eq!(iter.as_ptr(), digits[digits.len()..].as_ptr());
+}

notes-service/vendor/lexical-util/tests/not_feature_format_tests.rs

@@ -0,0 +1,53 @@
+#![cfg(not(feature = "format"))]
+
+use lexical_util::format::{self, NumberFormat, STANDARD};
+
+#[test]
+fn format_properties_test() {
+    let format = NumberFormat::<{ STANDARD }> {};
+    assert_eq!(format.flags(), STANDARD & format::FLAG_MASK);
+    assert_eq!(format.interface_flags(), STANDARD & format::INTERFACE_FLAG_MASK);
+    assert_eq!(format.digit_separator(), b'\x00');
+    assert_eq!(format.base_prefix(), b'\x00');
+    assert_eq!(format.base_suffix(), b'\x00');
+    assert_eq!(format.mantissa_radix(), 10);
+    assert_eq!(format.radix(), 10);
+    assert_eq!(format.exponent_base(), 10);
+    assert_eq!(format.exponent_radix(), 10);
+    assert_eq!(format.required_integer_digits(), false);
+    assert_eq!(format.required_fraction_digits(), false);
+    assert_eq!(format.required_exponent_digits(), true);
+    assert_eq!(format.required_mantissa_digits(), true);
+    assert_eq!(format.required_digits(), true);
+    assert_eq!(format.no_positive_mantissa_sign(), false);
+    assert_eq!(format.required_mantissa_sign(), false);
+    assert_eq!(format.no_exponent_notation(), false);
+    assert_eq!(format.no_positive_exponent_sign(), false);
+    assert_eq!(format.required_exponent_sign(), false);
+    assert_eq!(format.no_exponent_without_fraction(), false);
+    assert_eq!(format.no_special(), false);
+    assert_eq!(format.case_sensitive_special(), false);
+    assert_eq!(format.no_integer_leading_zeros(), false);
+    assert_eq!(format.no_float_leading_zeros(), false);
+    assert_eq!(format.required_exponent_notation(), false);
+    assert_eq!(format.case_sensitive_exponent(), false);
+    assert_eq!(format.case_sensitive_base_prefix(), false);
+    assert_eq!(format.case_sensitive_base_suffix(), false);
+    assert_eq!(format.integer_internal_digit_separator(), false);
+    assert_eq!(format.fraction_internal_digit_separator(), false);
+    assert_eq!(format.exponent_internal_digit_separator(), false);
+    assert_eq!(format.internal_digit_separator(), false);
+    assert_eq!(format.integer_leading_digit_separator(), false);
+    assert_eq!(format.fraction_leading_digit_separator(), false);
+    assert_eq!(format.exponent_leading_digit_separator(), false);
+    assert_eq!(format.leading_digit_separator(), false);
+    assert_eq!(format.integer_trailing_digit_separator(), false);
+    assert_eq!(format.fraction_trailing_digit_separator(), false);
+    assert_eq!(format.exponent_trailing_digit_separator(), false);
+    assert_eq!(format.trailing_digit_separator(), false);
+    assert_eq!(format.integer_consecutive_digit_separator(), false);
+    assert_eq!(format.fraction_consecutive_digit_separator(), false);
+    assert_eq!(format.exponent_consecutive_digit_separator(), false);
+    assert_eq!(format.consecutive_digit_separator(), false);
+    assert_eq!(format.special_digit_separator(), false);
+}

notes-service/vendor/lexical-util/tests/num_tests.rs

@@ -0,0 +1,254 @@
+use lexical_util::num;
+
+fn as_primitive<T: num::AsPrimitive>(t: T) {
+    let _: u8 = t.as_u8();
+    let _: u16 = t.as_u16();
+    let _: u32 = t.as_u32();
+    let _: u64 = t.as_u64();
+    let _: u128 = t.as_u128();
+    let _: usize = t.as_usize();
+    let _: i8 = t.as_i8();
+    let _: i16 = t.as_i16();
+    let _: i32 = t.as_i32();
+    let _: i64 = t.as_i64();
+    let _: i128 = t.as_i128();
+    let _: isize = t.as_isize();
+    let _: f32 = t.as_f32();
+    let _: f64 = t.as_f64();
+}
+
+#[test]
+fn as_primitive_test() {
+    as_primitive(1u8);
+    as_primitive(1u16);
+    as_primitive(1u32);
+    as_primitive(1u64);
+    as_primitive(1u128);
+    as_primitive(1usize);
+    as_primitive(1i8);
+    as_primitive(1i16);
+    as_primitive(1i32);
+    as_primitive(1i64);
+    as_primitive(1i128);
+    as_primitive(1isize);
+    as_primitive(1f32);
+    as_primitive(1f64);
+}
+
+fn as_cast<T: num::AsCast>(t: T) {
+    let _: i8 = num::as_cast(t);
+    let _: i16 = num::as_cast(t);
+    let _: i32 = num::as_cast(t);
+    let _: i64 = num::as_cast(t);
+    let _: i128 = num::as_cast(t);
+    let _: isize = num::as_cast(t);
+    let _: u8 = num::as_cast(t);
+    let _: u16 = num::as_cast(t);
+    let _: u32 = num::as_cast(t);
+    let _: u64 = num::as_cast(t);
+    let _: u128 = num::as_cast(t);
+    let _: usize = num::as_cast(t);
+    let _: f32 = num::as_cast(t);
+    let _: f64 = num::as_cast(t);
+}
+
+#[test]
+fn as_cast_test() {
+    as_cast(1u8);
+    as_cast(1u16);
+    as_cast(1u32);
+    as_cast(1u64);
+    as_cast(1u128);
+    as_cast(1usize);
+    as_cast(1i8);
+    as_cast(1i16);
+    as_cast(1i32);
+    as_cast(1i64);
+    as_cast(1i128);
+    as_cast(1isize);
+    as_cast(1f32);
+    as_cast(1f64);
+}
+
+fn check_number<T: num::Number>(x: T, mut y: T) {
+    // Copy, partialeq, partialord
+    let _ = x;
+    assert!(x < y);
+    assert!(x != y);
+
+    // Operations
+    let _ = y + x;
+    let _ = y - x;
+    let _ = y * x;
+    let _ = y / x;
+    let _ = y % x;
+    y += x;
+    y -= x;
+    y *= x;
+    y /= x;
+    y %= x;
+
+    // Conversions already tested.
+}
+
+#[test]
+fn number_test() {
+    check_number(1u8, 5);
+    check_number(1u16, 5);
+    check_number(1u32, 5);
+    check_number(1u64, 5);
+    check_number(1u128, 5);
+    check_number(1usize, 5);
+    check_number(1i8, 5);
+    check_number(1i16, 5);
+    check_number(1i32, 5);
+    check_number(1i64, 5);
+    check_number(1i128, 5);
+    check_number(1isize, 5);
+    check_number(1f32, 5.0);
+    check_number(1f64, 5.0);
+}
+
+fn check_integer<T: num::Integer>(mut x: T) {
+    // Copy, partialeq, partialord, ord, eq
+    let _ = x;
+    assert!(x > T::ONE);
+    assert!(x != T::ONE);
+    assert_eq!(x.min(T::ONE), T::ONE);
+    assert_eq!(x.max(T::ONE), x);
+
+    // Operations
+    let _ = x + T::ONE;
+    let _ = x - T::ONE;
+    let _ = x * T::ONE;
+    let _ = x / T::ONE;
+    let _ = x % T::ONE;
+    x += T::ONE;
+    x -= T::ONE;
+    x *= T::ONE;
+    x /= T::ONE;
+    x %= T::ONE;
+
+    // Bitwise operations
+    let _ = x & T::ONE;
+    let _ = x | T::ONE;
+    let _ = x ^ T::ONE;
+    x &= T::ONE;
+    x |= T::ONE;
+    x ^= T::ONE;
+
+    // Bit shifts
+    let _ = x << 1i32;
+    let _ = x >> 1i32;
+    x <<= 1i32;
+    x >>= 1i32;
+
+    // Conversions already tested.
+}
+
+#[test]
+fn integer_test() {
+    check_integer(65u8);
+    check_integer(65u16);
+    check_integer(65u32);
+    check_integer(65u64);
+    check_integer(65u128);
+    check_integer(65usize);
+    check_integer(65i8);
+    check_integer(65i16);
+    check_integer(65i32);
+    check_integer(65i64);
+    check_integer(65i128);
+    check_integer(65isize);
+}
+
+#[test]
+fn ceil_divmod_test() {
+    use lexical_util::num::Integer;
+
+    assert_eq!(5usize.ceil_divmod(7), (1, -2));
+    assert_eq!(0usize.ceil_divmod(7), (0, 0));
+    assert_eq!(35usize.ceil_divmod(7), (5, 0));
+    assert_eq!(36usize.ceil_divmod(7), (6, -6));
+}
+
+#[cfg(any(feature = "parse-floats", feature = "write-floats"))]
+fn check_float<T: num::Float>(mut x: T) {
+    // Copy, partialeq, partialord
+    let _ = x;
+    assert!(x > T::ONE);
+    assert!(x != T::ONE);
+
+    // Operations
+    let _ = x + T::ONE;
+    let _ = x - T::ONE;
+    let _ = x * T::ONE;
+    let _ = x / T::ONE;
+    let _ = x % T::ONE;
+    let _ = -x;
+    x += T::ONE;
+    x -= T::ONE;
+    x *= T::ONE;
+    x /= T::ONE;
+    x %= T::ONE;
+
+    // Check functions
+    let _ = x.to_bits();
+    assert_eq!(T::from_bits(x.to_bits()), x);
+    let _ = x.is_sign_positive();
+    let _ = x.is_sign_negative();
+    let _ = x.ln();
+    let _ = x.floor();
+
+    // Check properties
+    let _ = x.to_bits() & T::SIGN_MASK;
+    let _ = x.to_bits() & T::EXPONENT_MASK;
+    let _ = x.to_bits() & T::HIDDEN_BIT_MASK;
+    let _ = x.to_bits() & T::MANTISSA_MASK;
+    assert!(T::from_bits(T::INFINITY_BITS).is_special());
+}
+
+#[test]
+#[cfg(any(feature = "parse-floats", feature = "write-floats"))]
+fn float_test() {
+    use lexical_util::num::Float;
+
+    check_float(123f32);
+    check_float(123f64);
+
+    // b00000000000000000000000000000001
+    let f: f32 = 1e-45;
+    assert!(f.is_odd());
+    assert!(f.next().is_even());
+    assert!(f.next_positive().is_even());
+    assert!(f.prev().is_even());
+    assert!(f.prev_positive().is_even());
+    assert!(f.round_positive_even().is_even());
+    assert_eq!(f.prev().next(), f);
+    assert_eq!(f.prev_positive().next_positive(), f);
+    assert_eq!(f.round_positive_even(), f.next());
+
+    // b00111101110011001100110011001101
+    let f: f32 = 0.1;
+    assert!(f.is_odd());
+    assert!(f.next().is_even());
+    assert!(f.next_positive().is_even());
+    assert!(f.prev().is_even());
+    assert!(f.prev_positive().is_even());
+    assert!(f.round_positive_even().is_even());
+    assert_eq!(f.prev().next(), f);
+    assert_eq!(f.prev_positive().next_positive(), f);
+    assert_eq!(f.round_positive_even(), f.next());
+
+    // b01000000000000000000000000000000
+    let f: f32 = 1.0;
+    assert!(f.is_even());
+    assert!(f.next().is_odd());
+    assert!(f.next_positive().is_odd());
+    assert!(f.prev().is_odd());
+    assert!(f.prev_positive().is_odd());
+    assert!(f.round_positive_even().is_even());
+    assert_eq!(f.prev().next(), f);
+    assert_eq!(f.prev_positive().next_positive(), f);
+    assert_ne!(f.round_positive_even(), f.next());
+}

notes-service/vendor/lexical-util/tests/skip_tests.rs

@@ -0,0 +1,590 @@
+#![cfg(all(feature = "format", any(feature = "parse-floats", feature = "parse-integers")))]
+
+use core::num;
+
+use lexical_util::format::NumberFormatBuilder;
+use lexical_util::iterator::AsBytes;
+
+fn skip_iter_eq<const FORMAT: u128>(input: &[u8], output: &[u8]) {
+    // next is done in terms of peek, so we're safe here.
+    let mut input = input.bytes::<{ FORMAT }>();
+    let mut output = output.bytes::<{ FORMAT }>();
+    assert!(input.integer_iter().eq(output.integer_iter()));
+}
+
+#[test]
+fn test_skip_iter_i() {
+    // Test iterators that skip single, internal-only digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_internal_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"_45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b"_.45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b"__.45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4_");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4__");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4_.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4__.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"_455");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"__45__5");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b"_.455");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b"__.45__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"45_");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"45_.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"4__5__.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"_45_");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"__45__");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"_45_.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"__45__.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"_45_");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"__4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"_45_.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"__4__5__.56");
+}
+
+#[test]
+fn test_skip_iter_l() {
+    // Test iterators that skip single, leading-only digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_leading_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b"__.45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"4_5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4_");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4__");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4_.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4__.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"45_5");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"__45__5");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b".45_5");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b"__.45__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"4_5_");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"4_5_.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"4__5__.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"45_");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"__45__");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"45_.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"__45__.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"4_5_");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"__4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"4_5_.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"__4__5__.56");
+}
+
+#[test]
+fn test_skip_iter_t() {
+    // Test iterators that skip single, trailing-only digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_trailing_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"_45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b"__.45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"4_5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4__");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4__.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"_45_5");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"__45__5");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b".45_5");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b"__.45__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"4_5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"4_5.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"4__5__.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"_45");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"__45__");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"_45.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"__45__.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"_4_5");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"__4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"_4_5.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"__4__5__.56");
+}
+
+#[test]
+fn test_skip_iter_il() {
+    // Test iterators that skip single, internal or leading-only digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_internal_digit_separator(true)
+        .integer_leading_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b"__.45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4_");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4__");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4_.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4__.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"455");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"__45__5");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b".455");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b"__.45__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"45_");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"45_.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"4__5__.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"45_");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"__45__");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"45_.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"__45__.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"45_");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"__4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"45_.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"__4__5__.56");
+}
+
+#[test]
+fn test_skip_iter_it() {
+    // Test iterators that skip single, internal or trailing-only digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_internal_digit_separator(true)
+        .integer_trailing_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"_45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b"__.45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4__");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4__.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"_455");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"__45__5");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b".455");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b"__.45__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"45.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"4__5__.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"_45");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"__45__");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"_45.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"__45__.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"_45");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"__4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"_45.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"__4__5__.56");
+}
+
+#[test]
+fn test_skip_iter_lt() {
+    // Test iterators that skip single, leading or trailing-only digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_leading_digit_separator(true)
+        .integer_trailing_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b"__.45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"4_5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4__");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4__.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"45_5");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"__45__5");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b".45_5");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b"__.45__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"4_5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"4_5.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"4__5__.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"__45__");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"45.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"__45__.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"4_5");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"__4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"4_5.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"__4__5__.56");
+}
+
+#[test]
+fn test_skip_iter_ilt() {
+    // Test iterators that skip single digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_internal_digit_separator(true)
+        .integer_leading_digit_separator(true)
+        .integer_trailing_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b"__.45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4__");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4__.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"455");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"__45__5");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b".455");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b"__.45__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"45.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"4__5__.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"__45__");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"45.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"__45__.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"__4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"45.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"__4__5__.56");
+}
+
+#[test]
+fn test_skip_iter_ic() {
+    // Test iterators that skip multiple, internal digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_internal_digit_separator(true)
+        .integer_consecutive_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"_45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b"_.45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b"__.45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4_");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4__");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4_.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4__.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"_455");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"__455");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b"_.455");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b"__.455");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"45_");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"45__");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"45_.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"45__.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"_45_");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"__45__");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"_45_.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"__45__.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"_45_");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"__45__");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"_45_.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"__45__.56");
+}
+
+#[test]
+fn test_skip_iter_lc() {
+    // Test iterators that skip multiple, leading digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_leading_digit_separator(true)
+        .integer_consecutive_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"4_5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4_");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4__");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4_.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4__.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"45_5");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"45__5");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b".45_5");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b".45__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"4_5_");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"4_5_.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"4__5__.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"45_");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"45__");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"45_.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"45__.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"4_5_");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"4__5__");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"4_5_.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"4__5__.56");
+}
+
+#[test]
+fn test_skip_iter_tc() {
+    // Test iterators that skip multiple, trailing digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_trailing_digit_separator(true)
+        .integer_consecutive_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"_45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"4_5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"_45_5");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"__45__5");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b".45_5");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b".45__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"4_5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"4_5.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"4__5.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"_45");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"_45.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"__45.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"_4_5");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"__4__5");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"_4_5.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"__4__5.56");
+}
+
+#[test]
+fn test_skip_iter_ilc() {
+    // Test iterators that skip multiple, internal or leading digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_internal_digit_separator(true)
+        .integer_leading_digit_separator(true)
+        .integer_consecutive_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4_");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4__");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4_.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4__.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"455");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"455");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b".455");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b".455");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"45_");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"45__");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"45_.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"45__.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"45_");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"45__");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"45_.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"45__.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"45_");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"45__");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"45_.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"45__.56");
+}
+
+#[test]
+fn test_skip_iter_itc() {
+    // Test iterators that skip multiple, internal or trailing digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_internal_digit_separator(true)
+        .integer_trailing_digit_separator(true)
+        .integer_consecutive_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"_45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"_455");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"__455");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b".455");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b".455");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"45.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"45.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"_45");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"_45.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"__45.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"_45");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"__45");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"_45.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"__45.56");
+}
+
+#[test]
+fn test_skip_iter_ltc() {
+    // Test iterators that skip multiple, leading or trailing digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_leading_digit_separator(true)
+        .integer_trailing_digit_separator(true)
+        .integer_consecutive_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"4_5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"45_5");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"45__5");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b".45_5");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b".45__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"4_5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"4_5.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"4__5.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"45.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"45.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"4_5");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"4__5");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"4_5.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"4__5.56");
+}
+
+#[test]
+fn test_skip_iter_iltc() {
+    // Test iterators that skip multiple digit separators.
+    pub const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .integer_internal_digit_separator(true)
+        .integer_leading_digit_separator(true)
+        .integer_trailing_digit_separator(true)
+        .integer_consecutive_digit_separator(true)
+        .build_strict();
+
+    skip_iter_eq::<{ FORMAT }>(b"123.45", b"123.45");
+    skip_iter_eq::<{ FORMAT }>(b"1e45", b"1e45");
+    skip_iter_eq::<{ FORMAT }>(b"1e", b"1e");
+    skip_iter_eq::<{ FORMAT }>(b"1", b"1");
+    skip_iter_eq::<{ FORMAT }>(b"_45", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__45", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"_.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"__.45", b".45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4__5", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4_", b"4");
+    skip_iter_eq::<{ FORMAT }>(b"4__", b"4");
+    skip_iter_eq::<{ FORMAT }>(b"4_.", b"4.");
+    skip_iter_eq::<{ FORMAT }>(b"4__.", b"4.");
+    skip_iter_eq::<{ FORMAT }>(b"_45_5", b"455");
+    skip_iter_eq::<{ FORMAT }>(b"__45__5", b"455");
+    skip_iter_eq::<{ FORMAT }>(b"_.45_5", b".455");
+    skip_iter_eq::<{ FORMAT }>(b"__.45__5", b".455");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"4_5_.5", b"45.5");
+    skip_iter_eq::<{ FORMAT }>(b"4__5__.5", b"45.5");
+    skip_iter_eq::<{ FORMAT }>(b"_45_", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__45__", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"_45_.56", b"45.56");
+    skip_iter_eq::<{ FORMAT }>(b"__45__.56", b"45.56");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__", b"45");
+    skip_iter_eq::<{ FORMAT }>(b"_4_5_.56", b"45.56");
+    skip_iter_eq::<{ FORMAT }>(b"__4__5__.56", b"45.56");
+}