cargo +nightly fmt (#3540)

* cargo +nightly fmt

* add cargo-fmt check to ci

* update ci

* fmt

* fmt

* skip macro

* ignore bridges

polkadot/node/core/pvf/tests/it/adder.rs

@@ -15,22 +15,16 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use super::TestHost;
-use polkadot_parachain::{
-	primitives::{
-		RelayChainBlockNumber, BlockData as GenericBlockData, HeadData as GenericHeadData,
-		ValidationParams,
-	},
-};
+use adder::{hash_state, BlockData, HeadData};
 use parity_scale_codec::{Decode, Encode};
-use adder::{HeadData, BlockData, hash_state};
+use polkadot_parachain::primitives::{
+	BlockData as GenericBlockData, HeadData as GenericHeadData, RelayChainBlockNumber,
+	ValidationParams,
+};
 
 #[async_std::test]
 async fn execute_good_on_parent() {
-	let parent_head = HeadData {
-		number: 0,
-		parent_hash: [0; 32],
-		post_state: hash_state(0),
-	};
+	let parent_head = HeadData { number: 0, parent_hash: [0; 32], post_state: hash_state(0) };
 
 	let block_data = BlockData { state: 0, add: 512 };
 
@@ -65,16 +59,9 @@ async fn execute_good_chain_on_parent() {
 	let host = TestHost::new();
 
 	for add in 0..10 {
-		let parent_head = HeadData {
-			number,
-			parent_hash,
-			post_state: hash_state(last_state),
-		};
+		let parent_head = HeadData { number, parent_hash, post_state: hash_state(last_state) };
 
-		let block_data = BlockData {
-			state: last_state,
-			add,
-		};
+		let block_data = BlockData { state: last_state, add };
 
 		let ret = host
 			.validate_candidate(
@@ -103,11 +90,7 @@ async fn execute_good_chain_on_parent() {
 
 #[async_std::test]
 async fn execute_bad_on_parent() {
-	let parent_head = HeadData {
-		number: 0,
-		parent_hash: [0; 32],
-		post_state: hash_state(0),
-	};
+	let parent_head = HeadData { number: 0, parent_hash: [0; 32], post_state: hash_state(0) };
 
 	let block_data = BlockData {
 		state: 256, // start state is wrong.

polkadot/node/core/pvf/tests/it/main.rs

@@ -14,10 +14,12 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use polkadot_node_core_pvf::{Pvf, ValidationHost, start, Config, InvalidCandidate, ValidationError};
-use polkadot_parachain::primitives::{BlockData, ValidationParams, ValidationResult};
-use parity_scale_codec::Encode as _;
 use async_std::sync::Mutex;
+use parity_scale_codec::Encode as _;
+use polkadot_node_core_pvf::{
+	start, Config, InvalidCandidate, Pvf, ValidationError, ValidationHost,
+};
+use polkadot_parachain::primitives::{BlockData, ValidationParams, ValidationResult};
 
 mod adder;
 mod worker_common;
@@ -44,10 +46,7 @@ impl TestHost {
 		f(&mut config);
 		let (host, task) = start(config);
 		let _ = async_std::task::spawn(task);
-		Self {
-			_cache_dir: cache_dir,
-			host: Mutex::new(host),
-		}
+		Self { _cache_dir: cache_dir, host: Mutex::new(host) }
 	}
 
 	async fn validate_candidate(
@@ -57,7 +56,8 @@ impl TestHost {
 	) -> Result<ValidationResult, ValidationError> {
 		let (result_tx, result_rx) = futures::channel::oneshot::channel();
 
-		let code = sp_maybe_compressed_blob::decompress(code, 16 * 1024 * 1024).expect("Compression works");
+		let code = sp_maybe_compressed_blob::decompress(code, 16 * 1024 * 1024)
+			.expect("Compression works");
 
 		self.host
 			.lock()
@@ -91,7 +91,7 @@ async fn terminates_on_timeout() {
 		.await;
 
 	match result {
-		Err(ValidationError::InvalidCandidate(InvalidCandidate::HardTimeout)) => {}
+		Err(ValidationError::InvalidCandidate(InvalidCandidate::HardTimeout)) => {},
 		r => panic!("{:?}", r),
 	}
 }
@@ -124,8 +124,8 @@ async fn parallel_execution() {
 	// total time should be < 2 x EXECUTION_TIMEOUT_SEC
 	const EXECUTION_TIMEOUT_SEC: u64 = 3;
 	assert!(
-		std::time::Instant::now().duration_since(start)
-			< std::time::Duration::from_secs(EXECUTION_TIMEOUT_SEC * 2)
+		std::time::Instant::now().duration_since(start) <
+			std::time::Duration::from_secs(EXECUTION_TIMEOUT_SEC * 2)
 	);
 }
 

polkadot/node/core/pvf/tests/it/worker_common.rs

@@ -20,13 +20,9 @@ use std::time::Duration;
 
 #[async_std::test]
 async fn spawn_timeout() {
-	let result = spawn_with_program_path(
-		"integration-test",
-		PUPPET_EXE,
-		&["sleep"],
-		Duration::from_secs(2),
-	)
-	.await;
+	let result =
+		spawn_with_program_path("integration-test", PUPPET_EXE, &["sleep"], Duration::from_secs(2))
+			.await;
 	assert!(matches!(result, Err(SpawnErr::AcceptTimeout)));
 }