diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 00000000..5122b87a --- /dev/null +++ b/.editorconfig @@ -0,0 +1,5 @@ +# see https://editorconfig.org for more options, and setup instructions for yours editor + +[*.rs] +indent_style = space +indent_size = 4 diff --git a/.rustfmt.toml b/.rustfmt.toml new file mode 100644 index 00000000..da5f6e91 --- /dev/null +++ b/.rustfmt.toml @@ -0,0 +1 @@ +use_small_heuristics = "Off" diff --git a/src/de.rs b/src/de.rs index 170e0593..28744461 100644 --- a/src/de.rs +++ b/src/de.rs @@ -266,23 +266,17 @@ where fn parse_u16(&mut self) -> Result { let mut buf = [0; 2]; - self.read - .read_into(&mut buf) - .map(|()| u16::from_be_bytes(buf)) + self.read.read_into(&mut buf).map(|()| u16::from_be_bytes(buf)) } fn parse_u32(&mut self) -> Result { let mut buf = [0; 4]; - self.read - .read_into(&mut buf) - .map(|()| u32::from_be_bytes(buf)) + self.read.read_into(&mut buf).map(|()| u32::from_be_bytes(buf)) } fn parse_u64(&mut self) -> Result { let mut buf = [0; 8]; - self.read - .read_into(&mut buf) - .map(|()| u64::from_be_bytes(buf)) + self.read.read_into(&mut buf).map(|()| u64::from_be_bytes(buf)) } fn parse_bytes(&mut self, len: usize, visitor: V) -> Result @@ -355,10 +349,7 @@ where } } else { // An overflow would have occured. - Err(Error::syntax( - ErrorCode::LengthOutOfRange, - self.read.offset(), - )) + Err(Error::syntax(ErrorCode::LengthOutOfRange, self.read.offset())) } } @@ -440,7 +431,10 @@ where V: de::Visitor<'de>, { self.recursion_checked(|de| { - let value = visitor.visit_seq(SeqAccess { de, len: &mut len })?; + let value = visitor.visit_seq(SeqAccess { + de, + len: &mut len, + })?; if len != 0 { Err(de.error(ErrorCode::TrailingData)) @@ -455,7 +449,9 @@ where V: de::Visitor<'de>, { self.recursion_checked(|de| { - let value = visitor.visit_seq(IndefiniteSeqAccess { de })?; + let value = visitor.visit_seq(IndefiniteSeqAccess { + de, + })?; match de.next()? { Some(0xff) => Ok(value), Some(_) => Err(de.error(ErrorCode::TrailingData)), @@ -512,7 +508,10 @@ where { self.recursion_checked(|de| { let value = visitor.visit_enum(VariantAccess { - seq: SeqAccess { de, len: &mut len }, + seq: SeqAccess { + de, + len: &mut len, + }, })?; if len != 0 { @@ -554,7 +553,9 @@ where { self.recursion_checked(|de| { let value = visitor.visit_enum(VariantAccess { - seq: IndefiniteSeqAccess { de }, + seq: IndefiniteSeqAccess { + de, + }, })?; match de.next()? { Some(0xff) => Ok(value), @@ -868,7 +869,9 @@ where if !self.accept_standard_enums && !self.accept_legacy_enums { return Err(self.error(ErrorCode::WrongEnumFormat)); } - visitor.visit_enum(UnitVariantAccess { de: self }) + visitor.visit_enum(UnitVariantAccess { + de: self, + }) } } } @@ -1103,30 +1106,21 @@ where where T: de::DeserializeSeed<'de>, { - Err(de::Error::invalid_type( - de::Unexpected::UnitVariant, - &"newtype variant", - )) + Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"newtype variant")) } fn tuple_variant(self, _len: usize, _visitor: V) -> Result where V: de::Visitor<'de>, { - Err(de::Error::invalid_type( - de::Unexpected::UnitVariant, - &"tuple variant", - )) + Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant")) } fn struct_variant(self, _fields: &'static [&'static str], _visitor: V) -> Result where V: de::Visitor<'de>, { - Err(de::Error::invalid_type( - de::Unexpected::UnitVariant, - &"struct variant", - )) + Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant")) } } @@ -1190,7 +1184,9 @@ where where V: de::Visitor<'de>, { - let seed = StructVariantSeed { visitor }; + let seed = StructVariantSeed { + visitor, + }; match self.seq.next_element_seed(seed) { Ok(Some(variant)) => Ok(variant), Ok(None) => Err(self.seq.error(ErrorCode::ArrayTooShort)), @@ -1346,7 +1342,9 @@ where where V: de::Visitor<'de>, { - let seed = StructVariantSeed { visitor }; + let seed = StructVariantSeed { + visitor, + }; self.map.next_value_seed(seed) } @@ -1354,7 +1352,9 @@ where where V: de::Visitor<'de>, { - let seed = StructVariantSeed { visitor }; + let seed = StructVariantSeed { + visitor, + }; self.map.next_value_seed(seed) } } diff --git a/src/error.rs b/src/error.rs index b1a6a459..4bd25f53 100644 --- a/src/error.rs +++ b/src/error.rs @@ -35,7 +35,10 @@ impl Error { } pub(crate) fn syntax(code: ErrorCode, offset: u64) -> Error { - Error(ErrorImpl { code, offset }) + Error(ErrorImpl { + code, + offset, + }) } #[cfg(feature = "std")] diff --git a/src/read.rs b/src/read.rs index 1b53018d..21f9c646 100644 --- a/src/read.rs +++ b/src/read.rs @@ -153,7 +153,10 @@ where /// Creates a new CBOR input source to read from a std::io input stream. pub fn new(reader: R) -> IoRead { IoRead { - reader: OffsetReader { reader, offset: 0 }, + reader: OffsetReader { + reader, + offset: 0, + }, scratch: vec![], ch: None, } @@ -227,10 +230,7 @@ where match transfer_result { Ok(r) if r == n => Ok(()), - Ok(_) => Err(Error::syntax( - ErrorCode::EofWhileParsingValue, - self.offset(), - )), + Ok(_) => Err(Error::syntax(ErrorCode::EofWhileParsingValue, self.offset())), Err(e) => Err(Error::io(e)), } } @@ -318,10 +318,7 @@ impl<'a> SliceRead<'a> { fn end(&self, n: usize) -> Result { match self.index.checked_add(n) { Some(end) if end <= self.slice.len() => Ok(end), - _ => Err(Error::syntax( - ErrorCode::EofWhileParsingValue, - self.slice.len() as u64, - )), + _ => Err(Error::syntax(ErrorCode::EofWhileParsingValue, self.slice.len() as u64)), } } } @@ -334,10 +331,7 @@ impl<'a> Offset for SliceRead<'a> { } } -#[cfg(all( - any(feature = "std", feature = "alloc"), - not(feature = "unsealed_read_write") -))] +#[cfg(all(any(feature = "std", feature = "alloc"), not(feature = "unsealed_read_write")))] impl<'a> private::Sealed for SliceRead<'a> {} #[cfg(any(feature = "std", feature = "alloc"))] @@ -431,10 +425,7 @@ impl<'a, 'b> SliceReadFixed<'a, 'b> { fn end(&self, n: usize) -> Result { match self.index.checked_add(n) { Some(end) if end <= self.slice.len() => Ok(end), - _ => Err(Error::syntax( - ErrorCode::EofWhileParsingValue, - self.slice.len() as u64, - )), + _ => Err(Error::syntax(ErrorCode::EofWhileParsingValue, self.slice.len() as u64)), } } @@ -551,10 +542,7 @@ impl<'a> MutSliceRead<'a> { fn end(&self, n: usize) -> Result { match self.index.checked_add(n) { Some(end) if end <= self.slice.len() => Ok(end), - _ => Err(Error::syntax( - ErrorCode::EofWhileParsingValue, - self.slice.len() as u64, - )), + _ => Err(Error::syntax(ErrorCode::EofWhileParsingValue, self.slice.len() as u64)), } } } diff --git a/src/ser.rs b/src/ser.rs index 7016dc34..c2c3cf67 100644 --- a/src/ser.rs +++ b/src/ser.rs @@ -193,9 +193,7 @@ where false } None => { - self.writer - .write_all(&[major << 5 | 31]) - .map_err(|e| e.into())?; + self.writer.write_all(&[major << 5 | 31]).map_err(|e| e.into())?; true } }; @@ -224,7 +222,11 @@ where #[inline] fn serialize_bool(self, value: bool) -> Result<()> { - let value = if value { 0xf5 } else { 0xf4 }; + let value = if value { + 0xf5 + } else { + 0xf4 + }; self.writer.write_all(&[value]).map_err(|e| e.into()) } @@ -352,9 +354,7 @@ where #[inline] fn serialize_str(self, value: &str) -> Result<()> { self.write_u64(3, value.len() as u64)?; - self.writer - .write_all(value.as_bytes()) - .map_err(|e| e.into()) + self.writer.write_all(value.as_bytes()).map_err(|e| e.into()) } #[inline] @@ -494,7 +494,10 @@ where #[inline] fn serialize_struct(self, _name: &'static str, len: usize) -> Result> { self.write_u64(5, len as u64)?; - Ok(StructSerializer { ser: self, idx: 0 }) + Ok(StructSerializer { + ser: self, + idx: 0, + }) } #[inline] diff --git a/src/tags.rs b/src/tags.rs index 50e039e7..5b71cb9d 100644 --- a/src/tags.rs +++ b/src/tags.rs @@ -23,7 +23,10 @@ pub struct Tagged { impl Tagged { /// Create a new tagged value pub fn new(tag: Option, value: T) -> Self { - Self { tag, value } + Self { + tag, + value, + } } } @@ -42,8 +45,7 @@ fn untagged(value: T) -> Tagged { macro_rules! delegate { ($name: ident, $type: ty) => { - fn $name(self, v: $type) -> Result - { + fn $name(self, v: $type) -> Result { T::deserialize(v.into_deserializer()).map(untagged) } }; diff --git a/src/value/ser.rs b/src/value/ser.rs index 347aae96..8ba03c81 100644 --- a/src/value/ser.rs +++ b/src/value/ser.rs @@ -392,8 +392,7 @@ impl serde::ser::SerializeStructVariant for SerializeStructVariant { where T: Serialize, { - self.map - .insert(Value::from(String::from(key)), to_value(&value)?); + self.map.insert(Value::from(String::from(key)), to_value(&value)?); Ok(()) } diff --git a/src/write.rs b/src/write.rs index 94c326ef..a321dc23 100644 --- a/src/write.rs +++ b/src/write.rs @@ -102,10 +102,7 @@ impl Write for Vec { } } -#[cfg(all( - any(feature = "std", feature = "alloc"), - not(feature = "unsealed_read_write") -))] +#[cfg(all(any(feature = "std", feature = "alloc"), not(feature = "unsealed_read_write")))] impl private::Sealed for Vec {} #[cfg(not(feature = "std"))] @@ -142,7 +139,10 @@ pub struct SliceWrite<'a> { impl<'a> SliceWrite<'a> { /// Wraps a mutable slice so it can be used as a `Write`. pub fn new(slice: &'a mut [u8]) -> SliceWrite<'a> { - SliceWrite { slice, index: 0 } + SliceWrite { + slice, + index: 0, + } } /// Returns the number of bytes written to the underlying slice. diff --git a/tests/canonical.rs b/tests/canonical.rs index 438e29e7..9ce6e34d 100644 --- a/tests/canonical.rs +++ b/tests/canonical.rs @@ -34,10 +34,8 @@ mod std_tests { #[test] fn string_canonical_sort_order() { - let expected = ["", "a", "b", "aa"] - .iter() - .map(|s| Value::Text(s.to_string())) - .collect::>(); + let expected = + ["", "a", "b", "aa"].iter().map(|s| Value::Text(s.to_string())).collect::>(); let mut sorted = expected.clone(); sorted.sort(); diff --git a/tests/de.rs b/tests/de.rs index 01d79145..46d4e4c0 100644 --- a/tests/de.rs +++ b/tests/de.rs @@ -37,7 +37,10 @@ fn test_indefinite_object() { a: u64, b: [u64; 2], } - let expected = Foo { a: 1, b: [2, 3] }; + let expected = Foo { + a: 1, + b: [2, 3], + }; let actual: Foo = de::from_slice_with_scratch(b"\xbfaa\x01ab\x9f\x02\x03\xff\xff", &mut []).unwrap(); assert_eq!(expected, actual); @@ -119,11 +122,7 @@ mod std_tests { let value: error::Result = de::from_slice(b"\x83\x01\x02\x03"); assert_eq!( value.unwrap(), - Value::Array(vec![ - Value::Integer(1), - Value::Integer(2), - Value::Integer(3) - ]) + Value::Array(vec![Value::Integer(1), Value::Integer(2), Value::Integer(3)]) ); } @@ -134,10 +133,7 @@ mod std_tests { value.unwrap(), Value::Array(vec![ Value::Integer(1), - Value::Array(vec![ - Value::Integer(2), - Value::Array(vec![Value::Integer(3)]) - ]) + Value::Array(vec![Value::Integer(2), Value::Array(vec![Value::Integer(3)])]) ]) ); } @@ -171,11 +167,7 @@ mod std_tests { let value: error::Result = de::from_slice(b"\x9f\x01\x02\x03\xff"); assert_eq!( value.unwrap(), - Value::Array(vec![ - Value::Integer(1), - Value::Integer(2), - Value::Integer(3) - ]) + Value::Array(vec![Value::Integer(1), Value::Integer(2), Value::Integer(3)]) ); } @@ -183,10 +175,7 @@ mod std_tests { fn test_indefinite_string() { let value: error::Result = de::from_slice(b"\x7f\x65Mary \x64Had \x62a \x67Little \x60\x64Lamb\xff"); - assert_eq!( - value.unwrap(), - Value::Text("Mary Had a Little Lamb".to_owned()) - ); + assert_eq!(value.unwrap(), Value::Text("Mary Had a Little Lamb".to_owned())); } #[test] @@ -314,10 +303,7 @@ mod std_tests { let slice = b"\xbf\x67\x6d\x65\x73\x73\x61\x67\x65\x64\x70\x6f\x6e\x67\xff"; let value: Value = de::from_slice(slice).unwrap(); let mut map = BTreeMap::new(); - map.insert( - Value::Text("message".to_string()), - Value::Text("pong".to_string()), - ); + map.insert(Value::Text("message".to_string()), Value::Text("pong".to_string())); assert_eq!(value, Value::Map(map)) } @@ -327,10 +313,7 @@ mod std_tests { // 0.1% chance of not catching failure for _ in 0..10 { - assert_eq!( - &to_vec(&de::from_slice::(expected).unwrap()).unwrap(), - expected - ); + assert_eq!(&to_vec(&de::from_slice::(expected).unwrap()).unwrap(), expected); } } @@ -339,10 +322,7 @@ mod std_tests { let slice = b"\x01\x66foobar"; let mut it = Deserializer::from_slice(slice).into_iter::(); assert_eq!(Value::Integer(1), it.next().unwrap().unwrap()); - assert_eq!( - Value::Text("foobar".to_string()), - it.next().unwrap().unwrap() - ); + assert_eq!(Value::Text("foobar".to_string()), it.next().unwrap().unwrap()); assert!(it.next().is_none()); } @@ -381,10 +361,7 @@ mod std_tests { fn crash() { let file = include_bytes!("crash.cbor"); let value_result: error::Result = de::from_slice(file); - assert_eq!( - value_result.unwrap_err().classify(), - serde_cbor::error::Category::Syntax - ); + assert_eq!(value_result.unwrap_err().classify(), serde_cbor::error::Category::Syntax); } fn from_slice_stream<'a, T>(slice: &'a [u8]) -> error::Result<(&'a [u8], T)> @@ -501,7 +478,10 @@ mod std_tests { Unit, NewType(i32), Tuple(String, bool), - Struct { x: i32, y: i32 }, + Struct { + x: i32, + y: i32, + }, } // This is the format used in serde >= 0.10 @@ -520,16 +500,10 @@ mod std_tests { assert_eq!(value, Enum::NewType(10)); let value: error::Result<(&[u8], Enum)> = from_slice_stream_options(&v[..], Options::default().no_standard()); - assert_eq!( - value.unwrap_err().classify(), - serde_cbor::error::Category::Syntax - ); + assert_eq!(value.unwrap_err().classify(), serde_cbor::error::Category::Syntax); let value: error::Result<(&[u8], Enum)> = from_slice_stream_options(&v[..], Options::default().no_standard().no_legacy()); - assert_eq!( - value.unwrap_err().classify(), - serde_cbor::error::Category::Syntax - ); + assert_eq!(value.unwrap_err().classify(), serde_cbor::error::Category::Syntax); // Serialization of Enum::Unit let v: Vec = vec![ 0x64, 0x55, 0x6e, 0x69, 0x74, // utf8 string: Unit @@ -544,10 +518,7 @@ mod std_tests { assert_eq!(value, Enum::Unit); let value: error::Result<(&[u8], Enum)> = from_slice_stream_options(&v[..], Options::default().no_legacy().no_standard()); - assert_eq!( - value.unwrap_err().classify(), - serde_cbor::error::Category::Syntax - ); + assert_eq!(value.unwrap_err().classify(), serde_cbor::error::Category::Syntax); // This is the format used in serde <= 0.9 let v: Vec = vec![ @@ -560,19 +531,13 @@ mod std_tests { assert_eq!(value, Enum::NewType(10)); let value: error::Result<(&[u8], Enum)> = from_slice_stream_options(&v[..], Options::default().no_legacy()); - assert_eq!( - value.unwrap_err().classify(), - serde_cbor::error::Category::Syntax - ); + assert_eq!(value.unwrap_err().classify(), serde_cbor::error::Category::Syntax); let value: error::Result<(&[u8], Enum)> = from_slice_stream_options(&v[..], Options::default().no_standard()); assert_eq!(value.unwrap().1, Enum::NewType(10)); let value: error::Result<(&[u8], Enum)> = from_slice_stream_options(&v[..], Options::default().no_standard().no_legacy()); - assert_eq!( - value.unwrap_err().classify(), - serde_cbor::error::Category::Syntax - ); + assert_eq!(value.unwrap_err().classify(), serde_cbor::error::Category::Syntax); } #[test] @@ -612,10 +577,7 @@ mod std_tests { ); let value: error::Result<(&[u8], User)> = from_slice_stream_options(&v[..], Options::default().no_named()); - assert_eq!( - value.unwrap_err().classify(), - serde_cbor::error::Category::Syntax - ); + assert_eq!(value.unwrap_err().classify(), serde_cbor::error::Category::Syntax); // unpacked - indefinite length let v: Vec = vec![ @@ -647,10 +609,7 @@ mod std_tests { ); let value: error::Result<(&[u8], User)> = from_slice_stream_options(&v[..], Options::default().no_named()); - assert_eq!( - value.unwrap_err().classify(), - serde_cbor::error::Category::Syntax - ); + assert_eq!(value.unwrap_err().classify(), serde_cbor::error::Category::Syntax); // packed let v: Vec = vec![ @@ -680,10 +639,7 @@ mod std_tests { ); let value: error::Result<(&[u8], User)> = from_slice_stream_options(&v[..], Options::default().no_packed()); - assert_eq!( - value.unwrap_err().classify(), - serde_cbor::error::Category::Syntax - ); + assert_eq!(value.unwrap_err().classify(), serde_cbor::error::Category::Syntax); // packed - indefinite length let v: Vec = vec![ @@ -714,10 +670,7 @@ mod std_tests { ); let value: error::Result<(&[u8], User)> = from_slice_stream_options(&v[..], Options::default().no_packed()); - assert_eq!( - value.unwrap_err().classify(), - serde_cbor::error::Category::Syntax - ); + assert_eq!(value.unwrap_err().classify(), serde_cbor::error::Category::Syntax); } use serde_cbor::{de::from_slice, ser::to_vec_packed}; diff --git a/tests/enum.rs b/tests/enum.rs index 630500d6..b7739f2e 100644 --- a/tests/enum.rs +++ b/tests/enum.rs @@ -57,7 +57,9 @@ mod std_tests { #[test] fn test_enum() { - let enum_struct = EnumStruct { e: Enum::B }; + let enum_struct = EnumStruct { + e: Enum::B, + }; let raw = &to_vec(&enum_struct).unwrap(); println!("raw enum {:?}", raw); let re: EnumStruct = from_slice(raw).unwrap(); @@ -78,7 +80,9 @@ mod std_tests { #[test] fn test_repr_enum() { - let repr_enum_struct = ReprEnumStruct { e: ReprEnum::B }; + let repr_enum_struct = ReprEnumStruct { + e: ReprEnum::B, + }; let re: ReprEnumStruct = from_slice(&to_vec(&repr_enum_struct).unwrap()).unwrap(); assert_eq!(repr_enum_struct, re); } @@ -87,7 +91,10 @@ mod std_tests { enum DataEnum { A(u32), B(bool, u8), - C { x: u8, y: String }, + C { + x: u8, + y: String, + }, } #[test] @@ -111,14 +118,8 @@ mod std_tests { fn test_serialize() { assert_eq!(to_vec_legacy(&Enum::A).unwrap(), &[97, 65]); assert_eq!(to_vec_legacy(&Enum::B).unwrap(), &[97, 66]); - assert_eq!( - to_vec_legacy(&DataEnum::A(42)).unwrap(), - &[130, 97, 65, 24, 42] - ); - assert_eq!( - to_vec_legacy(&DataEnum::B(true, 9)).unwrap(), - &[131, 97, 66, 245, 9] - ); + assert_eq!(to_vec_legacy(&DataEnum::A(42)).unwrap(), &[130, 97, 65, 24, 42]); + assert_eq!(to_vec_legacy(&DataEnum::B(true, 9)).unwrap(), &[131, 97, 66, 245, 9]); } #[test] @@ -147,7 +148,10 @@ mod std_tests { Empty, Number(i32), Flag(String, bool), - Point { x: i32, y: i32 }, + Point { + x: i32, + y: i32, + }, } #[test] @@ -173,14 +177,15 @@ mod std_tests { assert_eq!(flag_s, flag_vec_s); // struct-variants serialize like ["", {struct..}] - let point_s = to_vec_legacy(&Bar::Point { x: 5, y: -5 }).unwrap(); + let point_s = to_vec_legacy(&Bar::Point { + x: 5, + y: -5, + }) + .unwrap(); let mut struct_map = BTreeMap::new(); struct_map.insert(Value::Text("x".to_string()), Value::Integer(5)); struct_map.insert(Value::Text("y".to_string()), Value::Integer(-5)); - let point_vec = vec![ - Value::Text("Point".to_string()), - Value::Map(struct_map.clone()), - ]; + let point_vec = vec![Value::Text("Point".to_string()), Value::Map(struct_map.clone())]; let point_vec_s = to_vec_legacy(&point_vec).unwrap(); assert_eq!(point_s, point_vec_s); @@ -200,15 +205,16 @@ mod std_tests { // multi-element tuple variants serialize like {"": [values..]} let flag_s = to_vec(&Bar::Flag("foo".to_string(), true)).unwrap(); let mut flag_map = BTreeMap::new(); - flag_map.insert( - "Flag", - vec![Value::Text("foo".to_string()), Value::Bool(true)], - ); + flag_map.insert("Flag", vec![Value::Text("foo".to_string()), Value::Bool(true)]); let flag_map_s = to_vec(&flag_map).unwrap(); assert_eq!(flag_s, flag_map_s); // struct-variants serialize like {"", {struct..}} - let point_s = to_vec(&Bar::Point { x: 5, y: -5 }).unwrap(); + let point_s = to_vec(&Bar::Point { + x: 5, + y: -5, + }) + .unwrap(); let mut point_map = BTreeMap::new(); point_map.insert("Point", Value::Map(struct_map)); let point_map_s = to_vec(&point_map).unwrap(); @@ -229,8 +235,20 @@ mod std_tests { assert_eq!(Bar::Flag("foo".to_string(), true), flag_map_ds); let point_vec_ds = from_slice(&point_vec_s).unwrap(); - assert_eq!(Bar::Point { x: 5, y: -5 }, point_vec_ds); + assert_eq!( + Bar::Point { + x: 5, + y: -5 + }, + point_vec_ds + ); let point_map_ds = from_slice(&point_map_s).unwrap(); - assert_eq!(Bar::Point { x: 5, y: -5 }, point_map_ds); + assert_eq!( + Bar::Point { + x: 5, + y: -5 + }, + point_map_ds + ); } } diff --git a/tests/ser.rs b/tests/ser.rs index d374ce2f..e718d0f8 100644 --- a/tests/ser.rs +++ b/tests/ser.rs @@ -98,16 +98,9 @@ mod std_tests { fn test_object_object_keys() { use std::iter::FromIterator; let mut object = BTreeMap::new(); - let keys = vec![ - vec!["a"], - vec!["b"], - vec!["c"], - vec!["d"], - vec!["aa"], - vec!["a", "aa"], - ] - .into_iter() - .map(|v| BTreeMap::from_iter(v.into_iter().map(|s| (s.to_owned(), ())))); + let keys = vec![vec!["a"], vec!["b"], vec!["c"], vec!["d"], vec!["aa"], vec!["a", "aa"]] + .into_iter() + .map(|v| BTreeMap::from_iter(v.into_iter().map(|s| (s.to_owned(), ())))); for key in keys { object.insert(key, ()); @@ -202,9 +195,7 @@ mod std_tests { // Very short byte strings have 1-byte headers let short = vec![0, 1, 2, 255]; let mut short_s = Vec::new(); - serde_cbor::Serializer::new(&mut short_s) - .serialize_bytes(&short) - .unwrap(); + serde_cbor::Serializer::new(&mut short_s).serialize_bytes(&short).unwrap(); assert_eq!(&short_s[..], [0x44, 0, 1, 2, 255]); // byte strings > 23 bytes have 2-byte headers @@ -212,9 +203,7 @@ mod std_tests { 0u8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 255, ]; let mut medium_s = Vec::new(); - serde_cbor::Serializer::new(&mut medium_s) - .serialize_bytes(&medium) - .unwrap(); + serde_cbor::Serializer::new(&mut medium_s).serialize_bytes(&medium).unwrap(); assert_eq!( &medium_s[..], [ @@ -226,18 +215,14 @@ mod std_tests { // byte strings > 256 bytes have 3-byte headers let long_vec = (0..256).map(|i| (i & 0xFF) as u8).collect::>(); let mut long_s = Vec::new(); - serde_cbor::Serializer::new(&mut long_s) - .serialize_bytes(&long_vec) - .unwrap(); + serde_cbor::Serializer::new(&mut long_s).serialize_bytes(&long_vec).unwrap(); assert_eq!(&long_s[0..3], [0x59, 1, 0]); assert_eq!(&long_s[3..], &long_vec[..]); // byte strings > 2^16 bytes have 5-byte headers let very_long_vec = (0..65536).map(|i| (i & 0xFF) as u8).collect::>(); let mut very_long_s = Vec::new(); - serde_cbor::Serializer::new(&mut very_long_s) - .serialize_bytes(&very_long_vec) - .unwrap(); + serde_cbor::Serializer::new(&mut very_long_s).serialize_bytes(&very_long_vec).unwrap(); assert_eq!(&very_long_s[0..5], [0x5a, 0, 1, 0, 0]); assert_eq!(&very_long_s[5..], &very_long_vec[..]); diff --git a/tests/std_types.rs b/tests/std_types.rs index 7a7ded48..fbba094f 100644 --- a/tests/std_types.rs +++ b/tests/std_types.rs @@ -52,11 +52,7 @@ mod std_tests { fn $name() { let expr: $ty = $expr; let mut serialized = to_binary($s); - assert_eq!( - to_vec(&expr).expect("ser1 works"), - serialized, - "serialization differs" - ); + assert_eq!(to_vec(&expr).expect("ser1 works"), serialized, "serialization differs"); let parsed: $ty = from_slice(&serialized[..]).expect("de1 works"); assert_eq!(parsed, expr, "parsed result differs"); let packed = &to_vec_packed(&expr).expect("serializing packed")[..]; @@ -96,12 +92,7 @@ mod std_tests { testcase!(test_f64_neg_infinity, f64, -::std::f64::INFINITY, "f9fc00"); testcase!(test_char_null, char, '\x00', "6100"); testcase!(test_char_broken_heart, char, '💔', "64f09f9294"); - testcase!( - test_str_pangram_de, - String, - "aâø↓é".to_owned(), - "6a61c3a2c3b8e28693c3a9" - ); + testcase!(test_str_pangram_de, String, "aâø↓é".to_owned(), "6a61c3a2c3b8e28693c3a9"); testcase!(test_unit, (), (), "f6"); #[derive(Debug, PartialEq, Deserialize, Serialize)] @@ -110,12 +101,7 @@ mod std_tests { #[derive(Debug, PartialEq, Deserialize, Serialize)] struct NewtypeStruct(bool); - testcase!( - test_newtype_struct, - NewtypeStruct, - NewtypeStruct(true), - "f5" - ); + testcase!(test_newtype_struct, NewtypeStruct, NewtypeStruct(true), "f5"); testcase!(test_option_none, Option, None, "f6"); testcase!(test_option_some, Option, Some(42), "182a"); @@ -163,12 +149,7 @@ mod std_tests { } testcase!(test_color_enum, Color, Color::Blue, "64426c7565"); - testcase!( - test_color_enum_transparent, - Color, - Color::Other(42), - "a1654f74686572182a" - ); + testcase!(test_color_enum_transparent, Color, Color::Other(42), "a1654f74686572182a"); testcase!( test_color_enum_with_alpha, Color, @@ -176,11 +157,6 @@ mod std_tests { "a165416c706861821a00039447183c" ); testcase!(test_i128_a, i128, -1i128, "20"); - testcase!( - test_i128_b, - i128, - -18446744073709551616i128, - "3BFFFFFFFFFFFFFFFF" - ); + testcase!(test_i128_b, i128, -18446744073709551616i128, "3BFFFFFFFFFFFFFFFF"); testcase!(test_u128, u128, 17, "11"); } diff --git a/tests/tags.rs b/tests/tags.rs index 92534c02..04e2af44 100644 --- a/tests/tags.rs +++ b/tests/tags.rs @@ -4,10 +4,7 @@ mod tagtests { use serde_cbor::{from_slice, to_vec}; fn decode_hex(s: &str) -> std::result::Result, std::num::ParseIntError> { - (0..s.len()) - .step_by(2) - .map(|i| u8::from_str_radix(&s[i..i + 2], 16)) - .collect() + (0..s.len()).step_by(2).map(|i| u8::from_str_radix(&s[i..i + 2], 16)).collect() } // get bytes from http://cbor.me/ trees diff --git a/tests/value.rs b/tests/value.rs index 554d7426..88880832 100644 --- a/tests/value.rs +++ b/tests/value.rs @@ -70,10 +70,7 @@ mod std_tests { panic!() } - for ((k1, v1), (k2, v2)) in as_object(&value) - .iter() - .zip(as_object(&data_de_value).iter()) - { + for ((k1, v1), (k2, v2)) in as_object(&value).iter().zip(as_object(&data_de_value).iter()) { assert_eq!(k1, k2); assert_eq!(v1, v2); } @@ -92,7 +89,10 @@ mod std_tests { // Test whether the packed format works. // Field names should not be serialized, // instead field indizes are serialized. - let value = SmallStruct { spam: 17, eggs: 42 }; + let value = SmallStruct { + spam: 17, + eggs: 42, + }; let data = serde_cbor::ser::to_vec_packed(&value).unwrap(); let reference = b"\xa2\x00\x11\x01\x18\x2a"; assert_eq!(data, reference);