cargo +nightly fmt (#3540)

* cargo +nightly fmt

* add cargo-fmt check to ci

* update ci

* fmt

* fmt

* skip macro

* ignore bridges

polkadot/node/core/candidate-validation/src/lib.rs

@@ -23,34 +23,32 @@
 #![deny(unused_crate_dependencies, unused_results)]
 #![warn(missing_docs)]
 
+use polkadot_node_core_pvf::{
+	InvalidCandidate as WasmInvalidCandidate, Pvf, ValidationError, ValidationHost,
+};
+use polkadot_node_primitives::{
+	BlockData, InvalidCandidate, PoV, ValidationResult, POV_BOMB_LIMIT, VALIDATION_CODE_BOMB_LIMIT,
+};
 use polkadot_node_subsystem::{
-	overseer,
-	SubsystemContext, SpawnedSubsystem, SubsystemResult, SubsystemError,
-	FromOverseer, OverseerSignal,
-	messages::{
-		CandidateValidationMessage, RuntimeApiMessage,
-		ValidationFailed, RuntimeApiRequest,
-	},
 	errors::RuntimeApiError,
+	messages::{
+		CandidateValidationMessage, RuntimeApiMessage, RuntimeApiRequest, ValidationFailed,
+	},
+	overseer, FromOverseer, OverseerSignal, SpawnedSubsystem, SubsystemContext, SubsystemError,
+	SubsystemResult,
 };
 use polkadot_node_subsystem_util::metrics::{self, prometheus};
-use polkadot_node_primitives::{
-	VALIDATION_CODE_BOMB_LIMIT, POV_BOMB_LIMIT, ValidationResult, InvalidCandidate, PoV, BlockData,
-};
-use polkadot_primitives::v1::{
-	ValidationCode, CandidateDescriptor, PersistedValidationData,
-	OccupiedCoreAssumption, Hash, CandidateCommitments,
-};
 use polkadot_parachain::primitives::{ValidationParams, ValidationResult as WasmValidationResult};
-use polkadot_node_core_pvf::{Pvf, ValidationHost, ValidationError, InvalidCandidate as WasmInvalidCandidate};
+use polkadot_primitives::v1::{
+	CandidateCommitments, CandidateDescriptor, Hash, OccupiedCoreAssumption,
+	PersistedValidationData, ValidationCode,
+};
 
 use parity_scale_codec::Encode;
 
-use futures::channel::oneshot;
-use futures::prelude::*;
+use futures::{channel::oneshot, prelude::*};
 
-use std::sync::Arc;
-use std::path::PathBuf;
+use std::{path::PathBuf, sync::Arc};
 
 use async_trait::async_trait;
 
@@ -81,7 +79,7 @@ impl CandidateValidationSubsystem {
 	///
 	/// Check out [`IsolationStrategy`] to get more details.
 	pub fn with_config(config: Config, metrics: Metrics) -> Self {
-		CandidateValidationSubsystem { config, metrics, }
+		CandidateValidationSubsystem { config, metrics }
 	}
 }
 
@@ -91,13 +89,11 @@ where
 	Context: overseer::SubsystemContext<Message = CandidateValidationMessage>,
 {
 	fn start(self, ctx: Context) -> SpawnedSubsystem {
-		let future = run(ctx, self.metrics, self.config.artifacts_cache_path, self.config.program_path)
-			.map_err(|e| SubsystemError::with_origin("candidate-validation", e))
-			.boxed();
-		SpawnedSubsystem {
-			name: "candidate-validation-subsystem",
-			future,
-		}
+		let future =
+			run(ctx, self.metrics, self.config.artifacts_cache_path, self.config.program_path)
+				.map_err(|e| SubsystemError::with_origin("candidate-validation", e))
+				.boxed();
+		SpawnedSubsystem { name: "candidate-validation-subsystem", future }
 	}
 }
 
@@ -118,8 +114,8 @@ where
 
 	loop {
 		match ctx.recv().await? {
-			FromOverseer::Signal(OverseerSignal::ActiveLeaves(_)) => {}
-			FromOverseer::Signal(OverseerSignal::BlockFinalized(..)) => {}
+			FromOverseer::Signal(OverseerSignal::ActiveLeaves(_)) => {},
+			FromOverseer::Signal(OverseerSignal::BlockFinalized(..)) => {},
 			FromOverseer::Signal(OverseerSignal::Conclude) => return Ok(()),
 			FromOverseer::Communication { msg } => match msg {
 				CandidateValidationMessage::ValidateFromChainState(
@@ -135,16 +131,17 @@ where
 						descriptor,
 						pov,
 						&metrics,
-					).await;
+					)
+					.await;
 
 					match res {
 						Ok(x) => {
 							metrics.on_validation_event(&x);
 							let _ = response_sender.send(x);
-						}
+						},
 						Err(e) => return Err(e),
 					}
-				}
+				},
 				CandidateValidationMessage::ValidateFromExhaustive(
 					persisted_validation_data,
 					validation_code,
@@ -161,7 +158,8 @@ where
 						descriptor,
 						pov,
 						&metrics,
-					).await;
+					)
+					.await;
 
 					match res {
 						Ok(x) => {
@@ -175,8 +173,8 @@ where
 						},
 						Err(e) => return Err(e),
 					}
