frame system: add event util functions for tests. (#8734)

* frame system: add event util functions for tests.

* URemove unused fn.

* Apply review suggestions.

substrate/frame/assets/src/benchmarking.rs

@@ -120,19 +120,11 @@ fn add_approvals<T: Config<I>, I: 'static>(minter: T::AccountId, n: u32) {
 }
 
 fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::Event) {
-	let events = frame_system::Pallet::<T>::events();
-	let system_event: <T as frame_system::Config>::Event = generic_event.into();
-	// compare to the last event record
-	let frame_system::EventRecord { event, .. } = &events[events.len() - 1];
-	assert_eq!(event, &system_event);
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
 }
 
 fn assert_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::Event) {
-	let system_event: <T as frame_system::Config>::Event = generic_event.into();
-	let events = frame_system::Pallet::<T>::events();
-	assert!(events.iter().any(|event_record| {
-		matches!(&event_record, frame_system::EventRecord { event, .. } if &system_event == event)
-	}));
+	frame_system::Pallet::<T>::assert_has_event(generic_event.into());
 }
 
 benchmarks_instance_pallet! {

substrate/frame/assets/src/tests.rs

@@ -23,10 +23,6 @@ use sp_runtime::TokenError;
 use frame_support::{assert_ok, assert_noop, traits::Currency};
 use pallet_balances::Error as BalancesError;
 
-fn last_event() -> mock::Event {
-	frame_system::Pallet::<Test>::events().pop().expect("Event expected").event
-}
-
 #[test]
 fn basic_minting_should_work() {
 	new_test_ext().execute_with(|| {
@@ -401,10 +397,7 @@ fn transferring_less_than_one_unit_is_fine() {
 		assert_ok!(Assets::mint(Origin::signed(1), 0, 1, 100));
 		assert_eq!(Assets::balance(0, 1), 100);
 		assert_ok!(Assets::transfer(Origin::signed(1), 0, 2, 0));
-		assert_eq!(
-			last_event(),
-			mock::Event::pallet_assets(crate::Event::Transferred(0, 1, 2, 0)),
-		);
+		System::assert_last_event(mock::Event::pallet_assets(crate::Event::Transferred(0, 1, 2, 0)));
 	});
 }
 
@@ -603,7 +596,7 @@ fn force_asset_status_should_work(){
 		assert_ok!(Assets::mint(Origin::signed(1), 0, 1, 50));
 		assert_ok!(Assets::mint(Origin::signed(1), 0, 2, 150));
 
-		//force asset status to change min_balance > balance 
+		//force asset status to change min_balance > balance
 		assert_ok!(Assets::force_asset_status(Origin::root(), 0, 1, 1, 1, 1, 100, true, false));
 		assert_eq!(Assets::balance(0, 1), 50);
 

substrate/frame/balances/src/tests.rs

@@ -54,10 +54,6 @@ macro_rules! decl_tests {
 			evt
 		}
 
-		fn last_event() -> Event {
-			system::Pallet::<Test>::events().pop().expect("Event expected").event
-		}
-
 		#[test]
 		fn basic_locking_should_work() {
 			<$ext_builder>::default().existential_deposit(1).monied(true).build().execute_with(|| {
@@ -467,9 +463,8 @@ macro_rules! decl_tests {
 				let _ = Balances::deposit_creating(&2, 1);
 				assert_ok!(Balances::reserve(&1, 110));
 				assert_ok!(Balances::repatriate_reserved(&1, &2, 41, Status::Free), 0);
-				assert_eq!(
-					last_event(),
-					Event::pallet_balances(crate::Event::ReserveRepatriated(1, 2, 41, Status::Free)),
+				System::assert_last_event(
+					Event::pallet_balances(crate::Event::ReserveRepatriated(1, 2, 41, Status::Free))
 				);
 				assert_eq!(Balances::reserved_balance(1), 69);
 				assert_eq!(Balances::free_balance(1), 0);
@@ -688,27 +683,18 @@ macro_rules! decl_tests {
 					System::set_block_number(2);
 					assert_ok!(Balances::reserve(&1, 10));
 
-					assert_eq!(
-						last_event(),
-						Event::pallet_balances(crate::Event::Reserved(1, 10)),
-					);
+					System::assert_last_event(Event::pallet_balances(crate::Event::Reserved(1, 10)));
 
 					System::set_block_number(3);
 					assert!(Balances::unreserve(&1, 5).is_zero());
 
-					assert_eq!(
-						last_event(),
-						Event::pallet_balances(crate::Event::Unreserved(1, 5)),
-					);
+					System::assert_last_event(Event::pallet_balances(crate::Event::Unreserved(1, 5)));
 
 					System::set_block_number(4);
 					assert_eq!(Balances::unreserve(&1, 6), 1);
 
 					// should only unreserve 5
-					assert_eq!(
-						last_event(),
-						Event::pallet_balances(crate::Event::Unreserved(1, 5)),
-					);
+					System::assert_last_event(Event::pallet_balances(crate::Event::Unreserved(1, 5)));
 				});
 		}
 

substrate/frame/balances/src/tests_reentrancy.rs

@@ -46,10 +46,6 @@ use frame_system::RawOrigin;
 type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
 type Block = frame_system::mocking::MockBlock<Test>;
 
-fn last_event() -> Event {
-	system::Pallet::<Test>::events().pop().expect("Event expected").event
-}
-
 frame_support::construct_runtime!(
 	pub enum Test where
 		Block = Block,
@@ -189,23 +185,8 @@ fn transfer_dust_removal_tst1_should_work() {
 			// Number of events expected is 8
 			assert_eq!(System::events().len(), 11);
 
-			assert!(
-				System::events().iter().any(
-					|er|
-					er.event == Event::pallet_balances(
-						crate::Event::Transfer(2, 3, 450),
-					),
-				),
-			);
-
-			assert!(
-				System::events().iter().any(
-					|er|
-					er.event == Event::pallet_balances(
-						crate::Event::DustLost(2, 50)
-					),
-				),
-			);
+			System::assert_has_event(Event::pallet_balances(crate::Event::Transfer(2, 3, 450)));
+			System::assert_has_event(Event::pallet_balances(crate::Event::DustLost(2, 50)));
 		}
 	);
 }
@@ -236,23 +217,8 @@ fn transfer_dust_removal_tst2_should_work() {
 			// Number of events expected is 8
 			assert_eq!(System::events().len(), 9);
 
-			assert!(
-				System::events().iter().any(
-					|er|
-					er.event == Event::pallet_balances(
-						crate::Event::Transfer(2, 1, 450),
-					),
-				),
-			);
-
-			assert!(
-				System::events().iter().any(
-					|er|
-					er.event == Event::pallet_balances(
-						crate::Event::DustLost(2, 50),
-					),
-				),
-			);
+			System::assert_has_event(Event::pallet_balances(crate::Event::Transfer(2, 1, 450)));
+			System::assert_has_event(Event::pallet_balances(crate::Event::DustLost(2, 50)));
 		}
 	);
 }
@@ -292,20 +258,11 @@ fn repatriating_reserved_balance_dust_removal_should_work() {
 			// Number of events expected is 10
 			assert_eq!(System::events().len(), 10);
 
-			assert!(
-				System::events().iter().any(
-					|er|
-					er.event == Event::pallet_balances(
-						crate::Event::ReserveRepatriated(2, 1, 450, Status::Free),
-					),
-				),
-			);
-
-			assert_eq!(
-				last_event(),
-				Event::pallet_balances(crate::Event::DustLost(2, 50)),
-			);
+			System::assert_has_event(Event::pallet_balances(
+				crate::Event::ReserveRepatriated(2, 1, 450, Status::Free),
+			));
 
+			System::assert_last_event(Event::pallet_balances(crate::Event::DustLost(2, 50)));
 		}
 	);
 }

substrate/frame/bounties/src/benchmarking.rs

@@ -22,7 +22,7 @@
 use super::*;
 
 use sp_runtime::traits::Bounded;
-use frame_system::{EventRecord, RawOrigin};
+use frame_system::RawOrigin;
 use frame_benchmarking::{benchmarks, account, whitelisted_caller, impl_benchmark_test_suite};
 use frame_support::traits::OnInitialize;
 
@@ -84,11 +84,7 @@ fn setup_pot_account<T: Config>() {
 }
 
 fn assert_last_event<T: Config>(generic_event: <T as Config>::Event) {
-	let events = frame_system::Pallet::<T>::events();
-	let system_event: <T as frame_system::Config>::Event = generic_event.into();
-	// compare to the last event record
-	let EventRecord { event, .. } = &events[events.len() - 1];
-	assert_eq!(event, &system_event);
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
 }
 
 const MAX_BYTES: u32 = 16384;

substrate/frame/collective/src/benchmarking.rs

@@ -20,7 +20,6 @@
 use super::*;
 
 use frame_system::RawOrigin as SystemOrigin;
-use frame_system::EventRecord;
 use frame_benchmarking::{
 	benchmarks_instance,
 	account,
@@ -39,11 +38,7 @@ const SEED: u32 = 0;
 const MAX_BYTES: u32 = 1_024;
 
 fn assert_last_event<T: Config<I>, I: Instance>(generic_event: <T as Config<I>>::Event) {
-	let events = System::<T>::events();
-	let system_event: <T as frame_system::Config>::Event = generic_event.into();
-	// compare to the last event record
-	let EventRecord { event, .. } = &events[events.len() - 1];
-	assert_eq!(event, &system_event);
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
 }
 
 benchmarks_instance! {

substrate/frame/democracy/src/benchmarking.rs

@@ -25,7 +25,7 @@ use frame_support::{
 	traits::{Currency, Get, EnsureOrigin, OnInitialize, UnfilteredDispatchable,
         schedule::DispatchTime},
 };
-use frame_system::{RawOrigin, Pallet as System, self, EventRecord};
+use frame_system::{RawOrigin, Pallet as System, self};
 use sp_runtime::traits::{Bounded, One};
 
 use crate::Pallet as Democracy;
@@ -36,11 +36,7 @@ const MAX_SECONDERS: u32 = 100;
 const MAX_BYTES: u32 = 16_384;
 
 fn assert_last_event<T: Config>(generic_event: <T as Config>::Event) {
-	let events = System::<T>::events();
-	let system_event: <T as frame_system::Config>::Event = generic_event.into();
-	// compare to the last event record
-	let EventRecord { event, .. } = &events[events.len() - 1];
-	assert_eq!(event, &system_event);
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
 }
 
 fn funded_account<T: Config>(name: &'static str, index: u32) -> T::AccountId {

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

@@ -2132,10 +2132,7 @@ mod tests {
 			System::set_block_number(5);
 			Elections::on_initialize(System::block_number());
 
-			assert_eq!(
-				System::events().iter().last().unwrap().event,
-				Event::elections_phragmen(super::Event::EmptyTerm),
-			)
+			System::assert_last_event(Event::elections_phragmen(super::Event::EmptyTerm));
 		})
 	}
 
@@ -2151,10 +2148,7 @@ mod tests {
 			System::set_block_number(5);
 			Elections::on_initialize(System::block_number());
 
-			assert_eq!(
-				System::events().iter().last().unwrap().event,
-				Event::elections_phragmen(super::Event::NewTerm(vec![(4, 40), (5, 50)])),
-			);
+			System::assert_last_event(Event::elections_phragmen(super::Event::NewTerm(vec![(4, 40), (5, 50)])));
 
 			assert_eq!(members_and_stake(), vec![(4, 40), (5, 50)]);
 			assert_eq!(runners_up_and_stake(), vec![]);
@@ -2165,10 +2159,7 @@ mod tests {
 			System::set_block_number(10);
 			Elections::on_initialize(System::block_number());
 
-			assert_eq!(
-				System::events().iter().last().unwrap().event,
-				Event::elections_phragmen(super::Event::NewTerm(vec![])),
-			);
+			System::assert_last_event(Event::elections_phragmen(super::Event::NewTerm(vec![])));
 
 			// outgoing have lost their bond.
 			assert_eq!(balances(&4), (37, 0));
@@ -2238,10 +2229,7 @@ mod tests {
 			assert_eq!(Elections::election_rounds(), 1);
 			assert!(members_ids().is_empty());
 
-			assert_eq!(
-				System::events().iter().last().unwrap().event,
-				Event::elections_phragmen(super::Event::NewTerm(vec![])),
-			)
+			System::assert_last_event(Event::elections_phragmen(super::Event::NewTerm(vec![])));
 		});
 	}
 
@@ -2599,9 +2587,7 @@ mod tests {
 			// 5 is an outgoing loser. will also get slashed.
 			assert_eq!(balances(&5), (45, 2));
 
-			assert!(System::events().iter().any(|event| {
-				event.event == Event::elections_phragmen(super::Event::NewTerm(vec![(4, 40), (5, 50)]))
-			}));
+			System::assert_has_event(Event::elections_phragmen(super::Event::NewTerm(vec![(4, 40), (5, 50)])));
 		})
 	}
 

