Use tracing-based subscriber logging (#6825)

* init_logger: switch from log-based to tracing-based and add compatibility layer

* Move tracing profiling subscriber related config realization

* sp-tracing: change profiling to be a layer instead of a subscriber

* Enable profiling layer in cli

* Change all test env_logger init to sp_tracing::try_init_simple

* Remove all local env_logger dependency

* Add missing tracing-subscriber dependency

* frame-sudo: fix tests

* frame-support: fix tests

* Fix frame/pallet and executor tests

* Fix the remaining tests

* Use subscriber's try_init as recommended by @davidbarsky

* Be explict that the tracing-log feature is needed

* Set subscriber writer to stderr

* Shorter line width

* Update cargo lock tracing version

* Fix sc_tracing crate compile

* Fix sc_authority_discovery crate test

* unremove default-features

* Leave enabled to default true

* Warn if global default cannot be set

* Fix unused import

* Remove unused PROXY_TARGET

* Change all reference from rc5 to rc6

* Change all reference of rc2 to rc6

* Fix styling

* Fix typo

* make logger init error'ing

* re-fixing the test issue

Co-authored-by: Benjamin Kampmann <ben@parity.io>

substrate/frame/elections-phragmen/src/lib.rs

@@ -1398,7 +1398,7 @@ mod tests {
 		assert!(
 			Elections::members().iter().chain(
 				Elections::runners_up().iter()
-			).all(|(_, s)| *s != Zero::zero())
+			).all(|(_, s)| *s != u64::zero())
 		);
 	}
 
@@ -1453,15 +1453,15 @@ mod tests {
 			assert_eq!(Elections::term_duration(), 5);
 			assert_eq!(Elections::election_rounds(), 0);
 
-			assert_eq!(Elections::members(), vec![]);
-			assert_eq!(Elections::runners_up(), vec![]);
+			assert!(Elections::members().is_empty());
+			assert!(Elections::runners_up().is_empty());
 
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::candidates().is_empty());
 			assert_eq!(<Candidates<Test>>::decode_len(), None);
 			assert!(Elections::is_candidate(&1).is_err());
 
-			assert_eq!(all_voters(), vec![]);
-			assert_eq!(votes_of(&1), vec![]);
+			assert!(all_voters().is_empty());
+			assert!(votes_of(&1).is_empty());
 		});
 	}
 
@@ -1536,16 +1536,16 @@ mod tests {
 			assert_eq!(Elections::desired_members(), 2);
 			assert_eq!(Elections::election_rounds(), 0);
 
-			assert_eq!(Elections::members_ids(), vec![]);
-			assert_eq!(Elections::runners_up(), vec![]);
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::members_ids().is_empty());
+			assert!(Elections::runners_up().is_empty());
+			assert!(Elections::candidates().is_empty());
 
 			System::set_block_number(5);
 			Elections::end_block(System::block_number());
 
-			assert_eq!(Elections::members_ids(), vec![]);
-			assert_eq!(Elections::runners_up(), vec![]);
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::members_ids().is_empty());
+			assert!(Elections::runners_up().is_empty());
+			assert!(Elections::candidates().is_empty());
 		});
 	}
 
@@ -1588,18 +1588,18 @@ mod tests {
 			assert!(Elections::is_candidate(&2).is_ok());
 			assert_eq!(Elections::candidates(), vec![1, 2]);
 
-			assert_eq!(Elections::members_ids(), vec![]);
-			assert_eq!(Elections::runners_up(), vec![]);
+			assert!(Elections::members_ids().is_empty());
+			assert!(Elections::runners_up().is_empty());
 
 			System::set_block_number(5);
 			Elections::end_block(System::block_number());
 
 			assert!(Elections::is_candidate(&1).is_err());
 			assert!(Elections::is_candidate(&2).is_err());
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::candidates().is_empty());
 
-			assert_eq!(Elections::members_ids(), vec![]);
-			assert_eq!(Elections::runners_up(), vec![]);
+			assert!(Elections::members_ids().is_empty());
+			assert!(Elections::runners_up().is_empty());
 		});
 	}
 