-				}
-			}
+				},
+			},
 		}
 	}
 }
@@ -191,12 +189,7 @@ where
 	Context: SubsystemContext<Message = CandidateValidationMessage>,
 	Context: overseer::SubsystemContext<Message = CandidateValidationMessage>,
 {
-	ctx.send_message(
-		RuntimeApiMessage::Request(
-			relay_parent,
-			request,
-		)
-	).await;
+	ctx.send_message(RuntimeApiMessage::Request(relay_parent, request)).await;
 
 	receiver.await.map_err(Into::into)
 }
@@ -222,44 +215,38 @@ where
 		let d = runtime_api_request(
 			ctx,
 			descriptor.relay_parent,
-			RuntimeApiRequest::PersistedValidationData(
-				descriptor.para_id,
-				assumption,
-				tx,
-			),
+			RuntimeApiRequest::PersistedValidationData(descriptor.para_id, assumption, tx),
 			rx,
-		).await?;
+		)
+		.await?;
 
 		match d {
-			Ok(None) | Err(_) => {
-				return Ok(AssumptionCheckOutcome::BadRequest);
-			}
+			Ok(None) | Err(_) => return Ok(AssumptionCheckOutcome::BadRequest),
 			Ok(Some(d)) => d,
 		}
 	};
 
 	let persisted_validation_data_hash = validation_data.hash();
 
-	SubsystemResult::Ok(if descriptor.persisted_validation_data_hash == persisted_validation_data_hash {
-		let (code_tx, code_rx) = oneshot::channel();
-		let validation_code = runtime_api_request(
-			ctx,
-			descriptor.relay_parent,
-			RuntimeApiRequest::ValidationCode(
-				descriptor.para_id,
-				assumption,
-				code_tx,
-			),
-			code_rx,
-		).await?;
+	SubsystemResult::Ok(
+		if descriptor.persisted_validation_data_hash == persisted_validation_data_hash {
+			let (code_tx, code_rx) = oneshot::channel();
+			let validation_code = runtime_api_request(
+				ctx,
+				descriptor.relay_parent,
+				RuntimeApiRequest::ValidationCode(descriptor.para_id, assumption, code_tx),
+				code_rx,
+			)
+			.await?;
 
-		match validation_code {
-			Ok(None) | Err(_) => AssumptionCheckOutcome::BadRequest,
-			Ok(Some(v)) => AssumptionCheckOutcome::Matches(validation_data, v),
-		}
-	} else {
-		AssumptionCheckOutcome::DoesNotMatch
-	})
+			match validation_code {
+				Ok(None) | Err(_) => AssumptionCheckOutcome::BadRequest,
+				Ok(Some(v)) => AssumptionCheckOutcome::Matches(validation_data, v),
+			}
+		} else {
+			AssumptionCheckOutcome::DoesNotMatch
+		},
+	)
 }
 
 async fn find_assumed_validation_data<Context>(
@@ -310,18 +297,16 @@ where
 {
 	let (validation_data, validation_code) =
 		match find_assumed_validation_data(ctx, &descriptor).await? {
-			AssumptionCheckOutcome::Matches(validation_data, validation_code) => {
-				(validation_data, validation_code)
-			}
+			AssumptionCheckOutcome::Matches(validation_data, validation_code) =>
+				(validation_data, validation_code),
 			AssumptionCheckOutcome::DoesNotMatch => {
 				// If neither the assumption of the occupied core having the para included or the assumption
 				// of the occupied core timing out are valid, then the persisted_validation_data_hash in the descriptor
 				// is not based on the relay parent and is thus invalid.
-				return Ok(Ok(ValidationResult::Invalid(InvalidCandidate::BadParent)));
-			}
-			AssumptionCheckOutcome::BadRequest => {
-				return Ok(Err(ValidationFailed("Assumption Check: Bad request".into())));
-			}
+				return Ok(Ok(ValidationResult::Invalid(InvalidCandidate::BadParent)))
+			},
+			AssumptionCheckOutcome::BadRequest =>
+				return Ok(Err(ValidationFailed("Assumption Check: Bad request".into()))),
 		};
 
 	let validation_result = validate_candidate_exhaustive(
@@ -344,15 +329,10 @@ where
 		)
 		.await?
 		{
-			Ok(true) => {}
-			Ok(false) => {
-				return Ok(Ok(ValidationResult::Invalid(
-					InvalidCandidate::InvalidOutputs,
-				)));
-			}
-			Err(_) => {
-				return Ok(Err(ValidationFailed("Check Validation Outputs: Bad request".into())));
-			}
+			Ok(true) => {},
+			Ok(false) => return Ok(Ok(ValidationResult::Invalid(InvalidCandidate::InvalidOutputs))),
+			Err(_) =>
+				return Ok(Err(ValidationFailed("Check Validation Outputs: Bad request".into()))),
 		}
 	}
 