substrate/frame/identity/src/benchmarking.rs

@@ -21,7 +21,7 @@
 
 use super::*;
 
-use frame_system::{EventRecord, RawOrigin};
+use frame_system::RawOrigin;
 use frame_benchmarking::{benchmarks, account, whitelisted_caller, impl_benchmark_test_suite};
 use sp_runtime::traits::Bounded;
 use frame_support::{ensure, traits::Get};
@@ -30,11 +30,7 @@ use crate::Pallet as Identity;
 const SEED: u32 = 0;
 
 fn assert_last_event<T: Config>(generic_event: <T as Config>::Event) {
-	let events = frame_system::Pallet::<T>::events();
-	let system_event: <T as frame_system::Config>::Event = generic_event.into();
-	// compare to the last event record
-	let EventRecord { event, .. } = &events[events.len() - 1];
-	assert_eq!(event, &system_event);
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
 }
 
 // Adds `r` registrars to the Identity Pallet. These registrars will have set fees and fields.

substrate/frame/multisig/src/tests.rs

@@ -124,14 +124,6 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
 	ext
 }
 
-fn last_event() -> Event {
-	system::Pallet::<Test>::events().pop().map(|e| e.event).expect("Event expected")
-}
-
-fn expect_event<E: Into<Event>>(e: E) {
-	assert_eq!(last_event(), e.into());
-}
-
 fn now() -> Timepoint<u64> {
 	Multisig::timepoint()
 }
