Add verify block to benchmark tests (#5551)

* Add verify block to benchmarks macro.

* Update all benchmarks.

* Add tests, add params.

* Should panic.

* ups, add closures

* Update tests.rs

* update macro syntax

* Revert benchmark syntax change

* verify only in tests

* Update tests.rs

* Uncomment staking

* Fix tests for benchmark instance

* Add docs

* Update frame/benchmarking/src/lib.rs

* add trace logs to benchmarks

* Verify returns closure

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>

substrate/frame/benchmarking/src/tests.rs

@@ -23,20 +23,28 @@ use codec::Decode;
 use sp_std::prelude::*;
 use sp_runtime::{traits::{BlakeTwo256, IdentityLookup}, testing::{H256, Header}};
 use frame_support::{
-	dispatch::DispatchResult, decl_module, impl_outer_origin, assert_ok, assert_err, ensure
+	dispatch::DispatchResult, decl_module, decl_storage, impl_outer_origin,
+	assert_ok, assert_err, ensure
 };
 use frame_system::{RawOrigin, ensure_signed, ensure_none};
 
+decl_storage! {
+	trait Store for Module<T: Trait> as Test {
+		Value get(fn value): Option<u32>;
+	}
+}
+
 decl_module! {
 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
 		#[weight = frame_support::weights::SimpleDispatchInfo::default()]
-		fn dummy(origin, _n: u32) -> DispatchResult {
+		fn set_value(origin, n: u32) -> DispatchResult {
 			let _sender = ensure_signed(origin)?;
+			Value::put(n);
 			Ok(())
 		}
 
 		#[weight = frame_support::weights::SimpleDispatchInfo::default()]
-		fn other_dummy(origin, _n: u32) -> DispatchResult {
+		fn dummy(origin, _n: u32) -> DispatchResult {
 			let _sender = ensure_none(origin)?;
 			Ok(())
 		}
@@ -98,15 +106,17 @@ benchmarks!{
 		let b in 1 .. 1000 => ();
 	}
 
-	dummy {
+	set_value {
 		let b in ...;
-		let caller = account("caller", 0, 0);
+		let caller = account::<T::AccountId>("caller", 0, 0);
 	}: _ (RawOrigin::Signed(caller), b.into())
+	verify {
+		assert_eq!(Value::get(), Some(b));
+	}
 
 	other_name {
 		let b in ...;
-		let caller = account("caller", 0, 0);
-	}: other_dummy (RawOrigin::Signed(caller), b.into())
+	}: dummy (RawOrigin::None, b.into())
 
 	sort_vector {
 		let x in 1 .. 10000;
@@ -116,24 +126,31 @@ benchmarks!{
 		}
 	}: {
 		m.sort();
+	} verify {
 		ensure!(m[0] == 0, "You forgot to sort!")
 	}
 
-	broken_benchmark {
+	bad_origin {
+		let b in ...;
+		let caller = account::<T::AccountId>("caller", 0, 0);
+	}: dummy (RawOrigin::Signed(caller), b.into())
+
+	bad_verify {
 		let x in 1 .. 10000;
 		let mut m = Vec::<u32>::new();
 		for i in (0..x).rev() {
 			m.push(i);
 		}
-	}: {
+	}: { }
+	verify {
 		ensure!(m[0] == 0, "You forgot to sort!")
 	}
 }
 
 #[test]
 fn benchmarks_macro_works() {
-	// Check benchmark creation for `dummy`.
-	let selected_benchmark = SelectedBenchmark::dummy;
+	// Check benchmark creation for `set_value`.
+	let selected_benchmark = SelectedBenchmark::set_value;
 
 	let components = <SelectedBenchmark as BenchmarkingSetup<Test>>::components(&selected_benchmark);
 	assert_eq!(components, vec![(BenchmarkParameter::b, 1, 1000)]);
@@ -161,7 +178,7 @@ fn benchmarks_macro_rename_works() {
 	).expect("failed to create closure");
 
 	new_test_ext().execute_with(|| {
-		assert_eq!(closure(), Err("Bad origin"));
+		assert_ok!(closure());
 	});
 }
 
@@ -181,11 +198,27 @@ fn benchmarks_macro_works_for_non_dispatchable() {
 }
 
 #[test]
-fn benchmarks_generate_unit_tests() {
+fn benchmarks_macro_verify_works() {
+	// Check postcondition for benchmark `set_value` is valid.
+	let selected_benchmark = SelectedBenchmark::set_value;
+
+	let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::verify(
+		&selected_benchmark,
+		&[(BenchmarkParameter::b, 1)],
+	).expect("failed to create closure");
+
 	new_test_ext().execute_with(|| {
-		assert_ok!(test_benchmark_dummy::<Test>());
-		assert_err!(test_benchmark_other_name::<Test>(), "Bad origin");
-		assert_ok!(test_benchmark_sort_vector::<Test>());
-		assert_err!(test_benchmark_broken_benchmark::<Test>(), "You forgot to sort!");
+		assert_ok!(closure());
+	});
+}
+
+#[test]
+fn benchmarks_generate_unit_tests() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(test_benchmark_set_value::<Test>());
+		assert_ok!(test_benchmark_other_name::<Test>());
+		assert_ok!(test_benchmark_sort_vector::<Test>());
+		assert_err!(test_benchmark_bad_origin::<Test>(), "Bad origin");
+		assert_err!(test_benchmark_bad_verify::<Test>(), "You forgot to sort!");
 	});
 }