@@ -1627,8 +1627,8 @@ mod tests {
 			Elections::end_block(System::block_number());
 
 			assert_eq!(Elections::members_ids(), vec![5]);
-			assert_eq!(Elections::runners_up(), vec![]);
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::runners_up().is_empty());
+			assert!(Elections::candidates().is_empty());
 
 			assert_noop!(
 				submit_candidacy(Origin::signed(5)),
@@ -1742,7 +1742,7 @@ mod tests {
 			Elections::end_block(System::block_number());
 
 			assert_eq!(Elections::members_ids(), vec![4, 5]);
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::candidates().is_empty());
 
 			assert_ok!(vote(Origin::signed(3), vec![4, 5], 10));
 		});
@@ -1765,7 +1765,7 @@ mod tests {
 			Elections::end_block(System::block_number());
 
 			assert_eq!(Elections::members_ids(), vec![4, 5]);
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::candidates().is_empty());
 
 			assert_ok!(vote(Origin::signed(3), vec![4, 5], 10));
 			assert_eq!(PRIME.with(|p| *p.borrow()), Some(4));
@@ -1791,7 +1791,7 @@ mod tests {
 			Elections::end_block(System::block_number());
 
 			assert_eq!(Elections::members_ids(), vec![3, 5]);
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::candidates().is_empty());
 
 			assert_eq!(PRIME.with(|p| *p.borrow()), Some(5));
 		});
@@ -1876,7 +1876,7 @@ mod tests {
 			assert_ok!(Elections::remove_voter(Origin::signed(2)));
 
 			assert_eq_uvec!(all_voters(), vec![3]);
-			assert_eq!(votes_of(&2), vec![]);
+			assert!(votes_of(&2).is_empty());
 			assert_eq!(Elections::locked_stake_of(&2), 0);
 
 			assert_eq!(balances(&2), (20, 0));
@@ -1898,7 +1898,7 @@ mod tests {
 			assert_ok!(vote(Origin::signed(2), vec![5], 20));
 
 			assert_ok!(Elections::remove_voter(Origin::signed(2)));
-			assert_eq!(all_voters(), vec![]);
+			assert!(all_voters().is_empty());
 
 			assert_noop!(Elections::remove_voter(Origin::signed(2)), Error::<Test>::MustBeVoter);
 		});
@@ -2008,7 +2008,7 @@ mod tests {
 
 			assert_eq!(Elections::members_ids(), vec![4, 5]);
 			assert_eq!(Elections::runners_up_ids(), vec![6]);
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::candidates().is_empty());
 
 			// all of them have a member or runner-up that they voted for.
 			assert_eq!(Elections::is_defunct_voter(&votes_of(&5)), false);
@@ -2044,7 +2044,7 @@ mod tests {
 			Elections::end_block(System::block_number());
 
 			assert_eq!(Elections::members_ids(), vec![4, 5]);
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::candidates().is_empty());
 
 			assert_eq!(balances(&3), (28, 2));
 			assert_eq!(balances(&5), (45, 5));
@@ -2072,7 +2072,7 @@ mod tests {
 			Elections::end_block(System::block_number());
 
 			assert_eq!(Elections::members_ids(), vec![4, 5]);
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::candidates().is_empty());
 
 			assert_eq!(balances(&4), (35, 5));
 			assert_eq!(balances(&5), (45, 5));
@@ -2113,9 +2113,9 @@ mod tests {
 			Elections::end_block(System::block_number());
 
 			assert_eq!(Elections::members(), vec![(3, 30), (5, 20)]);
-			assert_eq!(Elections::runners_up(), vec![]);
+			assert!(Elections::runners_up().is_empty());
 			assert_eq_uvec!(all_voters(), vec![2, 3, 4]);
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::candidates().is_empty());
 			assert_eq!(<Candidates<Test>>::decode_len(), None);
 
 			assert_eq!(Elections::election_rounds(), 1);
@@ -2180,9 +2180,9 @@ mod tests {
 			System::set_block_number(5);
 			Elections::end_block(System::block_number());
 
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::candidates().is_empty());
 			assert_eq!(Elections::election_rounds(), 1);
-			assert_eq!(Elections::members_ids(), vec![]);
+			assert!(Elections::members_ids().is_empty());
 
 			assert_eq!(
 				System::events().iter().last().unwrap().event,
@@ -2293,7 +2293,7 @@ mod tests {
 
 			System::set_block_number(10);
 			Elections::end_block(System::block_number());
-			assert_eq!(Elections::members_ids(), vec![]);
+			assert!(Elections::members_ids().is_empty());
 
 			assert_eq!(balances(&5), (47, 0));
 		});
