grassrootseconomics/openethereum
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Reformat the source code

Browse Source
This commit is contained in:
Artem Vorotnikov
2020-08-05 07:08:03 +03:00
parent 253ff3f37b
commit 610d9baba4
742 changed files with 175791 additions and 141379 deletions
Download Patch File Download Diff File Expand all files Collapse all files

207
json/src/trie/input.rs
View File

@@ -16,141 +16,164 @@
//! Trie test input deserialization.
use std::fmt;
use std::collections::BTreeMap;
use std::str::FromStr;
use bytes::Bytes;
use serde::{Deserialize, Deserializer};
use serde::de::{Error as ErrorTrait, Visitor, MapAccess, SeqAccess};
use serde::{
de::{Error as ErrorTrait, MapAccess, SeqAccess, Visitor},
Deserialize, Deserializer,
};
use std::{collections::BTreeMap, fmt, str::FromStr};
/// Trie test input.
#[derive(Debug, PartialEq)]
pub struct Input {
/// Input params.
pub data: BTreeMap<Bytes, Option<Bytes>>,
/// Input params.
pub data: BTreeMap<Bytes, Option<Bytes>>,
}
impl<'a> Deserialize<'a> for Input {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'a>
{
deserializer.deserialize_any(InputVisitor)
}
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'a>,
{
deserializer.deserialize_any(InputVisitor)
}
}
struct InputVisitor;
impl<'a> Visitor<'a> for InputVisitor {
type Value = Input;
type Value = Input;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, "a map of bytes into bytes")
}
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, "a map of bytes into bytes")
}
fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error> where V: MapAccess<'a> {
let mut result = BTreeMap::new();
fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
where
V: MapAccess<'a>,
{
let mut result = BTreeMap::new();
loop {
let key_str: Option<String> = visitor.next_key()?;
let key = match key_str {
Some(ref k) if k.starts_with("0x") => Bytes::from_str(k).map_err(V::Error::custom)?,
Some(k) => Bytes::new(k.into_bytes()),
None => { break; }
};
loop {
let key_str: Option<String> = visitor.next_key()?;
let key = match key_str {
Some(ref k) if k.starts_with("0x") => {
Bytes::from_str(k).map_err(V::Error::custom)?
}
Some(k) => Bytes::new(k.into_bytes()),
None => {
break;
}
};
let val_str: Option<String> = visitor.next_value()?;
let val = match val_str {
Some(ref v) if v.starts_with("0x") => Some(Bytes::from_str(v).map_err(V::Error::custom)?),
Some(v) => Some(Bytes::new(v.into_bytes())),
None => None,
};
let val_str: Option<String> = visitor.next_value()?;
let val = match val_str {
Some(ref v) if v.starts_with("0x") => {
Some(Bytes::from_str(v).map_err(V::Error::custom)?)
}
Some(v) => Some(Bytes::new(v.into_bytes())),
None => None,
};
result.insert(key, val);
}
result.insert(key, val);
}
let input = Input {
data: result
};
let input = Input { data: result };
Ok(input)
}
Ok(input)
}
fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error> where V: SeqAccess<'a> {
let mut result = BTreeMap::new();
fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
where
V: SeqAccess<'a>,
{
let mut result = BTreeMap::new();
loop {
let keyval: Option<Vec<Option<String>>> = visitor.next_element()?;
let keyval = match keyval {
Some(k) => k,
_ => { break; },
};
loop {
let keyval: Option<Vec<Option<String>>> = visitor.next_element()?;
let keyval = match keyval {
Some(k) => k,
_ => {
break;
}
};
if keyval.len() != 2 {
return Err(V::Error::custom("Invalid key value pair."));
}
if keyval.len() != 2 {
return Err(V::Error::custom("Invalid key value pair."));
}
let ref key_str: Option<String> = keyval[0];
let ref val_str: Option<String> = keyval[1];
let ref key_str: Option<String> = keyval[0];
let ref val_str: Option<String> = keyval[1];
let key = match *key_str {
Some(ref k) if k.starts_with("0x") => Bytes::from_str(k).map_err(V::Error::custom)?,
Some(ref k) => Bytes::new(k.clone().into_bytes()),
None => { break; }
};
let key = match *key_str {
Some(ref k) if k.starts_with("0x") => {
Bytes::from_str(k).map_err(V::Error::custom)?
}
Some(ref k) => Bytes::new(k.clone().into_bytes()),
None => {
break;
}
};
let val = match *val_str {
Some(ref v) if v.starts_with("0x") => Some(Bytes::from_str(v).map_err(V::Error::custom)?),
Some(ref v) => Some(Bytes::new(v.clone().into_bytes())),
None => None,
};
let val = match *val_str {
Some(ref v) if v.starts_with("0x") => {
Some(Bytes::from_str(v).map_err(V::Error::custom)?)
}
Some(ref v) => Some(Bytes::new(v.clone().into_bytes())),
None => None,
};
result.insert(key, val);
}
result.insert(key, val);
}
let input = Input {
data: result
};
let input = Input { data: result };
Ok(input)
}
Ok(input)
}
}
#[cfg(test)]
mod tests {
use std::collections::BTreeMap;
use serde_json;
use bytes::Bytes;
use super::Input;
use super::Input;
use bytes::Bytes;
use serde_json;
use std::collections::BTreeMap;
#[test]
fn input_deserialization_from_map() {
let s = r#"{
#[test]
fn input_deserialization_from_map() {
let s = r#"{
"0x0045" : "0x0123456789",
"be" : "e",
"0x0a" : null
}"#;
let input: Input = serde_json::from_str(s).unwrap();
let mut map = BTreeMap::new();
map.insert(Bytes::new(vec![0, 0x45]), Some(Bytes::new(vec![0x01, 0x23, 0x45, 0x67, 0x89])));
map.insert(Bytes::new(vec![0x62, 0x65]), Some(Bytes::new(vec![0x65])));
map.insert(Bytes::new(vec![0x0a]), None);
assert_eq!(input.data, map);
}
let input: Input = serde_json::from_str(s).unwrap();
let mut map = BTreeMap::new();
map.insert(
Bytes::new(vec![0, 0x45]),
Some(Bytes::new(vec![0x01, 0x23, 0x45, 0x67, 0x89])),
);
map.insert(Bytes::new(vec![0x62, 0x65]), Some(Bytes::new(vec![0x65])));
map.insert(Bytes::new(vec![0x0a]), None);
assert_eq!(input.data, map);
}
#[test]
fn input_deserialization_from_array() {
let s = r#"[
#[test]
fn input_deserialization_from_array() {
let s = r#"[
["0x0045", "0x0123456789"],
["be", "e"],
["0x0a", null]
]"#;
let input: Input = serde_json::from_str(s).unwrap();
let mut map = BTreeMap::new();
map.insert(Bytes::new(vec![0, 0x45]), Some(Bytes::new(vec![0x01, 0x23, 0x45, 0x67, 0x89])));
map.insert(Bytes::new(vec![0x62, 0x65]), Some(Bytes::new(vec![0x65])));
map.insert(Bytes::new(vec![0x0a]), None);
assert_eq!(input.data, map);
}
let input: Input = serde_json::from_str(s).unwrap();
let mut map = BTreeMap::new();
map.insert(
Bytes::new(vec![0, 0x45]),
Some(Bytes::new(vec![0x01, 0x23, 0x45, 0x67, 0x89])),
);
map.insert(Bytes::new(vec![0x62, 0x65]), Some(Bytes::new(vec![0x65])));
map.insert(Bytes::new(vec![0x0a]), None);
assert_eq!(input.data, map);
}
}

