Vendor dependencies

notes-service/vendor/lexical-parse-integer/tests/algorithm_tests.rs

@@ -0,0 +1,178 @@
+#![cfg(not(feature = "compact"))]
+
+mod util;
+
+use lexical_parse_integer::algorithm;
+use lexical_parse_integer::options::SMALL_NUMBERS;
+use lexical_util::format::STANDARD;
+use lexical_util::iterator::AsBytes;
+#[cfg(feature = "power-of-two")]
+use util::from_radix;
+
+#[test]
+fn test_is_4digits() {
+    let value: u32 = 0x31_32_33_34;
+    #[cfg(feature = "power-of-two")]
+    assert!(!algorithm::is_4digits::<{ from_radix(4) }>(value));
+    #[cfg(feature = "radix")]
+    assert!(algorithm::is_4digits::<{ from_radix(5) }>(value));
+    assert!(algorithm::is_4digits::<{ STANDARD }>(value));
+
+    let value: u32 = 0x29_30_39_38;
+    assert!(!algorithm::is_4digits::<{ STANDARD }>(value));
+
+    let value: u32 = 0x31_32_33_40;
+    assert!(!algorithm::is_4digits::<{ STANDARD }>(value));
+
+    let value: u32 = 0x31_32_33_39;
+    #[cfg(feature = "radix")]
+    assert!(!algorithm::is_4digits::<{ from_radix(9) }>(value));
+    assert!(algorithm::is_4digits::<{ STANDARD }>(value));
+}
+
+#[test]
+fn test_parse_4digits() {
+    assert_eq!(algorithm::parse_4digits::<{ STANDARD }>(0x31_32_33_34), 4321);
+    #[cfg(feature = "radix")]
+    assert_eq!(algorithm::parse_4digits::<{ from_radix(5) }>(0x31_32_33_34), 586);
+    assert_eq!(algorithm::parse_4digits::<{ STANDARD }>(0x36_37_38_39), 9876);
+}
+
+#[test]
+fn test_try_parse_4digits() {
+    let parse = |bytes: &[u8]| {
+        let mut digits = bytes.bytes::<{ STANDARD }>();
+        algorithm::try_parse_4digits::<u32, _, STANDARD>(&mut digits.integer_iter())
+    };
+    assert_eq!(parse(b"1234"), Some(1234));
+    assert_eq!(parse(b"123"), None);
+    assert_eq!(parse(b"123\x00"), None);
+    assert_eq!(parse(b"123."), None);
+    assert_eq!(parse(b"123_"), None);
+    assert_eq!(parse(b"1234_"), Some(1234));
+}
+
+#[test]
+fn test_is_8digits() {
+    let value: u64 = 0x31_32_33_34_35_36_37_38;
+    #[cfg(feature = "power-of-two")]
+    assert!(!algorithm::is_8digits::<{ from_radix(4) }>(value));
+    #[cfg(feature = "radix")]
+    assert!(!algorithm::is_8digits::<{ from_radix(5) }>(value));
+    assert!(algorithm::is_8digits::<{ STANDARD }>(value));
+
+    let value: u64 = 0x29_30_31_32_33_34_35_36;
+    assert!(!algorithm::is_8digits::<{ STANDARD }>(value));
+
+    let value: u64 = 0x30_31_32_33_34_35_36_40;
+    assert!(!algorithm::is_8digits::<{ STANDARD }>(value));
+
+    let value: u64 = 0x31_32_33_34_35_36_37_39;
+    #[cfg(feature = "radix")]
+    assert!(!algorithm::is_8digits::<{ from_radix(9) }>(value));
+    assert!(algorithm::is_8digits::<{ STANDARD }>(value));
+}
+
+#[test]
+fn test_parse_8digits() {
+    // 10000000
+    let value: u64 = 0x30_30_30_30_30_30_30_31;
+    assert_eq!(algorithm::parse_8digits::<{ STANDARD }>(value), 10000000);
+    #[cfg(feature = "radix")]
+    assert_eq!(algorithm::parse_8digits::<{ from_radix(5) }>(value), 78125);
+
+    // 00000010
+    let value: u64 = 0x30_31_30_30_30_30_30_30;
+    assert_eq!(algorithm::parse_8digits::<{ STANDARD }>(value), 10);
+    #[cfg(feature = "radix")]
+    assert_eq!(algorithm::parse_8digits::<{ from_radix(5) }>(value), 5);
+
+    // 12344321
+    let value: u64 = 0x31_32_33_34_34_33_32_31;
+    assert_eq!(algorithm::parse_8digits::<{ STANDARD }>(value), 12344321);
+    #[cfg(feature = "power-of-two")]
+    assert_eq!(algorithm::parse_8digits::<{ from_radix(8) }>(value), 2738385);
+
+    #[cfg(feature = "radix")]
+    {
+        assert_eq!(algorithm::parse_8digits::<{ from_radix(9) }>(value), 6052420);
+        assert_eq!(algorithm::parse_8digits::<{ from_radix(7) }>(value), 1120400);
+        assert_eq!(algorithm::parse_8digits::<{ from_radix(6) }>(value), 402745);
+        assert_eq!(algorithm::parse_8digits::<{ from_radix(5) }>(value), 121836);
+    }
+}
+
+#[test]
+fn test_try_parse_8digits() {
+    let parse = |bytes: &[u8]| {
+        let mut digits = bytes.bytes::<{ STANDARD }>();
+        algorithm::try_parse_8digits::<u64, _, STANDARD>(&mut digits.integer_iter())
+    };
+
+    assert_eq!(parse(b"12345678"), Some(12345678));
+    assert_eq!(parse(b"1234567"), None);
+    assert_eq!(parse(b"1234567\x00"), None);
+    assert_eq!(parse(b"1234567."), None);
+    assert_eq!(parse(b"1234567_"), None);
+    assert_eq!(parse(b"12345678"), Some(12345678));
+}
+
+#[cfg(feature = "power-of-two")]
+macro_rules! parse_radix {
+    ($i:literal) => {
+        |bytes: &[u8]| {
+            algorithm::algorithm_partial::<u32, { from_radix($i) }>(bytes, &SMALL_NUMBERS)
+        }
+    };
+}
+
+#[test]
+fn algorithm_test() {
+    let parse_u32 =
+        |bytes: &[u8]| algorithm::algorithm_partial::<u32, STANDARD>(bytes, &SMALL_NUMBERS);
+    let parse_i32 =
+        |bytes: &[u8]| algorithm::algorithm_partial::<i32, STANDARD>(bytes, &SMALL_NUMBERS);
+
+    assert_eq!(parse_u32(b"12345"), Ok((12345, 5)));
+    assert_eq!(parse_u32(b"+12345"), Ok((12345, 6)));
+    assert_eq!(parse_u32(b"-12345"), Ok((0, 0)));
+    assert_eq!(parse_i32(b"12345"), Ok((12345, 5)));
+    assert_eq!(parse_i32(b"-12345"), Ok((-12345, 6)));
+    assert_eq!(parse_i32(b"+12345"), Ok((12345, 6)));
+    assert_eq!(parse_i32(b"+123.45"), Ok((123, 4)));
+
+    // Need to try with other radixes here, especially to ensure no regressions with
+    // #71. Issue: https://github.com/Alexhuszagh/rust-lexical/issues/71
+    #[cfg(feature = "power-of-two")]
+    {
+        // This should try to invoke `parse_4digits` since it's more than
+        // 4 digits, and unsigned.
+        assert_eq!(parse_radix!(4)(b"12345"), Ok((27, 3)));
+        assert_eq!(parse_radix!(8)(b"12345"), Ok((5349, 5)));
+        assert_eq!(parse_radix!(16)(b"12345"), Ok((74565, 5)));
+        assert_eq!(parse_radix!(32)(b"12345"), Ok((1117317, 5)));
+    }
+
+    #[cfg(feature = "radix")]
+    {
+        assert_eq!(parse_radix!(6)(b"12345"), Ok((1865, 5)));
+        assert_eq!(parse_radix!(12)(b"12345"), Ok((24677, 5)));
+        assert_eq!(parse_radix!(24)(b"12345"), Ok((361253, 5)));
+    }
+}
+
+#[test]
+fn algorithm_128_test() {
+    let parse_u128 =
+        |bytes: &[u8]| algorithm::algorithm_partial::<u128, STANDARD>(bytes, &SMALL_NUMBERS);
+    let parse_i128 =
+        |bytes: &[u8]| algorithm::algorithm_partial::<i128, STANDARD>(bytes, &SMALL_NUMBERS);
+
+    assert_eq!(parse_u128(b"12345"), Ok((12345, 5)));
+    assert_eq!(parse_u128(b"+12345"), Ok((12345, 6)));
+    assert_eq!(parse_u128(b"-12345"), Ok((0, 0)));
+    assert_eq!(parse_i128(b"12345"), Ok((12345, 5)));
+    assert_eq!(parse_i128(b"-12345"), Ok((-12345, 6)));
+    assert_eq!(parse_i128(b"+12345"), Ok((12345, 6)));
+    assert_eq!(parse_i128(b"+123.45"), Ok((123, 4)));
+}