@@ -2378,7 +2378,7 @@ mod tests {
 				assert_eq!(Elections::members(), vec![(4, 40), (5, 50)]);
 				assert_eq!(Elections::runners_up(), vec![(2, 20), (3, 30)]);
 				// no new candidates but old members and runners-up are always added.
-				assert_eq!(Elections::candidates(), vec![]);
+				assert!(Elections::candidates().is_empty());
 				assert_eq!(Elections::election_rounds(), b / 5);
 				assert_eq_uvec!(all_voters(), vec![2, 3, 4, 5]);
 			};
@@ -2490,7 +2490,7 @@ mod tests {
 			// meanwhile, no one cares to become a candidate again.
 			System::set_block_number(10);
 			Elections::end_block(System::block_number());
-			assert_eq!(Elections::members_ids(), vec![]);
+			assert!(Elections::members_ids().is_empty());
 			assert_eq!(Elections::election_rounds(), 2);
 		});
 	}
@@ -2658,14 +2658,14 @@ mod tests {
 			Elections::end_block(System::block_number());
 
 			assert_eq!(Elections::members_ids(), vec![4, 5]);
-			assert_eq!(Elections::runners_up_ids(), vec![]);
+			assert!(Elections::runners_up_ids().is_empty());
 
 			assert_ok!(Elections::renounce_candidacy(Origin::signed(4), Renouncing::Member));
 			assert_eq!(balances(&4), (38, 2)); // 2 is voting bond.
 
 			// no replacement
 			assert_eq!(Elections::members_ids(), vec![5]);
-			assert_eq!(Elections::runners_up_ids(), vec![]);
+			assert!(Elections::runners_up_ids().is_empty());
 		})
 	}
 
@@ -2729,7 +2729,7 @@ mod tests {
 
 			assert_ok!(Elections::renounce_candidacy(Origin::signed(5), Renouncing::Candidate(1)));
 			assert_eq!(balances(&5), (50, 0));
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::candidates().is_empty());
 		})
 	}
 
@@ -2841,7 +2841,7 @@ mod tests {
 
 			assert_eq!(Elections::members_ids(), vec![1, 4]);
 			assert_eq!(Elections::runners_up_ids(), vec![2, 3]);
-			assert_eq!(Elections::candidates(), vec![]);
+			assert!(Elections::candidates().is_empty());
 		})
 	}
 }

substrate/frame/elections/src/tests.rs

@@ -46,14 +46,14 @@ fn params_should_work() {
 
 		assert_eq!(Elections::voters(0), Vec::<Option<u64>>::new());
 		assert_eq!(Elections::voter_info(1), None);
-		assert_eq!(Elections::all_approvals_of(&1), vec![]);
+		assert!(Elections::all_approvals_of(&1).is_empty());
 	});
 }
 
 #[test]
 fn chunking_bool_to_flag_should_work() {
 	ExtBuilder::default().build().execute_with(|| {
-		assert_eq!(Elections::bool_to_flag(vec![]), vec![]);
+		assert!(Elections::bool_to_flag(vec![]).is_empty());
 		assert_eq!(Elections::bool_to_flag(vec![false]), vec![0]);
 		assert_eq!(Elections::bool_to_flag(vec![true]), vec![1]);
 		assert_eq!(Elections::bool_to_flag(vec![true, true, true, true]), vec![15]);
@@ -274,11 +274,11 @@ fn chunking_approval_storage_should_work() {
 
 		assert_eq!(Elections::all_approvals_of(&2), vec![true]);
 		// NOTE: these two are stored in mem differently though.
-		assert_eq!(Elections::all_approvals_of(&3), vec![]);
-		assert_eq!(Elections::all_approvals_of(&4), vec![]);
+		assert!(Elections::all_approvals_of(&3).is_empty());
+		assert!(Elections::all_approvals_of(&4).is_empty());
 
 		assert_eq!(Elections::approvals_of((3, 0)), vec![0]);
-		assert_eq!(Elections::approvals_of((4, 0)), vec![]);
+		assert!(Elections::approvals_of((4, 0)).is_empty());
 	});
 }
 
@@ -385,7 +385,7 @@ fn voting_locking_stake_and_reserving_bond_works() {
 		assert_ok!(Elections::submit_candidacy(Origin::signed(5), 0));
 
 		assert_eq!(balances(&2), (20, 0));
-		assert_eq!(locks(&2), vec![]);
+		assert!(locks(&2).is_empty());
 		assert_ok!(Elections::set_approvals(Origin::signed(2), vec![], 0, 0, 15));
 		assert_eq!(balances(&2), (18, 2));
 		assert_eq!(locks(&2), vec![15]);
@@ -401,7 +401,7 @@ fn voting_locking_stake_and_reserving_bond_works() {
 		assert_ok!(Elections::retract_voter(Origin::signed(2), 0));
 
 		assert_eq!(balances(&2), (102, 0));
-		assert_eq!(locks(&2), vec![]);
+		assert!(locks(&2).is_empty());
 	});
 }
 

