poanetwork
/
parity-common
mirror of https://github.com/poanetwork/parity-common.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fix indentation.

This commit is contained in:
Tomasz Drwięga 2018-02-02 13:47:33 +01:00
parent 90a3ada499
commit bb33df436c
No known key found for this signature in database
GPG Key ID: B2BA26B1C688F8FC
5 changed files with 123 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ethbloom/src/lib.rs
View File

@ -235,7 +235,7 @@ impl<'a> From<&'a Bloom> for BloomRef<'a> {
#[cfg(feature="serialize")] #[cfg(feature="serialize")]
impl Serialize for Bloom { impl Serialize for Bloom {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 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) ethereum_types_serialize::serialize(&mut slice, &self.0, serializer)
} }
} }
@ -243,9 +243,9 @@ impl Serialize for Bloom {
#[cfg(feature="serialize")] #[cfg(feature="serialize")]
impl<'de> Deserialize<'de> for Bloom { impl<'de> Deserialize<'de> for Bloom {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 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))?; ethereum_types_serialize::deserialize_check_len(deserializer, ethereum_types_serialize::ExpectedLen::Exact(&mut bytes))?;
Ok(Bloom(bytes)) Ok(Bloom(bytes))
} }
} }

6
ethereum-types/src/hash.rs
View File

@ -81,7 +81,7 @@ macro_rules! impl_serde {
#[cfg(feature="serialize")] #[cfg(feature="serialize")]
impl Serialize for $name { impl Serialize for $name {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 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) ethereum_types_serialize::serialize(&mut slice, &self.0, serializer)
} }
} }
@ -89,9 +89,9 @@ macro_rules! impl_serde {
#[cfg(feature="serialize")] #[cfg(feature="serialize")]
impl<'de> Deserialize<'de> for $name { impl<'de> Deserialize<'de> for $name {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 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))?; ethereum_types_serialize::deserialize_check_len(deserializer, ethereum_types_serialize::ExpectedLen::Exact(&mut bytes))?;
Ok($name(bytes)) Ok($name(bytes))
} }
} }
} }

6
ethereum-types/src/uint.rs
View File

@ -334,7 +334,7 @@ macro_rules! impl_serde {
#[cfg(feature="serialize")] #[cfg(feature="serialize")]
impl Serialize for $name { impl Serialize for $name {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 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]; let mut bytes = [0u8; $len * 8];
self.to_big_endian(&mut bytes); self.to_big_endian(&mut bytes);
ethereum_types_serialize::serialize_uint(&mut slice, &bytes, serializer) ethereum_types_serialize::serialize_uint(&mut slice, &bytes, serializer)
@ -344,9 +344,9 @@ macro_rules! impl_serde {
#[cfg(feature="serialize")] #[cfg(feature="serialize")]
impl<'de> Deserialize<'de> for $name { impl<'de> Deserialize<'de> for $name {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 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))?; 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())
} }
} }
} }

94
serialize/src/lib.rs
View File