notes-service/vendor/lexical-parse-integer/tests/api_tests.rs

@@ -0,0 +1,359 @@
+mod util;
+
+use lexical_parse_integer::{FromLexical, FromLexicalWithOptions, Options};
+use lexical_util::error::Error;
+#[cfg(feature = "format")]
+use lexical_util::format::NumberFormatBuilder;
+use lexical_util::format::STANDARD;
+#[cfg(feature = "power-of-two")]
+use util::from_radix;
+
+#[test]
+fn u8_decimal_test() {
+    assert_eq!(Ok(0), u8::from_lexical(b"0"));
+    assert_eq!(Ok(127), u8::from_lexical(b"127"));
+    assert_eq!(Ok(128), u8::from_lexical(b"128"));
+    assert_eq!(Ok(255), u8::from_lexical(b"255"));
+    assert_eq!(Err(Error::InvalidDigit(0)), u8::from_lexical(b"-1"));
+    assert_eq!(Err(Error::InvalidDigit(1)), u8::from_lexical(b"1a"));
+}
+
+#[test]
+fn i8_decimal_test() {
+    assert_eq!(Ok(0), i8::from_lexical(b"0"));
+    assert_eq!(Ok(127), i8::from_lexical(b"127"));
+    assert_eq!(Err(Error::Overflow(2)), i8::from_lexical(b"128"));
+    assert_eq!(Err(Error::Overflow(2)), i8::from_lexical(b"255"));
+    assert_eq!(Ok(-1), i8::from_lexical(b"-1"));
+    assert_eq!(Err(Error::InvalidDigit(1)), i8::from_lexical(b"1a"));
+
+    assert_eq!(Ok((1, 1)), i8::from_lexical_partial(b"1"));
+    assert_eq!(Ok((1, 1)), i8::from_lexical_partial(b"1a"));
+    assert_eq!(Ok((-1, 2)), i8::from_lexical_partial(b"-1"));
+    assert_eq!(Ok((-1, 2)), i8::from_lexical_partial(b"-1a"));
+}
+
+#[test]
+fn u16_decimal_test() {
+    assert_eq!(Ok(0), u16::from_lexical(b"0"));
+    assert_eq!(Ok(32767), u16::from_lexical(b"32767"));
+    assert_eq!(Ok(32768), u16::from_lexical(b"32768"));
+    assert_eq!(Ok(65535), u16::from_lexical(b"65535"));
+    assert_eq!(Err(Error::InvalidDigit(0)), u16::from_lexical(b"-1"));
+    assert_eq!(Err(Error::InvalidDigit(1)), u16::from_lexical(b"1a"));
+}
+
+#[test]
+fn i16_decimal_test() {
+    assert_eq!(Ok(0), i16::from_lexical(b"0"));
+    assert_eq!(Ok(32767), i16::from_lexical(b"32767"));
+    assert_eq!(Err(Error::Overflow(4)), i16::from_lexical(b"32768"));
+    assert_eq!(Err(Error::Overflow(4)), i16::from_lexical(b"65535"));
+    assert_eq!(Ok(-1), i16::from_lexical(b"-1"));
+    assert_eq!(Err(Error::InvalidDigit(1)), i16::from_lexical(b"1a"));
+}
+
+#[test]
+fn u32_decimal_test() {
+    assert_eq!(Ok(0), u32::from_lexical(b"0"));
+    assert_eq!(Ok(2147483647), u32::from_lexical(b"2147483647"));
+    assert_eq!(Ok(2147483648), u32::from_lexical(b"2147483648"));
+    assert_eq!(Ok(4294967295), u32::from_lexical(b"4294967295"));
+    assert_eq!(Err(Error::InvalidDigit(0)), u32::from_lexical(b"-1"));
+    assert_eq!(Err(Error::InvalidDigit(1)), u32::from_lexical(b"1a"));
+}
+
+#[test]
+fn i32_decimal_test() {
+    assert_eq!(Ok(0), i32::from_lexical(b"0"));
+    assert_eq!(Ok(2147483647), i32::from_lexical(b"2147483647"));
+    assert_eq!(Err(Error::Overflow(9)), i32::from_lexical(b"2147483648"));
+    assert_eq!(Err(Error::Overflow(9)), i32::from_lexical(b"4294967295"));
+    assert_eq!(Ok(-1), i32::from_lexical(b"-1"));
+    assert_eq!(Err(Error::InvalidDigit(1)), i32::from_lexical(b"1a"));
+}
+
+#[test]
+fn u64_decimal_test() {
+    assert_eq!(Ok(0), u64::from_lexical(b"0"));
+    assert_eq!(Ok(9223372036854775807), u64::from_lexical(b"9223372036854775807"));
+    assert_eq!(Ok(9223372036854775808), u64::from_lexical(b"9223372036854775808"));
+    assert_eq!(Ok(18446744073709551615), u64::from_lexical(b"18446744073709551615"));
+    assert_eq!(Err(Error::InvalidDigit(0)), u64::from_lexical(b"-1"));
+    assert_eq!(Err(Error::InvalidDigit(1)), u64::from_lexical(b"1a"));
+}
+
+#[test]
+fn i64_decimal_test() {
+    assert_eq!(Ok(0), i64::from_lexical(b"0"));
+    assert_eq!(Ok(9223372036854775807), i64::from_lexical(b"9223372036854775807"));
+    assert_eq!(Err(Error::Overflow(18)), i64::from_lexical(b"9223372036854775808"));
+    assert_eq!(Err(Error::Overflow(19)), i64::from_lexical(b"18446744073709551615"));
+    assert_eq!(Ok(-1), i64::from_lexical(b"-1"));
+    assert_eq!(Err(Error::InvalidDigit(1)), i64::from_lexical(b"1a"));
+
+    // Add tests discovered via fuzzing. This won't necessarily be the
+    // proper index, since we use multi-digit parsing.
+    assert!(i64::from_lexical(b"406260572150672006000066000000060060007667760000000000000000000+00000006766767766666767665670000000000000000000000666").err().unwrap().is_overflow());
+    assert!(i64::from_lexical(b"406260572150672006000066000000060060007667760000000000000000000")
+        .err()
+        .unwrap()
+        .is_overflow());
+}
+
+#[test]
+fn u128_decimal_test() {
+    assert_eq!(Ok(0), u128::from_lexical(b"0"));
+    assert_eq!(
+        Ok(170141183460469231731687303715884105727),
+        u128::from_lexical(b"170141183460469231731687303715884105727")
+    );
+    assert_eq!(
+        Ok(170141183460469231731687303715884105728),
+        u128::from_lexical(b"170141183460469231731687303715884105728")
+    );
+    assert_eq!(
+        Ok(340282366920938463463374607431768211455),
+        u128::from_lexical(b"340282366920938463463374607431768211455")
+    );
+    assert_eq!(Err(Error::InvalidDigit(0)), u128::from_lexical(b"-1"));
+    assert_eq!(Err(Error::InvalidDigit(1)), u128::from_lexical(b"1a"));
+}
+
+#[test]
+fn i128_decimal_test() {
+    assert_eq!(Ok(0), i128::from_lexical(b"0"));
+    assert_eq!(
+        Ok(170141183460469231731687303715884105727),
+        i128::from_lexical(b"170141183460469231731687303715884105727")
+    );
+    assert_eq!(
+        Err(Error::Overflow(38)),
+        i128::from_lexical(b"170141183460469231731687303715884105728")
+    );
+    assert_eq!(
+        Err(Error::Overflow(38)),
+        i128::from_lexical(b"340282366920938463463374607431768211455")
+    );
+    assert_eq!(Ok(-1), i128::from_lexical(b"-1"));
+    assert_eq!(Err(Error::InvalidDigit(1)), i128::from_lexical(b"1a"));
+}
+
+#[test]
+fn double_sign_test() {
+    assert_eq!(Err(Error::InvalidDigit(1)), i16::from_lexical(b"+-0000"));
+    assert_eq!(Err(Error::InvalidDigit(1)), i128::from_lexical(b"+-0000"));
+}
+
+#[test]
+fn options_test() {
+    const OPTIONS: Options = Options::new();
+    assert_eq!(Ok(0), i128::from_lexical_with_options::<STANDARD>(b"0", &OPTIONS));
+}
+
+#[test]
+#[cfg(feature = "power-of-two")]
+fn i32_binary_test() {
+    const OPTIONS: Options = Options::new();
+    const FORMAT: u128 = from_radix(2);
+    assert_eq!(i32::from_lexical_with_options::<FORMAT>(b"11", &OPTIONS), Ok(3));
+    assert_eq!(i32::from_lexical_with_options::<FORMAT>(b"-11", &OPTIONS), Ok(-3));
+}
+
+#[cfg(feature = "radix")]
+fn radix_to_u32<const FORMAT: u128>(bytes: &[u8], expected: u32) {
+    const OPTIONS: Options = Options::new();
+    let result = u32::from_lexical_with_options::<{ FORMAT }>(bytes, &OPTIONS);
+    assert_eq!(result, Ok(expected));
+}
+
+#[test]
+#[cfg(feature = "radix")]
+fn radix_test() {
+    radix_to_u32::<{ from_radix(2) }>(b"100101", 37);
+    radix_to_u32::<{ from_radix(3) }>(b"1101", 37);
+    radix_to_u32::<{ from_radix(4) }>(b"211", 37);
+    radix_to_u32::<{ from_radix(5) }>(b"122", 37);
+    radix_to_u32::<{ from_radix(6) }>(b"101", 37);
+    radix_to_u32::<{ from_radix(7) }>(b"52", 37);
+    radix_to_u32::<{ from_radix(8) }>(b"45", 37);
+    radix_to_u32::<{ from_radix(9) }>(b"41", 37);
+    radix_to_u32::<{ from_radix(10) }>(b"37", 37);
+    radix_to_u32::<{ from_radix(11) }>(b"34", 37);
+    radix_to_u32::<{ from_radix(12) }>(b"31", 37);
+    radix_to_u32::<{ from_radix(13) }>(b"2B", 37);
+    radix_to_u32::<{ from_radix(14) }>(b"29", 37);
+    radix_to_u32::<{ from_radix(15) }>(b"27", 37);
+    radix_to_u32::<{ from_radix(16) }>(b"25", 37);
+    radix_to_u32::<{ from_radix(17) }>(b"23", 37);
+    radix_to_u32::<{ from_radix(18) }>(b"21", 37);
+    radix_to_u32::<{ from_radix(19) }>(b"1I", 37);
+    radix_to_u32::<{ from_radix(20) }>(b"1H", 37);
+    radix_to_u32::<{ from_radix(21) }>(b"1G", 37);
+    radix_to_u32::<{ from_radix(22) }>(b"1F", 37);
+    radix_to_u32::<{ from_radix(23) }>(b"1E", 37);
+    radix_to_u32::<{ from_radix(24) }>(b"1D", 37);
+    radix_to_u32::<{ from_radix(25) }>(b"1C", 37);
+    radix_to_u32::<{ from_radix(26) }>(b"1B", 37);
+    radix_to_u32::<{ from_radix(27) }>(b"1A", 37);
+    radix_to_u32::<{ from_radix(28) }>(b"19", 37);
+    radix_to_u32::<{ from_radix(29) }>(b"18", 37);
+    radix_to_u32::<{ from_radix(30) }>(b"17", 37);
+    radix_to_u32::<{ from_radix(31) }>(b"16", 37);
+    radix_to_u32::<{ from_radix(32) }>(b"15", 37);
+    radix_to_u32::<{ from_radix(33) }>(b"14", 37);
+    radix_to_u32::<{ from_radix(34) }>(b"13", 37);
+    radix_to_u32::<{ from_radix(35) }>(b"12", 37);
+    radix_to_u32::<{ from_radix(36) }>(b"11", 37);
+}
+
+#[test]
+#[cfg(feature = "format")]
+fn i32_no_leading_zeros_test() {
+    const OPTIONS: Options = Options::new();
+    const FORMAT: u128 = NumberFormatBuilder::new().no_integer_leading_zeros(true).build_strict();
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"1", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"0", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"01", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"10", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"010", &OPTIONS).is_err());
+}
+
+#[test]
+#[cfg(feature = "format")]
+fn i32_integer_internal_digit_separator_test() {
+    const OPTIONS: Options = Options::new();
+    const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(std::num::NonZeroU8::new(b'_'))
+        .integer_internal_digit_separator(true)
+        .build_strict();
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"3_1", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"_31", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"31_", &OPTIONS).is_err());
+}
+
+#[test]
+#[cfg(feature = "format")]
+fn i32_integer_leading_digit_separator_test() {
+    const OPTIONS: Options = Options::new();
+    const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(std::num::NonZeroU8::new(b'_'))
+        .integer_leading_digit_separator(true)
+        .build_strict();
+
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"3_1", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"_31", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"31_", &OPTIONS).is_err());
+}
+
+#[test]
+#[cfg(feature = "format")]
+fn i32_integer_trailing_digit_separator_test() {
+    const OPTIONS: Options = Options::new();
+    const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(std::num::NonZeroU8::new(b'_'))
+        .integer_trailing_digit_separator(true)
+        .build_strict();
+
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"3_1", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"_31", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"31_", &OPTIONS).is_ok());
+}
+
+#[test]
+#[cfg(feature = "format")]
+fn i32_integer_consecutive_digit_separator_test() {
+    const OPTIONS: Options = Options::new();
+    const FORMAT: u128 = NumberFormatBuilder::new()
+        .digit_separator(std::num::NonZeroU8::new(b'_'))
+        .integer_internal_digit_separator(true)
+        .integer_consecutive_digit_separator(true)
+        .build_strict();
+
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"3_1", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"3__1", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"_31", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"31_", &OPTIONS).is_err());
+}
+
+#[test]
+#[cfg(feature = "format")]
+fn i32_json_no_leading_zero() {
+    const OPTIONS: Options = Options::new();
+    use lexical_util::format::JSON;
+
+    assert!(i32::from_lexical_with_options::<{ JSON }>(b"12", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<{ JSON }>(b"-12", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<{ JSON }>(b"012", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<{ JSON }>(b"-012", &OPTIONS).is_err());
+}
+
+#[test]
+#[cfg(all(feature = "power-of-two", feature = "format"))]
+fn base_prefix_test() {
+    use core::num;
+
+    const FORMAT: u128 =
+        NumberFormatBuilder::new().base_prefix(num::NonZeroU8::new(b'x')).build_strict();
+    const OPTIONS: Options = Options::new();
+
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"0x", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"-0x", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"-0x1", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"0x12", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"12", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"-0x12", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"0x-12", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"012", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"-0x012", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"-0x012h", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"-0x012h ", &OPTIONS).is_err());
+
+    assert!(i32::from_lexical_partial_with_options::<FORMAT>(b"-0x012h", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_partial_with_options::<FORMAT>(b"-0x012h ", &OPTIONS).is_ok());
+}
+
+#[test]
+#[cfg(all(feature = "power-of-two", feature = "format"))]
+fn base_suffix_test() {
+    use core::num;
+
+    const FORMAT: u128 =
+        NumberFormatBuilder::new().base_suffix(num::NonZeroU8::new(b'h')).build_strict();
+    const OPTIONS: Options = Options::new();
+
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"h", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"-h", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"-1h", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"12h", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"12", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"-12h", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"0x-12", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"0x12", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"012h", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"-012", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"-0x012h", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"-0x012h ", &OPTIONS).is_err());
+
+    assert!(i32::from_lexical_partial_with_options::<FORMAT>(b"-0x012h", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_partial_with_options::<FORMAT>(b"-0x012h ", &OPTIONS).is_ok());
+}
+
+#[test]
+#[cfg(all(feature = "power-of-two", feature = "format"))]
+fn base_prefix_and_suffix_test() {
+    use core::num;
+
+    const FORMAT: u128 = NumberFormatBuilder::new()
+        .base_prefix(num::NonZeroU8::new(b'x'))
+        .base_suffix(num::NonZeroU8::new(b'h'))
+        .build_strict();
+    const OPTIONS: Options = Options::new();
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"+3h", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"+0x3", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"+0x3h", &OPTIONS).is_ok());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"+0x3h ", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"+0xh", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"+h", &OPTIONS).is_err());
+    assert!(i32::from_lexical_with_options::<FORMAT>(b"+0x", &OPTIONS).is_err());
+}