@@ -375,7 +355,7 @@ async fn validate_candidate_exhaustive(
 		&*pov,
 		&validation_code,
 	) {
-		return Ok(Ok(ValidationResult::Invalid(e)));
+		return Ok(Ok(ValidationResult::Invalid(e)))
 	}
 
 	let raw_validation_code = match sp_maybe_compressed_blob::decompress(
@@ -387,22 +367,20 @@ async fn validate_candidate_exhaustive(
 			tracing::debug!(target: LOG_TARGET, err=?e, "Invalid validation code");
 
 			// If the validation code is invalid, the candidate certainly is.
-			return Ok(Ok(ValidationResult::Invalid(InvalidCandidate::CodeDecompressionFailure)));
-		}
+			return Ok(Ok(ValidationResult::Invalid(InvalidCandidate::CodeDecompressionFailure)))
+		},
 	};
 
-	let raw_block_data = match sp_maybe_compressed_blob::decompress(
-		&pov.block_data.0,
-		POV_BOMB_LIMIT,
-	) {
-		Ok(block_data) => BlockData(block_data.to_vec()),
-		Err(e) => {
-			tracing::debug!(target: LOG_TARGET, err=?e, "Invalid PoV code");
+	let raw_block_data =
+		match sp_maybe_compressed_blob::decompress(&pov.block_data.0, POV_BOMB_LIMIT) {
+			Ok(block_data) => BlockData(block_data.to_vec()),
+			Err(e) => {
+				tracing::debug!(target: LOG_TARGET, err=?e, "Invalid PoV code");
 
-			// If the PoV is invalid, the candidate certainly is.
-			return Ok(Ok(ValidationResult::Invalid(InvalidCandidate::PoVDecompressionFailure)));
-		}
-	};
+				// If the PoV is invalid, the candidate certainly is.
+				return Ok(Ok(ValidationResult::Invalid(InvalidCandidate::PoVDecompressionFailure)))
+			},
+		};
 
 	let params = ValidationParams {
 		parent_head: persisted_validation_data.parent_head.clone(),
@@ -411,11 +389,8 @@ async fn validate_candidate_exhaustive(
 		relay_parent_storage_root: persisted_validation_data.relay_parent_storage_root,
 	};
 
-	let result =
-		validation_backend.validate_candidate(
-			raw_validation_code.to_vec(),
-			params
-		)
+	let result = validation_backend
+		.validate_candidate(raw_validation_code.to_vec(), params)
 		.await;
 
 	if let Err(ref e) = result {
@@ -434,9 +409,11 @@ async fn validate_candidate_exhaustive(
 		Err(ValidationError::InvalidCandidate(WasmInvalidCandidate::WorkerReportedError(e))) =>
 			Ok(ValidationResult::Invalid(InvalidCandidate::ExecutionError(e))),
 		Err(ValidationError::InvalidCandidate(WasmInvalidCandidate::AmbigiousWorkerDeath)) =>
-			Ok(ValidationResult::Invalid(InvalidCandidate::ExecutionError("ambigious worker death".to_string()))),
+			Ok(ValidationResult::Invalid(InvalidCandidate::ExecutionError(
+				"ambigious worker death".to_string(),
+			))),
 
-		Ok(res) => {
+		Ok(res) =>
 			if res.head_data.hash() != descriptor.para_head {
 				Ok(ValidationResult::Invalid(InvalidCandidate::ParaHeadHashMismatch))
 			} else {
@@ -449,8 +426,7 @@ async fn validate_candidate_exhaustive(
 					hrmp_watermark: res.hrmp_watermark,
 				};
 				Ok(ValidationResult::Valid(outputs, persisted_validation_data))
-			}
-		}
+			},
 	};
 
 	Ok(result)
@@ -461,7 +437,7 @@ trait ValidationBackend {
 	async fn validate_candidate(
 		&mut self,
 		raw_validation_code: Vec<u8>,
-		params: ValidationParams
+		params: ValidationParams,
 	) -> Result<WasmValidationResult, ValidationError>;
 }
 
@@ -470,16 +446,22 @@ impl ValidationBackend for &'_ mut ValidationHost {
 	async fn validate_candidate(
 		&mut self,
 		raw_validation_code: Vec<u8>,
-		params: ValidationParams
+		params: ValidationParams,
 	) -> Result<WasmValidationResult, ValidationError> {
 		let (tx, rx) = oneshot::channel();
-		if let Err(err) = self.execute_pvf(
-			Pvf::from_code(raw_validation_code),
-			params.encode(),
-			polkadot_node_core_pvf::Priority::Normal,
-			tx,
-		).await {
-			return Err(ValidationError::InternalError(format!("cannot send pvf to the validation host: {:?}", err)));
+		if let Err(err) = self
+			.execute_pvf(
+				Pvf::from_code(raw_validation_code),
+				params.encode(),
+				polkadot_node_core_pvf::Priority::Normal,
+				tx,
+			)
+			.await
+		{
+			return Err(ValidationError::InternalError(format!(
+				"cannot send pvf to the validation host: {:?}",
+				err
+			)))
 		}
 
 		let validation_result = rx
@@ -503,19 +485,19 @@ fn perform_basic_checks(
 
 	let encoded_pov_size = pov.encoded_size();
 	if encoded_pov_size > max_pov_size as usize {
-		return Err(InvalidCandidate::ParamsTooLarge(encoded_pov_size as u64));
+		return Err(InvalidCandidate::ParamsTooLarge(encoded_pov_size as u64))
 	}
 
 	if pov_hash != candidate.pov_hash {
-		return Err(InvalidCandidate::PoVHashMismatch);
+		return Err(InvalidCandidate::PoVHashMismatch)
 	}
 
 	if validation_code_hash != candidate.validation_code_hash {
-		return Err(InvalidCandidate::CodeHashMismatch);
+		return Err(InvalidCandidate::CodeHashMismatch)
 	}
 
 	if let Err(()) = candidate.check_collator_signature() {
-		return Err(InvalidCandidate::BadSignature);
+		return Err(InvalidCandidate::BadSignature)
 	}
 
 	Ok(())
@@ -551,18 +533,26 @@ impl Metrics {
 	}
 
 	/// Provide a timer for `validate_from_chain_state` which observes on drop.
-	fn time_validate_from_chain_state(&self) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
+	fn time_validate_from_chain_state(
+		&self,
+	) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
 		self.0.as_ref().map(|metrics| metrics.validate_from_chain_state.start_timer())
 	}
 
 	/// Provide a timer for `validate_from_exhaustive` which observes on drop.
-	fn time_validate_from_exhaustive(&self) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
+	fn time_validate_from_exhaustive(
+		&self,
+	) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
 		self.0.as_ref().map(|metrics| metrics.validate_from_exhaustive.start_timer())
 	}
 
 	/// Provide a timer for `validate_candidate_exhaustive` which observes on drop.
-	fn time_validate_candidate_exhaustive(&self) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
-		self.0.as_ref().map(|metrics| metrics.validate_candidate_exhaustive.start_timer())
+	fn time_validate_candidate_exhaustive(
+		&self,
+	) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
+		self.0
+			.as_ref()
+			.map(|metrics| metrics.validate_candidate_exhaustive.start_timer())
 	}
 }
 