@ -6,35 +6,35 @@ use serde::{de, Serializer, Deserializer};
static CHARS: &'static[u8] = b"0123456789abcdef"; static CHARS: &'static[u8] = b"0123456789abcdef";
fn to_hex<'a>(v: &'a mut [u8], bytes: &[u8], skip_leading_zero: bool) -> &'a str { 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[0] = '0' as u8;
v[1] = 'x' as u8; v[1] = 'x' as u8;
let mut idx = 2; let mut idx = 2;
let first_nibble = bytes[0] >> 4; let first_nibble = bytes[0] >> 4;
if first_nibble != 0 || !skip_leading_zero { if first_nibble != 0 || !skip_leading_zero {
v[idx] = CHARS[first_nibble as usize]; v[idx] = CHARS[first_nibble as usize];
idx += 1; idx += 1;
} }
v[idx] = CHARS[(bytes[0] & 0xf) as usize]; v[idx] = CHARS[(bytes[0] & 0xf) as usize];
idx += 1; idx += 1;
for &byte in bytes.iter().skip(1) { for &byte in bytes.iter().skip(1) {
v[idx] = CHARS[(byte >> 4) as usize]; v[idx] = CHARS[(byte >> 4) as usize];
v[idx + 1] = CHARS[(byte & 0xf) as usize]; v[idx + 1] = CHARS[(byte & 0xf) as usize];
idx += 2; 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. /// Serializes a slice of bytes.
pub fn serialize<S>(slice: &mut [u8], bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error> where pub fn serialize<S>(slice: &mut [u8], bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer, S: Serializer,
{ {
let mut v = Vec::with_capacity(2 + bytes.len() * 2); let mut v = Vec::with_capacity(2 + bytes.len() * 2);
v.resize(2 + bytes.len() * 2, 0); v.resize(2 + bytes.len() * 2, 0);
serializer.serialize_str(to_hex(slice, bytes, false)) 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 { let bytes = match self.len {
ExpectedLen::Exact(slice) => slice, ExpectedLen::Exact(slice) => slice,
ExpectedLen::Between(_, slice) => slice, ExpectedLen::Between(_, slice) => slice,
}; };
let mut modulus = v.len() % 2; let mut modulus = v.len() % 2;
let mut buf = 0; let mut buf = 0;
let mut pos = 0; let mut pos = 0;
for (idx, byte) in v.bytes().enumerate().skip(2) { for (idx, byte) in v.bytes().enumerate().skip(2) {
buf <<= 4; buf <<= 4;
match byte { match byte {
b'A'...b'F' => buf |= byte - b'A' + 10, b'A'...b'F' => buf |= byte - b'A' + 10,
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'0'...b'9' => buf |= byte - b'0',
b' '|b'\r'|b'\n'|b'\t' => { b' '|b'\r'|b'\n'|b'\t' => {
buf >>= 4; buf >>= 4;
continue continue
} }
_ => { _ => {
let ch = v[idx..].chars().next().unwrap(); let ch = v[idx..].chars().next().unwrap();
return Err(E::custom(&format!("invalid hex character: {}, at {}", ch, idx))) return Err(E::custom(&format!("invalid hex character: {}, at {}", ch, idx)))
} }
} }
modulus += 1; modulus += 1;
if modulus == 2 { if modulus == 2 {
modulus = 0; modulus = 0;
bytes[pos] = buf; bytes[pos] = buf;
pos += 1; pos += 1;
} }
} }
Ok(pos) Ok(pos)
} }
fn visit_string<E: de::Error>(self, v: String) -> Result<Self::Value, E> { fn visit_string<E: de::Error>(self, v: String) -> Result<Self::Value, E> {

134
tests/src/serialization.rs
View File

@ -2,36 +2,36 @@ use ethereum_types::{U256, U512, H160, H256};
use serde_json as ser; use serde_json as ser;
macro_rules! test { macro_rules! test {
($name: ident, $test_name: ident) => { ($name: ident, $test_name: ident) => {
#[test] #[test]
fn $test_name() { fn $test_name() {
let tests = vec![ let tests = vec![
($name::from(0), "0x0"), ($name::from(0), "0x0"),
($name::from(1), "0x1"), ($name::from(1), "0x1"),
($name::from(2), "0x2"), ($name::from(2), "0x2"),
($name::from(10), "0xa"), ($name::from(10), "0xa"),
($name::from(15), "0xf"), ($name::from(15), "0xf"),
($name::from(15), "0xf"), ($name::from(15), "0xf"),
($name::from(16), "0x10"), ($name::from(16), "0x10"),
($name::from(1_000), "0x3e8"), ($name::from(1_000), "0x3e8"),
($name::from(100_000), "0x186a0"), ($name::from(100_000), "0x186a0"),
($name::from(u64::max_value()), "0xffffffffffffffff"), ($name::from(u64::max_value()), "0xffffffffffffffff"),
($name::from(u64::max_value()) + 1.into(), "0x10000000000000000"), ($name::from(u64::max_value()) + 1.into(), "0x10000000000000000"),
]; ];
for (number, expected) in tests { for (number, expected) in tests {
assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap()); assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap());
assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap()); assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
} }
// Invalid examples // Invalid examples
assert!(ser::from_str::<$name>("\"0x\"").unwrap_err().is_data()); 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>("\"0xg\"").unwrap_err().is_data());
assert!(ser::from_str::<$name>("\"\"").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>("\"10\"").unwrap_err().is_data());
assert!(ser::from_str::<$name>("\"0\"").unwrap_err().is_data()); assert!(ser::from_str::<$name>("\"0\"").unwrap_err().is_data());
} }
} }
} }
test!(U256, test_u256); test!(U256, test_u256);
@ -39,57 +39,57 @@ test!(U512, test_u512);
#[test] #[test]
fn test_large_values() { fn test_large_values() {
assert_eq!( assert_eq!(
ser::to_string_pretty(&!U256::zero()).unwrap(), ser::to_string_pretty(&!U256::zero()).unwrap(),
"\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\"" "\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
); );
assert!( assert!(
ser::from_str::<U256>("\"0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\"").unwrap_err().is_data() ser::from_str::<U256>("\"0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\"").unwrap_err().is_data()
); );
} }
#[test] #[test]
fn test_h160() { fn test_h160() {
let tests = vec![ let tests = vec![
(H160::from(0), "0x0000000000000000000000000000000000000000"), (H160::from(0), "0x0000000000000000000000000000000000000000"),
(H160::from(2), "0x0000000000000000000000000000000000000002"), (H160::from(2), "0x0000000000000000000000000000000000000002"),
(H160::from(15), "0x000000000000000000000000000000000000000f"), (H160::from(15), "0x000000000000000000000000000000000000000f"),
(H160::from(16), "0x0000000000000000000000000000000000000010"), (H160::from(16), "0x0000000000000000000000000000000000000010"),
(H160::from(1_000), "0x00000000000000000000000000000000000003e8"), (H160::from(1_000), "0x00000000000000000000000000000000000003e8"),
(H160::from(100_000), "0x00000000000000000000000000000000000186a0"), (H160::from(100_000), "0x00000000000000000000000000000000000186a0"),
(H160::from(u64::max_value()), "0x000000000000000000000000ffffffffffffffff"), (H160::from(u64::max_value()), "0x000000000000000000000000ffffffffffffffff"),
]; ];
for (number, expected) in tests { for (number, expected) in tests {
assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap()); assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap());
assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap()); assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
} }
} }
#[test] #[test]
fn test_h256() { fn test_h256() {
let tests = vec![ let tests = vec![
(H256::from(0), "0x0000000000000000000000000000000000000000000000000000000000000000"), (H256::from(0), "0x0000000000000000000000000000000000000000000000000000000000000000"),
(H256::from(2), "0x0000000000000000000000000000000000000000000000000000000000000002"), (H256::from(2), "0x0000000000000000000000000000000000000000000000000000000000000002"),
(H256::from(15), "0x000000000000000000000000000000000000000000000000000000000000000f"), (H256::from(15), "0x000000000000000000000000000000000000000000000000000000000000000f"),
(H256::from(16), "0x0000000000000000000000000000000000000000000000000000000000000010"), (H256::from(16), "0x0000000000000000000000000000000000000000000000000000000000000010"),
(H256::from(1_000), "0x00000000000000000000000000000000000000000000000000000000000003e8"), (H256::from(1_000), "0x00000000000000000000000000000000000000000000000000000000000003e8"),
(H256::from(100_000), "0x00000000000000000000000000000000000000000000000000000000000186a0"), (H256::from(100_000), "0x00000000000000000000000000000000000000000000000000000000000186a0"),
(H256::from(u64::max_value()), "0x000000000000000000000000000000000000000000000000ffffffffffffffff"), (H256::from(u64::max_value()), "0x000000000000000000000000000000000000000000000000ffffffffffffffff"),
]; ];
for (number, expected) in tests { for (number, expected) in tests {
assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap()); assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap());
assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap()); assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
} }
} }
#[test] #[test]
fn test_invalid() { fn test_invalid() {
assert!(ser::from_str::<H256>("\"0x000000000000000000000000000000000000000000000000000000000000000\"").unwrap_err().is_data()); assert!(ser::from_str::<H256>("\"0x000000000000000000000000000000000000000000000000000000000000000\"").unwrap_err().is_data());
assert!(ser::from_str::<H256>("\"0x000000000000000000000000000000000000000000000000000000000000000g\"").unwrap_err().is_data()); assert!(ser::from_str::<H256>("\"0x000000000000000000000000000000000000000000000000000000000000000g\"").unwrap_err().is_data());
assert!(ser::from_str::<H256>("\"0x00000000000000000000000000000000000000000000000000000000000000000\"").unwrap_err().is_data()); assert!(ser::from_str::<H256>("\"0x00000000000000000000000000000000000000000000000000000000000000000\"").unwrap_err().is_data());
assert!(ser::from_str::<H256>("\"\"").unwrap_err().is_data()); assert!(ser::from_str::<H256>("\"\"").unwrap_err().is_data());
assert!(ser::from_str::<H256>("\"0\"").unwrap_err().is_data()); assert!(ser::from_str::<H256>("\"0\"").unwrap_err().is_data());
assert!(ser::from_str::<H256>("\"10\"").unwrap_err().is_data()); assert!(ser::from_str::<H256>("\"10\"").unwrap_err().is_data());
} }