notes-service/vendor/lexical-parse-integer/tests/issue_91_tests.rs

@@ -0,0 +1,27 @@
+use lexical_parse_integer::FromLexical;
+
+#[test]
+fn issue_91_test() {
+    // Derived from:
+    //  https://github.com/Alexhuszagh/rust-lexical/issues/91
+    assert!(u8::from_lexical(b"354").is_err());
+    assert!(u8::from_lexical(b"355").is_err());
+    assert!(u8::from_lexical(b"356").is_err());
+    assert!(u8::from_lexical(b"357").is_err());
+    assert!(u8::from_lexical(b"358").is_err());
+    assert!(u8::from_lexical(b"510").is_err());
+    assert!(u8::from_lexical(b"511").is_err());
+    assert!(u8::from_lexical(b"512").is_err());
+    assert!(u8::from_lexical(b"513").is_err());
+    assert!(u8::from_lexical(b"514").is_err());
+    assert!(u8::from_lexical(b"612").is_err());
+    assert!(u8::from_lexical(b"999").is_err());
+    assert!(u8::from_lexical(b"1000").is_err());
+
+    let n = u32::MAX as u64 + 1_000_000_000;
+    assert!(u32::from_lexical((n - 1).to_string().as_bytes()).is_err());
+    assert!(u32::from_lexical(n.to_string().as_bytes()).is_err());
+    assert!(u32::from_lexical((n + 1).to_string().as_bytes()).is_err());
+
+    assert!(u8::from_lexical(b"357").is_err());
+}