@@ -433,7 +425,7 @@ fn multisig_2_of_3_cannot_reissue_same_call() {
 		assert_ok!(Multisig::as_multi(Origin::signed(3), 2, vec![1, 2], Some(now()), data.clone(), false, call_weight));
 
 		let err = DispatchError::from(BalancesError::<Test, _>::InsufficientBalance).stripped();
-		expect_event(RawEvent::MultisigExecuted(3, now(), multi, hash, Err(err)));
+		System::assert_last_event(RawEvent::MultisigExecuted(3, now(), multi, hash, Err(err)).into());
 	});
 }
 

substrate/frame/proxy/src/benchmarking.rs

@@ -20,7 +20,7 @@
 #![cfg(feature = "runtime-benchmarks")]
 
 use super::*;
-use frame_system::{RawOrigin, EventRecord};
+use frame_system::RawOrigin;
 use frame_benchmarking::{benchmarks, account, whitelisted_caller, impl_benchmark_test_suite};
 use sp_runtime::traits::Bounded;
 use crate::Pallet as Proxy;
@@ -28,11 +28,7 @@ use crate::Pallet as Proxy;
 const SEED: u32 = 0;
 
 fn assert_last_event<T: Config>(generic_event: <T as Config>::Event) {
-	let events = frame_system::Pallet::<T>::events();
-	let system_event: <T as frame_system::Config>::Event = generic_event.into();
-	// compare to the last event record
-	let EventRecord { event, .. } = &events[events.len() - 1];
-	assert_eq!(event, &system_event);
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
 }
 
 fn add_proxies<T: Config>(n: u32, maybe_who: Option<T::AccountId>) -> Result<(), &'static str> {

