From f257da1c8860a7e4e3595b5780d259947f2e4305 Mon Sep 17 00:00:00 2001 From: Xavier Lau Date: Sun, 8 Dec 2024 01:47:58 +0800 Subject: [PATCH] Release `v7.0.0` --- .github/workflows/checks.yml | 2 +- CHANGELOG | 7 + README.md | 147 ++--- src/lib.rs | 286 +++++---- src/test.rs | 1075 ++++++++++++++++++++++++++++------ 5 files changed, 1158 insertions(+), 359 deletions(-) diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml index f935b70..50cb97e 100644 --- a/.github/workflows/checks.yml +++ b/.github/workflows/checks.yml @@ -47,7 +47,7 @@ jobs: cargo +nightly fmt --all -- --check - name: Cargo test if: matrix.action == 'test' - run: cargo test --profile ci-dev --workspace --all-features --all-targets --locked + run: RUST_MIN_STACK=67108864 cargo test --profile ci-dev --workspace --all-features --all-targets --locked - name: Fast fail uses: vishnudxb/cancel-workflow@v1.2 if: failure() diff --git a/CHANGELOG b/CHANGELOG index 3b219d6..090c85e 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,10 @@ +## v7.0.0 +- Improve docs. +- Improve tests. +- Add `se_hex`, `se_hex_without_prefix`. +- Rename `de_hex2num` to `de_try_from_hex` and make it support more types. +- Remove `de_hex2bytes`. + ## v6.2.3 - Add `slice2array_ref` and `slice2array_ref_unchecked`. - Bump dependencies. diff --git a/README.md b/README.md index 0e4304e..575821a 100644 --- a/README.md +++ b/README.md @@ -29,7 +29,7 @@ - type `AsRef<[u8]> -> u64` - type `AsRef<[u8]> -> u128` - Convert hex to array - - type `AsRef<[u8]> -> [u8; N]`, `N = { [1, 64], 128, 256, 512 }` + - type `AsRef<[u8]> -> [u8; N]`, `N = { [1, 64], 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536 }` - type `AsRef<[u8]> -> Vec` #### `Hex` trait @@ -48,7 +48,7 @@ - type `u128 -> String` - Convert array to hex - type `Vec -> String` - - type `[u8; N] -> String`, `N = { [1, 64], 128, 256, 512 }` + - type `[u8; N] -> String`, `N = { [1, 64], 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536 }` - type `&[u8] -> String` #### `slice` prefixed functions @@ -91,125 +91,96 @@ - `#[serde(deserialize_with = "array_bytes::hex_deserialize_n_into")]` - type `S -> T` - e.g. `"0x..." -> H160` -- `#[serde(deserialize_with = "array_bytes::de_hex2num")]` - - type `S -> Num` +- `#[serde(deserialize_with = "array_bytes::de_try_from_hex")]` + - type `S -> impl TryFromHex` - e.g. `"0xA" -> 10_u32` -- `#[serde(deserialize_with = "array_bytes::de_hex2bytes")]` - - type `S -> Vec` +- `#[serde(serialize_with = "array_bytes::se_hex")]` + - type `S -> impl Hex` - e.g. `"0x00" -> vec![0_u8]` ## Benchmark results
Tuesday, January 9th, 2024
```rs -array_bytes::bytes2hex time: [30.487 µs 30.513 µs 30.543 µs] - change: [-12.758% -7.1673% -2.3095%] (p = 0.00 < 0.05) - Performance has improved. +array_bytes::bytes2hex time: [26.426 µs 26.473 µs 26.518 µs] Found 4 outliers among 100 measurements (4.00%) - 3 (3.00%) high mild + 2 (2.00%) low mild + 1 (1.00%) high mild 1 (1.00%) high severe -const_hex::encode time: [2.1197 µs 2.2245 µs 2.3208 µs] - change: [+25.796% +31.010% +36.449%] (p = 0.00 < 0.05) - Performance has regressed. +const_hex::encode time: [994.78 ns 1.0084 µs 1.0232 µs] -faster_hex::hex_string time: [13.666 µs 13.711 µs 13.754 µs] - change: [-0.3508% +0.0892% +0.5043%] (p = 0.68 > 0.05) - No change in performance detected. +faster_hex::hex_string time: [11.728 µs 11.769 µs 11.815 µs] faster_hex::hex_encode_fallback - time: [13.476 µs 13.519 µs 13.564 µs] - change: [-0.1799% +0.2323% +0.6560%] (p = 0.27 > 0.05) - No change in performance detected. + time: [11.704 µs 11.737 µs 11.773 µs] Found 1 outliers among 100 measurements (1.00%) 1 (1.00%) high mild -hex::encode time: [133.99 µs 135.65 µs 137.13 µs] - change: [-1.6763% +0.2181% +2.1203%] (p = 0.82 > 0.05) - No change in performance detected. -Found 15 outliers among 100 measurements (15.00%) - 13 (13.00%) low severe - 2 (2.00%) low mild +hex::encode time: [86.105 µs 86.250 µs 86.433 µs] +Found 14 outliers among 100 measurements (14.00%) + 1 (1.00%) low severe + 4 (4.00%) low mild + 6 (6.00%) high mild + 3 (3.00%) high severe -rustc_hex::to_hex time: [118.83 µs 124.46 µs 129.51 µs] - change: [-3.5525% +2.8439% +10.307%] (p = 0.42 > 0.05) - No change in performance detected. +rustc_hex::to_hex time: [44.486 µs 45.538 µs 46.723 µs] +Found 16 outliers among 100 measurements (16.00%) + 1 (1.00%) low mild + 2 (2.00%) high mild + 13 (13.00%) high severe -array_bytes::hex2bytes time: [46.892 µs 47.510 µs 48.195 µs] - change: [-8.2282% -6.5411% -4.6367%] (p = 0.00 < 0.05) - Performance has improved. -Found 6 outliers among 100 measurements (6.00%) - 1 (1.00%) high mild - 5 (5.00%) high severe +array_bytes::hex2bytes time: [43.576 µs 44.529 µs 45.404 µs] + Performance has regressed. +Found 11 outliers among 100 measurements (11.00%) + 7 (7.00%) low mild + 4 (4.00%) high mild array_bytes::hex2bytes_unchecked - time: [73.450 µs 73.842 µs 74.251 µs] - change: [+0.5740% +1.3693% +2.1806%] (p = 0.00 < 0.05) - Change within noise threshold. -Found 17 outliers among 100 measurements (17.00%) - 11 (11.00%) low mild - 5 (5.00%) high mild - 1 (1.00%) high severe + time: [64.190 µs 65.311 µs 66.359 µs] -array_bytes::hex2slice time: [57.825 µs 57.915 µs 58.007 µs] - change: [-0.9051% -0.6249% -0.3523%] (p = 0.00 < 0.05) - Change within noise threshold. -Found 6 outliers among 100 measurements (6.00%) - 6 (6.00%) high mild +array_bytes::hex2slice time: [45.484 µs 46.988 µs 48.736 µs] + Performance has regressed. +Found 12 outliers among 100 measurements (12.00%) + 2 (2.00%) high mild + 10 (10.00%) high severe array_bytes::hex2slice_unchecked - time: [73.574 µs 73.917 µs 74.281 µs] - change: [-4.9137% -4.1840% -3.4519%] (p = 0.00 < 0.05) - Performance has improved. -Found 13 outliers among 100 measurements (13.00%) - 8 (8.00%) high mild - 5 (5.00%) high severe + time: [62.339 µs 63.317 µs 64.279 µs] + Performance has regressed. -const_hex::decode time: [15.849 µs 15.887 µs 15.924 µs] - change: [-3.1788% -2.1280% -1.2019%] (p = 0.00 < 0.05) +const_hex::decode time: [13.601 µs 13.629 µs 13.665 µs] Performance has improved. +Found 2 outliers among 100 measurements (2.00%) + 1 (1.00%) low mild + 1 (1.00%) high severe -faster_hex::hex_decode time: [31.735 µs 31.764 µs 31.800 µs] - change: [-0.7403% -0.5216% -0.2674%] (p = 0.00 < 0.05) - Change within noise threshold. -Found 7 outliers among 100 measurements (7.00%) - 5 (5.00%) high mild - 2 (2.00%) high severe +faster_hex::hex_decode time: [28.015 µs 28.061 µs 28.110 µs] + Performance has improved. +Found 1 outliers among 100 measurements (1.00%) + 1 (1.00%) high mild faster_hex::hex_decode_unchecked - time: [13.059 µs 13.098 µs 13.145 µs] - change: [-0.7125% -0.3968% -0.1100%] (p = 0.01 < 0.05) - Change within noise threshold. -Found 10 outliers among 100 measurements (10.00%) - 6 (6.00%) high mild - 4 (4.00%) high severe + time: [11.782 µs 11.797 µs 11.812 µs] +Found 3 outliers among 100 measurements (3.00%) + 2 (2.00%) low severe + 1 (1.00%) low mild faster_hex::hex_decode_fallback - time: [13.074 µs 13.090 µs 13.108 µs] - change: [-1.9404% -1.5652% -1.1912%] (p = 0.00 < 0.05) - Performance has improved. -Found 9 outliers among 100 measurements (9.00%) - 5 (5.00%) high mild - 4 (4.00%) high severe + time: [11.748 µs 11.767 µs 11.785 µs] +Found 7 outliers among 100 measurements (7.00%) + 2 (2.00%) low severe + 4 (4.00%) low mild + 1 (1.00%) high mild -hex::decode time: [131.19 µs 132.57 µs 134.26 µs] - change: [+1.9126% +3.2801% +4.8702%] (p = 0.00 < 0.05) - Performance has regressed. -Found 15 outliers among 100 measurements (15.00%) - 15 (15.00%) high severe +hex::decode time: [93.055 µs 94.781 µs 96.583 µs] -hex::decode_to_slice time: [57.577 µs 58.018 µs 58.447 µs] - change: [+0.0185% +1.1253% +2.2104%] (p = 0.04 < 0.05) - Change within noise threshold. -Found 2 outliers among 100 measurements (2.00%) - 1 (1.00%) high mild - 1 (1.00%) high severe +hex::decode_to_slice time: [31.949 µs 33.509 µs 35.285 µs] +Found 13 outliers among 100 measurements (13.00%) + 5 (5.00%) high mild + 8 (8.00%) high severe -rustc_hex::from_hex time: [130.19 µs 130.86 µs 131.48 µs] - change: [-1.8542% -1.4374% -0.9862%] (p = 0.00 < 0.05) - Change within noise threshold. -Found 2 outliers among 100 measurements (2.00%) - 2 (2.00%) high mild +rustc_hex::from_hex time: [105.99 µs 108.05 µs 110.11 µs] ```
diff --git a/src/lib.rs b/src/lib.rs index d65d2ae..1aa601d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,15 +12,15 @@ extern crate alloc; #[cfg(test)] mod test; // core -use core::{cmp::Ordering, convert::TryInto, result::Result as CoreResult, str}; +use core::{cmp::Ordering, convert::TryInto, str}; // alloc use alloc::{format, string::String, vec::Vec}; // crates.io -#[cfg(feature = "serde")] use serde::{de::Error as DeError, Deserialize, Deserializer}; -// use thiserror::Error as ThisError; +#[cfg(feature = "serde")] +use serde::{de::Error as DeError, Deserialize, Deserializer, Serializer}; /// The main result of array-bytes. -pub type Result = CoreResult; +pub type Result = core::result::Result; /// Try to convert the given hex to a specific type. /// @@ -28,7 +28,7 @@ pub type Result = CoreResult; /// ``` /// use array_bytes::TryFromHex; /// -/// assert_eq!(u128::try_from_hex("0x1a2b3c4d5e6f"), Ok(28772997619311)); +/// assert_eq!(u128::try_from_hex("0x5201314"), Ok(85_988_116)); /// ``` pub trait TryFromHex where @@ -148,6 +148,13 @@ impl_array_try_from_hex! { [u8; 128], [u8; 256], [u8; 512], + [u8; 1024], + [u8; 2048], + [u8; 4096], + [u8; 8192], + [u8; 16384], + [u8; 32768], + [u8; 65536], } impl TryFromHex for Vec { fn try_from_hex(hex: H) -> Result @@ -164,22 +171,34 @@ impl TryFromHex for Vec { /// ``` /// use array_bytes::Hex; /// -/// assert_eq!(28772997619311_u128.hex("0x"), "0x1a2b3c4d5e6f"); +/// assert_eq!(5_201_314_u128.hex("0x"), "0x4f5da2"); /// ``` pub trait Hex { /// Convert [`Self`] to hex with the given prefix. - fn hex(self, prefix: &str) -> String; + fn hex