substrate/frame/example/src/lib.rs

@@ -843,7 +843,7 @@ mod tests {
 				WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 150)
 					.unwrap()
 					.priority,
-				Bounded::max_value(),
+				u64::max_value(),
 			);
 			assert_eq!(
 				WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),

substrate/frame/scored-pool/src/tests.rs

@@ -153,7 +153,7 @@ fn unscored_entities_must_not_be_used_for_filling_members() {
 
 		// then
 		// the `None` candidates should not have been filled in
-		assert_eq!(ScoredPool::members(), vec![]);
+		assert!(ScoredPool::members().is_empty());
 		assert_eq!(MEMBERS.with(|m| m.borrow().clone()), ScoredPool::members());
 	});
 }

substrate/frame/staking/Cargo.toml

@@ -33,6 +33,7 @@ rand_chacha = { version = "0.2", default-features = false, optional = true }
 [dev-dependencies]
 sp-core = { version = "2.0.0-rc6", path = "../../primitives/core" }
 sp-storage = { version = "2.0.0-rc6", path = "../../primitives/storage" }
+sp-tracing = { version = "2.0.0-rc6", path = "../../primitives/tracing" }
 pallet-balances = { version = "2.0.0-rc6", path = "../balances" }
 pallet-timestamp = { version = "2.0.0-rc6", path = "../timestamp" }
 pallet-staking-reward-curve = { version = "2.0.0-rc6",  path = "../staking/reward-curve" }
@@ -40,7 +41,6 @@ substrate-test-utils = { version = "2.0.0-rc6", path = "../../test-utils" }
 frame-benchmarking = { version = "2.0.0-rc6", path = "../benchmarking" }
 rand_chacha = { version = "0.2" }
 parking_lot = "0.10.2"
-env_logger = "0.7.1"
 hex = "0.4"
 
 [features]

substrate/frame/staking/src/mock.rs