substrate/frame/proxy/src/tests.rs

@@ -164,14 +164,6 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
 	ext
 }
 
-fn last_event() -> Event {
-	system::Pallet::<Test>::events().pop().expect("Event expected").event
-}
-
-fn expect_event<E: Into<Event>>(e: E) {
-	assert_eq!(last_event(), e.into());
-}
-
 fn last_events(n: usize) -> Vec<Event> {
 	system::Pallet::<Test>::events().into_iter().rev().take(n).rev().map(|e| e.event).collect()
 }
@@ -311,11 +303,11 @@ fn filtering_works() {
 
 		let call = Box::new(Call::Balances(BalancesCall::transfer(6, 1)));
 		assert_ok!(Proxy::proxy(Origin::signed(2), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Ok(())));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Ok(())).into());
 		assert_ok!(Proxy::proxy(Origin::signed(3), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Ok(())));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Ok(())).into());
 		assert_ok!(Proxy::proxy(Origin::signed(4), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)).into());
 
 		let derivative_id = Utility::derivative_account_id(1, 0);
 		assert!(Balances::mutate_account(&derivative_id, |a| a.free = 1000).is_ok());
@@ -323,17 +315,17 @@ fn filtering_works() {
 
 		let call = Box::new(Call::Utility(UtilityCall::as_derivative(0, inner.clone())));
 		assert_ok!(Proxy::proxy(Origin::signed(2), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Ok(())));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Ok(())).into());
 		assert_ok!(Proxy::proxy(Origin::signed(3), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)).into());
 		assert_ok!(Proxy::proxy(Origin::signed(4), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)).into());
 
 		let call = Box::new(Call::Utility(UtilityCall::batch(vec![*inner])));
 		assert_ok!(Proxy::proxy(Origin::signed(2), 1, None, call.clone()));
 		expect_events(vec![UtilityEvent::BatchCompleted.into(), ProxyEvent::ProxyExecuted(Ok(())).into()]);
 		assert_ok!(Proxy::proxy(Origin::signed(3), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)).into());
 		assert_ok!(Proxy::proxy(Origin::signed(4), 1, None, call.clone()));
 		expect_events(vec![
 			UtilityEvent::BatchInterrupted(0, DispatchError::BadOrigin).into(),
@@ -345,7 +337,7 @@ fn filtering_works() {
 		assert_ok!(Proxy::proxy(Origin::signed(2), 1, None, call.clone()));
 		expect_events(vec![UtilityEvent::BatchCompleted.into(), ProxyEvent::ProxyExecuted(Ok(())).into()]);
 		assert_ok!(Proxy::proxy(Origin::signed(3), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)).into());
 		assert_ok!(Proxy::proxy(Origin::signed(4), 1, None, call.clone()));
 		expect_events(vec![
 			UtilityEvent::BatchInterrupted(0, DispatchError::BadOrigin).into(),
@@ -354,9 +346,9 @@ fn filtering_works() {
 
 		let call = Box::new(Call::Proxy(ProxyCall::remove_proxies()));
 		assert_ok!(Proxy::proxy(Origin::signed(3), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)).into());
 		assert_ok!(Proxy::proxy(Origin::signed(4), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)).into());
 		assert_ok!(Proxy::proxy(Origin::signed(2), 1, None, call.clone()));
 		expect_events(vec![BalancesEvent::<Test>::Unreserved(1, 5).into(), ProxyEvent::ProxyExecuted(Ok(())).into()]);
 	});
@@ -413,18 +405,18 @@ fn proxying_works() {
 			Error::<Test>::NotProxy
 		);
 		assert_ok!(Proxy::proxy(Origin::signed(2), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Ok(())));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Ok(())).into());
 		assert_eq!(Balances::free_balance(6), 1);
 
 		let call = Box::new(Call::System(SystemCall::set_code(vec![])));
 		assert_ok!(Proxy::proxy(Origin::signed(3), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)).into());
 
 		let call = Box::new(Call::Balances(BalancesCall::transfer_keep_alive(6, 1)));
 		assert_ok!(Call::Proxy(super::Call::proxy(1, None, call.clone())).dispatch(Origin::signed(2)));