(self, prefix: P) -> String + where + P: AsRef; } macro_rules! impl_num_hex { ($($t:ty,)+) => { $( impl Hex for $t { - fn hex(self, prefix: &str) -> String { + fn hex

(self, prefix: P) -> String + where + P: AsRef + { + let prefix = prefix.as_ref(); + format!("{prefix}{self:x}") } } impl Hex for &$t { - fn hex(self, prefix: &str) -> String { + fn hex

(self, prefix: P) -> String + where + P: AsRef + { + let prefix = prefix.as_ref(); + format!("{prefix}{self:x}") } } @@ -204,12 +223,18 @@ macro_rules! impl_array_hex { ($($t:ty,)+) => { $( impl Hex for $t { - fn hex(self, prefix: &str) -> String { + fn hex

(self, prefix: P) -> String + where + P: AsRef + { bytes2hex(prefix, self) } } impl Hex for &$t { - fn hex(self, prefix: &str) -> String { + fn hex

(self, prefix: P) -> String + where + P: AsRef + { bytes2hex(prefix, self) } } @@ -285,9 +310,19 @@ impl_array_hex! { [u8; 128], [u8; 256], [u8; 512], + [u8; 1024], + [u8; 2048], + [u8; 4096], + [u8; 8192], + [u8; 16384], + [u8; 32768], + [u8; 65536], } impl Hex for &[u8] { - fn hex(self, prefix: &str) -> String { + fn hex

(self, prefix: P) -> String + where + P: AsRef, + { bytes2hex(prefix, self) } } @@ -319,7 +354,10 @@ pub enum Error { /// /// # Examples /// ``` -/// assert_eq!(array_bytes::slice2array::<_, 8>(&[0; 8]), Ok([0; 8])); +/// assert_eq!( +/// array_bytes::slice2array::<_, 8>(&[5, 2, 0, 1, 3, 1, 4, 0]), +/// Ok([5, 2, 0, 1, 3, 1, 4, 0]) +/// ); /// ``` pub fn slice2array(slice: &[T]) -> Result<[T; N]> where @@ -332,7 +370,10 @@ where /// /// # Examples /// ``` -/// assert_eq!(array_bytes::slice2array_unchecked::<_, 8>(&[0; 8]), [0; 8]); +/// assert_eq!( +/// array_bytes::slice2array_unchecked::<_, 8>(&[5, 2, 0, 1, 3, 1, 4, 0]), +/// [5, 2, 0, 1, 3, 1, 4, 0] +/// ); /// ``` pub fn slice2array_unchecked(slice: &[T]) -> [T; N] where @@ -345,7 +386,10 @@ where /// /// # Examples /// ``` -/// assert_eq!(array_bytes::slice2array::<_, 8>(&[0; 8]), Ok(&[0; 8])); +/// assert_eq!( +/// array_bytes::slice2array_ref::<_, 8>(&[5, 2, 0, 1, 3, 1, 4, 0]), +/// Ok(&[5, 2, 0, 1, 3, 1, 4, 0]) +/// ); /// ``` pub fn slice2array_ref(slice: &[T]) -> Result<&[T; N]> where @@ -358,7 +402,10 @@ where /// /// # Examples /// ``` -/// assert_eq!(array_bytes::slice2array_unchecked::<_, 8>(&[0; 8]), &[0; 8]); +/// assert_eq!( +/// array_bytes::slice2array_ref_unchecked::<_, 8>(&[5, 2, 0, 1, 3, 1, 4, 0]), +/// &[5, 2, 0, 1, 3, 1, 4, 0] +/// ); /// ``` pub fn slice2array_ref_unchecked(slice: &[T]) -> &[T; N] where @@ -380,9 +427,9 @@ where /// /// # Examples /// ``` -/// assert_eq!(array_bytes::prefix_with::<_, _, 4>([1, 2, 3, 4], 0), [1, 2, 3, 4]); -/// assert_eq!(array_bytes::prefix_with::<_, _, 4>([1, 2, 3, 4, 5, 6], 0), [1, 2, 3, 4]); -/// assert_eq!(array_bytes::prefix_with::<_, _, 5>([1, 2, 3], 0), [0, 0, 1, 2, 3]); +/// assert_eq!(array_bytes::prefix_with::<_, _, 4>([5, 2, 0, 1], 0), [5, 2, 0, 1]); +/// assert_eq!(array_bytes::prefix_with::<_, _, 4>([5, 2, 0, 1, 3, 1, 4], 0), [5, 2, 0, 1]); +/// assert_eq!(array_bytes::prefix_with::<_, _, 5>([5, 2, 0], 0), [0, 0, 5, 2, 0]); /// ``` pub fn prefix_with(any: A, element: T) -> [T; N] where @@ -417,9 +464,9 @@ where /// /// # Examples /// ``` -/// assert_eq!(array_bytes::suffix_with::<_, _, 4>([1, 2, 3, 4], 0), [1, 2, 3, 4]); -/// assert_eq!(array_bytes::suffix_with::<_, _, 4>([1, 2, 3, 4, 5, 6], 0), [1, 2, 3, 4]); -/// assert_eq!(array_bytes::suffix_with::<_, _, 5>([1, 2, 3], 0), [1, 2, 3, 0, 0]); +/// assert_eq!(array_bytes::suffix_with::<_, _, 4>([5, 2, 0, 1], 0), [5, 2, 0, 1]); +/// assert_eq!(array_bytes::suffix_with::<_, _, 4>([5, 2, 0, 1, 3, 1, 4], 0), [5, 2, 0, 1]); +/// assert_eq!(array_bytes::suffix_with::<_, _, 5>([5, 2, 0], 0), [5, 2, 0, 0, 0]); /// ``` pub fn suffix_with(any: A, element: T) -> [T; N] where @@ -446,16 +493,16 @@ where /// # Examples /// ``` /// #[derive(Debug, PartialEq)] -/// struct LJF([u8; 17]); -/// impl From<[u8; 17]> for LJF { +/// struct Ljf([u8; 17]); +/// impl From<[u8; 17]> for Ljf { /// fn from(array: [u8; 17]) -> Self { /// Self(array) /// } /// } /// /// assert_eq!( -/// array_bytes::slice_n_into::(b"Love Jane Forever"), -/// Ok(LJF(*b"Love Jane Forever")) +/// array_bytes::slice_n_into::(b"Love Jane Forever"), +/// Ok(Ljf(*b"Love Jane Forever")) /// ); /// ``` pub fn slice_n_into(slice: &[T]) -> Result @@ -471,16 +518,16 @@ where /// # Examples /// ``` /// #[derive(Debug, PartialEq)] -/// struct LJF([u8; 17]); -/// impl From<[u8; 17]> for LJF { +/// struct Ljf([u8; 17]); +/// impl From<[u8; 17]> for Ljf { /// fn from(array: [u8; 17]) -> Self { /// Self(array) /// } /// } /// /// assert_eq!( -/// array_bytes::slice_n_into_unchecked::(b"Love Jane Forever"), -/// LJF(*b"Love Jane Forever") +/// array_bytes::slice_n_into_unchecked::(b"Love Jane Forever"), +/// Ljf(*b"Love Jane Forever") /// ); /// ``` pub fn slice_n_into_unchecked(slice: &[T]) -> V @@ -517,16 +564,16 @@ pub fn vec2array_unchecked(vec: Vec) -> [T; N] { /// /// ``` /// #[derive(Debug, PartialEq)] -/// struct LJF([u8; 17]); -/// impl From<[u8; 17]> for LJF { +/// struct Ljf([u8; 17]); +/// impl From<[u8; 17]> for Ljf { /// fn from(array: [u8; 17]) -> Self { /// Self(array) /// } /// } /// /// assert_eq!( -/// array_bytes::vec_n_into::(b"Love Jane Forever".to_vec()), -/// Ok(LJF(*b"Love Jane Forever")) +/// array_bytes::vec_n_into::(b"Love Jane Forever".to_vec()), +/// Ok(Ljf(*b"Love Jane Forever")) /// ); /// ``` pub fn vec_n_into(vec: Vec) -> Result @@ -541,16 +588,16 @@ where /// # Examples /// ``` /// #[derive(Debug, PartialEq)] -/// struct LJF([u8; 17]); -/// impl From<[u8; 17]> for LJF { +/// struct Ljf([u8; 17]); +/// impl From<[u8; 17]> for Ljf { /// fn from(array: [u8; 17]) -> Self { /// Self(array) /// } /// } /// /// assert_eq!( -/// array_bytes::vec_n_into_unchecked::(b"Love Jane Forever".to_vec()), -/// LJF(*b"Love Jane Forever") +/// array_bytes::vec_n_into_unchecked::(b"Love Jane Forever".to_vec()), +/// Ljf(*b"Love Jane Forever") /// ); /// ``` pub fn vec_n_into_unchecked(vec: Vec) -> V @@ -611,10 +658,12 @@ pub unsafe fn hex_bytes2hex_str_unchecked(bytes: &[u8]) -> &str { /// String::from("0x4c6f7665204a616e6520466f7265766572") /// ); /// ``` -pub fn bytes2hex(prefix: &str, bytes: B) -> String +pub fn bytes2hex(prefix: P, bytes: B) -> String where + P: AsRef, B: AsRef<[u8]>, { + let prefix = prefix.as_ref(); let bytes = bytes.as_ref(); let mut hex = String::with_capacity(prefix.len() + bytes.len() * 2); @@ -782,16 +831,16 @@ where /// # Examples /// ``` /// #[derive(Debug, PartialEq)] -/// struct LJF(Vec); -/// impl From> for LJF { +/// struct Ljf(Vec); +/// impl From> for Ljf { /// fn from(vec: Vec) -> Self { /// Self(vec) /// } /// } /// /// assert_eq!( -/// array_bytes::hex_into::<_, LJF>("0x4c6f7665204a616e6520466f7265766572"), -/// Ok(LJF(b"Love Jane Forever".to_vec())) +/// array_bytes::hex_into::<_, Ljf>("0x4c6f7665204a616e6520466f7265766572"), +/// Ok(Ljf(b"Love Jane Forever".to_vec())) /// ); /// ``` pub fn hex_into(hex: H) -> Result @@ -807,16 +856,16 @@ where /// # Examples /// ``` /// #[derive(Debug, PartialEq)] -/// struct LJF(Vec); -/// impl From> for LJF { +/// struct Ljf(Vec); +/// impl From> for Ljf { /// fn from(vec: Vec) -> Self { /// Self(vec) /// } /// } /// /// assert_eq!( -/// array_bytes::hex_into_unchecked::<_, LJF>("0x4c6f7665204a616e6520466f7265766572"), -/// LJF(b"Love Jane Forever".to_vec()) +/// array_bytes::hex_into_unchecked::<_, Ljf>("0x4c6f7665204a616e6520466f7265766572"), +/// Ljf(b"Love Jane Forever".to_vec()) /// ); /// ``` pub fn hex_into_unchecked(hex: H) -> T @@ -832,16 +881,16 @@ where /// # Examples /// ``` /// #[derive(Debug, PartialEq)] -/// struct LJF([u8; 17]); -/// impl From<[u8; 17]> for LJF { +/// struct Ljf([u8; 17]); +/// impl From<[u8; 17]> for Ljf { /// fn from(array: [u8; 17]) -> Self { /// Self(array) /// } /// } /// /// assert_eq!( -/// array_bytes::hex_n_into::<_, LJF, 17>("0x4c6f7665204a616e6520466f7265766572"), -/// Ok(LJF(*b"Love Jane Forever")) +/// array_bytes::hex_n_into::<_, Ljf, 17>("0x4c6f7665204a616e6520466f7265766572"), +/// Ok(Ljf(*b"Love Jane Forever")) /// ); /// ``` pub fn hex_n_into(hex: H) -> Result @@ -857,16 +906,16 @@ where /// # Examples /// ``` /// #[derive(Debug, PartialEq)] -/// struct LJF([u8; 17]); -/// impl From<[u8; 17]> for LJF { +/// struct Ljf([u8; 17]); +/// impl From<[u8; 17]> for Ljf { /// fn from(array: [u8; 17]) -> Self { /// Self(array) /// } /// } /// /// assert_eq!( -/// array_bytes::hex_n_into_unchecked::<_, LJF, 17>("0x4c6f7665204a616e6520466f7265766572"), -/// LJF(*b"Love Jane Forever") +/// array_bytes::hex_n_into_unchecked::<_, Ljf, 17>("0x4c6f7665204a616e6520466f7265766572"), +/// Ljf(*b"Love Jane Forever") /// ); /// ``` pub fn hex_n_into_unchecked(hex: H) -> T @@ -884,29 +933,29 @@ where /// use serde::Deserialize; /// /// #[derive(Debug, PartialEq)] -/// struct LJF(Vec); -/// impl From> for LJF { +/// struct Ljf(Vec); +/// impl From> for Ljf { /// fn from(vec: Vec) -> Self { /// Self(vec) /// } /// } /// /// #[derive(Debug, PartialEq, Deserialize)] -/// struct WrappedLJF { +/// struct WrappedLjf { /// #[serde(deserialize_with = "array_bytes::hex_deserialize_into")] -/// ljf: LJF, +/// ljf: Ljf, /// } /// /// assert_eq!( -/// serde_json::from_str::(r#"{ +/// serde_json::from_str::(r#"{ /// "ljf": "0x4c6f7665204a616e6520466f7265766572" /// }"#).unwrap(), -/// WrappedLJF { -/// ljf: LJF(b"Love Jane Forever".to_vec()) +/// WrappedLjf { +/// ljf: Ljf(b"Love Jane Forever".to_vec()) /// } /// ); #[cfg(feature = "serde")] -pub fn hex_deserialize_into<'de, D, T>(hex: D) -> CoreResult +pub fn hex_deserialize_into<'de, D, T>(hex: D) -> Result where D: Deserializer<'de>, T: From>, @@ -921,29 +970,29 @@ where /// use serde::Deserialize; /// /// #[derive(Debug, PartialEq)] -/// struct LJF([u8; 17]); -/// impl From<[u8; 17]> for LJF { +/// struct Ljf([u8; 17]); +/// impl From<[u8; 17]> for Ljf { /// fn from(array: [u8; 17]) -> Self { /// Self(array) /// } /// } /// /// #[derive(Debug, PartialEq, Deserialize)] -/// struct WrappedLJF { +/// struct WrappedLjf { /// #[serde(deserialize_with = "array_bytes::hex_deserialize_n_into")] -/// ljf: LJF, +/// ljf: Ljf, /// } /// /// assert_eq!( -/// serde_json::from_str::(r#"{ +/// serde_json::from_str::(r#"{ /// "ljf": "0x4c6f7665204a616e6520466f7265766572" /// }"#).unwrap(), -/// WrappedLJF { -/// ljf: LJF(*b"Love Jane Forever") +/// WrappedLjf { +/// ljf: Ljf(*b"Love Jane Forever") /// } /// ); #[cfg(feature = "serde")] -pub fn hex_deserialize_n_into<'de, D, T, const N: usize>(hex: D) -> CoreResult +pub fn hex_deserialize_n_into<'de, D, T, const N: usize>(hex: D) -> Result where D: Deserializer<'de>, T: From<[u8; N]>, @@ -951,78 +1000,109 @@ where Ok(hex2array_unchecked(<&str>::deserialize(hex)?).into()) } -/// Deserialize hex to any Rust primitive num types. +/// Deserialize hex to the pre-defined primitive types. /// /// # Examples /// ``` /// use serde::Deserialize; /// /// #[derive(Debug, PartialEq, Deserialize)] -/// struct LJF { -/// #[serde(deserialize_with = "array_bytes::de_hex2num")] +/// struct Ljf { +/// #[serde(deserialize_with = "array_bytes::de_try_from_hex")] /// _0: u8, -/// #[serde(deserialize_with = "array_bytes::de_hex2num")] -/// _1: u8, -/// #[serde(deserialize_with = "array_bytes::de_hex2num")] -/// _2: u8, -/// #[serde(deserialize_with = "array_bytes::de_hex2num")] -/// _3: u32, +/// #[serde(deserialize_with = "array_bytes::de_try_from_hex")] +/// _1: u16, +/// #[serde(deserialize_with = "array_bytes::de_try_from_hex")] +/// _2: u32, +/// #[serde(deserialize_with = "array_bytes::de_try_from_hex")] +/// _3: [u8; 4], /// } /// /// assert_eq!( -/// serde_json::from_str::( +/// serde_json::from_str::( /// r#"{ /// "_0": "0x5", /// "_1": "0x2", /// "_2": "0x0", -/// "_3": "0x522" +/// "_3": "0x01030104" /// }"# /// ) /// .unwrap(), -/// LJF { _0: 5, _1: 2, _2: 0, _3: 1314 } +/// Ljf { _0: 5, _1: 2, _2: 0, _3: [1, 3, 1, 4] } /// ); /// ``` #[cfg(feature = "serde")] -pub fn de_hex2num<'de, D, T>(hex: D) -> CoreResult +pub fn de_try_from_hex<'de, D, T>(hex: D) -> Result where D: Deserializer<'de>, T: TryFromHex, { let hex = <&str>::deserialize(hex)?; - T::try_from_hex(hex).map_err(|_| D::Error::custom(alloc::format!("Invalid hex str `{}`", hex))) + T::try_from_hex(hex).map_err(|_| D::Error::custom(alloc::format!("invalid hex str `{}`", hex))) } -/// Deserialize hex to [`Vec`]. +/// Serialize the pre-defined primitive types to hex. /// /// # Examples /// ``` -/// use serde::Deserialize; +/// use serde::Serialize; /// -/// #[derive(Debug, PartialEq, Deserialize)] -/// struct LJF { -/// #[serde(deserialize_with = "array_bytes::de_hex2bytes")] -/// ljf: Vec, +/// #[derive(Debug, PartialEq, Serialize)] +/// struct Ljf { +/// #[serde(serialize_with = "array_bytes::se_hex")] +/// _0: u8, +/// #[serde(serialize_with = "array_bytes::se_hex")] +/// _1: u16, +/// #[serde(serialize_with = "array_bytes::se_hex")] +/// _2: u32, +/// #[serde(serialize_with = "array_bytes::se_hex")] +/// _3: [u8; 4], /// } /// /// assert_eq!( -/// serde_json::from_str::( -/// r#"{ -/// "ljf": "0x4c6f7665204a616e6520466f7265766572" -/// }"# -/// ) -/// .unwrap(), -/// LJF { ljf: (*b"Love Jane Forever").to_vec() } +/// serde_json::to_string::(&Ljf { _0: 5, _1: 2, _2: 0, _3: [1, 3, 1, 4] }).unwrap(), +/// r#"{"_0":"0x5","_1":"0x2","_2":"0x0","_3":"0x01030104"}"# /// ); /// ``` #[cfg(feature = "serde")] -pub fn de_hex2bytes<'de, D>(hex: D) -> CoreResult, D::Error> +pub fn se_hex(hex: T, serializer: S) -> Result where - D: Deserializer<'de>, + S: Serializer, + T: Hex, { - let hex = <&str>::deserialize(hex)?; - - hex2bytes(hex).map_err(|_| D::Error::custom(alloc::format!("Invalid hex str `{}`", hex))) + serializer.serialize_str(&hex.hex("0x")) +} +/// Just like [`se_hex`] but without the prefix. +/// +/// # Examples +/// ``` +/// use serde::Serialize; +/// +/// #[derive(Debug, PartialEq, Serialize)] +/// struct Ljf { +/// #[serde(serialize_with = "array_bytes::se_hex_without_prefix")] +/// _0: u8, +/// #[serde(serialize_with = "array_bytes::se_hex_without_prefix")] +/// _1: u16, +/// #[serde(serialize_with = "array_bytes::se_hex_without_prefix")] +/// _2: u32, +/// #[serde(serialize_with = "array_bytes::se_hex_without_prefix")] +/// _3: [u8; 4], +/// } +/// +/// assert_eq!( +/// serde_json::to_string::(&Ljf { _0: 5, _1: 2, _2: 0, _3: [1, 3, 1, 4] }).unwrap(), +/// r#"{"_0":"5","_1":"2","_2":"0","_3":"01030104"}"# +/// ); +/// ``` +#[cfg(feature = "serde")] +pub fn se_hex_without_prefix(hex: T, serializer: S) -> Result +where + S: Serializer, + T: Hex, +{ + serializer.serialize_str(&hex.hex("")) } fn strip_0x(hex: &[u8]) -> &[u8] { diff --git a/src/test.rs b/src/test.rs index cb1a22f..3ef838e 100644 --- a/src/test.rs +++ b/src/test.rs @@ -1,70 +1,822 @@ #![allow(clippy::upper_case_acronyms)] -// array-bytes +// crates.io +#[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; +// self use crate::*; macro_rules! bytes { ($v:expr; $n:expr) => {{ - let mut v = Vec::new(); - - for _ in 0..$n { - v.push($v); - } - - v + (0..$n).map(|_| $v).collect::>() }}; } #[derive(Debug, PartialEq)] -struct LJF(Vec); -impl From> for LJF { +struct Ljf(Vec); +impl From> for Ljf { fn from(bytes: Vec) -> Self { Self(bytes) } } #[derive(Debug, PartialEq)] -struct LJFN([u8; 17]); -impl From<[u8; 17]> for LJFN { +struct Ljfn([u8; 17]); +impl From<[u8; 17]> for Ljfn { fn from(array: [u8; 17]) -> Self { Self(array) } } +#[derive(Debug, PartialEq)] +#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))] +struct LjfPredefined { + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _0: isize, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _1: i8, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _2: i16, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _3: i32, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _4: i64, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _5: i128, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _6: usize, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _7: u8, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _8: u16, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _9: u32, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _10: u64, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _11: u128, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _12: Vec, + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _13: [u8; 1], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _14: [u8; 2], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _15: [u8; 3], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _16: [u8; 4], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _17: [u8; 5], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _18: [u8; 6], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _19: [u8; 7], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _20: [u8; 8], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _21: [u8; 9], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _22: [u8; 10], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _23: [u8; 11], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _24: [u8; 12], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _25: [u8; 13], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _26: [u8; 14], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _27: [u8; 15], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _28: [u8; 16], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _29: [u8; 17], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _30: [u8; 18], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _31: [u8; 19], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _32: [u8; 20], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _33: [u8; 21], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _34: [u8; 22], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _35: [u8; 23], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _36: [u8; 24], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _37: [u8; 25], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _38: [u8; 26], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _39: [u8; 27], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _40: [u8; 28], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _41: [u8; 29], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _42: [u8; 30], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _43: [u8; 31], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _44: [u8; 32], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _45: [u8; 33], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _46: [u8; 34], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _47: [u8; 35], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _48: [u8; 36], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _49: [u8; 37], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _50: [u8; 38], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _51: [u8; 39], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _52: [u8; 40], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _53: [u8; 41], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _54: [u8; 42], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _55: [u8; 43], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _56: [u8; 44], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _57: [u8; 45], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _58: [u8; 46], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _59: [u8; 47], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _60: [u8; 48], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _61: [u8; 49], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _62: [u8; 50], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _63: [u8; 51], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _64: [u8; 52], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _65: [u8; 53], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _66: [u8; 54], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _67: [u8; 55], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _68: [u8; 56], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _69: [u8; 57], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _70: [u8; 58], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _71: [u8; 59], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _72: [u8; 60], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _73: [u8; 61], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _74: [u8; 62], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _75: [u8; 63], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _76: [u8; 64], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _77: [u8; 128], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _78: [u8; 256], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _79: [u8; 512], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _80: [u8; 1024], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _81: [u8; 2048], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _82: [u8; 4096], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _83: [u8; 8192], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _84: [u8; 16384], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _85: [u8; 32768], + #[cfg_attr( + feature = "serde", + serde(deserialize_with = "de_try_from_hex", serialize_with = "se_hex") + )] + _86: [u8; 65536], +} +impl Default for LjfPredefined { + fn default() -> Self { + Self { + _0: 5, + _1: 2, + _2: 0, + _3: 5_201_314, + _4: 5_201_314, + _5: 5_201_314, + _6: 5, + _7: 2, + _8: 0, + _9: 5_201_314, + _10: 5_201_314, + _11: 5_201_314, + _12: b"Love Jane Forever".to_vec(), + _13: [5], + _14: [5, 2], + _15: [5, 2, 0], + _16: [5, 2, 0, 1], + _17: [5, 2, 0, 1, 3], + _18: [5, 2, 0, 1, 3, 1], + _19: [5, 2, 0, 1, 3, 1, 4], + _20: [0; 8], + _21: [0; 9], + _22: [0; 10], + _23: [0; 11], + _24: [0; 12], + _25: [0; 13], + _26: [0; 14], + _27: [0; 15], + _28: [0; 16], + _29: [0; 17], + _30: [0; 18], + _31: [0; 19], + _32: [0; 20], + _33: [0; 21], + _34: [0; 22], + _35: [0; 23], + _36: [0; 24], + _37: [0; 25], + _38: [0; 26], + _39: [0; 27], + _40: [0; 28], + _41: [0; 29], + _42: [0; 30], + _43: [0; 31], + _44: [0; 32], + _45: [0; 33], + _46: [0; 34], + _47: [0; 35], + _48: [0; 36], + _49: [0; 37], + _50: [0; 38], + _51: [0; 39], + _52: [0; 40], + _53: [0; 41], + _54: [0; 42], + _55: [0; 43], + _56: [0; 44], + _57: [0; 45], + _58: [0; 46], + _59: [0; 47], + _60: [0; 48], + _61: [0; 49], + _62: [0; 50], + _63: [0; 51], + _64: [0; 52], + _65: [0; 53], + _66: [0; 54], + _67: [0; 55], + _68: [0; 56], + _69: [0; 57], + _70: [0; 58], + _71: [0; 59], + _72: [0; 60], + _73: [0; 61], + _74: [0; 62], + _75: [0; 63], + _76: [0; 64], + _77: [0; 128], + _78: [0; 256], + _79: [0; 512], + _80: [0; 1024], + _81: [0; 2048], + _82: [0; 4096], + _83: [0; 8192], + _84: [0; 16384], + _85: [0; 32768], + _86: [0; 65536], + } + } +} + #[test] fn try_from_hex_should_work() { - assert_eq!(u8::try_from_hex("0x8"), Ok(8)); - assert_eq!(u8::try_from_hex("8"), Ok(8)); - assert_eq!(u16::try_from_hex("0x10"), Ok(16)); - assert_eq!(u16::try_from_hex("10"), Ok(16)); - assert_eq!(u32::try_from_hex("0x20"), Ok(32)); - assert_eq!(u32::try_from_hex("20"), Ok(32)); - assert_eq!(u64::try_from_hex("0x40"), Ok(64)); - assert_eq!(u64::try_from_hex("40"), Ok(64)); - assert_eq!(u128::try_from_hex("0x80"), Ok(128)); - assert_eq!(u128::try_from_hex("80"), Ok(128)); - assert_eq!(u128::try_from_hex("0xabcdef"), Ok(11259375)); - assert_eq!(u128::try_from_hex("abcdef"), Ok(11259375)); - assert_eq!(u128::try_from_hex("0x1a2b3c4d5e6f"), Ok(28772997619311)); - assert_eq!(u128::try_from_hex("1a2b3c4d5e6f"), Ok(28772997619311)); + let ljf = LjfPredefined::default(); + + assert_eq!(TryFromHex::try_from_hex("0x5"), Ok(ljf._0)); + assert_eq!(TryFromHex::try_from_hex("5"), Ok(ljf._0)); + assert_eq!(TryFromHex::try_from_hex("0x2"), Ok(ljf._1)); + assert_eq!(TryFromHex::try_from_hex("2"), Ok(ljf._1)); + assert_eq!(TryFromHex::try_from_hex("0x0"), Ok(ljf._2)); + assert_eq!(TryFromHex::try_from_hex("0"), Ok(ljf._2)); + assert_eq!(TryFromHex::try_from_hex("0x4f5da2"), Ok(ljf._3)); + assert_eq!(TryFromHex::try_from_hex("4f5da2"), Ok(ljf._3)); + assert_eq!(TryFromHex::try_from_hex("0x4f5da2"), Ok(ljf._4)); + assert_eq!(TryFromHex::try_from_hex("4f5da2"), Ok(ljf._4)); + assert_eq!(TryFromHex::try_from_hex("0x4f5da2"), Ok(ljf._5)); + assert_eq!(TryFromHex::try_from_hex("4f5da2"), Ok(ljf._5)); + assert_eq!(TryFromHex::try_from_hex("0x5"), Ok(ljf._6)); + assert_eq!(TryFromHex::try_from_hex("5"), Ok(ljf._6)); + assert_eq!(TryFromHex::try_from_hex("0x2"), Ok(ljf._7)); + assert_eq!(TryFromHex::try_from_hex("2"), Ok(ljf._7)); + assert_eq!(TryFromHex::try_from_hex("0x0"), Ok(ljf._8)); + assert_eq!(TryFromHex::try_from_hex("0"), Ok(ljf._8)); + assert_eq!(TryFromHex::try_from_hex("0x4f5da2"), Ok(ljf._9)); + assert_eq!(TryFromHex::try_from_hex("4f5da2"), Ok(ljf._9)); + assert_eq!(TryFromHex::try_from_hex("0x4f5da2"), Ok(ljf._10)); + assert_eq!(TryFromHex::try_from_hex("4f5da2"), Ok(ljf._10)); + assert_eq!(TryFromHex::try_from_hex("0x4f5da2"), Ok(ljf._11)); + assert_eq!(TryFromHex::try_from_hex("4f5da2"), Ok(ljf._11)); + assert_eq!( + TryFromHex::try_from_hex("0x4c6f7665204a616e6520466f7265766572"), + Ok(ljf._12.clone()) + ); + assert_eq!(TryFromHex::try_from_hex("4c6f7665204a616e6520466f7265766572"), Ok(ljf._12)); + assert_eq!(TryFromHex::try_from_hex("0x05"), Ok(ljf._13)); + assert_eq!(TryFromHex::try_from_hex("05"), Ok(ljf._13)); + assert_eq!(TryFromHex::try_from_hex("0x0502"), Ok(ljf._14)); + assert_eq!(TryFromHex::try_from_hex("0502"), Ok(ljf._14)); + assert_eq!(TryFromHex::try_from_hex("0x050200"), Ok(ljf._15)); + assert_eq!(TryFromHex::try_from_hex("050200"), Ok(ljf._15)); + assert_eq!(TryFromHex::try_from_hex("0x05020001"), Ok(ljf._16)); + assert_eq!(TryFromHex::try_from_hex("05020001"), Ok(ljf._16)); + assert_eq!(TryFromHex::try_from_hex("0x0502000103"), Ok(ljf._17)); + assert_eq!(TryFromHex::try_from_hex("0502000103"), Ok(ljf._17)); + assert_eq!(TryFromHex::try_from_hex("0x050200010301"), Ok(ljf._18)); + assert_eq!(TryFromHex::try_from_hex("050200010301"), Ok(ljf._18)); + assert_eq!(TryFromHex::try_from_hex("0x05020001030104"), Ok(ljf._19)); + assert_eq!(TryFromHex::try_from_hex("05020001030104"), Ok(ljf._19)); + + macro_rules! assert_try_from_hex_array { + ($ljf:expr, $(($field:ident, $len:expr)),+,) => { + $( + let hex = "0".repeat($len * 2); + + assert_eq!(TryFromHex::try_from_hex(format!("0x{hex}")), Ok($ljf.$field)); + assert_eq!(TryFromHex::try_from_hex(hex), Ok($ljf.$field)); + )+ + }; + } + + assert_try_from_hex_array! { + ljf, + (_20, 8), + (_21, 9), + (_22, 10), + (_23, 11), + (_24, 12), + (_25, 13), + (_26, 14), + (_27, 15), + (_28, 16), + (_29, 17), + (_30, 18), + (_31, 19), + (_32, 20), + (_33, 21), + (_34, 22), + (_35, 23), + (_36, 24), + (_37, 25), + (_38, 26), + (_39, 27), + (_40, 28), + (_41, 29), + (_42, 30), + (_43, 31), + (_44, 32), + (_45, 33), + (_46, 34), + (_47, 35), + (_48, 36), + (_49, 37), + (_50, 38), + (_51, 39), + (_52, 40), + (_53, 41), + (_54, 42), + (_55, 43), + (_56, 44), + (_57, 45), + (_58, 46), + (_59, 47), + (_60, 48), + (_61, 49), + (_62, 50), + (_63, 51), + (_64, 52), + (_65, 53), + (_66, 54), + (_67, 55), + (_68, 56), + (_69, 57), + (_70, 58), + (_71, 59), + (_72, 60), + (_73, 61), + (_74, 62), + (_75, 63), + (_76, 64), + (_77, 128), + (_78, 256), + (_79, 512), + (_80, 1024), + (_81, 2048), + (_82, 4096), + (_83, 8192), + (_84, 16384), + (_85, 32768), + (_86, 65536), + } } #[test] fn hex_should_work() { - assert_eq!(8_u8.hex("0x"), "0x8"); - assert_eq!(8_u8.hex(""), "8"); - assert_eq!(16_u16.hex("0x"), "0x10"); - assert_eq!(16_u16.hex(""), "10"); - assert_eq!(32_u32.hex("0x"), "0x20"); - assert_eq!(32_u32.hex(""), "20"); - assert_eq!(64_u64.hex("0x"), "0x40"); - assert_eq!(64_u64.hex(""), "40"); - assert_eq!(128_u128.hex("0x"), "0x80"); - assert_eq!(128_u128.hex(""), "80"); - assert_eq!(11259375_u128.hex("0x"), "0xabcdef"); - assert_eq!(11259375_u128.hex(""), "abcdef"); - assert_eq!(28772997619311_u128.hex("0x"), "0x1a2b3c4d5e6f"); - assert_eq!(28772997619311_u128.hex(""), "1a2b3c4d5e6f"); + let ljf = LjfPredefined::default(); + + assert_eq!(ljf._0.hex("0x"), "0x5"); + assert_eq!(ljf._0.hex(""), "5"); + assert_eq!(ljf._1.hex("0x"), "0x2"); + assert_eq!(ljf._1.hex(""), "2"); + assert_eq!(ljf._2.hex("0x"), "0x0"); + assert_eq!(ljf._2.hex(""), "0"); + assert_eq!(ljf._3.hex("0x"), "0x4f5da2"); + assert_eq!(ljf._3.hex(""), "4f5da2"); + assert_eq!(ljf._4.hex("0x"), "0x4f5da2"); + assert_eq!(ljf._4.hex(""), "4f5da2"); + assert_eq!(ljf._5.hex("0x"), "0x4f5da2"); + assert_eq!(ljf._5.hex(""), "4f5da2"); + assert_eq!(ljf._6.hex("0x"), "0x5"); + assert_eq!(ljf._6.hex(""), "5"); + assert_eq!(ljf._7.hex("0x"), "0x2"); + assert_eq!(ljf._7.hex(""), "2"); + assert_eq!(ljf._8.hex("0x"), "0x0"); + assert_eq!(ljf._8.hex(""), "0"); + assert_eq!(ljf._9.hex("0x"), "0x4f5da2"); + assert_eq!(ljf._9.hex(""), "4f5da2"); + assert_eq!(ljf._10.hex("0x"), "0x4f5da2"); + assert_eq!(ljf._10.hex(""), "4f5da2"); + assert_eq!(ljf._11.hex("0x"), "0x4f5da2"); + assert_eq!(ljf._11.hex(""), "4f5da2"); + assert_eq!((&ljf._12).hex("0x"), "0x4c6f7665204a616e6520466f7265766572"); + assert_eq!(ljf._12.hex(""), "4c6f7665204a616e6520466f7265766572"); + assert_eq!(ljf._13.hex("0x"), "0x05"); + assert_eq!(ljf._13.hex(""), "05"); + assert_eq!(ljf._14.hex("0x"), "0x0502"); + assert_eq!(ljf._14.hex(""), "0502"); + assert_eq!(ljf._15.hex("0x"), "0x050200"); + assert_eq!(ljf._15.hex(""), "050200"); + assert_eq!(ljf._16.hex("0x"), "0x05020001"); + assert_eq!(ljf._16.hex(""), "05020001"); + assert_eq!(ljf._17.hex("0x"), "0x0502000103"); + assert_eq!(ljf._17.hex(""), "0502000103"); + assert_eq!(ljf._18.hex("0x"), "0x050200010301"); + assert_eq!(ljf._18.hex(""), "050200010301"); + assert_eq!(ljf._19.hex("0x"), "0x05020001030104"); + assert_eq!(ljf._19.hex(""), "05020001030104"); + + macro_rules! assert_hex_array { + ($ljf:expr, $(($field:ident, $len:expr)),+,) => { + $( + let hex = "0".repeat($len * 2); + + assert_eq!($ljf.$field.hex("0x"), format!("0x{hex}")); + assert_eq!($ljf.$field.hex(""), hex); + )+ + }; + } + + assert_hex_array! { + ljf, + (_20, 8), + (_21, 9), + (_22, 10), + (_23, 11), + (_24, 12), + (_25, 13), + (_26, 14), + (_27, 15), + (_28, 16), + (_29, 17), + (_30, 18), + (_31, 19), + (_32, 20), + (_33, 21), + (_34, 22), + (_35, 23), + (_36, 24), + (_37, 25), + (_38, 26), + (_39, 27), + (_40, 28), + (_41, 29), + (_42, 30), + (_43, 31), + (_44, 32), + (_45, 33), + (_46, 34), + (_47, 35), + (_48, 36), + (_49, 37), + (_50, 38), + (_51, 39), + (_52, 40), + (_53, 41), + (_54, 42), + (_55, 43), + (_56, 44), + (_57, 45), + (_58, 46), + (_59, 47), + (_60, 48), + (_61, 49), + (_62, 50), + (_63, 51), + (_64, 52), + (_65, 53), + (_66, 54), + (_67, 55), + (_68, 56), + (_69, 57), + (_70, 58), + (_71, 59), + (_72, 60), + (_73, 61), + (_74, 62), + (_75, 63), + (_76, 64), + (_77, 128), + (_78, 256), + (_79, 512), + (_80, 1024), + (_81, 2048), + (_82, 4096), + (_83, 8192), + (_84, 16384), + (_85, 32768), + (_86, 65536), + } } #[test] @@ -88,14 +840,14 @@ fn suffix_with_should_work() { #[test] fn slice_n_into_should_work() { - assert_eq!(slice_n_into::(b"Love Jane Forever"), Ok(LJFN(*b"Love Jane Forever"))); + assert_eq!(slice_n_into::(b"Love Jane Forever"), Ok(Ljfn(*b"Love Jane Forever"))); } #[test] fn slice_n_into_unchecked_should_work() { assert_eq!( - slice_n_into_unchecked::(b"Love Jane Forever"), - LJFN(*b"Love Jane Forever") + slice_n_into_unchecked::(b"Love Jane Forever"), + Ljfn(*b"Love Jane Forever") ); } @@ -107,16 +859,16 @@ fn vec2array_should_work() { #[test] fn vec_n_into_should_work() { assert_eq!( - vec_n_into::(b"Love Jane Forever".to_vec()), - Ok(LJFN(*b"Love Jane Forever")) + vec_n_into::(b"Love Jane Forever".to_vec()), + Ok(Ljfn(*b"Love Jane Forever")) ); } #[test] fn vec_n_into_unchecked_should_work() { assert_eq!( - vec_n_into_unchecked::(b"Love Jane Forever".to_vec()), - LJFN(*b"Love Jane Forever") + vec_n_into_unchecked::(b"Love Jane Forever".to_vec()), + Ljfn(*b"Love Jane Forever") ); } @@ -318,80 +1070,80 @@ fn hex2slice_unchecked_should_work() { #[test] fn hex_into_should_work() { assert_eq!( - hex_into::<_, LJF>("0x4c6f7665204a616e6520466f7265766572"), - Ok(LJF(b"Love Jane Forever".to_vec())) + hex_into::<_, Ljf>("0x4c6f7665204a616e6520466f7265766572"), + Ok(Ljf(b"Love Jane Forever".to_vec())) ); assert_eq!( - hex_into::<_, LJF>("0x4c6f7665204a616e6520466f7265766572".as_bytes()), - Ok(LJF(b"Love Jane Forever".to_vec())) + hex_into::<_, Ljf>("0x4c6f7665204a616e6520466f7265766572".as_bytes()), + Ok(Ljf(b"Love Jane Forever".to_vec())) ); assert_eq!( - hex_into::<_, LJF>("4c6f7665204a616e6520466f7265766572"), - Ok(LJF(b"Love Jane Forever".to_vec())) + hex_into::<_, Ljf>("4c6f7665204a616e6520466f7265766572"), + Ok(Ljf(b"Love Jane Forever".to_vec())) ); assert_eq!( - hex_into::<_, LJF>("4c6f7665204a616e6520466f7265766572".as_bytes()), - Ok(LJF(b"Love Jane Forever".to_vec())) + hex_into::<_, Ljf>("4c6f7665204a616e6520466f7265766572".as_bytes()), + Ok(Ljf(b"Love Jane Forever".to_vec())) ); } #[test] fn hex_n_into_should_work() { assert_eq!( - hex_n_into::<_, LJFN, 17>("0x4c6f7665204a616e6520466f7265766572"), - Ok(LJFN(*b"Love Jane Forever")) + hex_n_into::<_, Ljfn, 17>("0x4c6f7665204a616e6520466f7265766572"), + Ok(Ljfn(*b"Love Jane Forever")) ); assert_eq!( - hex_n_into::<_, LJFN, 17>("0x4c6f7665204a616e6520466f7265766572".as_bytes()), - Ok(LJFN(*b"Love Jane Forever")) + hex_n_into::<_, Ljfn, 17>("0x4c6f7665204a616e6520466f7265766572".as_bytes()), + Ok(Ljfn(*b"Love Jane Forever")) ); assert_eq!( - hex_n_into::<_, LJFN, 17>("4c6f7665204a616e6520466f7265766572"), - Ok(LJFN(*b"Love Jane Forever")) + hex_n_into::<_, Ljfn, 17>("4c6f7665204a616e6520466f7265766572"), + Ok(Ljfn(*b"Love Jane Forever")) ); assert_eq!( - hex_n_into::<_, LJFN, 17>("4c6f7665204a616e6520466f7265766572".as_bytes()), - Ok(LJFN(*b"Love Jane Forever")) + hex_n_into::<_, Ljfn, 17>("4c6f7665204a616e6520466f7265766572".as_bytes()), + Ok(Ljfn(*b"Love Jane Forever")) ); } #[test] fn hex_into_unchecked_should_work() { assert_eq!( - hex_into_unchecked::<_, LJF>("0x4c6f7665204a616e6520466f7265766572"), - LJF(b"Love Jane Forever".to_vec()) + hex_into_unchecked::<_, Ljf>("0x4c6f7665204a616e6520466f7265766572"), + Ljf(b"Love Jane Forever".to_vec()) ); assert_eq!( - hex_into_unchecked::<_, LJF>("0x4c6f7665204a616e6520466f7265766572".as_bytes()), - LJF(b"Love Jane Forever".to_vec()) + hex_into_unchecked::<_, Ljf>("0x4c6f7665204a616e6520466f7265766572".as_bytes()), + Ljf(b"Love Jane Forever".to_vec()) ); assert_eq!( - hex_into_unchecked::<_, LJF>("4c6f7665204a616e6520466f7265766572"), - LJF(b"Love Jane Forever".to_vec()) + hex_into_unchecked::<_, Ljf>("4c6f7665204a616e6520466f7265766572"), + Ljf(b"Love Jane Forever".to_vec()) ); assert_eq!( - hex_into_unchecked::<_, LJF>("4c6f7665204a616e6520466f7265766572".as_bytes()), - LJF(b"Love Jane Forever".to_vec()) + hex_into_unchecked::<_, Ljf>("4c6f7665204a616e6520466f7265766572".as_bytes()), + Ljf(b"Love Jane Forever".to_vec()) ); } #[test] fn hex_n_into_unchecked_should_work() { assert_eq!( - hex_n_into_unchecked::<_, LJFN, 17>("0x4c6f7665204a616e6520466f7265766572"), - LJFN(*b"Love Jane Forever") + hex_n_into_unchecked::<_, Ljfn, 17>("0x4c6f7665204a616e6520466f7265766572"), + Ljfn(*b"Love Jane Forever") ); assert_eq!( - hex_n_into_unchecked::<_, LJFN, 17>("0x4c6f7665204a616e6520466f7265766572".as_bytes()), - LJFN(*b"Love Jane Forever") + hex_n_into_unchecked::<_, Ljfn, 17>("0x4c6f7665204a616e6520466f7265766572".as_bytes()), + Ljfn(*b"Love Jane Forever") ); assert_eq!( - hex_n_into_unchecked::<_, LJFN, 17>("4c6f7665204a616e6520466f7265766572"), - LJFN(*b"Love Jane Forever") + hex_n_into_unchecked::<_, Ljfn, 17>("4c6f7665204a616e6520466f7265766572"), + Ljfn(*b"Love Jane Forever") ); assert_eq!( - hex_n_into_unchecked::<_, LJFN, 17>("4c6f7665204a616e6520466f7265766572".as_bytes()), - LJFN(*b"Love Jane Forever") + hex_n_into_unchecked::<_, Ljfn, 17>("4c6f7665204a616e6520466f7265766572".as_bytes()), + Ljfn(*b"Love Jane Forever") ); } @@ -399,28 +1151,28 @@ fn hex_n_into_unchecked_should_work() { #[test] fn hex_deserialize_into_should_work() { #[derive(Debug, PartialEq, Deserialize)] - struct WrappedLJF { + struct WrappedLjf { #[serde(deserialize_with = "hex_deserialize_into")] - ljf: LJF, + ljf: Ljf, } assert_eq!( - serde_json::from_str::( + serde_json::from_str::( r#"{ "ljf": "0x4c6f7665204a616e6520466f7265766572" }"# ) .unwrap(), - WrappedLJF { ljf: LJF(b"Love Jane Forever".to_vec()) } + WrappedLjf { ljf: Ljf(b"Love Jane Forever".to_vec()) } ); assert_eq!( - serde_json::from_str::( + serde_json::from_str::( r#"{ "ljf": "4c6f7665204a616e6520466f7265766572" }"# ) .unwrap(), - WrappedLJF { ljf: LJF(b"Love Jane Forever".to_vec()) } + WrappedLjf { ljf: Ljf(b"Love Jane Forever".to_vec()) } ); } @@ -428,115 +1180,104 @@ fn hex_deserialize_into_should_work() { #[test] fn hex_deserialize_n_into_should_work() { #[derive(Debug, PartialEq, Deserialize)] - struct WrappedLJF { + struct WrappedLjf { #[serde(deserialize_with = "hex_deserialize_n_into")] - ljf: LJFN, + ljf: Ljfn, } assert_eq!( - serde_json::from_str::( + serde_json::from_str::( r#"{ "ljf": "0x4c6f7665204a616e6520466f7265766572" }"# ) .unwrap(), - WrappedLJF { ljf: LJFN(*b"Love Jane Forever") } + WrappedLjf { ljf: Ljfn(*b"Love Jane Forever") } ); assert_eq!( - serde_json::from_str::( + serde_json::from_str::( r#"{ "ljf": "4c6f7665204a616e6520466f7265766572" }"# ) .unwrap(), - WrappedLJF { ljf: LJFN(*b"Love Jane Forever") } + WrappedLjf { ljf: Ljfn(*b"Love Jane Forever") } ); } #[cfg(feature = "serde")] #[test] -fn de_hex2num_should_work() { - macro_rules! assert_de_hex2num { - ($num_type:ty) => {{ - #[derive(Debug, PartialEq, Deserialize)] - struct LJFN { - #[serde(deserialize_with = "de_hex2num")] - _0: $num_type, - #[serde(deserialize_with = "de_hex2num")] - _1: $num_type, - #[serde(deserialize_with = "de_hex2num")] - _2: $num_type, - #[serde(deserialize_with = "de_hex2num")] - _3: u32, - } - - assert_eq!( - serde_json::from_str::( - r#"{ - "_0": "0x5", - "_1": "0x2", - "_2": "0x0", - "_3": "0x522" - }"# - ) - .unwrap(), - LJFN { _0: 5, _1: 2, _2: 0, _3: 1314 } - ); - assert_eq!( - serde_json::from_str::( - r#"{ - "_0": "5", - "_1": "2", - "_2": "0", - "_3": "522" - }"# - ) - .unwrap(), - LJFN { _0: 5, _1: 2, _2: 0, _3: 1314 } - ); - }}; - } +fn de_try_from_hex_should_work() { + let ljf = LjfPredefined::default(); + let mut json = String::from( + r#"{ + "_0": "0x5", + "_1": "2", + "_2": "0x0", + "_3": "0x4f5da2", + "_4": "4f5da2", + "_5": "0x4f5da2", + "_6": "5", + "_7": "0x2", + "_8": "0", + "_9": "0x4f5da2", + "_10": "4f5da2", + "_11": "0x4f5da2", + "_12": "0x4c6f7665204a616e6520466f7265766572", + "_13": "0x05", + "_14": "0x0502", + "_15": "0x050200", + "_16": "0x05020001", + "_17": "0x0502000103", + "_18": "0x050200010301", + "_19": "0x05020001030104","#, + ); + + (20..=76).for_each(|i| { + json.push_str(&format!(r#""_{i}":"0x{}","#, "0".repeat((i - 12) * 2))); + }); + json.push_str(&format!(r#""_77":"{}","#, "0".repeat(128 * 2))); + json.push_str(&format!(r#""_78":"{}","#, "0".repeat(256 * 2))); + json.push_str(&format!(r#""_79":"{}","#, "0".repeat(512 * 2))); + json.push_str(&format!(r#""_80":"{}","#, "0".repeat(1024 * 2))); + json.push_str(&format!(r#""_81":"{}","#, "0".repeat(2048 * 2))); + json.push_str(&format!(r#""_82":"{}","#, "0".repeat(4096 * 2))); + json.push_str(&format!(r#""_83":"{}","#, "0".repeat(8192 * 2))); + json.push_str(&format!(r#""_84":"{}","#, "0".repeat(16384 * 2))); + json.push_str(&format!(r#""_85":"{}","#, "0".repeat(32768 * 2))); + json.push_str(&format!(r#""_86":"{}""#, "0".repeat(65536 * 2))); + json.push('}'); + + assert_eq!(ljf, serde_json::from_str::(&json).unwrap()); - assert_de_hex2num!(isize); - assert_de_hex2num!(i8); - assert_de_hex2num!(i16); - assert_de_hex2num!(i32); - assert_de_hex2num!(i64); - assert_de_hex2num!(i128); - assert_de_hex2num!(usize); - assert_de_hex2num!(u8); - assert_de_hex2num!(u16); - assert_de_hex2num!(u32); - assert_de_hex2num!(u64); - assert_de_hex2num!(u128); + let json = json.split(",").map(|l| l.replacen("0x", "", 1)).collect::>().join(","); + + assert_eq!(ljf, serde_json::from_str::(&json).unwrap()); } #[cfg(feature = "serde")] #[test] -fn de_hex2bytes_should_work() { - #[derive(Debug, PartialEq, Deserialize)] - struct LJFN { - #[serde(deserialize_with = "de_hex2bytes")] - ljf: Vec, +fn se_hex_should_work() { + let ljf = LjfPredefined::default(); + let json = serde_json::to_string(&ljf).unwrap(); + + assert_eq!(ljf, serde_json::from_str::(&json).unwrap()); +} + +#[cfg(feature = "serde")] +#[test] +fn se_hex_without_prefix_should_work() { + #[derive(Debug, PartialEq, Serialize)] + struct Ljf { + #[serde(serialize_with = "se_hex_without_prefix")] + _0: Vec, } + let ljf = Ljf { _0: b"Love Jane Forever".to_vec() }; + assert_eq!( - serde_json::from_str::( - r#"{ - "ljf": "0x4c6f7665204a616e6520466f7265766572" - }"# - ) - .unwrap(), - LJFN { ljf: (*b"Love Jane Forever").to_vec() } - ); - assert_eq!( - serde_json::from_str::( - r#"{ - "ljf": "4c6f7665204a616e6520466f7265766572" - }"# - ) - .unwrap(), - LJFN { ljf: (*b"Love Jane Forever").to_vec() } + serde_json::to_string(&ljf).unwrap(), + r#"{"_0":"4c6f7665204a616e6520466f7265766572"}"# ); } @@ -547,7 +1288,7 @@ fn random_input_should_work() { let data = [DATA_1, DATA_2].concat(); - for chunks_size in [8, 16, 32, 64, 128, 256, 512, 1024] { + [8, 16, 32, 64, 128, 256, 512, 1024].into_iter().for_each(|chunks_size| { let mut data_pieces = Vec::new(); data.chunks(chunks_size).enumerate().for_each(|(i, chunk)| { @@ -570,5 +1311,5 @@ fn random_input_should_work() { .collect::>(); assert_eq!(data_pieces.concat(), data) - } + }); }