@@ -452,7 +452,7 @@ impl ExtBuilder {
 		MAX_ITERATIONS.with(|v| *v.borrow_mut() = self.max_offchain_iterations);
 	}
 	pub fn build(self) -> sp_io::TestExternalities {
-		let _ = env_logger::try_init();
+		sp_tracing::try_init_simple();
 		self.set_associated_constants();
 		let mut storage = frame_system::GenesisConfig::default()
 			.build_storage::<Test>()

substrate/frame/staking/src/tests.rs

@@ -1734,7 +1734,7 @@ fn bond_with_duplicate_vote_should_be_ignored_by_npos_election() {
 					.collect::<Vec<_>>(),
 				vec![(31, 1000), (21, 1000), (11, 1000)],
 			);
-			assert_eq!(<Nominators<Test>>::iter().map(|(n, _)| n).collect::<Vec<_>>(), vec![]);
+			assert!(<Nominators<Test>>::iter().map(|(n, _)| n).collect::<Vec<_>>().is_empty());
 
 			// give the man some money
 			let initial_balance = 1000;
@@ -1782,7 +1782,7 @@ fn bond_with_duplicate_vote_should_be_ignored_by_npos_election_elected() {
 					.collect::<Vec<_>>(),
 				vec![(31, 100), (21, 1000), (11, 1000)],
 			);
-			assert_eq!(<Nominators<Test>>::iter().map(|(n, _)| n).collect::<Vec<_>>(), vec![]);
+			assert!(<Nominators<Test>>::iter().map(|(n, _)| n).collect::<Vec<_>>().is_empty());
 
 			// give the man some money
 			let initial_balance = 1000;

substrate/frame/sudo/src/tests.rs

@@ -18,9 +18,9 @@
 //! Tests for the module.
 
 use super::*;
-use mock::{ 
+use mock::{
 	Sudo, SudoCall, Origin, Call, Test, new_test_ext, LoggerCall, Logger, System, TestEvent,
-}; 
+};
 use frame_support::{assert_ok, assert_noop};
 
 #[test]
@@ -28,8 +28,8 @@ fn test_setup_works() {
 	// Environment setup, logger storage, and sudo `key` retrieval should work as expected.
 	new_test_ext(1).execute_with(|| {
 		assert_eq!(Sudo::key(),  1u64);
-		assert_eq!(Logger::i32_log(), vec![]);
-		assert_eq!(Logger::account_log(), vec![]);
+		assert!(Logger::i32_log().is_empty());
+		assert!(Logger::account_log().is_empty());
 	});
 }
 
@@ -40,8 +40,8 @@ fn sudo_basics() {
 		// A privileged function should work when `sudo` is passed the root `key` as `origin`.
 		let call = Box::new(Call::Logger(LoggerCall::privileged_i32_log(42, 1_000)));
 		assert_ok!(Sudo::sudo(Origin::signed(1), call));
-		assert_eq!(Logger::i32_log(), vec![42i32]); 
-		
+		assert_eq!(Logger::i32_log(), vec![42i32]);
+
 		// A privileged function should not work when `sudo` is passed a non-root `key` as `origin`.
 		let call = Box::new(Call::Logger(LoggerCall::privileged_i32_log(42, 1_000)));
 		assert_noop!(Sudo::sudo(Origin::signed(2), call), Error::<Test>::RequireSudo);
@@ -58,7 +58,7 @@ fn sudo_emits_events_correctly() {
 		let call = Box::new(Call::Logger(LoggerCall::privileged_i32_log(42, 1)));
 		assert_ok!(Sudo::sudo(Origin::signed(1), call));
 		let expected_event = TestEvent::sudo(RawEvent::Sudid(Ok(())));
-		assert!(System::events().iter().any(|a| a.event == expected_event)); 
+		assert!(System::events().iter().any(|a| a.event == expected_event));
 	})
 }
 
