From 499f446a5ff6d920177790270179d20d50c6276f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?dj8yf0=CE=BCl?= <26653921+dj8yfo@users.noreply.github.com> Date: Tue, 26 Sep 2023 21:55:24 +0300 Subject: [PATCH] chore!: rename `"nil"` -> `"()"`, `"string"` -> `"String"`, `"nonzero_u16"` -> `"NonZeroU16"` (`schema::Declaration`) (#233) * chore!: rename `"nil"` -> `"()"` (`schema::Declaration`) * chore!: rename `"string"` -> `"String"` (`schema::Declaration`) * chore!: rename `"nonzero_u16"` -> `"NonZeroU16"` ... (`schema::Declaration`) --- borsh/src/schema.rs | 124 ++++++++++++--------- borsh/src/schema/container_ext/max_size.rs | 2 +- borsh/tests/test_schema_enums.rs | 18 ++- borsh/tests/test_schema_nested.rs | 42 +++---- borsh/tests/test_schema_recursive.rs | 16 +-- borsh/tests/test_schema_structs.rs | 66 +++++------ borsh/tests/test_schema_validate.rs | 2 +- borsh/tests/test_schema_with.rs | 40 +++---- 8 files changed, 165 insertions(+), 145 deletions(-) diff --git a/borsh/src/schema.rs b/borsh/src/schema.rs index 9145fdb32..701be6151 100644 --- a/borsh/src/schema.rs +++ b/borsh/src/schema.rs @@ -334,6 +334,20 @@ macro_rules! impl_for_renamed_primitives { } )+ }; + + ($($ty: ty : $name: expr, $size: expr);+) => { + $( + impl BorshSchema for $ty { + #[inline] + fn add_definitions_recursively(definitions: &mut BTreeMap) { + let definition = Definition::Primitive($size); + add_definition(Self::declaration(), definition, definitions); + } + #[inline] + fn declaration() -> Declaration { $name.into() } + } + )+ + }; } macro_rules! impl_for_primitives { @@ -347,20 +361,20 @@ impl_for_primitives!(u8 => 1; u16 => 2; u32 => 4; u64 => 8; u128 => 16); impl_for_renamed_primitives!(isize: i64 => 8); impl_for_renamed_primitives!(usize: u64 => 8); -impl_for_renamed_primitives!(core::num::NonZeroI8: nonzero_i8 => 1); -impl_for_renamed_primitives!(core::num::NonZeroI16: nonzero_i16 => 2); -impl_for_renamed_primitives!(core::num::NonZeroI32: nonzero_i32 => 4); -impl_for_renamed_primitives!(core::num::NonZeroI64: nonzero_i64 => 8); -impl_for_renamed_primitives!(core::num::NonZeroI128: nonzero_i128 => 16); -impl_for_renamed_primitives!(core::num::NonZeroU8: nonzero_u8 => 1); -impl_for_renamed_primitives!(core::num::NonZeroU16: nonzero_u16 => 2); -impl_for_renamed_primitives!(core::num::NonZeroU32: nonzero_u32 => 4); -impl_for_renamed_primitives!(core::num::NonZeroU64: nonzero_u64 => 8); -impl_for_renamed_primitives!(core::num::NonZeroU128: nonzero_u128 => 16); +impl_for_renamed_primitives!(core::num::NonZeroI8: NonZeroI8 => 1); +impl_for_renamed_primitives!(core::num::NonZeroI16: NonZeroI16 => 2); +impl_for_renamed_primitives!(core::num::NonZeroI32: NonZeroI32 => 4); +impl_for_renamed_primitives!(core::num::NonZeroI64: NonZeroI64 => 8); +impl_for_renamed_primitives!(core::num::NonZeroI128: NonZeroI128 => 16); +impl_for_renamed_primitives!(core::num::NonZeroU8: NonZeroU8 => 1); +impl_for_renamed_primitives!(core::num::NonZeroU16: NonZeroU16 => 2); +impl_for_renamed_primitives!(core::num::NonZeroU32: NonZeroU32 => 4); +impl_for_renamed_primitives!(core::num::NonZeroU64: NonZeroU64 => 8); +impl_for_renamed_primitives!(core::num::NonZeroU128: NonZeroU128 => 16); // see 12 lines above -impl_for_renamed_primitives!(core::num::NonZeroUsize: nonzero_u64 => 8); +impl_for_renamed_primitives!(core::num::NonZeroUsize: NonZeroUsize => 8); -impl_for_renamed_primitives!((): nil => 0); +impl_for_renamed_primitives!((): "()", 0); impl BorshSchema for String { #[inline] @@ -369,7 +383,7 @@ impl BorshSchema for String { } #[inline] fn declaration() -> Declaration { - "string".into() + str::declaration() } } impl BorshSchema for str { @@ -385,7 +399,7 @@ impl BorshSchema for str { } #[inline] fn declaration() -> Declaration { - "string".into() + "String".into() } } @@ -715,12 +729,12 @@ mod tests { "Option" => Definition::Enum { tag_width: 1, variants: vec![ - (0, "None".to_string(), "nil".to_string()), + (0, "None".to_string(), "()".to_string()), (1, "Some".to_string(), "u64".to_string()), ] }, "u64" => Definition::Primitive(8), - "nil" => Definition::Primitive(0) + "()" => Definition::Primitive(0) }, actual_defs ); @@ -737,19 +751,19 @@ mod tests { "Option" => Definition::Enum { tag_width: 1, variants: vec![ - (0, "None".to_string(), "nil".to_string()), + (0, "None".to_string(), "()".to_string()), (1, "Some".to_string(), "u64".to_string()), ] }, "Option>" => Definition::Enum { tag_width: 1, variants: vec![ - (0, "None".to_string(), "nil".to_string()), + (0, "None".to_string(), "()".to_string()), (1, "Some".to_string(), "Option".to_string()), ] }, "u64" => Definition::Primitive(8), - "nil" => Definition::Primitive(0) + "()" => Definition::Primitive(0) }, actual_defs ); @@ -803,19 +817,19 @@ mod tests { let actual_name = <(u64, core::num::NonZeroU16, String)>::declaration(); let mut actual_defs = map!(); <(u64, core::num::NonZeroU16, String)>::add_definitions_recursively(&mut actual_defs); - assert_eq!("Tuple", actual_name); + assert_eq!("Tuple", actual_name); assert_eq!( map! { - "Tuple" => Definition::Tuple { + "Tuple" => Definition::Tuple { elements: vec![ "u64".to_string(), - "nonzero_u16".to_string(), - "string".to_string() + "NonZeroU16".to_string(), + "String".to_string() ] }, "u64" => Definition::Primitive(8), - "nonzero_u16" => Definition::Primitive(2), - "string" => Definition::Sequence { + "NonZeroU16" => Definition::Primitive(2), + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -831,19 +845,19 @@ mod tests { let actual_name = <(u64, (u8, bool), String)>::declaration(); let mut actual_defs = map!(); <(u64, (u8, bool), String)>::add_definitions_recursively(&mut actual_defs); - assert_eq!("Tuple, string>", actual_name); + assert_eq!("Tuple, String>", actual_name); assert_eq!( map! { - "Tuple, string>" => Definition::Tuple { elements: vec![ + "Tuple, String>" => Definition::Tuple { elements: vec![ "u64".to_string(), "Tuple".to_string(), - "string".to_string(), + "String".to_string(), ]}, "Tuple" => Definition::Tuple { elements: vec![ "u8".to_string(), "bool".to_string()]}, "u64" => Definition::Primitive(8), "u8" => Definition::Primitive(1), "bool" => Definition::Primitive(1), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -859,19 +873,19 @@ mod tests { let actual_name = HashMap::::declaration(); let mut actual_defs = map!(); HashMap::::add_definitions_recursively(&mut actual_defs); - assert_eq!("HashMap", actual_name); + assert_eq!("HashMap", actual_name); assert_eq!( map! { - "HashMap" => Definition::Sequence { + "HashMap" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, - elements: "Tuple".to_string(), + elements: "Tuple".to_string(), } , - "Tuple" => Definition::Tuple { - elements: vec![ "u64".to_string(), "string".to_string()], + "Tuple" => Definition::Tuple { + elements: vec![ "u64".to_string(), "String".to_string()], }, "u64" => Definition::Primitive(8), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -889,15 +903,15 @@ mod tests { let actual_name = HashSet::::declaration(); let mut actual_defs = map!(); HashSet::::add_definitions_recursively(&mut actual_defs); - assert_eq!("HashSet", actual_name); + assert_eq!("HashSet", actual_name); assert_eq!( map! { - "HashSet" => Definition::Sequence { + "HashSet" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, - elements: "string".to_string(), + elements: "String".to_string(), }, - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -913,17 +927,17 @@ mod tests { let actual_name = BTreeMap::::declaration(); let mut actual_defs = map!(); BTreeMap::::add_definitions_recursively(&mut actual_defs); - assert_eq!("BTreeMap", actual_name); + assert_eq!("BTreeMap", actual_name); assert_eq!( map! { - "BTreeMap" => Definition::Sequence { + "BTreeMap" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, - elements: "Tuple".to_string(), + elements: "Tuple".to_string(), } , - "Tuple" => Definition::Tuple { elements: vec![ "u64".to_string(), "string".to_string()]}, + "Tuple" => Definition::Tuple { elements: vec![ "u64".to_string(), "String".to_string()]}, "u64" => Definition::Primitive(8), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -939,15 +953,15 @@ mod tests { let actual_name = BTreeSet::::declaration(); let mut actual_defs = map!(); BTreeSet::::add_definitions_recursively(&mut actual_defs); - assert_eq!("BTreeSet", actual_name); + assert_eq!("BTreeSet", actual_name); assert_eq!( map! { - "BTreeSet" => Definition::Sequence { + "BTreeSet" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, - elements: "string".to_string(), + elements: "String".to_string(), }, - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -1009,14 +1023,14 @@ mod tests { #[test] fn string() { let actual_name = str::declaration(); - assert_eq!("string", actual_name); + assert_eq!("String", actual_name); let actual_name = String::declaration(); - assert_eq!("string", actual_name); + assert_eq!("String", actual_name); let mut actual_defs = map!(); String::add_definitions_recursively(&mut actual_defs); assert_eq!( map! { - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -1030,7 +1044,7 @@ mod tests { str::add_definitions_recursively(&mut actual_defs); assert_eq!( map! { - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -1044,7 +1058,7 @@ mod tests { #[test] fn boxed_schema() { let boxed_declaration = Box::::declaration(); - assert_eq!("string", boxed_declaration); + assert_eq!("String", boxed_declaration); let boxed_declaration = Box::<[u8]>::declaration(); assert_eq!("Vec", boxed_declaration); } @@ -1052,9 +1066,9 @@ mod tests { #[test] fn phantom_data_schema() { let phantom_declaration = PhantomData::::declaration(); - assert_eq!("nil", phantom_declaration); + assert_eq!("()", phantom_declaration); let phantom_declaration = PhantomData::>::declaration(); - assert_eq!("nil", phantom_declaration); + assert_eq!("()", phantom_declaration); } #[test] diff --git a/borsh/src/schema/container_ext/max_size.rs b/borsh/src/schema/container_ext/max_size.rs index b71436bd4..8108b9daa 100644 --- a/borsh/src/schema/container_ext/max_size.rs +++ b/borsh/src/schema/container_ext/max_size.rs @@ -450,7 +450,7 @@ mod tests { tag_width: N, variants: vec![ (0, "Just".into(), T::declaration()), - (1, "Nothing".into(), "nil".into()), + (1, "Nothing".into(), <()>::declaration()), ], }; crate::schema::add_definition(Self::declaration(), definition, definitions); diff --git a/borsh/tests/test_schema_enums.rs b/borsh/tests/test_schema_enums.rs index cdb532cf9..ad6974879 100644 --- a/borsh/tests/test_schema_enums.rs +++ b/borsh/tests/test_schema_enums.rs @@ -270,19 +270,19 @@ pub fn complex_enum_generics() { fn common_map() -> BTreeMap { map! { - "EnumParametrized" => Definition::Enum { + "EnumParametrized" => Definition::Enum { tag_width: 1, variants: vec![ (0, "B".to_string(), "EnumParametrizedB".to_string()), - (1, "C".to_string(), "EnumParametrizedC".to_string()) + (1, "C".to_string(), "EnumParametrizedC".to_string()) ] }, "EnumParametrizedB" => Definition::Struct { fields: Fields::NamedFields(vec![ ("x".to_string(), "BTreeMap".to_string()), - ("y".to_string(), "string".to_string()), + ("y".to_string(), "String".to_string()), ("z".to_string(), "i8".to_string()) ])}, - "EnumParametrizedC" => Definition::Struct{ fields: Fields::UnnamedFields(vec!["string".to_string(), "u16".to_string()])}, + "EnumParametrizedC" => Definition::Struct{ fields: Fields::UnnamedFields(vec!["String".to_string(), "u16".to_string()])}, "BTreeMap" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, @@ -292,7 +292,7 @@ fn common_map() -> BTreeMap { "u32" => Definition::Primitive(4), "i8" => Definition::Primitive(1), "u16" => Definition::Primitive(2), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -330,7 +330,7 @@ pub fn generic_associated_item1() { } assert_eq!( - "EnumParametrized".to_string(), + "EnumParametrized".to_string(), >::declaration() ); @@ -367,6 +367,12 @@ pub fn generic_associated_item2() { }, C(T, u16), } + + assert_eq!( + "EnumParametrized".to_string(), + >::declaration() + ); + let mut defs = Default::default(); >::add_definitions_recursively(&mut defs); diff --git a/borsh/tests/test_schema_nested.rs b/borsh/tests/test_schema_nested.rs index 7d3c5e563..7b91c1e95 100644 --- a/borsh/tests/test_schema_nested.rs +++ b/borsh/tests/test_schema_nested.rs @@ -61,65 +61,65 @@ pub fn duplicated_instantiations() { Sausage { wrapper: W, filling: Filling }, } assert_eq!( - "A>".to_string(), + "A>".to_string(), >>::declaration() ); let mut defs = Default::default(); >>::add_definitions_recursively(&mut defs); assert_eq!( map! { - "A>" => Definition::Enum { + "A>" => Definition::Enum { tag_width: 1, variants: vec![ (0, "Bacon".to_string(), "ABacon".to_string()), (1, "Eggs".to_string(), "AEggs".to_string()), (2, "Salad".to_string(), "ASalad".to_string()), - (3, "Sausage".to_string(), "ASausage>".to_string()) + (3, "Sausage".to_string(), "ASausage>".to_string()) ] }, - "A" => Definition::Enum { + "A" => Definition::Enum { tag_width: 1, variants: vec![ (0, "Bacon".to_string(), "ABacon".to_string()), (1, "Eggs".to_string(), "AEggs".to_string()), - (2, "Salad".to_string(), "ASalad".to_string()), - (3, "Sausage".to_string(), "ASausage".to_string()) + (2, "Salad".to_string(), "ASalad".to_string()), + (3, "Sausage".to_string(), "ASausage".to_string()) ] }, "ABacon" => Definition::Struct {fields: Fields::Empty}, "AEggs" => Definition::Struct {fields: Fields::Empty}, - "ASalad" => Definition::Struct {fields: Fields::UnnamedFields(vec!["Tomatoes".to_string(), "Cucumber".to_string(), "Oil".to_string()])}, - "ASalad" => Definition::Struct { fields: Fields::UnnamedFields( vec!["Tomatoes".to_string(), "string".to_string(), "Oil".to_string() ])}, - "ASausage>" => Definition::Struct {fields: Fields::NamedFields(vec![("wrapper".to_string(), "Wrapper".to_string()), ("filling".to_string(), "Filling".to_string())])}, - "ASausage" => Definition::Struct{ fields: Fields::NamedFields(vec![("wrapper".to_string(), "string".to_string()), ("filling".to_string(), "Filling".to_string())])}, + "ASalad" => Definition::Struct {fields: Fields::UnnamedFields(vec!["Tomatoes".to_string(), "Cucumber".to_string(), "Oil".to_string()])}, + "ASalad" => Definition::Struct { fields: Fields::UnnamedFields( vec!["Tomatoes".to_string(), "String".to_string(), "Oil".to_string() ])}, + "ASausage>" => Definition::Struct {fields: Fields::NamedFields(vec![("wrapper".to_string(), "Wrapper".to_string()), ("filling".to_string(), "Filling".to_string())])}, + "ASausage" => Definition::Struct{ fields: Fields::NamedFields(vec![("wrapper".to_string(), "String".to_string()), ("filling".to_string(), "Filling".to_string())])}, "Cucumber" => Definition::Struct {fields: Fields::Empty}, "Filling" => Definition::Struct {fields: Fields::Empty}, - "HashMap" => Definition::Sequence { + "HashMap" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, - elements: "Tuple".to_string(), + elements: "Tuple".to_string(), }, - "Oil" => Definition::Struct { fields: Fields::NamedFields(vec![("seeds".to_string(), "HashMap".to_string()), ("liquid".to_string(), "Option".to_string())])}, - "Option" => Definition::Enum { + "Oil" => Definition::Struct { fields: Fields::NamedFields(vec![("seeds".to_string(), "HashMap".to_string()), ("liquid".to_string(), "Option".to_string())])}, + "Option" => Definition::Enum { tag_width: 1, variants: vec![ - (0, "None".to_string(), "nil".to_string()), - (1, "Some".to_string(), "string".to_string()) + (0, "None".to_string(), "()".to_string()), + (1, "Some".to_string(), "String".to_string()) ] }, "Option" => Definition::Enum { tag_width: 1, variants: vec![ - (0, "None".to_string(), "nil".to_string()), + (0, "None".to_string(), "()".to_string()), (1, "Some".to_string(), "u64".to_string()) ] }, "Tomatoes" => Definition::Struct {fields: Fields::Empty}, - "Tuple" => Definition::Tuple {elements: vec!["u64".to_string(), "string".to_string()]}, - "Wrapper" => Definition::Struct{ fields: Fields::NamedFields(vec![("foo".to_string(), "Option".to_string()), ("bar".to_string(), "A".to_string())])}, + "Tuple" => Definition::Tuple {elements: vec!["u64".to_string(), "String".to_string()]}, + "Wrapper" => Definition::Struct{ fields: Fields::NamedFields(vec![("foo".to_string(), "Option".to_string()), ("bar".to_string(), "A".to_string())])}, "u64" => Definition::Primitive(8), - "nil" => Definition::Primitive(0), - "string" => Definition::Sequence { + "()" => Definition::Primitive(0), + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() diff --git a/borsh/tests/test_schema_recursive.rs b/borsh/tests/test_schema_recursive.rs index 7b44dd38d..83e6a880b 100644 --- a/borsh/tests/test_schema_recursive.rs +++ b/borsh/tests/test_schema_recursive.rs @@ -48,24 +48,24 @@ pub fn recursive_struct_schema() { vec![ ( "a".to_string(), - "string".to_string(), + "String".to_string(), ), ( "b".to_string(), - "BTreeMap".to_string(), + "BTreeMap".to_string(), ), ] ) }, - "BTreeMap" => Definition::Sequence { + "BTreeMap" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, - elements: "Tuple".to_string(), + elements: "Tuple".to_string(), }, - "Tuple" => Definition::Tuple {elements: vec!["string".to_string(), "CRecC".to_string()]}, - "string" => Definition::Sequence { + "Tuple" => Definition::Tuple {elements: vec!["String".to_string(), "CRecC".to_string()]}, + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -92,7 +92,7 @@ pub fn recursive_enum_schema() { "ERecDB" => Definition::Struct { fields: Fields::NamedFields ( vec![ - ("x".to_string(), "string".to_string()), + ("x".to_string(), "String".to_string()), ("y".to_string(), "i32".to_string()), ] ) @@ -109,7 +109,7 @@ pub fn recursive_enum_schema() { elements: "ERecD".to_string(), }, "i32" => Definition::Primitive(4), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() diff --git a/borsh/tests/test_schema_structs.rs b/borsh/tests/test_schema_structs.rs index 2901e8272..c4bcc4919 100644 --- a/borsh/tests/test_schema_structs.rs +++ b/borsh/tests/test_schema_structs.rs @@ -63,10 +63,10 @@ pub fn simple_struct() { map! { "A" => Definition::Struct{ fields: Fields::NamedFields(vec![ ("_f1".to_string(), "u64".to_string()), - ("_f2".to_string(), "string".to_string()) + ("_f2".to_string(), "String".to_string()) ])}, "u64" => Definition::Primitive(8), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -97,12 +97,12 @@ pub fn boxed() { }, "A" => Definition::Struct{ fields: Fields::NamedFields(vec![ ("_f1".to_string(), "u64".to_string()), - ("_f2".to_string(), "string".to_string()), + ("_f2".to_string(), "String".to_string()), ("_f3".to_string(), "Vec".to_string()) ])}, "u64" => Definition::Primitive(8), "u8" => Definition::Primitive(1), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -138,10 +138,10 @@ pub fn tuple_struct() { assert_eq!( map! { "A" => Definition::Struct {fields: Fields::UnnamedFields(vec![ - "u64".to_string(), "string".to_string() + "u64".to_string(), "String".to_string() ])}, "u64" => Definition::Primitive(8), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -157,18 +157,18 @@ pub fn tuple_struct_params() { #[derive(borsh::BorshSchema)] struct A(K, V); assert_eq!( - "A".to_string(), + "A".to_string(), >::declaration() ); let mut defs = Default::default(); >::add_definitions_recursively(&mut defs); assert_eq!( map! { - "A" => Definition::Struct { fields: Fields::UnnamedFields(vec![ - "u64".to_string(), "string".to_string() + "A" => Definition::Struct { fields: Fields::UnnamedFields(vec![ + "u64".to_string(), "String".to_string() ])}, "u64" => Definition::Primitive(8), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -188,27 +188,27 @@ pub fn simple_generics() { _f2: String, } assert_eq!( - "A".to_string(), + "A".to_string(), >::declaration() ); let mut defs = Default::default(); >::add_definitions_recursively(&mut defs); assert_eq!( map! { - "A" => Definition::Struct { + "A" => Definition::Struct { fields: Fields::NamedFields(vec![ - ("_f1".to_string(), "HashMap".to_string()), - ("_f2".to_string(), "string".to_string()) + ("_f1".to_string(), "HashMap".to_string()), + ("_f2".to_string(), "String".to_string()) ]) }, - "HashMap" => Definition::Sequence { + "HashMap" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, - elements: "Tuple".to_string(), + elements: "Tuple".to_string(), }, - "Tuple" => Definition::Tuple{elements: vec!["u64".to_string(), "string".to_string()]}, + "Tuple" => Definition::Tuple{elements: vec!["u64".to_string(), "String".to_string()]}, "u64" => Definition::Primitive(8), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -222,14 +222,14 @@ pub fn simple_generics() { fn common_map() -> BTreeMap { map! { - "Parametrized" => Definition::Struct { + "Parametrized" => Definition::Struct { fields: Fields::NamedFields(vec![ ("field".to_string(), "i8".to_string()), - ("another".to_string(), "string".to_string()) + ("another".to_string(), "String".to_string()) ]) }, "i8" => Definition::Primitive(1), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -261,7 +261,7 @@ pub fn generic_associated_item() { } assert_eq!( - "Parametrized".to_string(), + "Parametrized".to_string(), >::declaration() ); @@ -294,7 +294,7 @@ pub fn generic_associated_item2() { } assert_eq!( - "Parametrized".to_string(), + "Parametrized".to_string(), >::declaration() ); @@ -327,7 +327,7 @@ pub fn generic_associated_item3() { } assert_eq!( - "Parametrized".to_string(), + "Parametrized".to_string(), >::declaration() ); @@ -335,10 +335,10 @@ pub fn generic_associated_item3() { >::add_definitions_recursively(&mut defs); assert_eq!( map! { - "Parametrized" => Definition::Struct { + "Parametrized" => Definition::Struct { fields: Fields::NamedFields(vec![ ("field".to_string(), "Tuple".to_string()), - ("another".to_string(), "string".to_string()) + ("another".to_string(), "String".to_string()) ]) }, "Tuple" => Definition::Tuple { @@ -346,7 +346,7 @@ pub fn generic_associated_item3() { }, "i8" => Definition::Primitive(1), "u32" => Definition::Primitive(4), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -367,7 +367,7 @@ pub fn with_phantom_data() { } assert_eq!( - "Parametrized".to_string(), + "Parametrized".to_string(), >::declaration() ); @@ -375,14 +375,14 @@ pub fn with_phantom_data() { >::add_definitions_recursively(&mut defs); assert_eq!( map! { - "Parametrized" => Definition::Struct { + "Parametrized" => Definition::Struct { fields: Fields::NamedFields(vec![ - ("field".to_string(), "string".to_string()), - ("another".to_string(), "nil".to_string()) + ("field".to_string(), "String".to_string()), + ("another".to_string(), "()".to_string()) ]) }, - "nil" => Definition::Primitive(0), - "string" => Definition::Sequence { + "()" => Definition::Primitive(0), + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() diff --git a/borsh/tests/test_schema_validate.rs b/borsh/tests/test_schema_validate.rs index 7d1936bce..fe82a146b 100644 --- a/borsh/tests/test_schema_validate.rs +++ b/borsh/tests/test_schema_validate.rs @@ -62,7 +62,7 @@ fn validate_for_derived_types() { #[test] fn validate_for_zst_sequences() { test_err::>>(SchemaContainerValidateError::ZSTSequence( - "Vec".to_string(), + "Vec<()>".to_string(), )); test_err::>(SchemaContainerValidateError::ZSTSequence( "Vec".to_string(), diff --git a/borsh/tests/test_schema_with.rs b/borsh/tests/test_schema_with.rs index 61704931e..a003d2eba 100644 --- a/borsh/tests/test_schema_with.rs +++ b/borsh/tests/test_schema_with.rs @@ -99,28 +99,28 @@ enum C { #[test] pub fn struct_overriden() { assert_eq!( - "A".to_string(), + "A".to_string(), >::declaration() ); let mut defs = Default::default(); >::add_definitions_recursively(&mut defs); assert_eq!( map! { - "A" => Definition::Struct { fields: Fields::NamedFields(vec![ - ("x".to_string(), "ThirdParty".to_string()), + "A" => Definition::Struct { fields: Fields::NamedFields(vec![ + ("x".to_string(), "ThirdParty".to_string()), ("y".to_string(), "u64".to_string())] )}, - "ThirdParty" => Definition::Struct { fields: Fields::UnnamedFields(vec![ - "BTreeMap".to_string(), + "ThirdParty" => Definition::Struct { fields: Fields::UnnamedFields(vec![ + "BTreeMap".to_string(), ]) }, - "BTreeMap"=> Definition::Sequence { + "BTreeMap"=> Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, - elements: "Tuple".to_string(), + elements: "Tuple".to_string(), }, - "Tuple" => Definition::Tuple { elements: vec!["u64".to_string(), "string".to_string()]}, + "Tuple" => Definition::Tuple { elements: vec!["u64".to_string(), "String".to_string()]}, "u64" => Definition::Primitive(8), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string() @@ -134,35 +134,35 @@ pub fn struct_overriden() { #[test] pub fn enum_overriden() { assert_eq!( - "C".to_string(), + "C".to_string(), >::declaration() ); let mut defs = Default::default(); >::add_definitions_recursively(&mut defs); assert_eq!( map! { - "C" => Definition::Enum { + "C" => Definition::Enum { tag_width: 1, variants: vec![ (0, "C3".to_string(), "CC3".to_string()), - (1, "C4".to_string(), "CC4".to_string()) + (1, "C4".to_string(), "CC4".to_string()) ] }, "CC3" => Definition::Struct { fields: Fields::UnnamedFields(vec!["u64".to_string(), "u64".to_string()]) }, - "CC4" => Definition::Struct { fields: Fields::UnnamedFields(vec![ - "u64".to_string(), "ThirdParty".to_string() + "CC4" => Definition::Struct { fields: Fields::UnnamedFields(vec![ + "u64".to_string(), "ThirdParty".to_string() ]) }, - "ThirdParty" => Definition::Struct { fields: Fields::UnnamedFields(vec![ - "BTreeMap".to_string(), + "ThirdParty" => Definition::Struct { fields: Fields::UnnamedFields(vec![ + "BTreeMap".to_string(), ]) }, - "BTreeMap"=> Definition::Sequence { + "BTreeMap"=> Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, - elements: "Tuple".to_string(), + elements: "Tuple".to_string(), }, - "Tuple" => Definition::Tuple { elements: vec!["u64".to_string(), "string".to_string()]}, + "Tuple" => Definition::Tuple { elements: vec!["u64".to_string(), "String".to_string()]}, "u64" => Definition::Primitive(8), - "string" => Definition::Sequence { + "String" => Definition::Sequence { length_width: Definition::DEFAULT_LENGTH_WIDTH, length_range: Definition::DEFAULT_LENGTH_RANGE, elements: "u8".to_string()