diff --git a/auction/src/tests.rs b/auction/src/tests.rs index 774ec636a..0c2864417 100644 --- a/auction/src/tests.rs +++ b/auction/src/tests.rs @@ -105,7 +105,7 @@ fn remove_auction_should_work() { ExtBuilder::default().build().execute_with(|| { assert_ok!(AuctionModule::new_auction(10, Some(100)), 0); assert_eq!(AuctionModule::auctions_index(), 1); - assert_eq!(AuctionModule::auctions(0).is_some(), true); + assert!(AuctionModule::auctions(0).is_some()); assert_eq!(AuctionModule::auction_end_time(100, 0), Some(())); AuctionModule::remove_auction(0); assert_eq!(AuctionModule::auctions(0), None); @@ -120,23 +120,23 @@ fn cleanup_auction_should_work() { assert_eq!(AuctionModule::auctions_index(), 1); assert_ok!(AuctionModule::new_auction(10, Some(50)), 1); assert_eq!(AuctionModule::auctions_index(), 2); - assert_eq!(AuctionModule::auctions(0).is_some(), true); - assert_eq!(AuctionModule::auctions(1).is_some(), true); + assert!(AuctionModule::auctions(0).is_some()); + assert!(AuctionModule::auctions(1).is_some()); assert_eq!(>::iter_prefix(0).count(), 0); assert_eq!(>::iter_prefix(50).count(), 1); assert_eq!(>::iter_prefix(100).count(), 1); AuctionModule::on_finalize(50); - assert_eq!(AuctionModule::auctions(0).is_some(), true); - assert_eq!(AuctionModule::auctions(1).is_some(), false); + assert!(AuctionModule::auctions(0).is_some()); + assert!(!AuctionModule::auctions(1).is_some()); assert_eq!(>::iter_prefix(0).count(), 0); assert_eq!(>::iter_prefix(50).count(), 0); assert_eq!(>::iter_prefix(100).count(), 1); AuctionModule::on_finalize(100); - assert_eq!(AuctionModule::auctions(0).is_some(), false); - assert_eq!(AuctionModule::auctions(1).is_some(), false); + assert!(!AuctionModule::auctions(0).is_some()); + assert!(!AuctionModule::auctions(1).is_some()); assert_eq!(>::iter_prefix(0).count(), 0); assert_eq!(>::iter_prefix(50).count(), 0); assert_eq!(>::iter_prefix(100).count(), 0); diff --git a/authority/src/mock.rs b/authority/src/mock.rs index 595287367..308ec3547 100644 --- a/authority/src/mock.rs +++ b/authority/src/mock.rs @@ -134,7 +134,11 @@ impl AsOriginId for MockAsOriginId { MockAsOriginId::Account1 => ensure_signed(origin)? == 1, MockAsOriginId::Account2 => ensure_signed(origin)? == 2, }; - return if ok { Ok(()) } else { Err(BadOrigin.into()) }; + if ok { + Ok(()) + } else { + Err(BadOrigin.into()) + } }) } } diff --git a/authority/src/tests.rs b/authority/src/tests.rs index 2e248ed7c..eb23db55e 100644 --- a/authority/src/tests.rs +++ b/authority/src/tests.rs @@ -22,7 +22,7 @@ fn dispatch_as_work() { assert_ok!(Authority::dispatch_as( Origin::root(), MockAsOriginId::Root, - Box::new(ensure_root_call.clone()) + Box::new(ensure_root_call) )); assert_ok!(Authority::dispatch_as( Origin::root(), @@ -46,7 +46,7 @@ fn dispatch_as_work() { Authority::dispatch_as( Origin::signed(1), MockAsOriginId::Account2, - Box::new(ensure_signed_call.clone()) + Box::new(ensure_signed_call) ), BadOrigin, ); @@ -59,7 +59,7 @@ fn schedule_dispatch_at_work() { let ensure_root_call = Call::System(frame_system::Call::fill_block(Perbill::one())); let call = Call::Authority(authority::Call::dispatch_as( MockAsOriginId::Root, - Box::new(ensure_root_call.clone()), + Box::new(ensure_root_call), )); run_to_block(1); assert_eq!( @@ -95,7 +95,7 @@ fn schedule_dispatch_at_work() { DispatchTime::At(3), 0, false, - Box::new(call.clone()) + Box::new(call) )); System::assert_last_event(mock::Event::Authority(Event::Scheduled( OriginCaller::system(RawOrigin::Root), @@ -117,7 +117,7 @@ fn schedule_dispatch_after_work() { let ensure_root_call = Call::System(frame_system::Call::fill_block(Perbill::one())); let call = Call::Authority(authority::Call::dispatch_as( MockAsOriginId::Root, - Box::new(ensure_root_call.clone()), + Box::new(ensure_root_call), )); run_to_block(1); assert_eq!( @@ -153,7 +153,7 @@ fn schedule_dispatch_after_work() { DispatchTime::After(0), 0, false, - Box::new(call.clone()) + Box::new(call) )); System::assert_last_event(mock::Event::Authority(Event::Scheduled( OriginCaller::system(RawOrigin::Root), @@ -176,7 +176,7 @@ fn fast_track_scheduled_dispatch_work() { let ensure_root_call = Call::System(frame_system::Call::fill_block(Perbill::one())); let call = Call::Authority(authority::Call::dispatch_as( MockAsOriginId::Root, - Box::new(ensure_root_call.clone()), + Box::new(ensure_root_call), )); run_to_block(1); assert_ok!(Authority::schedule_dispatch( @@ -195,7 +195,7 @@ fn fast_track_scheduled_dispatch_work() { ))); let schedule_origin = { - let origin: ::Origin = From::from(Origin::root()); + let origin: ::Origin = Origin::root(); let origin: ::Origin = From::from(DelayedOrigin::::PalletsOrigin> { delay: 1, @@ -225,7 +225,7 @@ fn fast_track_scheduled_dispatch_work() { DispatchTime::At(2), 0, false, - Box::new(call.clone()) + Box::new(call) )); System::assert_last_event(mock::Event::Authority(Event::Scheduled( OriginCaller::system(RawOrigin::Root), @@ -253,7 +253,7 @@ fn delay_scheduled_dispatch_work() { let ensure_root_call = Call::System(frame_system::Call::fill_block(Perbill::one())); let call = Call::Authority(authority::Call::dispatch_as( MockAsOriginId::Root, - Box::new(ensure_root_call.clone()), + Box::new(ensure_root_call), )); run_to_block(1); assert_ok!(Authority::schedule_dispatch( @@ -272,7 +272,7 @@ fn delay_scheduled_dispatch_work() { ))); let schedule_origin = { - let origin: ::Origin = From::from(Origin::root()); + let origin: ::Origin = Origin::root(); let origin: ::Origin = From::from(DelayedOrigin::::PalletsOrigin> { delay: 1, @@ -302,7 +302,7 @@ fn delay_scheduled_dispatch_work() { DispatchTime::At(2), 0, false, - Box::new(call.clone()) + Box::new(call) )); System::assert_last_event(mock::Event::Authority(Event::Scheduled( OriginCaller::system(RawOrigin::Root), @@ -329,7 +329,7 @@ fn cancel_scheduled_dispatch_work() { let ensure_root_call = Call::System(frame_system::Call::fill_block(Perbill::one())); let call = Call::Authority(authority::Call::dispatch_as( MockAsOriginId::Root, - Box::new(ensure_root_call.clone()), + Box::new(ensure_root_call), )); run_to_block(1); assert_ok!(Authority::schedule_dispatch( @@ -348,7 +348,7 @@ fn cancel_scheduled_dispatch_work() { ))); let schedule_origin = { - let origin: ::Origin = From::from(Origin::root()); + let origin: ::Origin = Origin::root(); let origin: ::Origin = From::from(DelayedOrigin::::PalletsOrigin> { delay: 1, @@ -372,7 +372,7 @@ fn cancel_scheduled_dispatch_work() { DispatchTime::At(2), 0, false, - Box::new(call.clone()) + Box::new(call) )); System::assert_last_event(mock::Event::Authority(Event::Scheduled( OriginCaller::system(RawOrigin::Root), diff --git a/bencher/src/build_wasm/mod.rs b/bencher/src/build_wasm/mod.rs index eca93486f..85d866be2 100644 --- a/bencher/src/build_wasm/mod.rs +++ b/bencher/src/build_wasm/mod.rs @@ -40,7 +40,7 @@ pub fn build() -> std::io::Result> { let (wasm_binary, bloaty) = wasm_project::create_and_compile( &project_cargo_toml, - &default_rustflags, + default_rustflags, cargo_cmd, vec!["bench".to_string()], None, diff --git a/bencher/src/build_wasm/wasm_project.rs b/bencher/src/build_wasm/wasm_project.rs index c924fb08a..c28d9099a 100644 --- a/bencher/src/build_wasm/wasm_project.rs +++ b/bencher/src/build_wasm/wasm_project.rs @@ -385,7 +385,7 @@ fn create_project( fs::create_dir_all(wasm_project_folder.join("src")).expect("Wasm project dir create can not fail; qed"); - let mut enabled_features = project_enabled_features(&project_cargo_toml, &crate_metadata); + let mut enabled_features = project_enabled_features(project_cargo_toml, crate_metadata); if has_runtime_wasm_feature_declared(project_cargo_toml, crate_metadata) { enabled_features.push("runtime-wasm".into()); @@ -398,7 +398,7 @@ fn create_project( &wasm_project_folder, workspace_root_path, &crate_name, - &crate_path, + crate_path, &wasm_binary, enabled_features.into_iter(), ); diff --git a/bencher/src/handler.rs b/bencher/src/handler.rs index a855037bc..065908f92 100644 --- a/bencher/src/handler.rs +++ b/bencher/src/handler.rs @@ -71,7 +71,7 @@ pub fn handle(output: Vec) { let stdout = ::std::io::stdout(); let mut handle = stdout.lock(); - handle.write_all(&json.as_bytes()).unwrap(); + handle.write_all(json.as_bytes()).unwrap(); } else { eprintln!("Could not write benchdata to JSON"); } diff --git a/benchmarking/src/tests.rs b/benchmarking/src/tests.rs index 56717b50c..47e1054c2 100644 --- a/benchmarking/src/tests.rs +++ b/benchmarking/src/tests.rs @@ -118,14 +118,14 @@ runtime_benchmarks! { set_value { let b in 1 .. 1000; let caller = account::("caller", 0, 0); - }: _ (RawOrigin::Signed(caller), b.into()) + }: _ (RawOrigin::Signed(caller), b) verify { assert_eq!(Pallet::value(), Some(b)); } other_name { let b in 1 .. 1000; - }: dummy (RawOrigin::None, b.into()) + }: dummy (RawOrigin::None, b) sort_vector { let x in 1 .. 10000; @@ -134,7 +134,7 @@ runtime_benchmarks! { m.push(i); } }: { - m.sort(); + m.sort_unstable(); } verify { ensure!(m[0] == 0, "You forgot to sort!") } @@ -142,7 +142,7 @@ runtime_benchmarks! { bad_origin { let b in 1 .. 1000; let caller = account::("caller", 0, 0); - }: dummy (RawOrigin::Signed(caller), b.into()) + }: dummy (RawOrigin::Signed(caller), b) bad_verify { let x in 1 .. 10000; diff --git a/gradually-update/src/tests.rs b/gradually-update/src/tests.rs index b2a221919..00bbf6a1f 100644 --- a/gradually-update/src/tests.rs +++ b/gradually-update/src/tests.rs @@ -48,7 +48,7 @@ fn gradually_update_should_fail() { per_block: 1u64.encode().try_into().unwrap(), }; assert_noop!( - GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()), + GraduallyUpdateModule::gradually_update(Origin::root(), update), Error::::InvalidPerBlockOrTargetValue ); @@ -67,12 +67,12 @@ fn gradually_update_should_fail() { per_block: 1u64.encode().try_into().unwrap(), }; assert_noop!( - GraduallyUpdateModule::gradually_update(Origin::root(), new_update.clone()), + GraduallyUpdateModule::gradually_update(Origin::root(), new_update), Error::::InvalidTargetValue ); assert_noop!( - GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()), + GraduallyUpdateModule::gradually_update(Origin::root(), update), Error::::GraduallyUpdateHasExisted ); }); @@ -100,7 +100,7 @@ fn cancel_gradually_update_should_work() { update.key.clone() )); System::assert_last_event(Event::GraduallyUpdateModule(crate::Event::GraduallyUpdateCancelled( - update.key.clone(), + update.key, ))); }); } @@ -122,7 +122,7 @@ fn cancel_gradually_update_should_fail() { assert_ok!(GraduallyUpdateModule::cancel_gradually_update( Origin::root(), - update.key.clone() + update.key )); }); } @@ -167,7 +167,7 @@ fn add_on_finalize_should_work() { assert_eq!(storage_get(&update.key), vec![30]); System::assert_last_event(Event::GraduallyUpdateModule(crate::Event::Updated( 40, - update.key.clone(), + update.key, vec![30].try_into().unwrap(), ))); }); @@ -214,7 +214,7 @@ fn sub_on_finalize_should_work() { assert_eq!(storage_get(&update.key), vec![5]); System::assert_last_event(Event::GraduallyUpdateModule(crate::Event::Updated( 40, - update.key.clone(), + update.key, vec![5].try_into().unwrap(), ))); }); diff --git a/nft/src/lib.rs b/nft/src/lib.rs index b2bff4c9a..909ecbbc5 100644 --- a/nft/src/lib.rs +++ b/nft/src/lib.rs @@ -179,7 +179,7 @@ pub mod module { let class_id = Pallet::::create_class(&token_class.0, token_class.1.to_vec(), token_class.2.clone()) .expect("Create class cannot fail while building genesis"); for (account_id, token_metadata, token_data) in &token_class.3 { - Pallet::::mint(&account_id, class_id, token_metadata.to_vec(), token_data.clone()) + Pallet::::mint(account_id, class_id, token_metadata.to_vec(), token_data.clone()) .expect("Token mint cannot fail during genesis"); } }) diff --git a/nft/src/tests.rs b/nft/src/tests.rs index c62354308..722d6da81 100644 --- a/nft/src/tests.rs +++ b/nft/src/tests.rs @@ -148,8 +148,8 @@ fn destroy_class_should_work() { assert_ok!(NonFungibleTokenModule::mint(&BOB, CLASS_ID, vec![1], ())); assert_ok!(NonFungibleTokenModule::burn(&BOB, (CLASS_ID, TOKEN_ID))); assert_ok!(NonFungibleTokenModule::destroy_class(&ALICE, CLASS_ID)); - assert_eq!(Classes::::contains_key(CLASS_ID), false); - assert_eq!(NextTokenId::::contains_key(CLASS_ID), false); + assert!(!Classes::::contains_key(CLASS_ID)); + assert!(!NextTokenId::::contains_key(CLASS_ID)); }); } @@ -175,7 +175,7 @@ fn destroy_class_should_fail() { assert_ok!(NonFungibleTokenModule::burn(&BOB, (CLASS_ID, TOKEN_ID))); assert_ok!(NonFungibleTokenModule::destroy_class(&ALICE, CLASS_ID)); - assert_eq!(Classes::::contains_key(CLASS_ID), false); + assert!(!Classes::::contains_key(CLASS_ID)); }); } diff --git a/oracle/src/lib.rs b/oracle/src/lib.rs index 50fff73fc..6a74d22b3 100644 --- a/oracle/src/lib.rs +++ b/oracle/src/lib.rs @@ -240,7 +240,7 @@ impl, I: 'static> Pallet { RawValues::::insert(&who, &key, timestamped); IsUpdated::::remove(&key); - T::OnNewData::on_new_data(&who, &key, &value); + T::OnNewData::on_new_data(&who, key, value); } Self::deposit_event(Event::NewFeedData(who, values)); Ok(()) diff --git a/oracle/src/tests.rs b/oracle/src/tests.rs index 3749d0265..6ff2819e4 100644 --- a/oracle/src/tests.rs +++ b/oracle/src/tests.rs @@ -92,11 +92,11 @@ fn should_feed_values_from_root() { fn should_update_is_updated() { new_test_ext().execute_with(|| { let key: u32 = 50; - assert_eq!(ModuleOracle::is_updated(key), false); + assert!(!ModuleOracle::is_updated(key)); assert_ok!(ModuleOracle::feed_values(Origin::signed(1), vec![(key, 1000)])); assert_ok!(ModuleOracle::feed_values(Origin::signed(2), vec![(key, 1000)])); assert_ok!(ModuleOracle::feed_values(Origin::signed(3), vec![(key, 1000)])); - assert_eq!(ModuleOracle::is_updated(key), false); + assert!(!ModuleOracle::is_updated(key)); assert_eq!( ModuleOracle::get(&key).unwrap(), TimestampedValue { @@ -104,10 +104,10 @@ fn should_update_is_updated() { timestamp: 12345 } ); - assert_eq!(ModuleOracle::is_updated(key), true); + assert!(ModuleOracle::is_updated(key)); ModuleOracle::on_finalize(1); assert_ok!(ModuleOracle::feed_values(Origin::signed(1), vec![(key, 1000)])); - assert_eq!(ModuleOracle::is_updated(key), false); + assert!(!ModuleOracle::is_updated(key)); }); } @@ -262,11 +262,11 @@ fn should_clear_is_updated_on_change_member() { timestamp: 12345 } ); - assert_eq!(ModuleOracle::is_updated(50), true); + assert!(ModuleOracle::is_updated(50)); ModuleOracle::change_members_sorted(&[4], &[1], &[2, 3, 4]); - assert_eq!(ModuleOracle::is_updated(50), false); + assert!(!ModuleOracle::is_updated(50)); }); } diff --git a/scripts/run-clippy.sh b/scripts/run-clippy.sh new file mode 100755 index 000000000..a172ae411 --- /dev/null +++ b/scripts/run-clippy.sh @@ -0,0 +1,17 @@ +#!/usr/bin/env bash + +set -e + +COMMAND=$1 + +ALLOW_CLIPPY_RULES=( + "clippy::identity_op" # this helps the code to be consistant + "clippy::blacklisted-name" # TODO: allow them in test only + "clippy::ptr-arg" # TODO: decide if we want to fix those + "clippy::match_single_binding" # TODO: fix those +) + +CLIPPY_RULE=$(printf " -A %s" "${ALLOW_CLIPPY_RULES[@]}") + +cargo clippy $@ -- $CLIPPY_RULE + diff --git a/tokens/src/lib.rs b/tokens/src/lib.rs index 3ef248829..6f3fa5f74 100644 --- a/tokens/src/lib.rs +++ b/tokens/src/lib.rs @@ -318,7 +318,7 @@ pub mod module { .iter() .for_each(|(account_id, currency_id, initial_balance)| { assert!( - *initial_balance >= T::ExistentialDeposits::get(¤cy_id), + *initial_balance >= T::ExistentialDeposits::get(currency_id), "the balance of any account should always be more than existential deposit.", ); Pallet::::mutate_account(account_id, *currency_id, |account_data, _| { @@ -1435,7 +1435,7 @@ where value: Self::Balance, existence_requirement: ExistenceRequirement, ) -> DispatchResult { - Pallet::::do_transfer(GetCurrencyId::get(), &source, &dest, value, existence_requirement) + Pallet::::do_transfer(GetCurrencyId::get(), source, dest, value, existence_requirement) } fn slash(who: &T::AccountId, value: Self::Balance) -> (Self::NegativeImbalance, Self::Balance) { diff --git a/tokens/src/mock.rs b/tokens/src/mock.rs index 5adacb00a..36ed286fe 100644 --- a/tokens/src/mock.rs +++ b/tokens/src/mock.rs @@ -212,6 +212,7 @@ impl Contains for MockDustRemovalWhitelist { parameter_type_with_key! { pub ExistentialDeposits: |currency_id: CurrencyId| -> Balance { + #[allow(clippy::match_ref_pats)] // false positive match currency_id { &BTC => 1, &DOT => 2, diff --git a/tokens/src/tests.rs b/tokens/src/tests.rs index e9400d487..3aacd5916 100644 --- a/tokens/src/tests.rs +++ b/tokens/src/tests.rs @@ -52,9 +52,9 @@ fn transfer_should_work() { assert_ok!(Tokens::transfer(Some(ALICE).into(), CHARLIE, DOT, 2)); // imply AllowDeath - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_ok!(Tokens::transfer(Some(ALICE).into(), BOB, DOT, 48)); - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 0); assert_eq!(Tokens::free_balance(DOT, &BOB), 198); assert_eq!(Tokens::total_issuance(DOT), 200); @@ -108,11 +108,11 @@ fn transfer_all_allow_death_should_work() { .balances(vec![(ALICE, DOT, 100), (BOB, DOT, 100)]) .build() .execute_with(|| { - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 100); assert_ok!(Tokens::transfer_all(Some(ALICE).into(), CHARLIE, DOT, false)); System::assert_last_event(Event::Tokens(crate::Event::Transfer(DOT, ALICE, CHARLIE, 100))); - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 0); assert_ok!(Tokens::set_lock(ID_1, DOT, &BOB, 50)); @@ -129,7 +129,7 @@ fn force_transfer_should_work() { .balances(vec![(ALICE, DOT, 100), (BOB, DOT, 100)]) .build() .execute_with(|| { - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 100); assert_eq!(Tokens::free_balance(DOT, &BOB), 100); assert_noop!( @@ -140,7 +140,7 @@ fn force_transfer_should_work() { // imply AllowDeath assert_ok!(Tokens::force_transfer(RawOrigin::Root.into(), ALICE, BOB, DOT, 100)); System::assert_last_event(Event::Tokens(crate::Event::Transfer(DOT, ALICE, BOB, 100))); - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 0); assert_eq!(Tokens::free_balance(DOT, &BOB), 200); }); @@ -173,37 +173,37 @@ fn set_balance_should_work() { ArithmeticError::Overflow ); - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 100); assert_eq!(Tokens::reserved_balance(DOT, &ALICE), 0); assert_eq!(Tokens::total_issuance(DOT), 200); assert_ok!(Tokens::set_balance(RawOrigin::Root.into(), ALICE, DOT, 200, 100)); System::assert_has_event(Event::Tokens(crate::Event::BalanceSet(DOT, ALICE, 200, 100))); - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 200); assert_eq!(Tokens::reserved_balance(DOT, &ALICE), 100); assert_eq!(Tokens::total_issuance(DOT), 400); - assert_eq!(Accounts::::contains_key(BOB, DOT), true); + assert!(Accounts::::contains_key(BOB, DOT)); assert_eq!(Tokens::free_balance(DOT, &BOB), 100); assert_eq!(Tokens::reserved_balance(DOT, &BOB), 0); assert_ok!(Tokens::set_balance(RawOrigin::Root.into(), BOB, DOT, 0, 0)); System::assert_has_event(Event::Tokens(crate::Event::BalanceSet(DOT, BOB, 0, 0))); - assert_eq!(Accounts::::contains_key(BOB, DOT), false); + assert!(!Accounts::::contains_key(BOB, DOT)); assert_eq!(Tokens::free_balance(DOT, &BOB), 0); assert_eq!(Tokens::reserved_balance(DOT, &BOB), 0); assert_eq!(Tokens::total_issuance(DOT), 300); - assert_eq!(Accounts::::contains_key(CHARLIE, DOT), false); + assert!(!Accounts::::contains_key(CHARLIE, DOT)); assert_eq!(Tokens::free_balance(DOT, &CHARLIE), 0); assert_eq!(Tokens::reserved_balance(DOT, &CHARLIE), 0); // below ED, assert_ok!(Tokens::set_balance(RawOrigin::Root.into(), CHARLIE, DOT, 1, 0)); System::assert_has_event(Event::Tokens(crate::Event::BalanceSet(DOT, CHARLIE, 0, 0))); - assert_eq!(Accounts::::contains_key(CHARLIE, DOT), false); + assert!(!Accounts::::contains_key(CHARLIE, DOT)); assert_eq!(Tokens::free_balance(DOT, &CHARLIE), 0); assert_eq!(Tokens::reserved_balance(DOT, &CHARLIE), 0); assert_eq!(Tokens::total_issuance(DOT), 300); @@ -353,7 +353,7 @@ fn withdraw_consequence_should_work() { assert_ok!(Tokens::update_balance(DOT, &ALICE, 2)); assert_eq!(System::providers(&ALICE), 1); assert_ok!(System::inc_consumers(&ALICE)); - assert_eq!(System::can_dec_provider(&ALICE), false); + assert!(!System::can_dec_provider(&ALICE)); assert_eq!( Tokens::withdraw_consequence( &ALICE, @@ -371,7 +371,7 @@ fn withdraw_consequence_should_work() { // below ED and can dec provider let _ = System::inc_providers(&ALICE); - assert_eq!(System::can_dec_provider(&ALICE), true); + assert!(System::can_dec_provider(&ALICE)); assert_eq!( Tokens::withdraw_consequence( &ALICE, @@ -448,47 +448,47 @@ fn ensure_can_withdraw_should_work() { fn set_free_balance_should_work() { ExtBuilder::default().build().execute_with(|| { /* Scenarios: ED is not zero, account is not in dust removal whitelist */ - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 0); assert_eq!(Tokens::free_balance(DOT, &DustReceiver::get()), 0); assert_eq!(Tokens::total_issuance(DOT), 0); // when total is below ED, account will be reaped. Tokens::set_free_balance(DOT, &ALICE, 1); - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 0); assert_eq!(Tokens::free_balance(DOT, &DustReceiver::get()), 1); // set_free_balance do not change total issuance. assert_eq!(Tokens::total_issuance(DOT), 0); Tokens::set_free_balance(DOT, &ALICE, 2); - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 2); assert_eq!(Tokens::free_balance(DOT, &DustReceiver::get()), 1); /* Scenarios: ED is not zero, account is in dust removal whitelist */ - assert_eq!(Accounts::::contains_key(DAVE, DOT), false); + assert!(!Accounts::::contains_key(DAVE, DOT)); assert_eq!(Tokens::free_balance(DOT, &DAVE), 0); assert_eq!(Tokens::free_balance(DOT, &DustReceiver::get()), 1); // set zero will not create account Tokens::set_free_balance(DOT, &DAVE, 0); - assert_eq!(Accounts::::contains_key(DAVE, DOT), false); + assert!(!Accounts::::contains_key(DAVE, DOT)); // when total is below ED, account will not be reaped. Tokens::set_free_balance(DOT, &DAVE, 1); - assert_eq!(Accounts::::contains_key(DAVE, DOT), true); + assert!(Accounts::::contains_key(DAVE, DOT)); assert_eq!(Tokens::free_balance(DOT, &DAVE), 1); assert_eq!(Tokens::free_balance(DOT, &DustReceiver::get()), 1); /* Scenarios: ED is zero */ - assert_eq!(Accounts::::contains_key(ALICE, ETH), false); + assert!(!Accounts::::contains_key(ALICE, ETH)); assert_eq!(Tokens::free_balance(ETH, &ALICE), 0); assert_eq!(Tokens::free_balance(ETH, &DustReceiver::get()), 0); // set zero will create account Tokens::set_free_balance(ETH, &ALICE, 0); - assert_eq!(Accounts::::contains_key(ALICE, ETH), true); + assert!(Accounts::::contains_key(ALICE, ETH)); assert_eq!(Tokens::free_balance(ETH, &ALICE), 0); assert_eq!(Tokens::free_balance(ETH, &DustReceiver::get()), 0); }); @@ -498,42 +498,42 @@ fn set_free_balance_should_work() { fn set_reserved_balance_should_work() { ExtBuilder::default().build().execute_with(|| { /* Scenarios: ED is not zero, account is not in dust removal whitelist */ - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::reserved_balance(DOT, &ALICE), 0); assert_eq!(Tokens::total_issuance(DOT), 0); // when total is below ED, account should be reaped. Tokens::set_reserved_balance(DOT, &ALICE, 1); // but reap it failed because failed to transfer/withdraw dust removal!!! - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::reserved_balance(DOT, &ALICE), 1); // set_reserved_balance do not change total issuance. assert_eq!(Tokens::total_issuance(DOT), 0); Tokens::set_reserved_balance(DOT, &ALICE, 2); - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::reserved_balance(DOT, &ALICE), 2); /* Scenarios: ED is not zero, account is in dust removal whitelist */ - assert_eq!(Accounts::::contains_key(DAVE, DOT), false); + assert!(!Accounts::::contains_key(DAVE, DOT)); assert_eq!(Tokens::free_balance(DOT, &DAVE), 0); // set zero will not create account Tokens::set_reserved_balance(DOT, &DAVE, 0); - assert_eq!(Accounts::::contains_key(DAVE, DOT), false); + assert!(!Accounts::::contains_key(DAVE, DOT)); // when total is below ED, account shouldn't be reaped. Tokens::set_reserved_balance(DOT, &DAVE, 1); - assert_eq!(Accounts::::contains_key(DAVE, DOT), true); + assert!(Accounts::::contains_key(DAVE, DOT)); assert_eq!(Tokens::reserved_balance(DOT, &DAVE), 1); /* Scenarios: ED is zero */ - assert_eq!(Accounts::::contains_key(ALICE, ETH), false); + assert!(!Accounts::::contains_key(ALICE, ETH)); assert_eq!(Tokens::reserved_balance(ETH, &ALICE), 0); // set zero will create account Tokens::set_reserved_balance(ETH, &ALICE, 0); - assert_eq!(Accounts::::contains_key(ALICE, ETH), true); + assert!(Accounts::::contains_key(ALICE, ETH)); assert_eq!(Tokens::reserved_balance(ETH, &ALICE), 0); }); } @@ -624,7 +624,7 @@ fn do_transfer_report_keep_alive_error_when_ed_is_not_zero() { // account will not be reaped. assert_eq!(Tokens::free_balance(DOT, &DAVE), 100); assert_eq!(Tokens::free_balance(DOT, &BOB), 0); - assert_eq!(Accounts::::contains_key(DAVE, DOT), true); + assert!(Accounts::::contains_key(DAVE, DOT)); assert_ok!(Tokens::do_transfer( DOT, &DAVE, @@ -634,7 +634,7 @@ fn do_transfer_report_keep_alive_error_when_ed_is_not_zero() { )); assert_eq!(Tokens::free_balance(DOT, &DAVE), 1); assert_eq!(Tokens::free_balance(DOT, &BOB), 99); - assert_eq!(Accounts::::contains_key(DAVE, DOT), true); + assert!(Accounts::::contains_key(DAVE, DOT)); }); } @@ -644,7 +644,7 @@ fn do_transfer_will_not_report_keep_alive_error_when_ed_is_zero() { .balances(vec![(ALICE, ETH, 100), (DAVE, ETH, 100)]) .build() .execute_with(|| { - assert_eq!(Accounts::::contains_key(ALICE, ETH), true); + assert!(Accounts::::contains_key(ALICE, ETH)); assert_eq!(Tokens::free_balance(ETH, &ALICE), 100); assert_eq!(Tokens::free_balance(ETH, &BOB), 0); assert_ok!(Tokens::do_transfer( @@ -654,12 +654,12 @@ fn do_transfer_will_not_report_keep_alive_error_when_ed_is_zero() { 99, ExistenceRequirement::KeepAlive )); - assert_eq!(Accounts::::contains_key(ALICE, ETH), true); + assert!(Accounts::::contains_key(ALICE, ETH)); assert_eq!(Tokens::free_balance(ETH, &ALICE), 1); assert_eq!(Tokens::free_balance(ETH, &BOB), 99); // account that total is zero will not be reaped because ED is zero - assert_eq!(Accounts::::contains_key(DAVE, ETH), true); + assert!(Accounts::::contains_key(DAVE, ETH)); assert_eq!(Tokens::free_balance(ETH, &DAVE), 100); assert_ok!(Tokens::do_transfer( ETH, @@ -668,7 +668,7 @@ fn do_transfer_will_not_report_keep_alive_error_when_ed_is_zero() { 100, ExistenceRequirement::KeepAlive )); - assert_eq!(Accounts::::contains_key(DAVE, ETH), true); + assert!(Accounts::::contains_key(DAVE, ETH)); assert_eq!(Tokens::free_balance(ETH, &DAVE), 0); assert_eq!(Tokens::free_balance(ETH, &BOB), 199); }); @@ -680,16 +680,16 @@ fn do_transfer_report_keep_alive_error_due_to_cannot_dec_provider_when_allow_dea .balances(vec![(ALICE, DOT, 100), (DAVE, DOT, 100)]) .build() .execute_with(|| { - assert_eq!(System::can_dec_provider(&ALICE), true); + assert!(System::can_dec_provider(&ALICE)); assert_ok!(System::inc_consumers(&ALICE)); - assert_eq!(System::can_dec_provider(&ALICE), false); + assert!(!System::can_dec_provider(&ALICE)); assert_noop!( Tokens::do_transfer(DOT, &ALICE, &BOB, 99, ExistenceRequirement::AllowDeath), Error::::KeepAlive ); assert_ok!(Tokens::deposit(BTC, &ALICE, 100)); - assert_eq!(System::can_dec_provider(&ALICE), true); + assert!(System::can_dec_provider(&ALICE)); assert_ok!(Tokens::do_transfer( DOT, &ALICE, @@ -712,7 +712,7 @@ fn do_transfer_report_existential_deposit_error_when_ed_is_not_zero() { ); // if receiver is in dust removal whitelist, will not be reaped. - assert_eq!(Accounts::::contains_key(DAVE, DOT), false); + assert!(!Accounts::::contains_key(DAVE, DOT)); assert_eq!(Tokens::free_balance(DOT, &DAVE), 0); assert_ok!(Tokens::do_transfer( DOT, @@ -721,7 +721,7 @@ fn do_transfer_report_existential_deposit_error_when_ed_is_not_zero() { 1, ExistenceRequirement::KeepAlive )); - assert_eq!(Accounts::::contains_key(DAVE, DOT), true); + assert!(Accounts::::contains_key(DAVE, DOT)); assert_eq!(Tokens::free_balance(DOT, &DAVE), 1); }); } @@ -733,9 +733,9 @@ fn do_withdraw_should_work() { .build() .execute_with(|| { // always ok if amount is zero - assert_eq!(Accounts::::contains_key(BOB, DOT), false); + assert!(!Accounts::::contains_key(BOB, DOT)); assert_ok!(Tokens::do_withdraw(DOT, &BOB, 0, ExistenceRequirement::KeepAlive, true)); - assert_eq!(Accounts::::contains_key(BOB, DOT), false); + assert!(!Accounts::::contains_key(BOB, DOT)); assert_noop!( Tokens::do_withdraw(DOT, &ALICE, 101, ExistenceRequirement::KeepAlive, true), @@ -781,7 +781,7 @@ fn do_withdraw_dust_removal_when_allow_death() { .build() .execute_with(|| { assert_eq!(Tokens::total_issuance(DOT), 100); - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 100); assert_eq!(Tokens::free_balance(DOT, &DustReceiver::get()), 0); @@ -793,7 +793,7 @@ fn do_withdraw_dust_removal_when_allow_death() { true )); assert_eq!(Tokens::total_issuance(DOT), 1); - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 0); assert_eq!(Tokens::free_balance(DOT, &DustReceiver::get()), 1); }); @@ -812,7 +812,7 @@ fn do_withdraw_report_keep_alive_error_when_ed_is_not_zero() { // dave is in dust removal whitelist, still can withdraw if remainer is not zero // but below ED. - assert_eq!(Accounts::::contains_key(DAVE, DOT), true); + assert!(Accounts::::contains_key(DAVE, DOT)); assert_eq!(Tokens::free_balance(DOT, &DAVE), 100); assert_eq!(Tokens::total_issuance(DOT), 200); assert_ok!(Tokens::do_withdraw( @@ -822,7 +822,7 @@ fn do_withdraw_report_keep_alive_error_when_ed_is_not_zero() { ExistenceRequirement::KeepAlive, true )); - assert_eq!(Accounts::::contains_key(DAVE, DOT), true); + assert!(Accounts::::contains_key(DAVE, DOT)); assert_eq!(Tokens::free_balance(DOT, &DAVE), 1); assert_eq!(Tokens::total_issuance(DOT), 101); @@ -841,7 +841,7 @@ fn do_withdraw_will_not_report_keep_alive_error_when_ed_is_zero() { .balances(vec![(ALICE, ETH, 100), (DAVE, ETH, 100)]) .build() .execute_with(|| { - assert_eq!(Accounts::::contains_key(ALICE, ETH), true); + assert!(Accounts::::contains_key(ALICE, ETH)); assert_eq!(Tokens::free_balance(ETH, &ALICE), 100); assert_eq!(Tokens::total_issuance(ETH), 200); assert_ok!(Tokens::do_withdraw( @@ -851,11 +851,11 @@ fn do_withdraw_will_not_report_keep_alive_error_when_ed_is_zero() { ExistenceRequirement::KeepAlive, true )); - assert_eq!(Accounts::::contains_key(ALICE, ETH), true); + assert!(Accounts::::contains_key(ALICE, ETH)); assert_eq!(Tokens::free_balance(ETH, &ALICE), 0); assert_eq!(Tokens::total_issuance(ETH), 100); - assert_eq!(Accounts::::contains_key(DAVE, ETH), true); + assert!(Accounts::::contains_key(DAVE, ETH)); assert_eq!(Tokens::free_balance(ETH, &DAVE), 100); assert_ok!(Tokens::do_withdraw( ETH, @@ -864,7 +864,7 @@ fn do_withdraw_will_not_report_keep_alive_error_when_ed_is_zero() { ExistenceRequirement::KeepAlive, true )); - assert_eq!(Accounts::::contains_key(DAVE, ETH), true); + assert!(Accounts::::contains_key(DAVE, ETH)); assert_eq!(Tokens::free_balance(ETH, &DAVE), 0); assert_eq!(Tokens::total_issuance(ETH), 0); }); @@ -880,15 +880,15 @@ fn do_deposit_should_work() { assert_ok!(Tokens::do_deposit(DOT, &CHARLIE, 0, true, true)); assert_ok!(Tokens::do_deposit(DOT, &CHARLIE, 0, false, true)); - assert_eq!(Accounts::::contains_key(CHARLIE, DOT), false); + assert!(!Accounts::::contains_key(CHARLIE, DOT)); assert_eq!(Tokens::free_balance(DOT, &CHARLIE), 0); assert_eq!(Tokens::total_issuance(DOT), 100); assert_ok!(Tokens::do_deposit(DOT, &CHARLIE, 10, false, true)); - assert_eq!(Accounts::::contains_key(CHARLIE, DOT), true); + assert!(Accounts::::contains_key(CHARLIE, DOT)); assert_eq!(Tokens::free_balance(DOT, &CHARLIE), 10); assert_eq!(Tokens::total_issuance(DOT), 110); - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 100); assert_ok!(Tokens::do_deposit(DOT, &ALICE, 10, true, true)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 110); @@ -909,7 +909,7 @@ fn do_deposit_should_work() { #[test] fn do_deposit_report_dead_account_error() { ExtBuilder::default().build().execute_with(|| { - assert_eq!(Accounts::::contains_key(CHARLIE, DOT), false); + assert!(!Accounts::::contains_key(CHARLIE, DOT)); assert_noop!( Tokens::do_deposit(DOT, &CHARLIE, 10, true, true), Error::::DeadAccount @@ -920,17 +920,17 @@ fn do_deposit_report_dead_account_error() { #[test] fn do_deposit_report_existential_deposit_error() { ExtBuilder::default().build().execute_with(|| { - assert_eq!(Accounts::::contains_key(CHARLIE, DOT), false); + assert!(!Accounts::::contains_key(CHARLIE, DOT)); assert_noop!( Tokens::do_deposit(DOT, &CHARLIE, 1, false, true), Error::::ExistentialDeposit ); - assert_eq!(Accounts::::contains_key(DAVE, DOT), false); + assert!(!Accounts::::contains_key(DAVE, DOT)); assert_eq!(Tokens::free_balance(DOT, &DAVE), 0); assert_eq!(Tokens::total_issuance(DOT), 0); assert_ok!(Tokens::do_deposit(DOT, &DAVE, 1, false, true)); - assert_eq!(Accounts::::contains_key(DAVE, DOT), true); + assert!(Accounts::::contains_key(DAVE, DOT)); assert_eq!(Tokens::free_balance(DOT, &DAVE), 1); assert_eq!(Tokens::total_issuance(DOT), 1); }); @@ -944,11 +944,11 @@ fn do_deposit_report_existential_deposit_error() { fn endowed_account_work() { ExtBuilder::default().build().execute_with(|| { assert_eq!(System::providers(&ALICE), 0); - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); Tokens::set_free_balance(DOT, &ALICE, 100); System::assert_last_event(Event::Tokens(crate::Event::Endowed(DOT, ALICE, 100))); assert_eq!(System::providers(&ALICE), 1); - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); }); } @@ -959,10 +959,10 @@ fn remove_account_work() { .build() .execute_with(|| { assert_eq!(System::providers(&ALICE), 1); - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); Tokens::set_free_balance(DOT, &ALICE, 0); assert_eq!(System::providers(&ALICE), 0); - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); }); } @@ -973,8 +973,8 @@ fn reap_account_will_dec_providers_work() { .build() .execute_with(|| { assert_eq!(System::providers(&ALICE), 3); - assert_eq!(System::account_exists(&ALICE), true); - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(System::account_exists(&ALICE)); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_ok!(Tokens::do_transfer( DOT, @@ -984,12 +984,12 @@ fn reap_account_will_dec_providers_work() { ExistenceRequirement::AllowDeath )); assert_eq!(System::providers(&ALICE), 2); - assert_eq!(System::account_exists(&ALICE), true); - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(System::account_exists(&ALICE)); + assert!(!Accounts::::contains_key(ALICE, DOT)); // ED of ETH is zero, the account will retain even if the total is zero, // will not dec_providers - assert_eq!(Accounts::::contains_key(ALICE, ETH), true); + assert!(Accounts::::contains_key(ALICE, ETH)); assert_ok!(Tokens::do_transfer( ETH, &ALICE, @@ -998,10 +998,10 @@ fn reap_account_will_dec_providers_work() { ExistenceRequirement::AllowDeath )); assert_eq!(System::providers(&ALICE), 2); - assert_eq!(System::account_exists(&ALICE), true); - assert_eq!(Accounts::::contains_key(ALICE, ETH), true); + assert!(System::account_exists(&ALICE)); + assert!(Accounts::::contains_key(ALICE, ETH)); - assert_eq!(Accounts::::contains_key(ALICE, BTC), true); + assert!(Accounts::::contains_key(ALICE, BTC)); assert_ok!(Tokens::do_transfer( BTC, &ALICE, @@ -1010,8 +1010,8 @@ fn reap_account_will_dec_providers_work() { ExistenceRequirement::AllowDeath )); assert_eq!(System::providers(&ALICE), 1); - assert_eq!(System::account_exists(&ALICE), true); - assert_eq!(Accounts::::contains_key(ALICE, BTC), false); + assert!(System::account_exists(&ALICE)); + assert!(!Accounts::::contains_key(ALICE, BTC)); }); } @@ -1022,23 +1022,23 @@ fn dust_removal_work() { .build() .execute_with(|| { assert_eq!(System::providers(&ALICE), 1); - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 100); assert_eq!(Tokens::free_balance(DOT, &DustReceiver::get()), 0); Tokens::set_free_balance(DOT, &ALICE, 1); System::assert_last_event(Event::Tokens(crate::Event::DustLost(DOT, ALICE, 1))); assert_eq!(System::providers(&ALICE), 0); - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 0); assert_eq!(Tokens::free_balance(DOT, &DustReceiver::get()), 1); // dave is in dust removal whitelist, will not remove its dust even if its total // below ED - assert_eq!(Accounts::::contains_key(DAVE, DOT), false); + assert!(!Accounts::::contains_key(DAVE, DOT)); assert_eq!(System::providers(&DAVE), 0); assert_eq!(Tokens::free_balance(DOT, &DAVE), 0); Tokens::set_free_balance(DOT, &DAVE, 1); - assert_eq!(Accounts::::contains_key(DAVE, DOT), true); + assert!(Accounts::::contains_key(DAVE, DOT)); assert_eq!(System::providers(&DAVE), 1); assert_eq!(Tokens::free_balance(DOT, &DAVE), 1); System::assert_last_event(Event::Tokens(crate::Event::Endowed(DOT, DAVE, 1))); @@ -1053,14 +1053,14 @@ fn account_survive_due_to_dust_transfer_failure() { assert_eq!(Tokens::free_balance(DOT, &dust_account), 0); assert_eq!(Tokens::total_balance(DOT, &ALICE), 0); assert_eq!(System::providers(&ALICE), 0); - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); Tokens::set_reserved_balance(DOT, &ALICE, 1); System::assert_last_event(Event::Tokens(crate::Event::DustLost(DOT, ALICE, 1))); assert_eq!(Tokens::free_balance(DOT, &dust_account), 0); assert_eq!(Tokens::total_balance(DOT, &ALICE), 1); assert_eq!(System::providers(&ALICE), 1); - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); }); } @@ -1072,11 +1072,11 @@ fn account_survive_due_to_dust_transfer_failure() { #[test] fn multicurrency_deposit_work() { ExtBuilder::default().build().execute_with(|| { - assert_eq!(Accounts::::contains_key(CHARLIE, DOT), false); + assert!(!Accounts::::contains_key(CHARLIE, DOT)); assert_eq!(Tokens::free_balance(DOT, &CHARLIE), 0); assert_eq!(Tokens::total_issuance(DOT), 0); assert_ok!(Tokens::deposit(DOT, &CHARLIE, 10)); - assert_eq!(Accounts::::contains_key(CHARLIE, DOT), true); + assert!(Accounts::::contains_key(CHARLIE, DOT)); assert_eq!(Tokens::free_balance(DOT, &CHARLIE), 10); assert_eq!(Tokens::total_issuance(DOT), 10); }); @@ -1088,11 +1088,11 @@ fn multicurrency_withdraw_work() { .balances(vec![(ALICE, DOT, 100)]) .build() .execute_with(|| { - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 100); assert_eq!(Tokens::total_issuance(DOT), 100); assert_ok!(Tokens::withdraw(DOT, &ALICE, 99)); - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 0); assert_eq!(Tokens::total_issuance(DOT), 1); }); @@ -1104,11 +1104,11 @@ fn multicurrency_transfer_work() { .balances(vec![(ALICE, DOT, 100), (BOB, DOT, 100)]) .build() .execute_with(|| { - assert_eq!(Accounts::::contains_key(ALICE, DOT), true); + assert!(Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 100); assert_eq!(Tokens::free_balance(DOT, &BOB), 100); assert_ok!(>::transfer(DOT, &ALICE, &BOB, 99)); - assert_eq!(Accounts::::contains_key(ALICE, DOT), false); + assert!(!Accounts::::contains_key(ALICE, DOT)); assert_eq!(Tokens::free_balance(DOT, &ALICE), 0); assert_eq!(Tokens::free_balance(DOT, &BOB), 199); }); @@ -1121,8 +1121,8 @@ fn multicurrency_can_slash_work() { .build() .execute_with(|| { assert_eq!(Tokens::free_balance(DOT, &ALICE), 100); - assert_eq!(Tokens::can_slash(DOT, &ALICE, 101), false); - assert_eq!(Tokens::can_slash(DOT, &ALICE, 100), true); + assert!(!Tokens::can_slash(DOT, &ALICE, 101)); + assert!(Tokens::can_slash(DOT, &ALICE, 100)); }); } @@ -1220,9 +1220,9 @@ fn multi_reservable_currency_can_reserve_work() { .balances(vec![(ALICE, DOT, 100)]) .build() .execute_with(|| { - assert_eq!(Tokens::can_reserve(DOT, &ALICE, 0), true); - assert_eq!(Tokens::can_reserve(DOT, &ALICE, 101), false); - assert_eq!(Tokens::can_reserve(DOT, &ALICE, 100), true); + assert!(Tokens::can_reserve(DOT, &ALICE, 0)); + assert!(!Tokens::can_reserve(DOT, &ALICE, 101)); + assert!(Tokens::can_reserve(DOT, &ALICE, 100)); }); } @@ -1423,10 +1423,10 @@ fn currency_adapter_ensure_currency_adapter_should_work() { ::Currency::total_balance(&TREASURY_ACCOUNT), 100 ); - assert_eq!( - ::Currency::can_slash(&TREASURY_ACCOUNT, 10), - true - ); + assert!(::Currency::can_slash( + &TREASURY_ACCOUNT, + 10 + )); assert_eq!( ::Currency::total_issuance(), 100 @@ -1435,10 +1435,10 @@ fn currency_adapter_ensure_currency_adapter_should_work() { ::Currency::minimum_balance(), 2 ); - assert_eq!( - ::Currency::can_reserve(&TREASURY_ACCOUNT, 5), - true - ); + assert!(::Currency::can_reserve( + &TREASURY_ACCOUNT, + 5 + )); // burn let imbalance = ::Currency::burn(10); @@ -2053,8 +2053,8 @@ fn fungibles_inspect_hold_trait_should_work() { .build() .execute_with(|| { assert_eq!(>::balance_on_hold(DOT, &ALICE), 0); - assert_eq!(>::can_hold(DOT, &ALICE, 50), true); - assert_eq!(>::can_hold(DOT, &ALICE, 100), false); + assert!(>::can_hold(DOT, &ALICE, 50)); + assert!(!>::can_hold(DOT, &ALICE, 100)); }); } diff --git a/utilities/src/ordered_set.rs b/utilities/src/ordered_set.rs index b4bbb9289..342022b8d 100644 --- a/utilities/src/ordered_set.rs +++ b/utilities/src/ordered_set.rs @@ -42,7 +42,7 @@ impl> OrderedSet { /// Remove an element. /// Return true if removal happened. pub fn remove(&mut self, value: &T) -> bool { - match self.0.binary_search(&value) { + match self.0.binary_search(value) { Ok(loc) => { self.0.remove(loc); true @@ -53,7 +53,7 @@ impl> OrderedSet { /// Return if the set contains `value` pub fn contains(&self, value: &T) -> bool { - self.0.binary_search(&value).is_ok() + self.0.binary_search(value).is_ok() } /// Clear the set @@ -107,16 +107,16 @@ mod tests { let mut set: OrderedSet = OrderedSet::new(); assert_eq!(set, OrderedSet::::from(vec![].try_into().unwrap())); - assert_eq!(set.insert(1), true); + assert!(set.insert(1)); assert_eq!(set, OrderedSet::::from(vec![1].try_into().unwrap())); - assert_eq!(set.insert(5), true); + assert!(set.insert(5)); assert_eq!(set, OrderedSet::::from(vec![1, 5].try_into().unwrap())); - assert_eq!(set.insert(3), true); + assert!(set.insert(3)); assert_eq!(set, OrderedSet::::from(vec![1, 3, 5].try_into().unwrap())); - assert_eq!(set.insert(3), false); + assert!(!set.insert(3)); assert_eq!(set, OrderedSet::::from(vec![1, 3, 5].try_into().unwrap())); } @@ -124,28 +124,28 @@ mod tests { fn remove() { let mut set: OrderedSet = OrderedSet::from(vec![1, 2, 3, 4].try_into().unwrap()); - assert_eq!(set.remove(&5), false); + assert!(!set.remove(&5)); assert_eq!( set, OrderedSet::::from(vec![1, 2, 3, 4].try_into().unwrap()) ); - assert_eq!(set.remove(&1), true); + assert!(set.remove(&1)); assert_eq!(set, OrderedSet::::from(vec![2, 3, 4].try_into().unwrap())); - assert_eq!(set.remove(&3), true); + assert!(set.remove(&3)); assert_eq!(set, OrderedSet::::from(vec![2, 4].try_into().unwrap())); - assert_eq!(set.remove(&3), false); + assert!(!set.remove(&3)); assert_eq!(set, OrderedSet::::from(vec![2, 4].try_into().unwrap())); - assert_eq!(set.remove(&4), true); + assert!(set.remove(&4)); assert_eq!(set, OrderedSet::::from(vec![2].try_into().unwrap())); - assert_eq!(set.remove(&2), true); + assert!(set.remove(&2)); assert_eq!(set, OrderedSet::::from(vec![].try_into().unwrap())); - assert_eq!(set.remove(&2), false); + assert!(!set.remove(&2)); assert_eq!(set, OrderedSet::::from(vec![].try_into().unwrap())); } @@ -153,11 +153,11 @@ mod tests { fn contains() { let set: OrderedSet = OrderedSet::from(vec![1, 2, 3, 4].try_into().unwrap()); - assert_eq!(set.contains(&5), false); + assert!(!set.contains(&5)); - assert_eq!(set.contains(&1), true); + assert!(set.contains(&1)); - assert_eq!(set.contains(&3), true); + assert!(set.contains(&3)); } #[test] @@ -172,6 +172,6 @@ mod tests { let mut set: OrderedSet = OrderedSet::from(vec![1, 2, 3, 4, 5].try_into().unwrap()); let inserted = set.insert(6); - assert_eq!(inserted, false) + assert!(!inserted) } } diff --git a/vesting/src/tests.rs b/vesting/src/tests.rs index b6039ccd6..093b2bd90 100644 --- a/vesting/src/tests.rs +++ b/vesting/src/tests.rs @@ -111,7 +111,7 @@ fn cannot_use_fund_if_not_claimed() { period_count: 1u32, per_period: 50u64, }; - assert_ok!(Vesting::vested_transfer(Origin::signed(ALICE), BOB, schedule.clone())); + assert_ok!(Vesting::vested_transfer(Origin::signed(ALICE), BOB, schedule)); assert!(PalletBalances::ensure_can_withdraw(&BOB, 1, WithdrawReasons::TRANSFER, 49).is_err()); }); } @@ -126,7 +126,7 @@ fn vested_transfer_fails_if_zero_period_or_count() { per_period: 100u64, }; assert_noop!( - Vesting::vested_transfer(Origin::signed(ALICE), BOB, schedule.clone()), + Vesting::vested_transfer(Origin::signed(ALICE), BOB, schedule), Error::::ZeroVestingPeriod ); @@ -137,7 +137,7 @@ fn vested_transfer_fails_if_zero_period_or_count() { per_period: 100u64, }; assert_noop!( - Vesting::vested_transfer(Origin::signed(ALICE), BOB, schedule.clone()), + Vesting::vested_transfer(Origin::signed(ALICE), BOB, schedule), Error::::ZeroVestingPeriodCount ); }); @@ -153,7 +153,7 @@ fn vested_transfer_fails_if_transfer_err() { per_period: 100u64, }; assert_noop!( - Vesting::vested_transfer(Origin::signed(BOB), ALICE, schedule.clone()), + Vesting::vested_transfer(Origin::signed(BOB), ALICE, schedule), pallet_balances::Error::::InsufficientBalance, ); }); @@ -196,7 +196,7 @@ fn vested_transfer_fails_if_bad_origin() { per_period: 100u64, }; assert_noop!( - Vesting::vested_transfer(Origin::signed(CHARLIE), BOB, schedule.clone()), + Vesting::vested_transfer(Origin::signed(CHARLIE), BOB, schedule), BadOrigin ); }); @@ -211,14 +211,14 @@ fn claim_works() { period_count: 2u32, per_period: 10u64, }; - assert_ok!(Vesting::vested_transfer(Origin::signed(ALICE), BOB, schedule.clone())); + assert_ok!(Vesting::vested_transfer(Origin::signed(ALICE), BOB, schedule)); MockBlockNumberProvider::set(11); // remain locked if not claimed assert!(PalletBalances::transfer(Origin::signed(BOB), ALICE, 10).is_err()); // unlocked after claiming assert_ok!(Vesting::claim(Origin::signed(BOB))); - assert_eq!(VestingSchedules::::contains_key(BOB), true); + assert!(VestingSchedules::::contains_key(BOB)); assert_ok!(PalletBalances::transfer(Origin::signed(BOB), ALICE, 10)); // more are still locked assert!(PalletBalances::transfer(Origin::signed(BOB), ALICE, 1).is_err()); @@ -226,7 +226,7 @@ fn claim_works() { MockBlockNumberProvider::set(21); // claim more assert_ok!(Vesting::claim(Origin::signed(BOB))); - assert_eq!(VestingSchedules::::contains_key(BOB), false); + assert!(!VestingSchedules::::contains_key(BOB)); assert_ok!(PalletBalances::transfer(Origin::signed(BOB), ALICE, 10)); // all used up assert_eq!(PalletBalances::free_balance(BOB), 0); @@ -245,7 +245,7 @@ fn claim_for_works() { period_count: 2u32, per_period: 10u64, }; - assert_ok!(Vesting::vested_transfer(Origin::signed(ALICE), BOB, schedule.clone())); + assert_ok!(Vesting::vested_transfer(Origin::signed(ALICE), BOB, schedule)); assert_ok!(Vesting::claim_for(Origin::signed(ALICE), BOB)); @@ -257,7 +257,7 @@ fn claim_for_works() { reasons: Reasons::All, }) ); - assert_eq!(VestingSchedules::::contains_key(&BOB), true); + assert!(VestingSchedules::::contains_key(&BOB)); MockBlockNumberProvider::set(21); @@ -265,7 +265,7 @@ fn claim_for_works() { // no locks anymore assert_eq!(PalletBalances::locks(&BOB), vec![]); - assert_eq!(VestingSchedules::::contains_key(&BOB), false); + assert!(!VestingSchedules::::contains_key(&BOB)); }); } @@ -278,7 +278,7 @@ fn update_vesting_schedules_works() { period_count: 2u32, per_period: 10u64, }; - assert_ok!(Vesting::vested_transfer(Origin::signed(ALICE), BOB, schedule.clone())); + assert_ok!(Vesting::vested_transfer(Origin::signed(ALICE), BOB, schedule)); let updated_schedule = VestingSchedule { start: 0u64, @@ -301,7 +301,7 @@ fn update_vesting_schedules_works() { assert_ok!(PalletBalances::transfer(Origin::signed(BOB), ALICE, 10)); // empty vesting schedules cleanup the storage and unlock the fund - assert_eq!(VestingSchedules::::contains_key(BOB), true); + assert!(VestingSchedules::::contains_key(BOB)); assert_eq!( PalletBalances::locks(&BOB).get(0), Some(&BalanceLock { @@ -311,7 +311,7 @@ fn update_vesting_schedules_works() { }) ); assert_ok!(Vesting::update_vesting_schedules(Origin::root(), BOB, vec![])); - assert_eq!(VestingSchedules::::contains_key(BOB), false); + assert!(!VestingSchedules::::contains_key(BOB)); assert_eq!(PalletBalances::locks(&BOB), vec![]); }); } @@ -334,7 +334,7 @@ fn vested_transfer_check_for_min() { per_period: 3u64, }; assert_noop!( - Vesting::vested_transfer(Origin::signed(BOB), ALICE, schedule.clone()), + Vesting::vested_transfer(Origin::signed(BOB), ALICE, schedule), Error::::AmountLow ); }); @@ -371,7 +371,7 @@ fn multiple_vesting_schedule_claim_works() { assert_ok!(Vesting::claim(Origin::signed(BOB))); - assert_eq!(VestingSchedules::::contains_key(&BOB), false); + assert!(!VestingSchedules::::contains_key(&BOB)); assert_eq!(PalletBalances::locks(&BOB), vec![]); }); @@ -393,7 +393,7 @@ fn exceeding_maximum_schedules_should_fail() { Error::::MaxVestingSchedulesExceeded ); - let schedules = vec![schedule.clone(), schedule.clone(), schedule.clone()]; + let schedules = vec![schedule.clone(), schedule.clone(), schedule]; assert_noop!( Vesting::update_vesting_schedules(Origin::root(), BOB, schedules), diff --git a/weight-meter/src/mock.rs b/weight-meter/src/mock.rs index bce1f08fb..654913ef5 100644 --- a/weight-meter/src/mock.rs +++ b/weight-meter/src/mock.rs @@ -125,9 +125,7 @@ pub mod test_module { } #[orml_weight_meter::weight(Weight::MAX)] - fn max_weight() { - return; - } + fn max_weight() {} } } diff --git a/xcm-support/src/currency_adapter.rs b/xcm-support/src/currency_adapter.rs index fb2cd364d..202f170e8 100644 --- a/xcm-support/src/currency_adapter.rs +++ b/xcm-support/src/currency_adapter.rs @@ -76,7 +76,7 @@ impl< match ( AccountIdConvert::convert_ref(location), CurrencyIdConvert::convert(asset.clone()), - Match::matches_fungible(&asset), + Match::matches_fungible(asset), ) { // known asset (Ok(who), Some(currency_id), Some(amount)) => { @@ -93,7 +93,7 @@ impl< .map_err(|_| XcmError::from(Error::AccountIdConversionFailed))?; let currency_id = CurrencyIdConvert::convert(asset.clone()) .ok_or_else(|| XcmError::from(Error::CurrencyIdConversionFailed))?; - let amount: MultiCurrency::Balance = Match::matches_fungible(&asset) + let amount: MultiCurrency::Balance = Match::matches_fungible(asset) .ok_or_else(|| XcmError::from(Error::FailedToMatchFungible))? .saturated_into(); MultiCurrency::withdraw(currency_id, &who, amount).map_err(|e| XcmError::FailedToTransactAsset(e.into())) diff --git a/xcm-support/src/tests.rs b/xcm-support/src/tests.rs index d866793ab..a05082603 100644 --- a/xcm-support/src/tests.rs +++ b/xcm-support/src/tests.rs @@ -96,14 +96,11 @@ fn multi_native_asset() { }, &X2(Parent, Parachain(1)), )); - assert_eq!( - MultiNativeAsset::filter_asset_location( - &ConcreteFungible { - id: X3(Parent, Parachain(1), GeneralKey("TokenA".into())), - amount: 10, - }, - &X1(Parent), - ), - false - ); + assert!(!MultiNativeAsset::filter_asset_location( + &ConcreteFungible { + id: X3(Parent, Parachain(1), GeneralKey("TokenA".into())), + amount: 10, + }, + &X1(Parent), + )); } diff --git a/xtokens/src/lib.rs b/xtokens/src/lib.rs index 48c3cece8..9b6308bfd 100644 --- a/xtokens/src/lib.rs +++ b/xtokens/src/lib.rs @@ -142,7 +142,7 @@ pub mod module { /// received. Receiving depends on if the XCM message could be delivered /// by the network, and if the receiving chain would handle /// messages correctly. - #[pallet::weight(Pallet::::weight_of_transfer(currency_id.clone(), *amount, &dest))] + #[pallet::weight(Pallet::::weight_of_transfer(currency_id.clone(), *amount, dest))] #[transactional] pub fn transfer( origin: OriginFor, @@ -167,7 +167,7 @@ pub mod module { /// received. Receiving depends on if the XCM message could be delivered /// by the network, and if the receiving chain would handle /// messages correctly. - #[pallet::weight(Pallet::::weight_of_transfer_multiasset(&asset, &dest))] + #[pallet::weight(Pallet::::weight_of_transfer_multiasset(asset, dest))] #[transactional] pub fn transfer_multiasset( origin: OriginFor, @@ -409,7 +409,7 @@ pub mod module { id, amount: amount.into(), }; - Self::weight_of_transfer_multiasset(&asset, &dest) + Self::weight_of_transfer_multiasset(&asset, dest) } else { 0 } diff --git a/xtokens/src/tests.rs b/xtokens/src/tests.rs index 64323a14e..bd0b3caf9 100644 --- a/xtokens/src/tests.rs +++ b/xtokens/src/tests.rs @@ -361,11 +361,10 @@ fn send_as_sovereign() { Relay::execute_with(|| { relay::System::events().iter().any(|r| { - if let relay::Event::System(frame_system::Event::::Remarked(_, _)) = r.event { - true - } else { - false - } + matches!( + r.event, + relay::Event::System(frame_system::Event::::Remarked(_, _)) + ) }); }) }