@@ -68,16 +68,16 @@ fn sudo_unchecked_weight_basics() {
 		// A privileged function should work when `sudo` is passed the root `key` as origin.
 		let call = Box::new(Call::Logger(LoggerCall::privileged_i32_log(42, 1_000)));
 		assert_ok!(Sudo::sudo_unchecked_weight(Origin::signed(1), call, 1_000));
-		assert_eq!(Logger::i32_log(), vec![42i32]); 
+		assert_eq!(Logger::i32_log(), vec![42i32]);
 
 		// A privileged function should not work when called with a non-root `key`.
 		let call = Box::new(Call::Logger(LoggerCall::privileged_i32_log(42, 1_000)));
 		assert_noop!(
-			Sudo::sudo_unchecked_weight(Origin::signed(2), call, 1_000), 
+			Sudo::sudo_unchecked_weight(Origin::signed(2), call, 1_000),
 			Error::<Test>::RequireSudo,
 		);
 		// `I32Log` is unchanged after unsuccessful call.
-		assert_eq!(Logger::i32_log(), vec![42i32]); 
+		assert_eq!(Logger::i32_log(), vec![42i32]);
 
 		// Controls the dispatched weight.
 		let call = Box::new(Call::Logger(LoggerCall::privileged_i32_log(42, 1)));
@@ -103,7 +103,7 @@ fn sudo_unchecked_weight_emits_events_correctly() {
 
 #[test]
 fn set_key_basics() {
-	new_test_ext(1).execute_with(|| {	
+	new_test_ext(1).execute_with(|| {
 		// A root `key` can change the root `key`
 		assert_ok!(Sudo::set_key(Origin::signed(1), 2));
 		assert_eq!(Sudo::key(),  2u64);
@@ -117,7 +117,7 @@ fn set_key_basics() {
 
 #[test]
 fn set_key_emits_events_correctly() {
-	new_test_ext(1).execute_with(|| {	
+	new_test_ext(1).execute_with(|| {
 		// Set block number to 1 because events are not emitted on block 0.
 		System::set_block_number(1);
 
@@ -138,8 +138,8 @@ fn sudo_as_basics() {
 		// A privileged function will not work when passed to `sudo_as`.
 		let call = Box::new(Call::Logger(LoggerCall::privileged_i32_log(42, 1_000)));
 		assert_ok!(Sudo::sudo_as(Origin::signed(1), 2, call));
-		assert_eq!(Logger::i32_log(), vec![]); 
-		assert_eq!(Logger::account_log(), vec![]);
+		assert!(Logger::i32_log().is_empty());
+		assert!(Logger::account_log().is_empty());
 
 		// A non-privileged function should not work when called with a non-root `key`.
 		let call = Box::new(Call::Logger(LoggerCall::non_privileged_log(42, 1)));
@@ -156,7 +156,7 @@ fn sudo_as_basics() {
 
 #[test]
 fn sudo_as_emits_events_correctly() {
-		new_test_ext(1).execute_with(|| {	
+		new_test_ext(1).execute_with(|| {
 		// Set block number to 1 because events are not emitted on block 0.
 		System::set_block_number(1);
 

substrate/frame/support/src/storage/mod.rs

@@ -656,7 +656,7 @@ mod test {
 			assert_eq!(MyStorage::final_prefix().to_vec(), k);
 
 			// test iteration
-			assert_eq!(MyStorage::iter_values().collect::<Vec<_>>(), vec![]);
+			assert!(MyStorage::iter_values().collect::<Vec<_>>().is_empty());
 
 			unhashed::put(&[&k[..], &vec![1][..]].concat(), &1u64);
 			unhashed::put(&[&k[..], &vec![1, 1][..]].concat(), &2u64);
@@ -667,13 +667,13 @@ mod test {
 
 			// test removal
 			MyStorage::remove_all();
-			assert_eq!(MyStorage::iter_values().collect::<Vec<_>>(), vec![]);
+			assert!(MyStorage::iter_values().collect::<Vec<_>>().is_empty());
 
 			// test migration
 			unhashed::put(&[&k[..], &vec![1][..]].concat(), &1u32);
 			unhashed::put(&[&k[..], &vec![8][..]].concat(), &2u32);
 
-			assert_eq!(MyStorage::iter_values().collect::<Vec<_>>(), vec![]);
+			assert!(MyStorage::iter_values().collect::<Vec<_>>().is_empty());
 			MyStorage::translate_values(|v: u32| Some(v as u64));
 			assert_eq!(MyStorage::iter_values().collect::<Vec<_>>(), vec![1, 2]);
 			MyStorage::remove_all();

substrate/frame/support/test/tests/decl_storage.rs

@@ -520,7 +520,7 @@ mod test_append_and_len {
 	fn default_for_option() {
 		TestExternalities::default().execute_with(|| {
 			assert_eq!(OptionVec::get(), None);
-			assert_eq!(JustVec::get(), vec![]);
+			assert!(JustVec::get().is_empty());
 		});
 	}
 
@@ -553,7 +553,7 @@ mod test_append_and_len {
 			let key = JustVec::hashed_key();
 			// Set it to some invalid value.
 			frame_support::storage::unhashed::put_raw(&key, &*b"1");
-			assert_eq!(JustVec::get(), Vec::new());
+			assert!(JustVec::get().is_empty());
 			assert_eq!(frame_support::storage::unhashed::get_raw(&key), Some(b"1".to_vec()));
 
 			JustVec::append(1);
@@ -600,7 +600,7 @@ mod test_append_and_len {
 	fn len_works_ignores_default_assignment() {
 		TestExternalities::default().execute_with(|| {
 			// vec
-			assert_eq!(JustVec::get(), vec![]);
+			assert!(JustVec::get().is_empty());
 			assert_eq!(JustVec::decode_len(), None);
 
 			assert_eq!(JustVecWithDefault::get(), vec![6, 9]);
@@ -610,7 +610,7 @@ mod test_append_and_len {
 			assert_eq!(OptionVec::decode_len(), None);
 
 			// map
-			assert_eq!(MapVec::get(0), vec![]);
+			assert!(MapVec::get(0).is_empty());
 			assert_eq!(MapVec::decode_len(0), None);
 
 			assert_eq!(MapVecWithDefault::get(0), vec![6, 9]);
@@ -620,7 +620,7 @@ mod test_append_and_len {
 			assert_eq!(OptionMapVec::decode_len(0), None);
 
 			// Double map
-			assert_eq!(DoubleMapVec::get(0, 0), vec![]);
+			assert!(DoubleMapVec::get(0, 0).is_empty());
 			assert_eq!(DoubleMapVec::decode_len(0, 1), None);
 
 			assert_eq!(DoubleMapVecWithDefault::get(0, 0), vec![6, 9]);