-		expect_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Err(DispatchError::BadOrigin)).into());
 		assert_ok!(Proxy::proxy(Origin::signed(3), 1, None, call.clone()));
-		expect_event(ProxyEvent::ProxyExecuted(Ok(())));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Ok(())).into());
 		assert_eq!(Balances::free_balance(6), 2);
 	});
 }
@@ -434,7 +426,7 @@ fn anonymous_works() {
 	new_test_ext().execute_with(|| {
 		assert_ok!(Proxy::anonymous(Origin::signed(1), ProxyType::Any, 0, 0));
 		let anon = Proxy::anonymous_account(&1, &ProxyType::Any, 0, None);
-		expect_event(ProxyEvent::AnonymousCreated(anon.clone(), 1, ProxyType::Any, 0));
+		System::assert_last_event(ProxyEvent::AnonymousCreated(anon.clone(), 1, ProxyType::Any, 0).into());
 
 		// other calls to anonymous allowed as long as they're not exactly the same.
 		assert_ok!(Proxy::anonymous(Origin::signed(1), ProxyType::JustTransfer, 0, 0));
@@ -451,13 +443,13 @@ fn anonymous_works() {
 		let call = Box::new(Call::Balances(BalancesCall::transfer(6, 1)));
 		assert_ok!(Balances::transfer(Origin::signed(3), anon, 5));
 		assert_ok!(Proxy::proxy(Origin::signed(1), anon, None, call));
-		expect_event(ProxyEvent::ProxyExecuted(Ok(())));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Ok(())).into());
 		assert_eq!(Balances::free_balance(6), 1);
 
 		let call = Box::new(Call::Proxy(ProxyCall::kill_anonymous(1, ProxyType::Any, 0, 1, 0)));
 		assert_ok!(Proxy::proxy(Origin::signed(2), anon2, None, call.clone()));
 		let de = DispatchError::from(Error::<Test>::NoPermission).stripped();
-		expect_event(ProxyEvent::ProxyExecuted(Err(de)));
+		System::assert_last_event(ProxyEvent::ProxyExecuted(Err(de)).into());
 		assert_noop!(
 			Proxy::kill_anonymous(Origin::signed(1), 1, ProxyType::Any, 0, 1, 0),
 			Error::<Test>::NoPermission

substrate/frame/sudo/src/tests.rs

@@ -58,8 +58,7 @@ fn sudo_emits_events_correctly() {
 		// Should emit event to indicate success when called with the root `key` and `call` is `Ok`.
 		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(Event::Sudid(Ok(())));
-		assert!(System::events().iter().any(|a| a.event == expected_event));
+		System::assert_has_event(TestEvent::sudo(Event::Sudid(Ok(()))));
 	})
 }
 
@@ -97,8 +96,7 @@ fn sudo_unchecked_weight_emits_events_correctly() {
 		// Should emit event to indicate success when called with the root `key` and `call` is `Ok`.
 		let call = Box::new(Call::Logger(LoggerCall::privileged_i32_log(42, 1)));
 		assert_ok!(Sudo::sudo_unchecked_weight(Origin::signed(1), call, 1_000));
-		let expected_event = TestEvent::sudo(Event::Sudid(Ok(())));
-		assert!(System::events().iter().any(|a| a.event == expected_event));
+		System::assert_has_event(TestEvent::sudo(Event::Sudid(Ok(()))));
 	})
 }
 
