From bb33df436c0643b59ac8598c19eb17752982a449 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= Date: Fri, 2 Feb 2018 13:47:33 +0100 Subject: [PATCH] Fix indentation. --- ethbloom/src/lib.rs | 6 +- ethereum-types/src/hash.rs | 6 +- ethereum-types/src/uint.rs | 6 +- serialize/src/lib.rs | 94 +++++++++++++------------- tests/src/serialization.rs | 134 ++++++++++++++++++------------------- 5 files changed, 123 insertions(+), 123 deletions(-) diff --git a/ethbloom/src/lib.rs b/ethbloom/src/lib.rs index 2991a87..1ea977b 100644 --- a/ethbloom/src/lib.rs +++ b/ethbloom/src/lib.rs @@ -235,7 +235,7 @@ impl<'a> From<&'a Bloom> for BloomRef<'a> { #[cfg(feature="serialize")] impl Serialize for Bloom { fn serialize(&self, serializer: S) -> Result where S: Serializer { - let mut slice = [0u8; 2 + 2 * BLOOM_SIZE]; + let mut slice = [0u8; 2 + 2 * BLOOM_SIZE]; ethereum_types_serialize::serialize(&mut slice, &self.0, serializer) } } @@ -243,9 +243,9 @@ impl Serialize for Bloom { #[cfg(feature="serialize")] impl<'de> Deserialize<'de> for Bloom { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de> { - let mut bytes = [0; BLOOM_SIZE]; + let mut bytes = [0; BLOOM_SIZE]; ethereum_types_serialize::deserialize_check_len(deserializer, ethereum_types_serialize::ExpectedLen::Exact(&mut bytes))?; - Ok(Bloom(bytes)) + Ok(Bloom(bytes)) } } diff --git a/ethereum-types/src/hash.rs b/ethereum-types/src/hash.rs index f0c4c81..fcb5999 100644 --- a/ethereum-types/src/hash.rs +++ b/ethereum-types/src/hash.rs @@ -81,7 +81,7 @@ macro_rules! impl_serde { #[cfg(feature="serialize")] impl Serialize for $name { fn serialize(&self, serializer: S) -> Result where S: Serializer { - let mut slice = [0u8; 2 + 2 * $len]; + let mut slice = [0u8; 2 + 2 * $len]; ethereum_types_serialize::serialize(&mut slice, &self.0, serializer) } } @@ -89,9 +89,9 @@ macro_rules! impl_serde { #[cfg(feature="serialize")] impl<'de> Deserialize<'de> for $name { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de> { - let mut bytes = [0u8; $len]; + let mut bytes = [0u8; $len]; ethereum_types_serialize::deserialize_check_len(deserializer, ethereum_types_serialize::ExpectedLen::Exact(&mut bytes))?; - Ok($name(bytes)) + Ok($name(bytes)) } } } diff --git a/ethereum-types/src/uint.rs b/ethereum-types/src/uint.rs index a8ca234..98fc250 100644 --- a/ethereum-types/src/uint.rs +++ b/ethereum-types/src/uint.rs @@ -334,7 +334,7 @@ macro_rules! impl_serde { #[cfg(feature="serialize")] impl Serialize for $name { fn serialize(&self, serializer: S) -> Result where S: Serializer { - let mut slice = [0u8; 2 + 2 * $len * 8]; + let mut slice = [0u8; 2 + 2 * $len * 8]; let mut bytes = [0u8; $len * 8]; self.to_big_endian(&mut bytes); ethereum_types_serialize::serialize_uint(&mut slice, &bytes, serializer) @@ -344,9 +344,9 @@ macro_rules! impl_serde { #[cfg(feature="serialize")] impl<'de> Deserialize<'de> for $name { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de> { - let mut bytes = [0u8; $len * 8]; + let mut bytes = [0u8; $len * 8]; let wrote = ethereum_types_serialize::deserialize_check_len(deserializer, ethereum_types_serialize::ExpectedLen::Between(0, &mut bytes))?; - Ok(bytes[0..wrote].into()) + Ok(bytes[0..wrote].into()) } } } diff --git a/serialize/src/lib.rs b/serialize/src/lib.rs index e3a1873..b7e858c 100644 --- a/serialize/src/lib.rs +++ b/serialize/src/lib.rs @@ -6,35 +6,35 @@ use serde::{de, Serializer, Deserializer}; static CHARS: &'static[u8] = b"0123456789abcdef"; fn to_hex<'a>(v: &'a mut [u8], bytes: &[u8], skip_leading_zero: bool) -> &'a str { - assert!(v.len() > 1 + bytes.len() * 2); + assert!(v.len() > 1 + bytes.len() * 2); - v[0] = '0' as u8; - v[1] = 'x' as u8; + v[0] = '0' as u8; + v[1] = 'x' as u8; - let mut idx = 2; - let first_nibble = bytes[0] >> 4; - if first_nibble != 0 || !skip_leading_zero { - v[idx] = CHARS[first_nibble as usize]; - idx += 1; - } - v[idx] = CHARS[(bytes[0] & 0xf) as usize]; - idx += 1; + let mut idx = 2; + let first_nibble = bytes[0] >> 4; + if first_nibble != 0 || !skip_leading_zero { + v[idx] = CHARS[first_nibble as usize]; + idx += 1; + } + v[idx] = CHARS[(bytes[0] & 0xf) as usize]; + idx += 1; - for &byte in bytes.iter().skip(1) { - v[idx] = CHARS[(byte >> 4) as usize]; - v[idx + 1] = CHARS[(byte & 0xf) as usize]; - idx += 2; - } + for &byte in bytes.iter().skip(1) { + v[idx] = CHARS[(byte >> 4) as usize]; + v[idx + 1] = CHARS[(byte & 0xf) as usize]; + idx += 2; + } - ::std::str::from_utf8(&v[0..idx]).expect("All characters are coming from CHARS") + ::std::str::from_utf8(&v[0..idx]).expect("All characters are coming from CHARS") } /// Serializes a slice of bytes. pub fn serialize(slice: &mut [u8], bytes: &[u8], serializer: S) -> Result where S: Serializer, { - let mut v = Vec::with_capacity(2 + bytes.len() * 2); - v.resize(2 + bytes.len() * 2, 0); + let mut v = Vec::with_capacity(2 + bytes.len() * 2); + v.resize(2 + bytes.len() * 2, 0); serializer.serialize_str(to_hex(slice, bytes, false)) } @@ -103,38 +103,38 @@ pub fn deserialize_check_len<'a, 'de, D>(deserializer: D, len: ExpectedLen<'a>) let bytes = match self.len { ExpectedLen::Exact(slice) => slice, - ExpectedLen::Between(_, slice) => slice, - }; + ExpectedLen::Between(_, slice) => slice, + }; - let mut modulus = v.len() % 2; - let mut buf = 0; - let mut pos = 0; - for (idx, byte) in v.bytes().enumerate().skip(2) { - buf <<= 4; + let mut modulus = v.len() % 2; + let mut buf = 0; + let mut pos = 0; + for (idx, byte) in v.bytes().enumerate().skip(2) { + buf <<= 4; - match byte { - b'A'...b'F' => buf |= byte - b'A' + 10, - b'a'...b'f' => buf |= byte - b'a' + 10, - b'0'...b'9' => buf |= byte - b'0', - b' '|b'\r'|b'\n'|b'\t' => { - buf >>= 4; - continue - } - _ => { - let ch = v[idx..].chars().next().unwrap(); - return Err(E::custom(&format!("invalid hex character: {}, at {}", ch, idx))) - } - } + match byte { + b'A'...b'F' => buf |= byte - b'A' + 10, + b'a'...b'f' => buf |= byte - b'a' + 10, + b'0'...b'9' => buf |= byte - b'0', + b' '|b'\r'|b'\n'|b'\t' => { + buf >>= 4; + continue + } + _ => { + let ch = v[idx..].chars().next().unwrap(); + return Err(E::custom(&format!("invalid hex character: {}, at {}", ch, idx))) + } + } - modulus += 1; - if modulus == 2 { - modulus = 0; - bytes[pos] = buf; - pos += 1; - } - } + modulus += 1; + if modulus == 2 { + modulus = 0; + bytes[pos] = buf; + pos += 1; + } + } - Ok(pos) + Ok(pos) } fn visit_string(self, v: String) -> Result { diff --git a/tests/src/serialization.rs b/tests/src/serialization.rs index a926e67..8054e32 100644 --- a/tests/src/serialization.rs +++ b/tests/src/serialization.rs @@ -2,36 +2,36 @@ use ethereum_types::{U256, U512, H160, H256}; use serde_json as ser; macro_rules! test { - ($name: ident, $test_name: ident) => { - #[test] - fn $test_name() { - let tests = vec![ - ($name::from(0), "0x0"), - ($name::from(1), "0x1"), - ($name::from(2), "0x2"), - ($name::from(10), "0xa"), - ($name::from(15), "0xf"), - ($name::from(15), "0xf"), - ($name::from(16), "0x10"), - ($name::from(1_000), "0x3e8"), - ($name::from(100_000), "0x186a0"), - ($name::from(u64::max_value()), "0xffffffffffffffff"), - ($name::from(u64::max_value()) + 1.into(), "0x10000000000000000"), - ]; + ($name: ident, $test_name: ident) => { + #[test] + fn $test_name() { + let tests = vec![ + ($name::from(0), "0x0"), + ($name::from(1), "0x1"), + ($name::from(2), "0x2"), + ($name::from(10), "0xa"), + ($name::from(15), "0xf"), + ($name::from(15), "0xf"), + ($name::from(16), "0x10"), + ($name::from(1_000), "0x3e8"), + ($name::from(100_000), "0x186a0"), + ($name::from(u64::max_value()), "0xffffffffffffffff"), + ($name::from(u64::max_value()) + 1.into(), "0x10000000000000000"), + ]; - for (number, expected) in tests { - assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap()); - assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap()); - } + for (number, expected) in tests { + assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap()); + assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap()); + } - // Invalid examples - assert!(ser::from_str::<$name>("\"0x\"").unwrap_err().is_data()); - assert!(ser::from_str::<$name>("\"0xg\"").unwrap_err().is_data()); - assert!(ser::from_str::<$name>("\"\"").unwrap_err().is_data()); - assert!(ser::from_str::<$name>("\"10\"").unwrap_err().is_data()); - assert!(ser::from_str::<$name>("\"0\"").unwrap_err().is_data()); - } - } + // Invalid examples + assert!(ser::from_str::<$name>("\"0x\"").unwrap_err().is_data()); + assert!(ser::from_str::<$name>("\"0xg\"").unwrap_err().is_data()); + assert!(ser::from_str::<$name>("\"\"").unwrap_err().is_data()); + assert!(ser::from_str::<$name>("\"10\"").unwrap_err().is_data()); + assert!(ser::from_str::<$name>("\"0\"").unwrap_err().is_data()); + } + } } test!(U256, test_u256); @@ -39,57 +39,57 @@ test!(U512, test_u512); #[test] fn test_large_values() { - assert_eq!( - ser::to_string_pretty(&!U256::zero()).unwrap(), - "\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\"" - ); - assert!( - ser::from_str::("\"0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\"").unwrap_err().is_data() - ); + assert_eq!( + ser::to_string_pretty(&!U256::zero()).unwrap(), + "\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\"" + ); + assert!( + ser::from_str::("\"0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\"").unwrap_err().is_data() + ); } #[test] fn test_h160() { - let tests = vec![ - (H160::from(0), "0x0000000000000000000000000000000000000000"), - (H160::from(2), "0x0000000000000000000000000000000000000002"), - (H160::from(15), "0x000000000000000000000000000000000000000f"), - (H160::from(16), "0x0000000000000000000000000000000000000010"), - (H160::from(1_000), "0x00000000000000000000000000000000000003e8"), - (H160::from(100_000), "0x00000000000000000000000000000000000186a0"), - (H160::from(u64::max_value()), "0x000000000000000000000000ffffffffffffffff"), - ]; + let tests = vec![ + (H160::from(0), "0x0000000000000000000000000000000000000000"), + (H160::from(2), "0x0000000000000000000000000000000000000002"), + (H160::from(15), "0x000000000000000000000000000000000000000f"), + (H160::from(16), "0x0000000000000000000000000000000000000010"), + (H160::from(1_000), "0x00000000000000000000000000000000000003e8"), + (H160::from(100_000), "0x00000000000000000000000000000000000186a0"), + (H160::from(u64::max_value()), "0x000000000000000000000000ffffffffffffffff"), + ]; - for (number, expected) in tests { - assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap()); - assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap()); - } + for (number, expected) in tests { + assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap()); + assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap()); + } } #[test] fn test_h256() { - let tests = vec![ - (H256::from(0), "0x0000000000000000000000000000000000000000000000000000000000000000"), - (H256::from(2), "0x0000000000000000000000000000000000000000000000000000000000000002"), - (H256::from(15), "0x000000000000000000000000000000000000000000000000000000000000000f"), - (H256::from(16), "0x0000000000000000000000000000000000000000000000000000000000000010"), - (H256::from(1_000), "0x00000000000000000000000000000000000000000000000000000000000003e8"), - (H256::from(100_000), "0x00000000000000000000000000000000000000000000000000000000000186a0"), - (H256::from(u64::max_value()), "0x000000000000000000000000000000000000000000000000ffffffffffffffff"), - ]; + let tests = vec![ + (H256::from(0), "0x0000000000000000000000000000000000000000000000000000000000000000"), + (H256::from(2), "0x0000000000000000000000000000000000000000000000000000000000000002"), + (H256::from(15), "0x000000000000000000000000000000000000000000000000000000000000000f"), + (H256::from(16), "0x0000000000000000000000000000000000000000000000000000000000000010"), + (H256::from(1_000), "0x00000000000000000000000000000000000000000000000000000000000003e8"), + (H256::from(100_000), "0x00000000000000000000000000000000000000000000000000000000000186a0"), + (H256::from(u64::max_value()), "0x000000000000000000000000000000000000000000000000ffffffffffffffff"), + ]; - for (number, expected) in tests { - assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap()); - assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap()); - } + for (number, expected) in tests { + assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap()); + assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap()); + } } #[test] fn test_invalid() { - assert!(ser::from_str::("\"0x000000000000000000000000000000000000000000000000000000000000000\"").unwrap_err().is_data()); - assert!(ser::from_str::("\"0x000000000000000000000000000000000000000000000000000000000000000g\"").unwrap_err().is_data()); - assert!(ser::from_str::("\"0x00000000000000000000000000000000000000000000000000000000000000000\"").unwrap_err().is_data()); - assert!(ser::from_str::("\"\"").unwrap_err().is_data()); - assert!(ser::from_str::("\"0\"").unwrap_err().is_data()); - assert!(ser::from_str::("\"10\"").unwrap_err().is_data()); + assert!(ser::from_str::("\"0x000000000000000000000000000000000000000000000000000000000000000\"").unwrap_err().is_data()); + assert!(ser::from_str::("\"0x000000000000000000000000000000000000000000000000000000000000000g\"").unwrap_err().is_data()); + assert!(ser::from_str::("\"0x00000000000000000000000000000000000000000000000000000000000000000\"").unwrap_err().is_data()); + assert!(ser::from_str::("\"\"").unwrap_err().is_data()); + assert!(ser::from_str::("\"0\"").unwrap_err().is_data()); + assert!(ser::from_str::("\"10\"").unwrap_err().is_data()); }