pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-26 18:07:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Run cargo fmt on the whole code base (#9394)

Browse Source 
* Run cargo fmt on the whole code base

* Second run

* Add CI check

* Fix compilation

* More unnecessary braces

* Handle weights

* Use --all

* Use correct attributes...

* Fix UI tests

* AHHHHHHHHH

* 🤦

* Docs

* Fix compilation

* 🤷

* Please stop

* 🤦 x 2

* More

* make rustfmt.toml consistent with polkadot

Co-authored-by: André Silva <andrerfosilva@gmail.com>
This commit is contained in:
Bastian Köcher
2021-07-21 16:32:32 +02:00
committed by GitHub
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/test-utils/runtime/client/src/trait_tests.rs
+240 -251
View File
@@ -23,192 +23,169 @@
use std::sync::Arc;
use crate::{
AccountKeyring, ClientBlockImportExt, BlockBuilderExt, TestClientBuilder, TestClientBuilderExt,
AccountKeyring, BlockBuilderExt, ClientBlockImportExt, TestClientBuilder, TestClientBuilderExt,
};
use sc_client_api::backend;
use sc_client_api::blockchain::{Backend as BlockChainBackendT, HeaderBackend};
use sp_consensus::BlockOrigin;
use substrate_test_runtime::{self, Transfer};
use sp_runtime::generic::BlockId;
use sp_runtime::traits::Block as BlockT;
use sc_block_builder::BlockBuilderProvider;
use futures::executor::block_on;
use sc_block_builder::BlockBuilderProvider;
use sc_client_api::{
backend,
blockchain::{Backend as BlockChainBackendT, HeaderBackend},
};
use sp_consensus::BlockOrigin;
use sp_runtime::{generic::BlockId, traits::Block as BlockT};
use substrate_test_runtime::{self, Transfer};
/// helper to test the `leaves` implementation for various backends
pub fn test_leaves_for_backend<B: 'static>(backend: Arc<B>) where
pub fn test_leaves_for_backend<B: 'static>(backend: Arc<B>)
where
B: backend::Backend<substrate_test_runtime::Block>,
{
// block tree:
// G -> A1 -> A2 -> A3 -> A4 -> A5
// A1 -> B2 -> B3 -> B4
// B2 -> C3
// A1 -> D2
// A1 -> B2 -> B3 -> B4
// B2 -> C3
// A1 -> D2
let mut client = TestClientBuilder::with_backend(backend.clone()).build();
let blockchain = backend.blockchain();
let genesis_hash = client.chain_info().genesis_hash;
assert_eq!(
blockchain.leaves().unwrap(),
vec![genesis_hash]);
assert_eq!(blockchain.leaves().unwrap(), vec![genesis_hash]);
// G -> A1
let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
assert_eq!(
blockchain.leaves().unwrap(),
vec![a1.hash()],
);
assert_eq!(blockchain.leaves().unwrap(), vec![a1.hash()],);
// A1 -> A2
let a2 = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let a2 = client
.new_block_at(&BlockId::Hash(a1.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
#[allow(deprecated)]
assert_eq!(
blockchain.leaves().unwrap(),
vec![a2.hash()],
);
assert_eq!(blockchain.leaves().unwrap(), vec![a2.hash()],);
// A2 -> A3
let a3 = client.new_block_at(
&BlockId::Hash(a2.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let a3 = client
.new_block_at(&BlockId::Hash(a2.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
assert_eq!(
blockchain.leaves().unwrap(),
vec![a3.hash()],
);
assert_eq!(blockchain.leaves().unwrap(), vec![a3.hash()],);
// A3 -> A4
let a4 = client.new_block_at(
&BlockId::Hash(a3.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let a4 = client
.new_block_at(&BlockId::Hash(a3.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
assert_eq!(
blockchain.leaves().unwrap(),
vec![a4.hash()],
);
assert_eq!(blockchain.leaves().unwrap(), vec![a4.hash()],);
// A4 -> A5
let a5 = client.new_block_at(
&BlockId::Hash(a4.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let a5 = client
.new_block_at(&BlockId::Hash(a4.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
assert_eq!(
blockchain.leaves().unwrap(),
vec![a5.hash()],
);
assert_eq!(blockchain.leaves().unwrap(), vec![a5.hash()],);
// A1 -> B2
let mut builder = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap();
let mut builder = client
.new_block_at(&BlockId::Hash(a1.hash()), Default::default(), false)
.unwrap();
// this push is required as otherwise B2 has the same hash as A2 and won't get imported
builder.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 41,
nonce: 0,
}).unwrap();
builder
.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 41,
nonce: 0,
})
.unwrap();
let b2 = builder.build().unwrap().block;
block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
assert_eq!(
blockchain.leaves().unwrap(),
vec![a5.hash(), b2.hash()],
);
assert_eq!(blockchain.leaves().unwrap(), vec![a5.hash(), b2.hash()],);
// B2 -> B3
let b3 = client.new_block_at(
&BlockId::Hash(b2.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let b3 = client
.new_block_at(&BlockId::Hash(b2.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
assert_eq!(
blockchain.leaves().unwrap(),
vec![a5.hash(), b3.hash()],
);
assert_eq!(blockchain.leaves().unwrap(), vec![a5.hash(), b3.hash()],);
// B3 -> B4
let b4 = client.new_block_at(
&BlockId::Hash(b3.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let b4 = client
.new_block_at(&BlockId::Hash(b3.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, b4.clone())).unwrap();
assert_eq!(
blockchain.leaves().unwrap(),
vec![a5.hash(), b4.hash()],
);
assert_eq!(blockchain.leaves().unwrap(), vec![a5.hash(), b4.hash()],);
// // B2 -> C3
let mut builder = client.new_block_at(
&BlockId::Hash(b2.hash()),
Default::default(),
false,
).unwrap();
let mut builder = client
.new_block_at(&BlockId::Hash(b2.hash()), Default::default(), false)
.unwrap();
// this push is required as otherwise C3 has the same hash as B3 and won't get imported
builder.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 1,
nonce: 1,
}).unwrap();
builder
.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 1,
nonce: 1,
})
.unwrap();
let c3 = builder.build().unwrap().block;
block_on(client.import(BlockOrigin::Own, c3.clone())).unwrap();
assert_eq!(
blockchain.leaves().unwrap(),
vec![a5.hash(), b4.hash(), c3.hash()],
);
assert_eq!(blockchain.leaves().unwrap(), vec![a5.hash(), b4.hash(), c3.hash()],);
// A1 -> D2
let mut builder = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap();
let mut builder = client
.new_block_at(&BlockId::Hash(a1.hash()), Default::default(), false)
.unwrap();
// this push is required as otherwise D2 has the same hash as B2 and won't get imported
builder.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 1,
nonce: 0,
}).unwrap();
builder
.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 1,
nonce: 0,
})
.unwrap();
let d2 = builder.build().unwrap().block;
block_on(client.import(BlockOrigin::Own, d2.clone())).unwrap();
assert_eq!(
blockchain.leaves().unwrap(),
vec![a5.hash(), b4.hash(), c3.hash(), d2.hash()],
);
assert_eq!(blockchain.leaves().unwrap(), vec![a5.hash(), b4.hash(), c3.hash(), d2.hash()],);
}
/// helper to test the `children` implementation for various backends
pub fn test_children_for_backend<B: 'static>(backend: Arc<B>) where
pub fn test_children_for_backend<B: 'static>(backend: Arc<B>)
where
B: backend::LocalBackend<substrate_test_runtime::Block>,
{
// block tree:
// G -> A1 -> A2 -> A3 -> A4 -> A5
// A1 -> B2 -> B3 -> B4
// B2 -> C3
// A1 -> D2
// A1 -> B2 -> B3 -> B4
// B2 -> C3
// A1 -> D2
let mut client = TestClientBuilder::with_backend(backend.clone()).build();
let blockchain = backend.blockchain();
@@ -218,98 +195,104 @@ pub fn test_children_for_backend<B: 'static>(backend: Arc<B>) where
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
// A1 -> A2
let a2 = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let a2 = client
.new_block_at(&BlockId::Hash(a1.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
// A2 -> A3
let a3 = client.new_block_at(
&BlockId::Hash(a2.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let a3 = client
.new_block_at(&BlockId::Hash(a2.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
// A3 -> A4
let a4 = client.new_block_at(
&BlockId::Hash(a3.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let a4 = client
.new_block_at(&BlockId::Hash(a3.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
// A4 -> A5
let a5 = client.new_block_at(
&BlockId::Hash(a4.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let a5 = client
.new_block_at(&BlockId::Hash(a4.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
// A1 -> B2
let mut builder = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap();
let mut builder = client
.new_block_at(&BlockId::Hash(a1.hash()), Default::default(), false)
.unwrap();
// this push is required as otherwise B2 has the same hash as A2 and won't get imported
builder.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 41,
nonce: 0,
}).unwrap();
builder
.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 41,
nonce: 0,
})
.unwrap();
let b2 = builder.build().unwrap().block;
block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
// B2 -> B3
let b3 = client.new_block_at(
&BlockId::Hash(b2.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let b3 = client
.new_block_at(&BlockId::Hash(b2.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
// B3 -> B4
let b4 = client.new_block_at(
&BlockId::Hash(b3.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let b4 = client
.new_block_at(&BlockId::Hash(b3.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, b4)).unwrap();
// // B2 -> C3
let mut builder = client.new_block_at(
&BlockId::Hash(b2.hash()),
Default::default(),
false,
).unwrap();
let mut builder = client
.new_block_at(&BlockId::Hash(b2.hash()), Default::default(), false)
.unwrap();
// this push is required as otherwise C3 has the same hash as B3 and won't get imported
builder.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 1,
nonce: 1,
}).unwrap();
builder
.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 1,
nonce: 1,
})
.unwrap();
let c3 = builder.build().unwrap().block;
block_on(client.import(BlockOrigin::Own, c3.clone())).unwrap();
// A1 -> D2
let mut builder = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap();
let mut builder = client
.new_block_at(&BlockId::Hash(a1.hash()), Default::default(), false)
.unwrap();
// this push is required as otherwise D2 has the same hash as B2 and won't get imported
builder.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 1,
nonce: 0,
}).unwrap();
builder
.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 1,
nonce: 0,
})
.unwrap();
let d2 = builder.build().unwrap().block;
block_on(client.import(BlockOrigin::Own, d2.clone())).unwrap();
@@ -334,9 +317,9 @@ where
{
// block tree:
// G -> A1 -> A2 -> A3 -> A4 -> A5
// A1 -> B2 -> B3 -> B4
// B2 -> C3
// A1 -> D2
// A1 -> B2 -> B3 -> B4
// B2 -> C3
// A1 -> D2
let mut client = TestClientBuilder::with_backend(backend.clone()).build();
let blockchain = backend.blockchain();
@@ -345,98 +328,104 @@ where
block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
// A1 -> A2
let a2 = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let a2 = client
.new_block_at(&BlockId::Hash(a1.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
// A2 -> A3
let a3 = client.new_block_at(
&BlockId::Hash(a2.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let a3 = client
.new_block_at(&BlockId::Hash(a2.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
// A3 -> A4
let a4 = client.new_block_at(
&BlockId::Hash(a3.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let a4 = client
.new_block_at(&BlockId::Hash(a3.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
// A4 -> A5
let a5 = client.new_block_at(
&BlockId::Hash(a4.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let a5 = client
.new_block_at(&BlockId::Hash(a4.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
// A1 -> B2
let mut builder = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap();
let mut builder = client
.new_block_at(&BlockId::Hash(a1.hash()), Default::default(), false)
.unwrap();
// this push is required as otherwise B2 has the same hash as A2 and won't get imported
builder.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 41,
nonce: 0,
}).unwrap();
builder
.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 41,
nonce: 0,
})
.unwrap();
let b2 = builder.build().unwrap().block;
block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
// B2 -> B3
let b3 = client.new_block_at(
&BlockId::Hash(b2.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let b3 = client
.new_block_at(&BlockId::Hash(b2.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
// B3 -> B4
let b4 = client.new_block_at(
&BlockId::Hash(b3.hash()),
Default::default(),
false,
).unwrap().build().unwrap().block;
let b4 = client
.new_block_at(&BlockId::Hash(b3.hash()), Default::default(), false)
.unwrap()
.build()
.unwrap()
.block;
block_on(client.import(BlockOrigin::Own, b4)).unwrap();
// // B2 -> C3
let mut builder = client.new_block_at(
&BlockId::Hash(b2.hash()),
Default::default(),
false,
).unwrap();
let mut builder = client
.new_block_at(&BlockId::Hash(b2.hash()), Default::default(), false)
.unwrap();
// this push is required as otherwise C3 has the same hash as B3 and won't get imported
builder.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 1,
nonce: 1,
}).unwrap();
builder
.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 1,
nonce: 1,
})
.unwrap();
let c3 = builder.build().unwrap().block;
block_on(client.import(BlockOrigin::Own, c3)).unwrap();
// A1 -> D2
let mut builder = client.new_block_at(
&BlockId::Hash(a1.hash()),
Default::default(),
false,
).unwrap();
let mut builder = client
.new_block_at(&BlockId::Hash(a1.hash()), Default::default(), false)
.unwrap();
// this push is required as otherwise D2 has the same hash as B2 and won't get imported
builder.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 1,
nonce: 0,
}).unwrap();
builder
.push_transfer(Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Ferdie.into(),
amount: 1,
nonce: 0,
})
.unwrap();
let d2 = builder.build().unwrap().block;
block_on(client.import(BlockOrigin::Own, d2)).unwrap();