@@ -124,12 +122,10 @@ fn set_key_emits_events_correctly() {
 
 		// A root `key` can change the root `key`.
 		assert_ok!(Sudo::set_key(Origin::signed(1), 2));
-		let expected_event = TestEvent::sudo(Event::KeyChanged(1));
-		assert!(System::events().iter().any(|a| a.event == expected_event));
+		System::assert_has_event(TestEvent::sudo(Event::KeyChanged(1)));
 		// Double check.
 		assert_ok!(Sudo::set_key(Origin::signed(2), 4));
-		let expected_event = TestEvent::sudo(Event::KeyChanged(2));
-		assert!(System::events().iter().any(|a| a.event == expected_event));
+		System::assert_has_event(TestEvent::sudo(Event::KeyChanged(2)));
 	});
 }
 
@@ -164,7 +160,6 @@ fn sudo_as_emits_events_correctly() {
 		// A non-privileged function will work when passed to `sudo_as` with the root `key`.
 		let call = Box::new(Call::Logger(LoggerCall::non_privileged_log(42, 1)));
 		assert_ok!(Sudo::sudo_as(Origin::signed(1), 2, call));
-		let expected_event = TestEvent::sudo(Event::SudoAsDone(Ok(())));
-		assert!(System::events().iter().any(|a| a.event == expected_event));
+		System::assert_has_event(TestEvent::sudo(Event::SudoAsDone(Ok(()))));
 	});
 }

substrate/frame/system/src/lib.rs

@@ -1449,6 +1449,18 @@ impl<T: Config> Pallet<T> {
 		<EventTopics<T>>::remove_all();
 	}
 
+	/// Assert the given `event` exists.
+	#[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
+	pub fn assert_has_event(event: T::Event) {
+		assert!(Self::events().iter().any(|record| record.event == event))
+	}
+
+	/// Assert the last event equal to the given `event`.
+	#[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
+	pub fn assert_last_event(event: T::Event) {
+		assert_eq!(Self::events().last().expect("events expected").event, event);
+	}
+
 	/// Return the chain's current runtime version.
 	pub fn runtime_version() -> RuntimeVersion { T::Version::get() }
 

substrate/frame/system/src/tests.rs

@@ -374,6 +374,17 @@ fn deposit_event_topics() {
 	});
 }
 
