1use 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 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 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_prepare_period::<T, I>(index);
106
107 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 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 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 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 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 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 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 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 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 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 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 let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
471 .expect("SubmitOrigin has no successful origin required for the benchmark");
472 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 }: 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 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 }: 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}