referrerpolicy=no-referrer-when-downgrade

pallet_referenda/
benchmarking.rs

1// This file is part of Substrate.
2
3// Copyright (C) Parity Technologies (UK) Ltd.
4// SPDX-License-Identifier: Apache-2.0
5
6// Licensed under the Apache License, Version 2.0 (the "License");
7// you may not use this file except in compliance with the License.
8// You may obtain a copy of the License at
9//
10// 	http://www.apache.org/licenses/LICENSE-2.0
11//
12// Unless required by applicable law or agreed to in writing, software
13// distributed under the License is distributed on an "AS IS" BASIS,
14// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15// See the License for the specific language governing permissions and
16// limitations under the License.
17
18//! Democracy pallet benchmarking.
19
20use super::*;
21use crate::Pallet as Referenda;
22use alloc::{borrow::Cow, vec, vec::Vec};
23use assert_matches::assert_matches;
24use frame_benchmarking::v1::{
25	account, benchmarks_instance_pallet, whitelist_account, BenchmarkError,
26};
27use frame_support::{
28	assert_ok,
29	traits::{Currency, EnsureOrigin, EnsureOriginWithArg, UnfilteredDispatchable},
30};
31use frame_system::RawOrigin;
32use sp_runtime::traits::Bounded as ArithBounded;
33
34const SEED: u32 = 0;
35
36fn set_block_number<T: Config<I>, I: 'static>(n: BlockNumberFor<T, I>) {
37	<T as Config<I>>::BlockNumberProvider::set_block_number(n);
38}
39
40fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
41	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
42}
43
44fn funded_account<T: Config<I>, I: 'static>(name: &'static str, index: u32) -> T::AccountId {
45	let caller: T::AccountId = account(name, index, SEED);
46	T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
47	caller
48}
49
50fn dummy_call<T: Config<I>, I: 'static>() -> BoundedCallOf<T, I> {
51	let inner = frame_system::Call::remark { remark: vec![] };
52	let call = <T as Config<I>>::RuntimeCall::from(inner);
53	T::Preimages::bound(call).unwrap()
54}
55
56fn create_referendum<T: Config<I>, I: 'static>(origin: T::RuntimeOrigin) -> ReferendumIndex {
57	if let Ok(caller) = frame_system::ensure_signed(origin.clone()) {
58		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
59		whitelist_account!(caller);
60	}
61
62	let proposal_origin = Box::new(RawOrigin::Root.into());
63	let proposal = dummy_call::<T, I>();
64	let enactment_moment = DispatchTime::After(0u32.into());
65	let call = crate::Call::<T, I>::submit { proposal_origin, proposal, enactment_moment };
66	assert_ok!(call.dispatch_bypass_filter(origin.clone()));
67	let index = ReferendumCount::<T, I>::get() - 1;
68	index
69}
70
71fn place_deposit<T: Config<I>, I: 'static>(index: ReferendumIndex) {
72	let caller = funded_account::<T, I>("caller", 0);
73	whitelist_account!(caller);
74	assert_ok!(Referenda::<T, I>::place_decision_deposit(RawOrigin::Signed(caller).into(), index));
75}
76
77fn nudge<T: Config<I>, I: 'static>(index: ReferendumIndex) {
78	assert_ok!(Referenda::<T, I>::nudge_referendum(RawOrigin::Root.into(), index));
79}
80
81fn fill_queue<T: Config<I>, I: 'static>(
82	origin: T::RuntimeOrigin,
83	index: ReferendumIndex,
84	spaces: u32,
85	pass_after: u32,
86) -> Vec<ReferendumIndex> {
87	// First, create enough other referendums to fill the track.
88	let mut others = vec![];
89	for _ in 0..info::<T, I>(index).max_deciding {
90		let index = create_referendum::<T, I>(origin.clone());
91		place_deposit::<T, I>(index);
92		others.push(index);
93	}
94
95	// We will also need enough referenda which are queued and passing, we want `MaxQueued - 1`
96	// in order to force the maximum amount of work to insert ours into the queue.
97	for _ in spaces..T::MaxQueued::get() {
98		let index = create_referendum::<T, I>(origin.clone());
99		place_deposit::<T, I>(index);
100		make_passing_after::<T, I>(index, Perbill::from_percent(pass_after));
101		others.push(index);
102	}
103
104	// Skip to when they can start being decided.
105	skip_prepare_period::<T, I>(index);
106
107	// Manually nudge the other referenda first to ensure that they begin.
108	others.iter().for_each(|&i| nudge::<T, I>(i));
109
110	others
111}
112
113fn info<T: Config<I>, I: 'static>(index: ReferendumIndex) -> Cow<'static, TrackInfoOf<T, I>> {
114	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
115	T::Tracks::info(status.track).expect("Id value returned from T::Tracks")
116}
117
118fn make_passing_after<T: Config<I>, I: 'static>(index: ReferendumIndex, period_portion: Perbill) {
119	// We add an extra 1 percent to handle any perbill rounding errors which may cause
120	// a proposal to not actually pass.
121	let support = info::<T, I>(index)
122		.min_support
123		.threshold(period_portion)
124		.saturating_add(Perbill::from_percent(1));
125	let approval = info::<T, I>(index)
126		.min_approval
127		.threshold(period_portion)
128		.saturating_add(Perbill::from_percent(1));
129	Referenda::<T, I>::access_poll(index, |status| {
130		if let PollStatus::Ongoing(tally, class) = status {
131			T::Tally::setup(class, Perbill::from_rational(1u32, 1000u32));
132			*tally = T::Tally::from_requirements(support, approval, class);
133		}
134	});
135}
136
137fn make_passing<T: Config<I>, I: 'static>(index: ReferendumIndex) {
138	Referenda::<T, I>::access_poll(index, |status| {
139		if let PollStatus::Ongoing(tally, class) = status {
140			T::Tally::setup(class, Perbill::from_rational(1u32, 1000u32));
141			*tally = T::Tally::unanimity(class);
142		}
143	});
144}
145
146fn make_failing<T: Config<I>, I: 'static>(index: ReferendumIndex) {
147	Referenda::<T, I>::access_poll(index, |status| {
148		if let PollStatus::Ongoing(tally, class) = status {
149			T::Tally::setup(class, Perbill::from_rational(1u32, 1000u32));
150			*tally = T::Tally::rejection(class);
151		}
152	});
153}
154
155fn skip_prepare_period<T: Config<I>, I: 'static>(index: ReferendumIndex) {
156	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
157	let prepare_period_over = status.submitted + info::<T, I>(index).prepare_period;
158	set_block_number::<T, I>(prepare_period_over);
159}
160
161fn skip_decision_period<T: Config<I>, I: 'static>(index: ReferendumIndex) {
162	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
163	let decision_period_over = status.deciding.unwrap().since + info::<T, I>(index).decision_period;
164	set_block_number::<T, I>(decision_period_over);
165}
166
167fn skip_confirm_period<T: Config<I>, I: 'static>(index: ReferendumIndex) {
168	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
169	let confirm_period_over = status.deciding.unwrap().confirming.unwrap();
170	set_block_number::<T, I>(confirm_period_over);
171}
172
173fn skip_timeout_period<T: Config<I>, I: 'static>(index: ReferendumIndex) {
174	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
175	let timeout_period_over = status.submitted + T::UndecidingTimeout::get();
176	set_block_number::<T, I>(timeout_period_over);
177}
178
179fn alarm_time<T: Config<I>, I: 'static>(index: ReferendumIndex) -> BlockNumberFor<T, I> {
180	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
181	status.alarm.unwrap().0
182}
183
184fn is_confirming<T: Config<I>, I: 'static>(index: ReferendumIndex) -> bool {
185	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
186	matches!(
187		status,
188		ReferendumStatus { deciding: Some(DecidingStatus { confirming: Some(_), .. }), .. }
189	)
190}
191
192fn is_not_confirming<T: Config<I>, I: 'static>(index: ReferendumIndex) -> bool {
193	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
194	matches!(
195		status,
196		ReferendumStatus { deciding: Some(DecidingStatus { confirming: None, .. }), .. }
197	)
198}
199
200benchmarks_instance_pallet! {
201	submit {
202		let origin =
203			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
204		if let Ok(caller) = frame_system::ensure_signed(origin.clone()) {
205			T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
206			whitelist_account!(caller);
207		}
208	}: _<T::RuntimeOrigin>(
209		origin,
210		Box::new(RawOrigin::Root.into()),
211		dummy_call::<T, I>(),
212		DispatchTime::After(0u32.into())
213	) verify {
214		let index = ReferendumCount::<T, I>::get().checked_sub(1).unwrap();
215		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Ongoing(_)));
216	}
217
218	place_decision_deposit_preparing {
219		let origin =
220			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
221		let index = create_referendum::<T, I>(origin.clone());
222	}: place_decision_deposit<T::RuntimeOrigin>(origin, index)
223	verify {
224		assert!(Referenda::<T, I>::ensure_ongoing(index).unwrap().decision_deposit.is_some());
225	}
226
227	place_decision_deposit_queued {
228		let origin =
229			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
230		let index = create_referendum::<T, I>(origin.clone());
231		fill_queue::<T, I>(origin.clone(), index, 1, 90);
232	}: place_decision_deposit<T::RuntimeOrigin>(origin, index)
233	verify {
234		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
235		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
236		assert!(TrackQueue::<T, I>::get(&track).contains(&(index, 0u32.into())));
237	}
238
239	place_decision_deposit_not_queued {
240		let origin =
241			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
242		let index = create_referendum::<T, I>(origin.clone());
243		fill_queue::<T, I>(origin.clone(), index, 0, 90);
244		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
245		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
246		assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(i, _)| i != index));
247	}: place_decision_deposit<T::RuntimeOrigin>(origin, index)
248	verify {
249		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
250		assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(i, _)| i != index));
251	}
252
253	place_decision_deposit_passing {
254		let origin =
255			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
256		let index = create_referendum::<T, I>(origin.clone());
257		skip_prepare_period::<T, I>(index);
258		make_passing::<T, I>(index);
259	}: place_decision_deposit<T::RuntimeOrigin>(origin, index)
260	verify {
261		assert!(is_confirming::<T, I>(index));
262	}
263
264	place_decision_deposit_failing {
265		let origin =
266			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
267		let index = create_referendum::<T, I>(origin.clone());
268		skip_prepare_period::<T, I>(index);
269	}: place_decision_deposit<T::RuntimeOrigin>(origin, index)
270	verify {
271		assert!(is_not_confirming::<T, I>(index));
272	}
273
274	refund_decision_deposit {
275		let origin =
276			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
277		let index = create_referendum::<T, I>(origin.clone());
278		place_deposit::<T, I>(index);
279		assert_ok!(Referenda::<T, I>::cancel(
280			T::CancelOrigin::try_successful_origin()
281				.expect("CancelOrigin has no successful origin required for the benchmark"),
282			index,
283		));
284	}: _<T::RuntimeOrigin>(origin, index)
285	verify {
286		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Cancelled(_, _, None)));
287	}
288
289	refund_submission_deposit {
290		let origin =
291			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
292		let index = create_referendum::<T, I>(origin.clone());
293		let caller = frame_system::ensure_signed(origin.clone()).unwrap();
294		let balance = T::Currency::free_balance(&caller);
295		assert_ok!(Referenda::<T, I>::cancel(
296			T::CancelOrigin::try_successful_origin()
297				.expect("CancelOrigin has no successful origin required for the benchmark"),
298			index,
299		));
300		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Cancelled(_, Some(_), _)));
301	}: _<T::RuntimeOrigin>(origin, index)
302	verify {
303		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Cancelled(_, None, _)));
304		let new_balance = T::Currency::free_balance(&caller);
305		// the deposit is zero or make sure it was unreserved.
306		assert!(T::SubmissionDeposit::get().is_zero() || new_balance > balance);
307	}
308
309	slash_submission_deposit {
310		let origin =
311			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
312		let index = create_referendum::<T, I>(origin.clone());
313		place_deposit::<T, I>(index);
314		skip_prepare_period::<T, I>(index);
315		make_failing::<T, I>(index);
316		nudge::<T, I>(index);
317		skip_decision_period::<T, I>(index);
318		nudge::<T, I>(index);
319		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Rejected(_, Some(_), _)));
320	}: _<T::RuntimeOrigin>(origin, index)
321	verify {
322		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Rejected(_, None, _)));
323	}
324
325	cancel {
326		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
327			.expect("SubmitOrigin has no successful origin required for the benchmark");
328		let index = create_referendum::<T, I>(origin);
329		place_deposit::<T, I>(index);
330	}: _<T::RuntimeOrigin>(
331		T::CancelOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
332		index
333	) verify {
334		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Cancelled(..)));
335	}
336
337	kill {
338		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
339			.expect("SubmitOrigin has no successful origin required for the benchmark");
340		let index = create_referendum::<T, I>(origin);
341		place_deposit::<T, I>(index);
342	}: _<T::RuntimeOrigin>(
343		T::KillOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
344		index
345	) verify {
346		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Killed(..)));
347	}
348
349	one_fewer_deciding_queue_empty {
350		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
351			.expect("SubmitOrigin has no successful origin required for the benchmark");
352		let index = create_referendum::<T, I>(origin);
353		place_deposit::<T, I>(index);
354		skip_prepare_period::<T, I>(index);
355		nudge::<T, I>(index);
356		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
357		assert_ok!(Referenda::<T, I>::cancel(
358			T::CancelOrigin::try_successful_origin()
359				.expect("CancelOrigin has no successful origin required for the benchmark"),
360			index,
361		));
362		assert_eq!(DecidingCount::<T, I>::get(&track), 1);
363	}: one_fewer_deciding(RawOrigin::Root, track)
364	verify {
365		assert_eq!(DecidingCount::<T, I>::get(&track), 0);
366	}
367
368	one_fewer_deciding_failing {
369		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
370			.expect("SubmitOrigin has no successful origin required for the benchmark");
371		let index = create_referendum::<T, I>(origin.clone());
372		// No spaces free in the queue.
373		let queued = fill_queue::<T, I>(origin, index, 0, 90);
374		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
375		assert_ok!(Referenda::<T, I>::cancel(
376			T::CancelOrigin::try_successful_origin()
377				.expect("CancelOrigin has no successful origin required for the benchmark"),
378			queued[0],
379		));
380		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
381		let deciding_count = DecidingCount::<T, I>::get(&track);
382	}: one_fewer_deciding(RawOrigin::Root, track)
383	verify {
384		assert_eq!(DecidingCount::<T, I>::get(&track), deciding_count);
385		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get() - 1);
386		assert!(queued.into_iter().skip(1).all(|i| Referenda::<T, I>::ensure_ongoing(i)
387			.unwrap()
388			.deciding
389			.map_or(true, |d| d.confirming.is_none())
390		));
391	}
392
393	one_fewer_deciding_passing {
394		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
395			.expect("SubmitOrigin has no successful origin required for the benchmark");
396		let index = create_referendum::<T, I>(origin.clone());
397		// No spaces free in the queue.
398		let queued = fill_queue::<T, I>(origin, index, 0, 0);
399		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
400		assert_ok!(Referenda::<T, I>::cancel(
401			T::CancelOrigin::try_successful_origin()
402				.expect("CancelOrigin has no successful origin required for the benchmark"),
403			queued[0],
404		));
405		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
406		let deciding_count = DecidingCount::<T, I>::get(&track);
407	}: one_fewer_deciding(RawOrigin::Root, track)
408	verify {
409		assert_eq!(DecidingCount::<T, I>::get(&track), deciding_count);
410		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get() - 1);
411		assert!(queued.into_iter().skip(1).filter(|i| Referenda::<T, I>::ensure_ongoing(*i)
412			.unwrap()
413			.deciding
414			.map_or(false, |d| d.confirming.is_some())
415		).count() == 1);
416	}
417
418	nudge_referendum_requeued_insertion {
419		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
420			.expect("SubmitOrigin has no successful origin required for the benchmark");
421		// First create our referendum and place the deposit. It will be failing.
422		let index = create_referendum::<T, I>(origin.clone());
423		place_deposit::<T, I>(index);
424		fill_queue::<T, I>(origin, index, 0, 90);
425
426		// Now nudge ours, with the track now full and the queue full of referenda with votes,
427		// ours will not be in the queue.
428		nudge::<T, I>(index);
429		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
430		assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(i, _)| i != index));
431
432		// Now alter the voting, so that ours goes into pole-position and shifts others down.
433		make_passing::<T, I>(index);
434	}: nudge_referendum(RawOrigin::Root, index)
435	verify {
436		let t = TrackQueue::<T, I>::get(&track);
437		assert_eq!(t.len() as u32, T::MaxQueued::get());
438		assert_eq!(t[t.len() - 1].0, index);
439	}
440
441	nudge_referendum_requeued_slide {
442		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
443			.expect("SubmitOrigin has no successful origin required for the benchmark");
444		// First create our referendum and place the deposit. It will be failing.
445		let index = create_referendum::<T, I>(origin.clone());
446		place_deposit::<T, I>(index);
447		fill_queue::<T, I>(origin, index, 1, 90);
448
449		// Now nudge ours, with the track now full, ours will be queued, but with no votes, it
450		// will have the worst position.
451		nudge::<T, I>(index);
452		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
453		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
454		assert_eq!(TrackQueue::<T, I>::get(&track)[0], (index, 0u32.into()));
455
456		// Now alter the voting, so that ours leap-frogs all into the best position.
457		make_passing::<T, I>(index);
458	}: nudge_referendum(RawOrigin::Root, index)
459	verify {
460		let t = TrackQueue::<T, I>::get(&track);
461		assert_eq!(t.len() as u32, T::MaxQueued::get());
462		assert_eq!(t[t.len() - 1].0, index);
463	}
464
465	nudge_referendum_queued {
466		// NOTE: worst possible queue situation is with a queue full of passing refs with one slot
467		// free and this failing. It would result in `QUEUE_SIZE - 1` items being shifted for the
468		// insertion at the beginning.
469
470		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
471			.expect("SubmitOrigin has no successful origin required for the benchmark");
472		// First create our referendum and place the deposit. It will be failing.
473		let index = create_referendum::<T, I>(origin.clone());
474		place_deposit::<T, I>(index);
475		fill_queue::<T, I>(origin, index, 1, 0);
476
477		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
478		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get() - 1);
479		assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(_, v)| v > 0u32.into()));
480
481		// Then nudge ours, with the track now full, ours will be queued.
482	}: nudge_referendum(RawOrigin::Root, index)
483	verify {
484		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
485		assert_eq!(TrackQueue::<T, I>::get(&track)[0], (index, 0u32.into()));
486	}
487
488	nudge_referendum_not_queued {
489		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
490			.expect("SubmitOrigin has no successful origin required for the benchmark");
491		// First create our referendum and place the deposit. It will be failing.
492		let index = create_referendum::<T, I>(origin.clone());
493		place_deposit::<T, I>(index);
494		fill_queue::<T, I>(origin, index, 0, 0);
495
496		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
497		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
498		assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(_, v)| v > 0u32.into()));
499
500		// Then nudge ours, with the track now full, ours will be queued.
501	}: nudge_referendum(RawOrigin::Root, index)
502	verify {
503		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
504		assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(i, _)| i != index));
505	}
506
507	nudge_referendum_no_deposit {
508		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
509			.expect("SubmitOrigin has no successful origin required for the benchmark");
510		let index = create_referendum::<T, I>(origin);
511		skip_prepare_period::<T, I>(index);
512	}: nudge_referendum(RawOrigin::Root, index)
513	verify {
514		let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
515		assert_matches!(status, ReferendumStatus { deciding: None, .. });
516	}
517
518	nudge_referendum_preparing {
519		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
520			.expect("SubmitOrigin has no successful origin required for the benchmark");
521		let index = create_referendum::<T, I>(origin);
522		place_deposit::<T, I>(index);
523	}: nudge_referendum(RawOrigin::Root, index)
524	verify {
525		let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
526		assert_matches!(status, ReferendumStatus { deciding: None, .. });
527	}
528
529	nudge_referendum_timed_out {
530		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
531			.expect("SubmitOrigin has no successful origin required for the benchmark");
532		let index = create_referendum::<T, I>(origin);
533		skip_timeout_period::<T, I>(index);
534	}: nudge_referendum(RawOrigin::Root, index)
535	verify {
536		let info = ReferendumInfoFor::<T, I>::get(index).unwrap();
537		assert_matches!(info, ReferendumInfo::TimedOut(..));
538	}
539
540	nudge_referendum_begin_deciding_failing {
541		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
542			.expect("SubmitOrigin has no successful origin required for the benchmark");
543		let index = create_referendum::<T, I>(origin);
544		place_deposit::<T, I>(index);
545		skip_prepare_period::<T, I>(index);
546	}: nudge_referendum(RawOrigin::Root, index)
547	verify {
548		assert!(is_not_confirming::<T, I>(index));
549	}
550
551	nudge_referendum_begin_deciding_passing {
552		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
553			.expect("SubmitOrigin has no successful origin required for the benchmark");
554		let index = create_referendum::<T, I>(origin);
555		place_deposit::<T, I>(index);
556		make_passing::<T, I>(index);
557		skip_prepare_period::<T, I>(index);
558	}: nudge_referendum(RawOrigin::Root, index)
559	verify {
560		assert!(is_confirming::<T, I>(index));
561	}
562
563	nudge_referendum_begin_confirming {
564		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
565			.expect("SubmitOrigin has no successful origin required for the benchmark");
566		let index = create_referendum::<T, I>(origin);
567		place_deposit::<T, I>(index);
568		skip_prepare_period::<T, I>(index);
569		nudge::<T, I>(index);
570		assert!(!is_confirming::<T, I>(index));
571		make_passing::<T, I>(index);
572	}: nudge_referendum(RawOrigin::Root, index)
573	verify {
574		assert!(is_confirming::<T, I>(index));
575	}
576
577	nudge_referendum_end_confirming {
578		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
579			.expect("SubmitOrigin has no successful origin required for the benchmark");
580		let index = create_referendum::<T, I>(origin);
581		place_deposit::<T, I>(index);
582		skip_prepare_period::<T, I>(index);
583		make_passing::<T, I>(index);
584		nudge::<T, I>(index);
585		assert!(is_confirming::<T, I>(index));
586		make_failing::<T, I>(index);
587	}: nudge_referendum(RawOrigin::Root, index)
588	verify {
589		assert!(!is_confirming::<T, I>(index));
590	}
591
592	nudge_referendum_continue_not_confirming {
593		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
594			.expect("SubmitOrigin has no successful origin required for the benchmark");
595		let index = create_referendum::<T, I>(origin);
596		place_deposit::<T, I>(index);
597		skip_prepare_period::<T, I>(index);
598		nudge::<T, I>(index);
599		assert!(!is_confirming::<T, I>(index));
600		let old_alarm = alarm_time::<T, I>(index);
601		make_passing_after::<T, I>(index, Perbill::from_percent(50));
602	}: nudge_referendum(RawOrigin::Root, index)
603	verify {
604		assert_ne!(old_alarm, alarm_time::<T, I>(index));
605		assert!(!is_confirming::<T, I>(index));
606	}
607
608	nudge_referendum_continue_confirming {
609		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
610			.expect("SubmitOrigin has no successful origin required for the benchmark");
611		let index = create_referendum::<T, I>(origin);
612		place_deposit::<T, I>(index);
613		make_passing::<T, I>(index);
614		skip_prepare_period::<T, I>(index);
615		nudge::<T, I>(index);
616		assert!(is_confirming::<T, I>(index));
617		let old_alarm = alarm_time::<T, I>(index);
618	}: nudge_referendum(RawOrigin::Root, index)
619	verify {
620		assert!(is_confirming::<T, I>(index));
621	}
622
623	nudge_referendum_approved {
624		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
625			.expect("SubmitOrigin has no successful origin required for the benchmark");
626		let index = create_referendum::<T, I>(origin);
627		place_deposit::<T, I>(index);
628		skip_prepare_period::<T, I>(index);
629		make_passing::<T, I>(index);
630		nudge::<T, I>(index);
631		skip_confirm_period::<T, I>(index);
632	}: nudge_referendum(RawOrigin::Root, index)
633	verify {
634		let info = ReferendumInfoFor::<T, I>::get(index).unwrap();
635		assert_matches!(info, ReferendumInfo::Approved(..));
636	}
637
638	nudge_referendum_rejected {
639		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
640			.expect("SubmitOrigin has no successful origin required for the benchmark");
641		let index = create_referendum::<T, I>(origin);
642		place_deposit::<T, I>(index);
643		skip_prepare_period::<T, I>(index);
644		make_failing::<T, I>(index);
645		nudge::<T, I>(index);
646		skip_decision_period::<T, I>(index);
647	}: nudge_referendum(RawOrigin::Root, index)
648	verify {
649		let info = ReferendumInfoFor::<T, I>::get(index).unwrap();
650		assert_matches!(info, ReferendumInfo::Rejected(..));
651	}
652
653	set_some_metadata {
654		use alloc::borrow::Cow;
655		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
656			.expect("SubmitOrigin has no successful origin required for the benchmark");
657		let index = create_referendum::<T, I>(origin.clone());
658		let hash = T::Preimages::note(Cow::from(vec![5, 6])).unwrap();
659	}: set_metadata<T::RuntimeOrigin>(origin, index, Some(hash))
660	verify {
661		assert_last_event::<T, I>(Event::MetadataSet { index, hash }.into());
662	}
663
664	clear_metadata {
665		use alloc::borrow::Cow;
666		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
667			.expect("SubmitOrigin has no successful origin required for the benchmark");
668		let index = create_referendum::<T, I>(origin.clone());
669		let hash = T::Preimages::note(Cow::from(vec![6, 7, 8])).unwrap();
670		assert_ok!(
671			Referenda::<T, I>::set_metadata(origin.clone(), index, Some(hash))
672		);
673	}: set_metadata<T::RuntimeOrigin>(origin, index, None)
674	verify {
675		assert_last_event::<T, I>(Event::MetadataCleared { index, hash }.into());
676	}
677
678	impl_benchmark_test_suite!(
679		Referenda,
680		crate::mock::ExtBuilder::default().build(),
681		crate::mock::Test
682	);
683}