notes-service/vendor/lexical-parse-integer/tests/issue_96_tests.rs

@@ -0,0 +1,371 @@
+#![cfg(feature = "format")]
+
+use core::num;
+
+use lexical_parse_integer::{
+    Error,
+    FromLexical,
+    FromLexicalWithOptions,
+    NumberFormatBuilder,
+    Options,
+};
+
+#[test]
+fn issue_96_test() {
+    const OPTS: Options = Options::new();
+    const NO_CONSECUTIVE: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .leading_digit_separator(true)
+        .internal_digit_separator(true)
+        .trailing_digit_separator(true)
+        .consecutive_digit_separator(false)
+        .build_strict();
+    const CONSECUTIVE: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .leading_digit_separator(true)
+        .internal_digit_separator(true)
+        .trailing_digit_separator(true)
+        .consecutive_digit_separator(true)
+        .build_strict();
+    const NO_LEADING: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .leading_digit_separator(false)
+        .internal_digit_separator(true)
+        .trailing_digit_separator(true)
+        .consecutive_digit_separator(true)
+        .build_strict();
+
+    let result = i64::from_lexical(b"_-1234");
+    assert_eq!(result, Err(Error::InvalidDigit(0)));
+
+    // NOTE: We need to make sure we're not skipping digit separators before the
+    // sign, which is never allowed.
+    let result = u64::from_lexical_with_options::<NO_CONSECUTIVE>(b"_-1234", &OPTS);
+    assert_eq!(result, Err(Error::InvalidDigit(1)));
+
+    let result = i64::from_lexical_with_options::<NO_CONSECUTIVE>(b"_-1234", &OPTS);
+    assert_eq!(result, Err(Error::InvalidDigit(1)));
+
+    let result = i64::from_lexical_with_options::<NO_LEADING>(b"^-1234", &OPTS);
+    assert_eq!(result, Err(Error::InvalidDigit(0)));
+
+    // NOTE: This uis correct, since it's "trailing"
+    let result = i64::from_lexical_with_options::<NO_LEADING>(b"_-1234", &OPTS);
+    assert_eq!(result, Err(Error::InvalidDigit(1)));
+
+    let result = i64::from_lexical_with_options::<NO_LEADING>(b"_1234", &OPTS);
+    assert_eq!(result, Err(Error::InvalidDigit(0)));
+
+    let result = i64::from_lexical_with_options::<NO_LEADING>(b"X1234", &OPTS);
+    assert_eq!(result, Err(Error::InvalidDigit(0)));
+
+    let result = i64::from_lexical_with_options::<NO_CONSECUTIVE>(b"__1__234__", &OPTS);
+    assert_eq!(result, Err(Error::InvalidDigit(0)));
+
+    let result = i64::from_lexical_with_options::<CONSECUTIVE>(b"__1__234__", &OPTS);
+    assert_eq!(result, Ok(1234));
+}
+
+#[test]
+fn issue_96_i_test() {
+    const OPTS: Options = Options::new();
+    const FMT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .internal_digit_separator(true)
+        .consecutive_digit_separator(false)
+        .required_digits(true)
+        .build_strict();
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"", &OPTS);
+    assert_eq!(result, Err(Error::Empty(0)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(0)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_1_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(0)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_1_23", &OPTS);
+    assert_eq!(result, Err(Error::Empty(0)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_1_23", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1__1_23", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1", &OPTS);
+    assert_eq!(result, Ok((11, 3)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1_23", &OPTS);
+    assert_eq!(result, Ok((1123, 6)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1__23", &OPTS);
+    assert_eq!(result, Ok((11, 3)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1_23_", &OPTS);
+    assert_eq!(result, Ok((1123, 6)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1_23.", &OPTS);
+    assert_eq!(result, Ok((1123, 6)));
+}
+
+#[test]
+fn issue_96_l_test() {
+    const OPTS: Options = Options::new();
+    const FMT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .leading_digit_separator(true)
+        .consecutive_digit_separator(false)
+        .build_strict();
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"", &OPTS);
+    assert_eq!(result, Err(Error::Empty(0)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(2)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_1_23", &OPTS);
+    assert_eq!(result, Ok((1, 2)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_1_23", &OPTS);
+    assert_eq!(result, Ok((1, 3)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1__1_23", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_+1_23", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+}
+
+#[test]
+fn issue_96_t_test() {
+    const OPTS: Options = Options::new();
+    const FMT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .trailing_digit_separator(true)
+        .consecutive_digit_separator(false)
+        .build_strict();
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"", &OPTS);
+    assert_eq!(result, Err(Error::Empty(0)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(2)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_1_23", &OPTS);
+    assert_eq!(result, Err(Error::Empty(0)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_1_23", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1__1_23", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_+1_23", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+123_", &OPTS);
+    assert_eq!(result, Ok((123, 5)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+123__", &OPTS);
+    assert_eq!(result, Ok((123, 4)));
+}
+
+#[test]
+fn issue_96_il_test() {
+    const OPTS: Options = Options::new();
+    const FMT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .internal_digit_separator(true)
+        .leading_digit_separator(true)
+        .consecutive_digit_separator(false)
+        .build_strict();
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"", &OPTS);
+    assert_eq!(result, Err(Error::Empty(0)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(2)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_1_23", &OPTS);
+    assert_eq!(result, Ok((123, 5)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_1_23", &OPTS);
+    assert_eq!(result, Ok((123, 6)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1__1_23", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1", &OPTS);
+    assert_eq!(result, Ok((11, 3)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1_", &OPTS);
+    assert_eq!(result, Ok((11, 3)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_+1_23", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+123_", &OPTS);
+    assert_eq!(result, Ok((123, 4)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+123__", &OPTS);
+    assert_eq!(result, Ok((123, 4)));
+}
+
+#[test]
+fn issue_96_it_test() {
+    const OPTS: Options = Options::new();
+    const FMT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .internal_digit_separator(true)
+        .trailing_digit_separator(true)
+        .consecutive_digit_separator(false)
+        .build_strict();
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"", &OPTS);
+    assert_eq!(result, Err(Error::Empty(0)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(2)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_1_23", &OPTS);
+    assert_eq!(result, Err(Error::Empty(0)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_1_23", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1__1_23", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1", &OPTS);
+    assert_eq!(result, Ok((11, 3)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1_", &OPTS);
+    assert_eq!(result, Ok((11, 4)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_+1_23", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+123_", &OPTS);
+    assert_eq!(result, Ok((123, 5)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+123__", &OPTS);
+    assert_eq!(result, Ok((123, 4)));
+}
+
+#[test]
+fn issue_96_lt_test() {
+    const OPTS: Options = Options::new();
+    const FMT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .leading_digit_separator(true)
+        .trailing_digit_separator(true)
+        .consecutive_digit_separator(false)
+        .build_strict();
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"", &OPTS);
+    assert_eq!(result, Err(Error::Empty(0)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_", &OPTS);
+    assert_eq!(result, Err(Error::Empty(2)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_1_23", &OPTS);
+    assert_eq!(result, Ok((1, 2)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_1_23", &OPTS);
+    assert_eq!(result, Ok((1, 3)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1__1_23", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1_", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_11_", &OPTS);
+    assert_eq!(result, Ok((11, 4)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_+1_23", &OPTS);
+    assert_eq!(result, Err(Error::Empty(1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+123_", &OPTS);
+    assert_eq!(result, Ok((123, 5)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+123__", &OPTS);
+    assert_eq!(result, Ok((123, 4)));
+}
+
+#[test]
+fn issue_96_no_required_test() {
+    const OPTS: Options = Options::new();
+    const FMT: u128 = NumberFormatBuilder::new()
+        .digit_separator(num::NonZeroU8::new(b'_'))
+        .leading_digit_separator(true)
+        .trailing_digit_separator(true)
+        .consecutive_digit_separator(false)
+        .required_digits(false)
+        .build_strict();
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"", &OPTS);
+    assert_eq!(result, Ok((0, 0)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_", &OPTS);
+    assert_eq!(result, Ok((0, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_", &OPTS);
+    assert_eq!(result, Ok((0, 2)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_1_23", &OPTS);
+    assert_eq!(result, Ok((1, 2)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+_1_23", &OPTS);
+    assert_eq!(result, Ok((1, 3)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1__1_23", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"1_1_", &OPTS);
+    assert_eq!(result, Ok((1, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_11_", &OPTS);
+    assert_eq!(result, Ok((11, 4)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"_+1_23", &OPTS);
+    assert_eq!(result, Ok((0, 1)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+123_", &OPTS);
+    assert_eq!(result, Ok((123, 5)));
+
+    let result = i64::from_lexical_partial_with_options::<FMT>(b"+123__", &OPTS);
+    assert_eq!(result, Ok((123, 4)));
+}

notes-service/vendor/lexical-parse-integer/tests/issue_98_tests.rs

@@ -0,0 +1,67 @@
+#![cfg(all(feature = "power-of-two", feature = "format"))]
+
+use lexical_parse_integer::FromLexicalWithOptions;
+use lexical_parse_integer::NumberFormatBuilder;
+use lexical_parse_integer::Options;
+use lexical_util::error::Error;
+
+#[test]
+fn issue_98_test() {
+    const DECIMAL_FORMAT: u128 = NumberFormatBuilder::new()
+        .required_digits(true)
+        .no_positive_mantissa_sign(false)
+        .no_special(true)
+        .no_integer_leading_zeros(true)
+        .no_float_leading_zeros(false)
+        .build_strict();
+    let result = i64::from_lexical_with_options::<DECIMAL_FORMAT>(b"1.1.0", &Options::new());
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), Error::InvalidDigit(1));
+    assert_eq!(
+        i64::from_lexical_partial_with_options::<DECIMAL_FORMAT>(b"1.1.0", &Options::new()),
+        Ok((1, 1))
+    );
+
+    let result = i64::from_lexical_with_options::<DECIMAL_FORMAT>(b"1.1", &Options::new());
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), Error::InvalidDigit(1));
+    assert!(i64::from_lexical_with_options::<DECIMAL_FORMAT>(b"1.1", &Options::new()).is_err());
+    assert_eq!(
+        i64::from_lexical_partial_with_options::<DECIMAL_FORMAT>(b"1.1", &Options::new()),
+        Ok((1, 1))
+    );
+
+    let result = i64::from_lexical_with_options::<DECIMAL_FORMAT>(b"0.1.0", &Options::new());
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), Error::InvalidDigit(1));
+    assert_eq!(
+        i64::from_lexical_partial_with_options::<DECIMAL_FORMAT>(b"0.1.0", &Options::new()),
+        Ok((0, 1))
+    );
+
+    let result = i64::from_lexical_with_options::<DECIMAL_FORMAT>(b"0.1", &Options::new());
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), Error::InvalidDigit(1));
+    assert!(i64::from_lexical_with_options::<DECIMAL_FORMAT>(b"0.1", &Options::new()).is_err());
+    assert_eq!(
+        i64::from_lexical_partial_with_options::<DECIMAL_FORMAT>(b"0.1", &Options::new()),
+        Ok((0, 1))
+    );
+
+    let result = i64::from_lexical_with_options::<DECIMAL_FORMAT>(b"01.1", &Options::new());
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), Error::InvalidLeadingZeros(0));
+
+    let result = i64::from_lexical_with_options::<DECIMAL_FORMAT>(b"00.1", &Options::new());
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), Error::InvalidLeadingZeros(0));
+
+    assert_eq!(
+        i64::from_lexical_partial_with_options::<DECIMAL_FORMAT>(b"10.1", &Options::new()),
+        Ok((10, 2))
+    );
+    assert_eq!(
+        i64::from_lexical_partial_with_options::<DECIMAL_FORMAT>(b"11.1", &Options::new()),
+        Ok((11, 2))
+    );
+}

notes-service/vendor/lexical-parse-integer/tests/options_tests.rs

@@ -0,0 +1,17 @@
+use lexical_parse_integer::options::{Options, OptionsBuilder};
+
+#[test]
+fn options_tests() {
+    let builder = OptionsBuilder::new();
+    assert!(builder.is_valid());
+    assert!(builder.build_unchecked().is_valid());
+    assert!(OptionsBuilder::default().is_valid());
+
+    let options: Options = Options::new();
+    assert!(options.is_valid());
+    assert_eq!(options, Options::default());
+    assert!(OptionsBuilder::new().build().is_ok());
+    assert!(OptionsBuilder::default().build().is_ok());
+    assert!(OptionsBuilder::default().is_valid());
+    assert_eq!(options.rebuild(), Options::builder());
+}

notes-service/vendor/lexical-parse-integer/tests/partial_tests.rs

@@ -0,0 +1,34 @@
+use lexical_parse_integer::{FromLexical, FromLexicalWithOptions, Options};
+use lexical_util::error::Error;
+#[cfg(all(feature = "format", feature = "power-of-two"))]
+use lexical_util::format::NumberFormatBuilder;
+use lexical_util::format::STANDARD;
+
+#[test]
+fn u8_decimal_test() {
+    assert_eq!(Ok((0, 1)), u8::from_lexical_partial(b"0"));
+    assert_eq!(Ok((127, 3)), u8::from_lexical_partial(b"127"));
+    assert_eq!(Ok((128, 3)), u8::from_lexical_partial(b"128"));
+    assert_eq!(Ok((255, 3)), u8::from_lexical_partial(b"255"));
+    assert_eq!(Err(Error::InvalidDigit(0)), u8::from_lexical(b"-1"));
+    assert_eq!(Ok((1, 1)), u8::from_lexical_partial(b"1a"));
+
+    const OPTIONS: Options = Options::new();
+    assert_eq!(Ok((0, 1)), u8::from_lexical_partial_with_options::<{ STANDARD }>(b"0", &OPTIONS));
+}
+
+#[test]
+#[cfg(all(feature = "format", feature = "power-of-two"))]
+fn u8_decimal_format_test() {
+    // Test an invalid format.
+    const FORMAT: u128 = NumberFormatBuilder::from_radix(1);
+    const OPTIONS: Options = Options::new();
+    assert_eq!(
+        Err(Error::InvalidMantissaRadix),
+        u8::from_lexical_with_options::<FORMAT>(b"0", &OPTIONS)
+    );
+    assert_eq!(
+        Err(Error::InvalidMantissaRadix),
+        u8::from_lexical_partial_with_options::<FORMAT>(b"0", &OPTIONS)
+    );
+}

notes-service/vendor/lexical-parse-integer/tests/util.rs

@@ -0,0 +1,9 @@
+#![allow(dead_code, unused_imports)]
+
+#[cfg(feature = "power-of-two")]
+use lexical_util::format::NumberFormatBuilder;
+
+#[cfg(feature = "power-of-two")]
+pub const fn from_radix(radix: u8) -> u128 {
+    NumberFormatBuilder::from_radix(radix)
+}