@@ -580,30 +570,24 @@ impl metrics::Metrics for Metrics {
 				registry,
 			)?,
 			validate_from_chain_state: prometheus::register(
-				prometheus::Histogram::with_opts(
-					prometheus::HistogramOpts::new(
-						"parachain_candidate_validation_validate_from_chain_state",
-						"Time spent within `candidate_validation::validate_from_chain_state`",
-					)
-				)?,
+				prometheus::Histogram::with_opts(prometheus::HistogramOpts::new(
+					"parachain_candidate_validation_validate_from_chain_state",
+					"Time spent within `candidate_validation::validate_from_chain_state`",
+				))?,
 				registry,
 			)?,
 			validate_from_exhaustive: prometheus::register(
-				prometheus::Histogram::with_opts(
-					prometheus::HistogramOpts::new(
-						"parachain_candidate_validation_validate_from_exhaustive",
-						"Time spent within `candidate_validation::validate_from_exhaustive`",
-					)
-				)?,
+				prometheus::Histogram::with_opts(prometheus::HistogramOpts::new(
+					"parachain_candidate_validation_validate_from_exhaustive",
+					"Time spent within `candidate_validation::validate_from_exhaustive`",
+				))?,
 				registry,
 			)?,
 			validate_candidate_exhaustive: prometheus::register(
-				prometheus::Histogram::with_opts(
-					prometheus::HistogramOpts::new(
-						"parachain_candidate_validation_validate_candidate_exhaustive",
-						"Time spent within `candidate_validation::validate_candidate_exhaustive`",
-					)
-				)?,
+				prometheus::Histogram::with_opts(prometheus::HistogramOpts::new(
+					"parachain_candidate_validation_validate_candidate_exhaustive",
+					"Time spent within `candidate_validation::validate_candidate_exhaustive`",
+				))?,
 				registry,
 			)?,
 		};

