This is an automated email from the ASF dual-hosted git repository.
chaokunyang pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/fory.git
The following commit(s) were added to refs/heads/main by this push:
new b3f6fc5ad feat(Rust): Support u128 & u128_array (#2899)
b3f6fc5ad is described below
commit b3f6fc5ade9456fa1d4636ed63d5463a43a50cdc
Author: urlyy <[email protected]>
AuthorDate: Thu Nov 6 11:21:06 2025 +0800
feat(Rust): Support u128 & u128_array (#2899)
## What does this PR do?
Support `u128` & `u128_array` in Rust native protocol.
## Related issues
close #2895
---
rust/fory-core/src/buffer.rs | 21 ++++++++++++++
rust/fory-core/src/meta/type_meta.rs | 1 +
rust/fory-core/src/resolver/type_resolver.rs | 2 ++
rust/fory-core/src/serializer/core.rs | 2 +-
rust/fory-core/src/serializer/list.rs | 4 ++-
rust/fory-core/src/serializer/primitive_list.rs | 2 +-
rust/fory-core/src/serializer/skip.rs | 6 ++++
rust/fory-core/src/serializer/unsigned_number.rs | 1 +
rust/fory-core/src/serializer/util.rs | 17 +++++++++--
rust/fory-core/src/types.rs | 37 +++++++++++++++---------
rust/fory-derive/src/object/util.rs | 15 ++++++++--
rust/tests/tests/test_unsigned.rs | 30 ++++++++++++++++++-
12 files changed, 116 insertions(+), 22 deletions(-)
diff --git a/rust/fory-core/src/buffer.rs b/rust/fory-core/src/buffer.rs
index 1141d035c..3dc7c40cb 100644
--- a/rust/fory-core/src/buffer.rs
+++ b/rust/fory-core/src/buffer.rs
@@ -179,6 +179,19 @@ impl<'a> Writer<'a> {
self.write_u64(value as u64);
}
+ #[inline(always)]
+ pub fn write_u128(&mut self, value: u128) {
+ #[cfg(target_endian = "little")]
+ {
+ let bytes = unsafe { &*(&value as *const u128 as *const [u8; 16])
};
+ self.bf.extend_from_slice(bytes);
+ }
+ #[cfg(target_endian = "big")]
+ {
+ self.bf.extend_from_slice(&value.to_le_bytes());
+ }
+ }
+
#[inline(always)]
pub fn write_varint32(&mut self, value: i32) {
let zigzag = ((value as i64) << 1) ^ ((value as i64) >> 31);
@@ -523,6 +536,14 @@ impl<'a> Reader<'a> {
Ok(self.read_u64()? as usize)
}
+ #[inline(always)]
+ pub fn read_u128(&mut self) -> Result<u128, Error> {
+ let slice = self.slice_after_cursor();
+ let result = LittleEndian::read_u128(slice);
+ self.cursor += 16;
+ Ok(result)
+ }
+
#[inline(always)]
pub fn read_i64(&mut self) -> Result<i64, Error> {
Ok(self.read_u64()? as i64)
diff --git a/rust/fory-core/src/meta/type_meta.rs
b/rust/fory-core/src/meta/type_meta.rs
index 9b58a05ef..641fa7be7 100644
--- a/rust/fory-core/src/meta/type_meta.rs
+++ b/rust/fory-core/src/meta/type_meta.rs
@@ -462,6 +462,7 @@ impl TypeMetaLayer {
TypeId::U32 => 4,
TypeId::U64 => 8,
TypeId::USIZE => 8,
+ TypeId::U128 => 16,
_ => unreachable!(),
}
}
diff --git a/rust/fory-core/src/resolver/type_resolver.rs
b/rust/fory-core/src/resolver/type_resolver.rs
index f86090967..2709cc837 100644
--- a/rust/fory-core/src/resolver/type_resolver.rs
+++ b/rust/fory-core/src/resolver/type_resolver.rs
@@ -553,6 +553,7 @@ impl TypeResolver {
self.register_internal_serializer::<u32>(TypeId::U32)?;
self.register_internal_serializer::<u64>(TypeId::U64)?;
self.register_internal_serializer::<usize>(TypeId::USIZE)?;
+ self.register_internal_serializer::<u128>(TypeId::U128)?;
self.register_internal_serializer::<String>(TypeId::STRING)?;
self.register_internal_serializer::<NaiveDateTime>(TypeId::TIMESTAMP)?;
self.register_internal_serializer::<NaiveDate>(TypeId::LOCAL_DATE)?;
@@ -569,6 +570,7 @@ impl TypeResolver {
self.register_internal_serializer::<Vec<u32>>(TypeId::U32_ARRAY)?;
self.register_internal_serializer::<Vec<u64>>(TypeId::U64_ARRAY)?;
self.register_internal_serializer::<Vec<usize>>(TypeId::USIZE_ARRAY)?;
+ self.register_internal_serializer::<Vec<u128>>(TypeId::U128_ARRAY)?;
self.register_generic_trait::<Vec<String>>()?;
self.register_generic_trait::<LinkedList<i32>>()?;
self.register_generic_trait::<LinkedList<String>>()?;
diff --git a/rust/fory-core/src/serializer/core.rs
b/rust/fory-core/src/serializer/core.rs
index df443cec4..6351e3127 100644
--- a/rust/fory-core/src/serializer/core.rs
+++ b/rust/fory-core/src/serializer/core.rs
@@ -1073,7 +1073,7 @@ pub trait Serializer: 'static {
///
/// # Type ID Categories
///
- /// - **Primitives**: `I8`, `I16`, `I32`, `I64`, `U8`, `U16`, `U32`,
`U64`, `F32`, `F64`, `BOOL`
+ /// - **Primitives**: `BOOL`, `I8`, `I16`, `I32`, `I64`, `U8`, `U16`,
`U32`, `U64`, `USIZE`, `U128`, `F32`, `F64`
/// - **Strings**: `STRING`
/// - **Collections**: `LIST`, `MAP`, `SET`
/// - **Structs**: `STRUCT`
diff --git a/rust/fory-core/src/serializer/list.rs
b/rust/fory-core/src/serializer/list.rs
index b1ab31c6f..58711242c 100644
--- a/rust/fory-core/src/serializer/list.rs
+++ b/rust/fory-core/src/serializer/list.rs
@@ -47,6 +47,7 @@ pub(super) fn get_primitive_type_id<T: Serializer>() ->
TypeId {
TypeId::U32 => TypeId::U32_ARRAY,
TypeId::U64 => TypeId::U64_ARRAY,
TypeId::USIZE => TypeId::USIZE_ARRAY,
+ TypeId::U128 => TypeId::U128_ARRAY,
_ => TypeId::UNKNOWN,
}
}
@@ -69,7 +70,8 @@ pub(super) fn is_primitive_type<T: Serializer>() -> bool {
| TypeId::U16
| TypeId::U32
| TypeId::U64
- | TypeId::USIZE,
+ | TypeId::USIZE
+ | TypeId::U128,
)
}
diff --git a/rust/fory-core/src/serializer/primitive_list.rs
b/rust/fory-core/src/serializer/primitive_list.rs
index 168e56178..d0a32e717 100644
--- a/rust/fory-core/src/serializer/primitive_list.rs
+++ b/rust/fory-core/src/serializer/primitive_list.rs
@@ -26,7 +26,7 @@ pub fn fory_write_data<T: Serializer>(this: &[T], context:
&mut WriteContext) ->
if context.is_xlang()
&& matches!(
T::fory_static_type_id(),
- TypeId::U8 | TypeId::U16 | TypeId::U32 | TypeId::U64 |
TypeId::USIZE
+ TypeId::U8 | TypeId::U16 | TypeId::U32 | TypeId::U64 |
TypeId::USIZE | TypeId::U128
)
{
return Err(Error::not_allowed(
diff --git a/rust/fory-core/src/serializer/skip.rs
b/rust/fory-core/src/serializer/skip.rs
index ea103bd37..cb8a23130 100644
--- a/rust/fory-core/src/serializer/skip.rs
+++ b/rust/fory-core/src/serializer/skip.rs
@@ -424,6 +424,9 @@ fn skip_value(
types::USIZE => {
<usize as Serializer>::fory_read_data(context)?;
}
+ types::U128 => {
+ <u128 as Serializer>::fory_read_data(context)?;
+ }
types::U16_ARRAY => {
<Vec<u16> as Serializer>::fory_read_data(context)?;
}
@@ -436,6 +439,9 @@ fn skip_value(
types::USIZE_ARRAY => {
<Vec<usize> as Serializer>::fory_read_data(context)?;
}
+ types::U128_ARRAY => {
+ <Vec<u128> as Serializer>::fory_read_data(context)?;
+ }
// Container types
types::LIST | types::SET => {
diff --git a/rust/fory-core/src/serializer/unsigned_number.rs
b/rust/fory-core/src/serializer/unsigned_number.rs
index 9277b7e4d..4d424fee4 100644
--- a/rust/fory-core/src/serializer/unsigned_number.rs
+++ b/rust/fory-core/src/serializer/unsigned_number.rs
@@ -98,3 +98,4 @@ impl_unsigned_num_serializer!(
Reader::read_usize,
TypeId::USIZE
);
+impl_unsigned_num_serializer!(u128, Writer::write_u128, Reader::read_u128,
TypeId::U128);
diff --git a/rust/fory-core/src/serializer/util.rs
b/rust/fory-core/src/serializer/util.rs
index b82ece8df..8f02a46a1 100644
--- a/rust/fory-core/src/serializer/util.rs
+++ b/rust/fory-core/src/serializer/util.rs
@@ -21,8 +21,8 @@ use crate::resolver::context::{ReadContext, WriteContext};
use crate::serializer::Serializer;
use crate::types::TypeId;
use crate::types::{
- is_user_type, BOOL, ENUM, FLOAT32, FLOAT64, INT16, INT32, INT64, INT8,
NAMED_ENUM, U16, U32,
- U64, U8, USIZE,
+ is_user_type, BOOL, ENUM, FLOAT32, FLOAT64, INT16, INT32, INT64, INT8,
NAMED_ENUM, U128, U16,
+ U32, U64, U8, USIZE,
};
#[inline(always)]
@@ -70,7 +70,18 @@ pub const fn field_need_write_ref_into(type_id: u32,
nullable: bool) -> bool {
let internal_type_id = type_id & 0xff;
!matches!(
internal_type_id,
- BOOL | INT8 | INT16 | INT32 | INT64 | FLOAT32 | FLOAT64 | U8 | U16 |
U32 | U64 | USIZE
+ BOOL | INT8
+ | INT16
+ | INT32
+ | INT64
+ | FLOAT32
+ | FLOAT64
+ | U8
+ | U16
+ | U32
+ | U64
+ | USIZE
+ | U128
)
}
diff --git a/rust/fory-core/src/types.rs b/rust/fory-core/src/types.rs
index f736d70b7..f3733bf0c 100644
--- a/rust/fory-core/src/types.rs
+++ b/rust/fory-core/src/types.rs
@@ -86,14 +86,16 @@ pub enum TypeId {
U32 = 66,
U64 = 67,
USIZE = 68,
- VAR_U32 = 69,
- VAR_U64 = 70,
- SLI_U64 = 71,
- U16_ARRAY = 72,
- U32_ARRAY = 73,
- U64_ARRAY = 74,
- USIZE_ARRAY = 75,
- UNKNOWN = 76,
+ U128 = 69,
+ VAR_U32 = 70,
+ VAR_U64 = 71,
+ SLI_U64 = 72,
+ U16_ARRAY = 73,
+ U32_ARRAY = 74,
+ U64_ARRAY = 75,
+ USIZE_ARRAY = 76,
+ U128_ARRAY = 77,
+ UNKNOWN = 78,
}
pub const BOOL: u32 = TypeId::BOOL as u32;
@@ -140,6 +142,7 @@ pub const U16: u32 = TypeId::U16 as u32;
pub const U32: u32 = TypeId::U32 as u32;
pub const U64: u32 = TypeId::U64 as u32;
pub const USIZE: u32 = TypeId::USIZE as u32;
+pub const U128: u32 = TypeId::U128 as u32;
pub const VAR_U32: u32 = TypeId::VAR_U32 as u32;
pub const VAR_U64: u32 = TypeId::VAR_U64 as u32;
pub const SLI_U64: u32 = TypeId::SLI_U64 as u32;
@@ -147,6 +150,7 @@ pub const U16_ARRAY: u32 = TypeId::U16_ARRAY as u32;
pub const U32_ARRAY: u32 = TypeId::U32_ARRAY as u32;
pub const U64_ARRAY: u32 = TypeId::U64_ARRAY as u32;
pub const USIZE_ARRAY: u32 = TypeId::USIZE_ARRAY as u32;
+pub const U128_ARRAY: u32 = TypeId::U128_ARRAY as u32;
pub const UNKNOWN: u32 = TypeId::UNKNOWN as u32;
const MAX_UNT32: u64 = (1 << 31) - 1;
@@ -164,7 +168,7 @@ pub fn compute_string_hash(s: &str) -> u32 {
hash as u32
}
-pub static BASIC_TYPES: [TypeId; 27] = [
+pub static BASIC_TYPES: [TypeId; 29] = [
TypeId::BOOL,
TypeId::INT8,
TypeId::INT16,
@@ -188,13 +192,15 @@ pub static BASIC_TYPES: [TypeId; 27] = [
TypeId::U32,
TypeId::U64,
TypeId::USIZE,
+ TypeId::U128,
TypeId::U16_ARRAY,
TypeId::U32_ARRAY,
TypeId::U64_ARRAY,
TypeId::USIZE_ARRAY,
+ TypeId::U128_ARRAY,
];
-pub static PRIMITIVE_TYPES: [u32; 12] = [
+pub static PRIMITIVE_TYPES: [u32; 13] = [
TypeId::BOOL as u32,
TypeId::INT8 as u32,
TypeId::INT16 as u32,
@@ -207,9 +213,10 @@ pub static PRIMITIVE_TYPES: [u32; 12] = [
TypeId::U32 as u32,
TypeId::U64 as u32,
TypeId::USIZE as u32,
+ TypeId::U128 as u32,
];
-pub static PRIMITIVE_ARRAY_TYPES: [u32; 12] = [
+pub static PRIMITIVE_ARRAY_TYPES: [u32; 13] = [
TypeId::BOOL_ARRAY as u32,
TypeId::BINARY as u32,
TypeId::INT8_ARRAY as u32,
@@ -221,10 +228,11 @@ pub static PRIMITIVE_ARRAY_TYPES: [u32; 12] = [
TypeId::U16_ARRAY as u32,
TypeId::U32_ARRAY as u32,
TypeId::U64_ARRAY as u32,
- TypeId::U64_ARRAY as u32,
+ TypeId::USIZE_ARRAY as u32,
+ TypeId::U128_ARRAY as u32,
];
-pub static BASIC_TYPE_NAMES: [&str; 15] = [
+pub static BASIC_TYPE_NAMES: [&str; 16] = [
"bool",
"i8",
"i16",
@@ -240,6 +248,7 @@ pub static BASIC_TYPE_NAMES: [&str; 15] = [
"u32",
"u64",
"usize",
+ "u128",
];
pub static CONTAINER_TYPES: [TypeId; 3] = [TypeId::LIST, TypeId::SET,
TypeId::MAP];
@@ -259,6 +268,7 @@ pub static PRIMITIVE_ARRAY_TYPE_MAP: &[(&str, u32, &str)] =
&[
("u32", TypeId::U32_ARRAY as u32, "Vec<u32>"),
("u64", TypeId::U64_ARRAY as u32, "Vec<u64>"),
("usize", TypeId::USIZE_ARRAY as u32, "Vec<usize>"),
+ ("u128", TypeId::U128_ARRAY as u32, "Vec<u128>"),
];
/// Keep as const fn for compile time evaluation or constant folding
@@ -278,6 +288,7 @@ pub const fn is_primitive_type_id(type_id: TypeId) -> bool {
| TypeId::U32
| TypeId::U64
| TypeId::USIZE
+ | TypeId::U128
)
}
diff --git a/rust/fory-derive/src/object/util.rs
b/rust/fory-derive/src/object/util.rs
index 8d567adc0..2b50a7393 100644
--- a/rust/fory-derive/src/object/util.rs
+++ b/rust/fory-derive/src/object/util.rs
@@ -408,6 +408,7 @@ pub(super) fn generic_tree_to_tokens(node: &TypeNode) ->
TokenStream {
"u32" => quote! { fory_core::types::TypeId::U32_ARRAY as
u32 },
"u64" => quote! { fory_core::types::TypeId::U64_ARRAY as
u32 },
"usize" => quote! { fory_core::types::TypeId::USIZE_ARRAY
as u32 },
+ "u128" => quote! { fory_core::types::TypeId::U128_ARRAY as
u32 },
_ => quote! { fory_core::types::TypeId::LIST as u32 },
};
return quote! {
@@ -528,8 +529,8 @@ fn extract_option_inner(s: &str) -> Option<&str> {
s.strip_prefix("Option<")?.strip_suffix(">")
}
-const PRIMITIVE_TYPE_NAMES: [&str; 12] = [
- "bool", "i8", "i16", "i32", "i64", "f32", "f64", "u8", "u16", "u32",
"u64", "usize",
+const PRIMITIVE_TYPE_NAMES: [&str; 13] = [
+ "bool", "i8", "i16", "i32", "i64", "f32", "f64", "u8", "u16", "u32",
"u64", "usize", "u128",
];
fn get_primitive_type_id(ty: &str) -> u32 {
@@ -546,6 +547,7 @@ fn get_primitive_type_id(ty: &str) -> u32 {
"u32" => TypeId::U32 as u32,
"u64" => TypeId::U64 as u32,
"usize" => TypeId::USIZE as u32,
+ "u128" => TypeId::U128 as u32,
_ => unreachable!("Unknown primitive type: {}", ty),
}
}
@@ -569,6 +571,7 @@ static PRIMITIVE_IO_METHODS: &[(&str, &str, &str)] = &[
("u32", "write_u32", "read_u32"),
("u64", "write_u64", "read_u64"),
("usize", "write_usize", "read_usize"),
+ ("u128", "write_u128", "read_u128"),
];
/// Check if a type is a direct primitive numeric type (not wrapped in Option,
Vec, etc.)
@@ -654,6 +657,7 @@ pub(crate) fn get_type_id_by_name(ty: &str) -> u32 {
"Vec<u32>" => return TypeId::U32_ARRAY as u32,
"Vec<u64>" => return TypeId::U64_ARRAY as u32,
"Vec<usize>" => return TypeId::USIZE_ARRAY as u32,
+ "Vec<u128>" => return TypeId::U128_ARRAY as u32,
_ => {}
}
@@ -675,6 +679,7 @@ pub(crate) fn get_type_id_by_name(ty: &str) -> u32 {
"u32" => return TypeId::U32_ARRAY as u32,
"u64" => return TypeId::U64_ARRAY as u32,
"usize" => return TypeId::USIZE_ARRAY as u32,
+ "u128" => return TypeId::U128_ARRAY as u32,
_ => {
// Non-primitive array elements, treat as LIST
return TypeId::LIST as u32;
@@ -727,6 +732,7 @@ fn get_primitive_type_size(type_id_num: u32) -> i32 {
TypeId::U32 => 4,
TypeId::U64 => 8,
TypeId::USIZE => 8,
+ TypeId::U128 => 16,
_ => unreachable!(),
}
}
@@ -757,6 +763,11 @@ fn is_internal_type_id(type_id: u32) -> bool {
TypeId::FLOAT16_ARRAY as u32,
TypeId::FLOAT32_ARRAY as u32,
TypeId::FLOAT64_ARRAY as u32,
+ TypeId::U16_ARRAY as u32,
+ TypeId::U32_ARRAY as u32,
+ TypeId::U64_ARRAY as u32,
+ TypeId::USIZE_ARRAY as u32,
+ TypeId::U128_ARRAY as u32,
]
.contains(&type_id)
}
diff --git a/rust/tests/tests/test_unsigned.rs
b/rust/tests/tests/test_unsigned.rs
index 68d2b1f2d..f6c790e3d 100644
--- a/rust/tests/tests/test_unsigned.rs
+++ b/rust/tests/tests/test_unsigned.rs
@@ -29,6 +29,7 @@ fn test_unsigned_numbers() {
test_roundtrip(&fory, u32::MAX);
test_roundtrip(&fory, u64::MAX);
test_roundtrip(&fory, usize::MAX);
+ test_roundtrip(&fory, u128::MAX);
}
#[test]
@@ -39,6 +40,7 @@ fn test_unsigned_arrays() {
test_roundtrip(&fory, vec![0u32, 1000, 1000000, u32::MAX]);
test_roundtrip(&fory, vec![0u64, 1000000, 1000000000000, u64::MAX]);
test_roundtrip(&fory, vec![0usize, 1000000, 1000000000000, usize::MAX]);
+ test_roundtrip(&fory, vec![0u128, 1000000000000, u128::MAX]);
}
#[test]
@@ -49,6 +51,7 @@ fn test_unsigned_arrays_when_xlang() {
assert!(fory.serialize(&vec![u32::MAX]).is_err());
assert!(fory.serialize(&vec![u64::MAX]).is_err());
assert!(fory.serialize(&vec![usize::MAX]).is_err());
+ assert!(fory.serialize(&vec![u128::MAX]).is_err());
}
#[test]
@@ -60,11 +63,13 @@ fn test_unsigned_struct_non_compatible() {
c: u32,
d: u64,
e: usize,
+ f: u128,
vec_u8: Vec<u8>,
vec_u16: Vec<u16>,
vec_u32: Vec<u32>,
vec_u64: Vec<u64>,
vec_usize: Vec<usize>,
+ vec_u128: Vec<u128>,
}
let mut fory = Fory::default();
@@ -76,11 +81,13 @@ fn test_unsigned_struct_non_compatible() {
c: u32::MAX,
d: u64::MAX,
e: usize::MAX,
+ f: u128::MAX,
vec_u8: vec![0, 1, 10, u8::MAX],
vec_u16: vec![0, 100, 1000, u16::MAX],
vec_u32: vec![0, 1000, 1000000, u32::MAX],
vec_u64: vec![0, 1000000, 1000000000000, u64::MAX],
vec_usize: vec![0, 1000000, 1000000000000, usize::MAX],
+ vec_u128: vec![0u128, 1000000000000, u128::MAX],
};
let bytes = fory.serialize(&data).unwrap();
@@ -97,11 +104,13 @@ fn test_unsigned_struct_compatible() {
c: u32,
d: u64,
e: usize,
+ f: u128,
vec_u8: Vec<u8>,
vec_u16: Vec<u16>,
vec_u32: Vec<u32>,
vec_u64: Vec<u64>,
vec_usize: Vec<usize>,
+ vec_u128: Vec<u128>,
}
let mut fory = Fory::default().compatible(true);
@@ -113,11 +122,13 @@ fn test_unsigned_struct_compatible() {
c: u32::MAX,
d: u64::MAX,
e: usize::MAX,
+ f: u128::MAX,
vec_u8: vec![0, 1, 10, u8::MAX],
vec_u16: vec![0, 100, 1000, u16::MAX],
vec_u32: vec![0, 1000, 1000000, u32::MAX],
vec_u64: vec![0, 1000000, 1000000000000, u64::MAX],
vec_usize: vec![0, 1000000, 1000000000000, usize::MAX],
+ vec_u128: vec![0u128, 1000000000000, u128::MAX],
};
let bytes = fory.serialize(&data).unwrap();
@@ -195,6 +206,7 @@ fn test_unsigned_edge_cases() {
test_roundtrip(&fory, 0u32);
test_roundtrip(&fory, 0u64);
test_roundtrip(&fory, 0usize);
+ test_roundtrip(&fory, 0u128);
// Test maximum values
test_roundtrip(&fory, u8::MAX);
@@ -202,6 +214,7 @@ fn test_unsigned_edge_cases() {
test_roundtrip(&fory, u32::MAX);
test_roundtrip(&fory, u64::MAX);
test_roundtrip(&fory, usize::MAX);
+ test_roundtrip(&fory, u128::MAX);
// Test empty arrays
test_roundtrip(&fory, Vec::<u8>::new());
@@ -209,6 +222,7 @@ fn test_unsigned_edge_cases() {
test_roundtrip(&fory, Vec::<u32>::new());
test_roundtrip(&fory, Vec::<u64>::new());
test_roundtrip(&fory, Vec::<usize>::new());
+ test_roundtrip(&fory, Vec::<u128>::new());
}
#[test]
@@ -220,6 +234,7 @@ fn test_unsigned_with_option_non_compatible() {
opt_u32: Option<u32>,
opt_u64: Option<u64>,
opt_usize: Option<usize>,
+ opt_u128: Option<u128>,
}
let mut fory = Fory::default();
@@ -232,6 +247,7 @@ fn test_unsigned_with_option_non_compatible() {
opt_u32: Some(u32::MAX),
opt_u64: Some(u64::MAX),
opt_usize: Some(usize::MAX),
+ opt_u128: Some(u128::MAX),
};
let bytes = fory.serialize(&data_some).unwrap();
@@ -245,6 +261,7 @@ fn test_unsigned_with_option_non_compatible() {
opt_u32: None,
opt_u64: None,
opt_usize: None,
+ opt_u128: None,
};
let bytes = fory.serialize(&data_none).unwrap();
@@ -261,6 +278,7 @@ fn test_unsigned_with_option_compatible() {
opt_u32: Option<u32>,
opt_u64: Option<u64>,
opt_usize: Option<usize>,
+ opt_u128: Option<u128>,
}
let mut fory = Fory::default().compatible(true);
@@ -273,6 +291,7 @@ fn test_unsigned_with_option_compatible() {
opt_u32: Some(u32::MAX),
opt_u64: Some(u64::MAX),
opt_usize: Some(usize::MAX),
+ opt_u128: Some(u128::MAX),
};
let bytes = fory.serialize(&data_some).unwrap();
@@ -286,6 +305,7 @@ fn test_unsigned_with_option_compatible() {
opt_u32: None,
opt_u64: None,
opt_usize: None,
+ opt_u128: None,
};
let bytes = fory.serialize(&data_none).unwrap();
@@ -310,6 +330,7 @@ fn test_unsigned_mixed_fields_compatible() {
new_u64: u64,
new_opt_u32: Option<u32>,
new_usize: usize,
+ new_u128: u128,
}
let mut fory1 = Fory::default().compatible(true);
@@ -330,7 +351,8 @@ fn test_unsigned_mixed_fields_compatible() {
assert_eq!(result.vec_u32, vec![1000, 2000, 3000]);
assert_eq!(result.new_u64, 0); // Default value
assert_eq!(result.new_opt_u32, None); // Default value
- assert_eq!(result.new_usize, 0)
+ assert_eq!(result.new_usize, 0); // Default value
+ assert_eq!(result.new_u128, 0); // Default value
}
#[test]
@@ -343,6 +365,7 @@ fn test_unsigned_with_smart_pointers() {
test_box_any(&fory, u32::MAX);
test_box_any(&fory, u64::MAX);
test_box_any(&fory, usize::MAX);
+ test_box_any(&fory, u128::MAX);
// Test Rc<dyn Any> with unsigned types
test_rc_any(&fory, u8::MAX);
@@ -350,6 +373,7 @@ fn test_unsigned_with_smart_pointers() {
test_rc_any(&fory, u32::MAX);
test_rc_any(&fory, u64::MAX);
test_rc_any(&fory, usize::MAX);
+ test_rc_any(&fory, u128::MAX);
// Test Arc<dyn Any> with unsigned types
test_arc_any(&fory, u8::MAX);
@@ -357,6 +381,7 @@ fn test_unsigned_with_smart_pointers() {
test_arc_any(&fory, u32::MAX);
test_arc_any(&fory, u64::MAX);
test_arc_any(&fory, usize::MAX);
+ test_arc_any(&fory, u128::MAX);
// Test Box<dyn Any> with unsigned arrays
test_box_any(&fory, vec![0u8, 127, u8::MAX]);
@@ -364,6 +389,7 @@ fn test_unsigned_with_smart_pointers() {
test_box_any(&fory, vec![0u32, 1000000, u32::MAX]);
test_box_any(&fory, vec![0u64, 1000000000000, u64::MAX]);
test_box_any(&fory, vec![0usize, 1000000000000, usize::MAX]);
+ test_box_any(&fory, vec![0u128, 1000000000000, u128::MAX]);
// Test Rc<dyn Any> with unsigned arrays
test_rc_any(&fory, vec![0u8, 127, u8::MAX]);
@@ -371,6 +397,7 @@ fn test_unsigned_with_smart_pointers() {
test_rc_any(&fory, vec![1000u32, 2000, 3000, u32::MAX]);
test_rc_any(&fory, vec![0u64, 1000000000000, u64::MAX]);
test_rc_any(&fory, vec![0usize, 1000000000000, usize::MAX]);
+ test_rc_any(&fory, vec![0u128, 1000000000000, u128::MAX]);
// Test Arc<dyn Any> with unsigned arrays
test_arc_any(&fory, vec![0u8, 127, u8::MAX]);
@@ -378,4 +405,5 @@ fn test_unsigned_with_smart_pointers() {
test_arc_any(&fory, vec![999u32, 888, 777, u32::MAX]);
test_arc_any(&fory, vec![123u64, 456789, 987654321, u64::MAX]);
test_arc_any(&fory, vec![123usize, 456789, 987654321, usize::MAX]);
+ test_arc_any(&fory, vec![0u128, 1000000000000, u128::MAX]);
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