+#[test]
+fn event_util_functions_should_work() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		System::deposit_event(SysEvent::CodeUpdated);
+
+		System::assert_has_event(SysEvent::CodeUpdated.into());
+		System::assert_last_event(SysEvent::CodeUpdated.into());
+	});
+}
+
 #[test]
 fn prunes_block_hash_mappings() {
 	new_test_ext().execute_with(|| {

substrate/frame/transaction-payment/src/lib.rs

@@ -1150,13 +1150,9 @@ mod tests {
 			);
 			assert_eq!(Balances::free_balance(2), 0);
 			// Transfer Event
-			assert!(System::events().iter().any(|event| {
-				event.event == Event::pallet_balances(pallet_balances::Event::Transfer(2, 3, 80))
-			}));
+			System::assert_has_event(Event::pallet_balances(pallet_balances::Event::Transfer(2, 3, 80)));
 			// Killed Event
-			assert!(System::events().iter().any(|event| {
-				event.event == Event::system(system::Event::KilledAccount(2))
-			}));
+			System::assert_has_event(Event::system(system::Event::KilledAccount(2)));
 		});
 	}
 

substrate/frame/utility/src/benchmarking.rs

@@ -20,17 +20,13 @@
 #![cfg(feature = "runtime-benchmarks")]
 
 use super::*;
-use frame_system::{RawOrigin, EventRecord};
+use frame_system::RawOrigin;
 use frame_benchmarking::{benchmarks, account, whitelisted_caller, impl_benchmark_test_suite};
 
 const SEED: u32 = 0;
 
 fn assert_last_event<T: Config>(generic_event: <T as Config>::Event) {
-	let events = frame_system::Pallet::<T>::events();
-	let system_event: <T as frame_system::Config>::Event = generic_event.into();
-	// compare to the last event record
-	let EventRecord { event, .. } = &events[events.len() - 1];
-	assert_eq!(event, &system_event);
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
 }
 
 benchmarks! {

substrate/frame/utility/src/tests.rs

@@ -171,14 +171,6 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
 	ext
 }
 
-fn last_event() -> Event {
-	frame_system::Pallet::<Test>::events().pop().map(|e| e.event).expect("Event expected")
-}
-
-fn expect_event<E: Into<Event>>(e: E) {
-	assert_eq!(last_event(), e.into());
-}
-
 #[test]
 fn as_derivative_works() {
 	new_test_ext().execute_with(|| {
@@ -313,7 +305,7 @@ fn batch_with_signed_filters() {
 				Call::Balances(pallet_balances::Call::transfer_keep_alive(2, 1))
 			]),
 		);
-		expect_event(utility::Event::BatchInterrupted(0, DispatchError::BadOrigin));
+		System::assert_last_event(utility::Event::BatchInterrupted(0, DispatchError::BadOrigin).into());
 	});
 }
 
@@ -387,7 +379,7 @@ fn batch_handles_weight_refund() {
 		let info = call.get_dispatch_info();
 		let result = call.dispatch(Origin::signed(1));
 		assert_ok!(result);
-		expect_event(utility::Event::BatchInterrupted(1, DispatchError::Other("")));
+		System::assert_last_event(utility::Event::BatchInterrupted(1, DispatchError::Other("")).into());
 		// No weight is refunded
 		assert_eq!(extract_actual_weight(&result, &info), info.weight);
 
@@ -400,7 +392,7 @@ fn batch_handles_weight_refund() {
 		let info = call.get_dispatch_info();
 		let result = call.dispatch(Origin::signed(1));
 		assert_ok!(result);
-		expect_event(utility::Event::BatchInterrupted(1, DispatchError::Other("")));
+		System::assert_last_event(utility::Event::BatchInterrupted(1, DispatchError::Other("")).into());
 		assert_eq!(extract_actual_weight(&result, &info), info.weight - diff * batch_len);
 
 		// Partial batch completion
@@ -411,7 +403,7 @@ fn batch_handles_weight_refund() {
 		let info = call.get_dispatch_info();
 		let result = call.dispatch(Origin::signed(1));
 		assert_ok!(result);
-		expect_event(utility::Event::BatchInterrupted(1, DispatchError::Other("")));
+		System::assert_last_event(utility::Event::BatchInterrupted(1, DispatchError::Other("")).into());
 		assert_eq!(
 			extract_actual_weight(&result, &info),
 			// Real weight is 2 calls at end_weight