6
json/src/trie/mod.rs
View File

@@ -17,9 +17,7 @@
//! Trie test deserialization.
mod input;
mod trie;
mod test;
mod trie;
pub use self::input::Input;
pub use self::trie::Trie;
pub use self::test::Test;
pub use self::{input::Input, test::Test, trie::Trie};

27
json/src/trie/test.rs
View File

@@ -16,10 +16,8 @@
//! TransactionTest test deserializer.
use std::collections::BTreeMap;
use std::io::Read;
use serde_json;
use serde_json::Error;
use serde_json::{self, Error};
use std::{collections::BTreeMap, io::Read};
use trie::Trie;
/// TransactionTest test deserializer.
@@ -27,17 +25,20 @@ use trie::Trie;
pub struct Test(BTreeMap<String, Trie>);
impl IntoIterator for Test {
type Item = <BTreeMap<String, Trie> as IntoIterator>::Item;
type IntoIter = <BTreeMap<String, Trie> as IntoIterator>::IntoIter;
type Item = <BTreeMap<String, Trie> as IntoIterator>::Item;
type IntoIter = <BTreeMap<String, Trie> as IntoIterator>::IntoIter;
fn into_iter(self) -> Self::IntoIter {
self.0.into_iter()
}
fn into_iter(self) -> Self::IntoIter {
self.0.into_iter()
}
}
impl Test {
/// Loads test from json.
pub fn load<R>(reader: R) -> Result<Self, Error> where R: Read {
serde_json::from_reader(reader)
}
/// Loads test from json.
pub fn load<R>(reader: R) -> Result<Self, Error>
where
R: Read,
{
serde_json::from_reader(reader)
}
}

10
json/src/trie/trie.rs
View File

@@ -22,9 +22,9 @@ use trie::Input;
/// Trie test deserialization.
#[derive(Debug, Deserialize, PartialEq)]
pub struct Trie {
/// Trie test input.
#[serde(rename = "in")]
pub input: Input,
/// Trie root hash.
pub root: H256,
/// Trie test input.
#[serde(rename = "in")]
pub input: Input,
/// Trie root hash.
pub root: H256,
}