polkadot/node/core/candidate-validation/src/tests.rs

@@ -15,12 +15,12 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use super::*;
+use assert_matches::assert_matches;
+use futures::executor;
 use polkadot_node_subsystem::messages::AllMessages;
 use polkadot_node_subsystem_test_helpers as test_helpers;
 use polkadot_primitives::v1::{HeadData, UpwardMessage};
 use sp_core::testing::TaskExecutor;
-use futures::executor;
-use assert_matches::assert_matches;
 use sp_keyring::Sr25519Keyring;
 
 fn collator_sign(descriptor: &mut CandidateDescriptor, collator: Sr25519Keyring) {
@@ -54,11 +54,9 @@ fn correctly_checks_included_assumption() {
 	let pool = TaskExecutor::new();
 	let (mut ctx, mut ctx_handle) = test_helpers::make_subsystem_context(pool.clone());
 
-	let (check_fut, check_result) = check_assumption_validation_data(
-		&mut ctx,
-		&candidate,
-		OccupiedCoreAssumption::Included,
-	).remote_handle();
+	let (check_fut, check_result) =
+		check_assumption_validation_data(&mut ctx, &candidate, OccupiedCoreAssumption::Included)
+			.remote_handle();
 
 	let test_fut = async move {
 		assert_matches!(
@@ -118,11 +116,9 @@ fn correctly_checks_timed_out_assumption() {
 	let pool = TaskExecutor::new();
 	let (mut ctx, mut ctx_handle) = test_helpers::make_subsystem_context(pool.clone());
 
-	let (check_fut, check_result) = check_assumption_validation_data(
-		&mut ctx,
-		&candidate,
-		OccupiedCoreAssumption::TimedOut,
-	).remote_handle();
+	let (check_fut, check_result) =
+		check_assumption_validation_data(&mut ctx, &candidate, OccupiedCoreAssumption::TimedOut)
+			.remote_handle();
 
 	let test_fut = async move {
 		assert_matches!(
@@ -180,11 +176,9 @@ fn check_is_bad_request_if_no_validation_data() {
 	let pool = TaskExecutor::new();
 	let (mut ctx, mut ctx_handle) = test_helpers::make_subsystem_context(pool.clone());
 
-	let (check_fut, check_result) = check_assumption_validation_data(
-		&mut ctx,
-		&candidate,
-		OccupiedCoreAssumption::Included,
-	).remote_handle();
+	let (check_fut, check_result) =
+		check_assumption_validation_data(&mut ctx, &candidate, OccupiedCoreAssumption::Included)
+			.remote_handle();
 
 	let test_fut = async move {
 		assert_matches!(
@@ -226,11 +220,9 @@ fn check_is_bad_request_if_no_validation_code() {
 	let pool = TaskExecutor::new();
 	let (mut ctx, mut ctx_handle) = test_helpers::make_subsystem_context(pool.clone());
 
-	let (check_fut, check_result) = check_assumption_validation_data(
-		&mut ctx,
-		&candidate,
-		OccupiedCoreAssumption::TimedOut,
-	).remote_handle();
+	let (check_fut, check_result) =
+		check_assumption_validation_data(&mut ctx, &candidate, OccupiedCoreAssumption::TimedOut)
+			.remote_handle();
 
 	let test_fut = async move {
 		assert_matches!(
@@ -284,11 +276,9 @@ fn check_does_not_match() {
 	let pool = TaskExecutor::new();
 	let (mut ctx, mut ctx_handle) = test_helpers::make_subsystem_context(pool.clone());
 
-	let (check_fut, check_result) = check_assumption_validation_data(
-		&mut ctx,
-		&candidate,
-		OccupiedCoreAssumption::Included,
-	).remote_handle();
+	let (check_fut, check_result) =
+		check_assumption_validation_data(&mut ctx, &candidate, OccupiedCoreAssumption::Included)
+			.remote_handle();
 
 	let test_fut = async move {
 		assert_matches!(
@@ -321,9 +311,7 @@ struct MockValidatorBackend {
 
 impl MockValidatorBackend {
 	fn with_hardcoded_result(result: Result<WasmValidationResult, ValidationError>) -> Self {
-		Self {
-			result,
-		}
+		Self { result }
 	}
 }
 
@@ -332,7 +320,7 @@ impl ValidationBackend for MockValidatorBackend {
 	async fn validate_candidate(
 		&mut self,
 		_raw_validation_code: Vec<u8>,
-		_params: ValidationParams
+		_params: ValidationParams,
 	) -> Result<WasmValidationResult, ValidationError> {
 		self.result.clone()
 	}
@@ -352,12 +340,8 @@ fn candidate_validation_ok_is_ok() {
 	descriptor.validation_code_hash = validation_code.hash();
 	collator_sign(&mut descriptor, Sr25519Keyring::Alice);
 
-	let check = perform_basic_checks(
-		&descriptor,
-		validation_data.max_pov_size,
-		&pov,
-		&validation_code,
-	);
+	let check =
+		perform_basic_checks(&descriptor, validation_data.max_pov_size, &pov, &validation_code);
 	assert!(check.is_ok());
 
 	let validation_result = WasmValidationResult {
@@ -402,18 +386,14 @@ fn candidate_validation_bad_return_is_invalid() {
 	descriptor.validation_code_hash = validation_code.hash();
 	collator_sign(&mut descriptor, Sr25519Keyring::Alice);
 
-	let check = perform_basic_checks(
-		&descriptor,
-		validation_data.max_pov_size,
-		&pov,
-		&validation_code,
-	);
+	let check =
+		perform_basic_checks(&descriptor, validation_data.max_pov_size, &pov, &validation_code);
 	assert!(check.is_ok());
 
 	let v = executor::block_on(validate_candidate_exhaustive(
-		MockValidatorBackend::with_hardcoded_result(
-			Err(ValidationError::InvalidCandidate(WasmInvalidCandidate::AmbigiousWorkerDeath))
-		),
+		MockValidatorBackend::with_hardcoded_result(Err(ValidationError::InvalidCandidate(
+			WasmInvalidCandidate::AmbigiousWorkerDeath,
+		))),
 		validation_data,
 		validation_code,
 		descriptor,
@@ -438,18 +418,14 @@ fn candidate_validation_timeout_is_internal_error() {
 	descriptor.validation_code_hash = validation_code.hash();
 	collator_sign(&mut descriptor, Sr25519Keyring::Alice);
 
-	let check = perform_basic_checks(
-		&descriptor,
-		validation_data.max_pov_size,
-		&pov,
-		&validation_code,
-	);
+	let check =
+		perform_basic_checks(&descriptor, validation_data.max_pov_size, &pov, &validation_code);
 	assert!(check.is_ok());
 
 	let v = executor::block_on(validate_candidate_exhaustive(
-		MockValidatorBackend::with_hardcoded_result(
-			Err(ValidationError::InvalidCandidate(WasmInvalidCandidate::HardTimeout)),
-		),
+		MockValidatorBackend::with_hardcoded_result(Err(ValidationError::InvalidCandidate(
+			WasmInvalidCandidate::HardTimeout,
+		))),
 		validation_data,
 		validation_code,
 		descriptor,
@@ -473,18 +449,14 @@ fn candidate_validation_code_mismatch_is_invalid() {
 	descriptor.validation_code_hash = ValidationCode(vec![1; 16]).hash();
 	collator_sign(&mut descriptor, Sr25519Keyring::Alice);
 
-	let check = perform_basic_checks(
-		&descriptor,
-		validation_data.max_pov_size,
-		&pov,
-		&validation_code,
-	);
+	let check =
+		perform_basic_checks(&descriptor, validation_data.max_pov_size, &pov, &validation_code);
 	assert_matches!(check, Err(InvalidCandidate::CodeHashMismatch));
 
 	let v = executor::block_on(validate_candidate_exhaustive(
-		MockValidatorBackend::with_hardcoded_result(
-			Err(ValidationError::InvalidCandidate(WasmInvalidCandidate::HardTimeout)),
-		),
+		MockValidatorBackend::with_hardcoded_result(Err(ValidationError::InvalidCandidate(
+			WasmInvalidCandidate::HardTimeout,
+		))),
 		validation_data,
 		validation_code,
 		descriptor,
@@ -504,10 +476,7 @@ fn compressed_code_works() {
 	let head_data = HeadData(vec![1, 1, 1]);
 
 	let raw_code = vec![2u8; 16];
-	let validation_code = sp_maybe_compressed_blob::compress(
-		&raw_code,
-		VALIDATION_CODE_BOMB_LIMIT,
-	)
+	let validation_code = sp_maybe_compressed_blob::compress(&raw_code, VALIDATION_CODE_BOMB_LIMIT)
 		.map(ValidationCode)
 		.unwrap();
 
@@ -546,12 +515,10 @@ fn code_decompression_failure_is_invalid() {
 	let head_data = HeadData(vec![1, 1, 1]);
 
 	let raw_code = vec![2u8; VALIDATION_CODE_BOMB_LIMIT + 1];
-	let validation_code = sp_maybe_compressed_blob::compress(
-		&raw_code,
-		VALIDATION_CODE_BOMB_LIMIT + 1,
-	)
-		.map(ValidationCode)
-		.unwrap();
+	let validation_code =
+		sp_maybe_compressed_blob::compress(&raw_code, VALIDATION_CODE_BOMB_LIMIT + 1)
+			.map(ValidationCode)
+			.unwrap();
 
 	let mut descriptor = CandidateDescriptor::default();
 	descriptor.pov_hash = pov.hash();
@@ -578,25 +545,17 @@ fn code_decompression_failure_is_invalid() {
 	))
 	.unwrap();
 
-	assert_matches!(
-		v,
-		Ok(ValidationResult::Invalid(InvalidCandidate::CodeDecompressionFailure))
-	);
+	assert_matches!(v, Ok(ValidationResult::Invalid(InvalidCandidate::CodeDecompressionFailure)));
 }
 
 #[test]
 fn pov_decompression_failure_is_invalid() {
-	let validation_data = PersistedValidationData {
-		max_pov_size: POV_BOMB_LIMIT as u32,
-		..Default::default()
-	 };
+	let validation_data =
+		PersistedValidationData { max_pov_size: POV_BOMB_LIMIT as u32, ..Default::default() };
 	let head_data = HeadData(vec![1, 1, 1]);
 
 	let raw_block_data = vec![2u8; POV_BOMB_LIMIT + 1];
-	let pov = sp_maybe_compressed_blob::compress(
-		&raw_block_data,
-		POV_BOMB_LIMIT + 1,
-	)
+	let pov = sp_maybe_compressed_blob::compress(&raw_block_data, POV_BOMB_LIMIT + 1)
 		.map(|raw| PoV { block_data: BlockData(raw) })
 		.unwrap();
 
@@ -627,8 +586,5 @@ fn pov_decompression_failure_is_invalid() {
 	))
 	.unwrap();
 
-	assert_matches!(
-		v,
-		Ok(ValidationResult::Invalid(InvalidCandidate::PoVDecompressionFailure))
-	);
+	assert_matches!(v, Ok(ValidationResult::Invalid(InvalidCandidate::PoVDecompressionFailure)));
 }