pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-27 12:48:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add Benchmarking Instance to Pallets (#12026)

Browse Source 
* benchmark instance

* add benchmark instance to conviction voting

* instance on bags list

* fmt
This commit is contained in:
Shawn Tabrizi
2022-08-13 16:07:10 +01:00
committed by GitHub
parent 2950340edc
commit e5ed764d39
3 changed files with 266 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/referenda/src/benchmarking.rs
+204 -204
View File
@@ -20,7 +20,7 @@
use super::*;
use crate::Pallet as Referenda;
use assert_matches::assert_matches;
use frame_benchmarking::{account, benchmarks, whitelist_account};
use frame_benchmarking::{account, benchmarks_instance_pallet, whitelist_account};
use frame_support::{
assert_ok,
traits::{Currency, EnsureOrigin},
@@ -31,157 +31,157 @@ use sp_runtime::traits::{Bounded, Hash};
const SEED: u32 = 0;
#[allow(dead_code)]
fn assert_last_event<T: Config>(generic_event: <T as Config>::Event) {
fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::Event) {
frame_system::Pallet::<T>::assert_last_event(generic_event.into());
}
fn funded_account<T: Config>(name: &'static str, index: u32) -> T::AccountId {
fn funded_account<T: Config<I>, I: 'static>(name: &'static str, index: u32) -> T::AccountId {
let caller: T::AccountId = account(name, index, SEED);
T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
caller
}
fn create_referendum<T: Config>() -> (T::AccountId, ReferendumIndex) {
let caller = funded_account::<T>("caller", 0);
fn create_referendum<T: Config<I>, I: 'static>() -> (T::AccountId, ReferendumIndex) {
let caller = funded_account::<T, I>("caller", 0);
whitelist_account!(caller);
assert_ok!(Referenda::<T>::submit(
assert_ok!(Referenda::<T, I>::submit(
RawOrigin::Signed(caller.clone()).into(),
Box::new(RawOrigin::Root.into()),
T::Hashing::hash_of(&0),
DispatchTime::After(0u32.into())
));
let index = ReferendumCount::<T>::get() - 1;
let index = ReferendumCount::<T, I>::get() - 1;
(caller, index)
}
fn place_deposit<T: Config>(index: ReferendumIndex) {
let caller = funded_account::<T>("caller", 0);
fn place_deposit<T: Config<I>, I: 'static>(index: ReferendumIndex) {
let caller = funded_account::<T, I>("caller", 0);
whitelist_account!(caller);
assert_ok!(Referenda::<T>::place_decision_deposit(RawOrigin::Signed(caller).into(), index));
assert_ok!(Referenda::<T, I>::place_decision_deposit(RawOrigin::Signed(caller).into(), index));
}
fn nudge<T: Config>(index: ReferendumIndex) {
assert_ok!(Referenda::<T>::nudge_referendum(RawOrigin::Root.into(), index));
fn nudge<T: Config<I>, I: 'static>(index: ReferendumIndex) {
assert_ok!(Referenda::<T, I>::nudge_referendum(RawOrigin::Root.into(), index));
}
fn fill_queue<T: Config>(
fn fill_queue<T: Config<I>, I: 'static>(
index: ReferendumIndex,
spaces: u32,
pass_after: u32,
) -> Vec<ReferendumIndex> {
// First, create enough other referendums to fill the track.
let mut others = vec![];
for _ in 0..info::<T>(index).max_deciding {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
for _ in 0..info::<T, I>(index).max_deciding {
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
others.push(index);
}
// We will also need enough referenda which are queued and passing, we want `MaxQueued - 1`
// in order to force the maximum amount of work to insert ours into the queue.
for _ in spaces..T::MaxQueued::get() {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
make_passing_after::<T>(index, Perbill::from_percent(pass_after));
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
make_passing_after::<T, I>(index, Perbill::from_percent(pass_after));
others.push(index);
}
// Skip to when they can start being decided.
skip_prepare_period::<T>(index);
skip_prepare_period::<T, I>(index);
// Manually nudge the other referenda first to ensure that they begin.
others.iter().for_each(|&i| nudge::<T>(i));
others.iter().for_each(|&i| nudge::<T, I>(i));
others
}
fn info<T: Config>(index: ReferendumIndex) -> &'static TrackInfoOf<T> {
let status = Referenda::<T>::ensure_ongoing(index).unwrap();
fn info<T: Config<I>, I: 'static>(index: ReferendumIndex) -> &'static TrackInfoOf<T, I> {
let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
T::Tracks::info(status.track).expect("Id value returned from T::Tracks")
}
fn make_passing_after<T: Config>(index: ReferendumIndex, period_portion: Perbill) {
fn make_passing_after<T: Config<I>, I: 'static>(index: ReferendumIndex, period_portion: Perbill) {
// We add an extra 1 percent to handle any perbill rounding errors which may cause
// a proposal to not actually pass.
let support = info::<T>(index)
let support = info::<T, I>(index)
.min_support
.threshold(period_portion)
.saturating_add(Perbill::from_percent(1));
let approval = info::<T>(index)
let approval = info::<T, I>(index)
.min_approval
.threshold(period_portion)
.saturating_add(Perbill::from_percent(1));
Referenda::<T>::access_poll(index, |status| {
Referenda::<T, I>::access_poll(index, |status| {
if let PollStatus::Ongoing(tally, class) = status {
*tally = T::Tally::from_requirements(support, approval, class);
}
});
}
fn make_passing<T: Config>(index: ReferendumIndex) {
Referenda::<T>::access_poll(index, |status| {
fn make_passing<T: Config<I>, I: 'static>(index: ReferendumIndex) {
Referenda::<T, I>::access_poll(index, |status| {
if let PollStatus::Ongoing(tally, class) = status {
*tally = T::Tally::unanimity(class);
}
});
}
fn make_failing<T: Config>(index: ReferendumIndex) {
Referenda::<T>::access_poll(index, |status| {
fn make_failing<T: Config<I>, I: 'static>(index: ReferendumIndex) {
Referenda::<T, I>::access_poll(index, |status| {
if let PollStatus::Ongoing(tally, class) = status {
*tally = T::Tally::rejection(class);
}
});
}
fn skip_prepare_period<T: Config>(index: ReferendumIndex) {
let status = Referenda::<T>::ensure_ongoing(index).unwrap();
let prepare_period_over = status.submitted + info::<T>(index).prepare_period;
fn skip_prepare_period<T: Config<I>, I: 'static>(index: ReferendumIndex) {
let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
let prepare_period_over = status.submitted + info::<T, I>(index).prepare_period;
frame_system::Pallet::<T>::set_block_number(prepare_period_over);
}
fn skip_decision_period<T: Config>(index: ReferendumIndex) {
let status = Referenda::<T>::ensure_ongoing(index).unwrap();
let decision_period_over = status.deciding.unwrap().since + info::<T>(index).decision_period;
fn skip_decision_period<T: Config<I>, I: 'static>(index: ReferendumIndex) {
let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
let decision_period_over = status.deciding.unwrap().since + info::<T, I>(index).decision_period;
frame_system::Pallet::<T>::set_block_number(decision_period_over);
}
fn skip_confirm_period<T: Config>(index: ReferendumIndex) {
let status = Referenda::<T>::ensure_ongoing(index).unwrap();
fn skip_confirm_period<T: Config<I>, I: 'static>(index: ReferendumIndex) {
let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
let confirm_period_over = status.deciding.unwrap().confirming.unwrap();
frame_system::Pallet::<T>::set_block_number(confirm_period_over);
}
fn skip_timeout_period<T: Config>(index: ReferendumIndex) {
let status = Referenda::<T>::ensure_ongoing(index).unwrap();
fn skip_timeout_period<T: Config<I>, I: 'static>(index: ReferendumIndex) {
let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
let timeout_period_over = status.submitted + T::UndecidingTimeout::get();
frame_system::Pallet::<T>::set_block_number(timeout_period_over);
}
fn alarm_time<T: Config>(index: ReferendumIndex) -> T::BlockNumber {
let status = Referenda::<T>::ensure_ongoing(index).unwrap();
fn alarm_time<T: Config<I>, I: 'static>(index: ReferendumIndex) -> T::BlockNumber {
let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
status.alarm.unwrap().0
}
fn is_confirming<T: Config>(index: ReferendumIndex) -> bool {
let status = Referenda::<T>::ensure_ongoing(index).unwrap();
fn is_confirming<T: Config<I>, I: 'static>(index: ReferendumIndex) -> bool {
let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
matches!(
status,
ReferendumStatus { deciding: Some(DecidingStatus { confirming: Some(_), .. }), .. }
)
}
fn is_not_confirming<T: Config>(index: ReferendumIndex) -> bool {
let status = Referenda::<T>::ensure_ongoing(index).unwrap();
fn is_not_confirming<T: Config<I>, I: 'static>(index: ReferendumIndex) -> bool {
let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
matches!(
status,
ReferendumStatus { deciding: Some(DecidingStatus { confirming: None, .. }), .. }
)
}
benchmarks! {
benchmarks_instance_pallet! {
submit {
let caller = funded_account::<T>("caller", 0);
let caller = funded_account::<T, I>("caller", 0);
whitelist_account!(caller);
}: _(
RawOrigin::Signed(caller),
@@ -189,105 +189,105 @@ benchmarks! {
T::Hashing::hash_of(&0),
DispatchTime::After(0u32.into())
) verify {
let index = ReferendumCount::<T>::get().checked_sub(1).unwrap();
assert_matches!(ReferendumInfoFor::<T>::get(index), Some(ReferendumInfo::Ongoing(_)));
let index = ReferendumCount::<T, I>::get().checked_sub(1).unwrap();
assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Ongoing(_)));
}
place_decision_deposit_preparing {
let (caller, index) = create_referendum::<T>();
let (caller, index) = create_referendum::<T, I>();
}: place_decision_deposit(RawOrigin::Signed(caller), index)
verify {
assert!(Referenda::<T>::ensure_ongoing(index).unwrap().decision_deposit.is_some());
assert!(Referenda::<T, I>::ensure_ongoing(index).unwrap().decision_deposit.is_some());
}
place_decision_deposit_queued {
let (caller, index) = create_referendum::<T>();
fill_queue::<T>(index, 1, 90);
let (caller, index) = create_referendum::<T, I>();
fill_queue::<T, I>(index, 1, 90);
}: place_decision_deposit(RawOrigin::Signed(caller), index)
verify {
let track = Referenda::<T>::ensure_ongoing(index).unwrap().track;
assert_eq!(TrackQueue::<T>::get(&track).len() as u32, T::MaxQueued::get());
assert_eq!(TrackQueue::<T>::get(&track)[0], (index, 0u32.into()));
let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
assert_eq!(TrackQueue::<T, I>::get(&track)[0], (index, 0u32.into()));
}
place_decision_deposit_not_queued {
let (caller, index) = create_referendum::<T>();
fill_queue::<T>(index, 0, 90);
let (caller, index) = create_referendum::<T, I>();
fill_queue::<T, I>(index, 0, 90);
}: place_decision_deposit(RawOrigin::Signed(caller), index)
verify {
let track = Referenda::<T>::ensure_ongoing(index).unwrap().track;
assert_eq!(TrackQueue::<T>::get(&track).len() as u32, T::MaxQueued::get());
assert!(TrackQueue::<T>::get(&track).into_iter().all(|(i, _)| i != index));
let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(i, _)| i != index));
}
place_decision_deposit_passing {
let (caller, index) = create_referendum::<T>();
skip_prepare_period::<T>(index);
make_passing::<T>(index);
let (caller, index) = create_referendum::<T, I>();
skip_prepare_period::<T, I>(index);
make_passing::<T, I>(index);
}: place_decision_deposit(RawOrigin::Signed(caller), index)
verify {
assert!(is_confirming::<T>(index));
assert!(is_confirming::<T, I>(index));
}
place_decision_deposit_failing {
let (caller, index) = create_referendum::<T>();
skip_prepare_period::<T>(index);
let (caller, index) = create_referendum::<T, I>();
skip_prepare_period::<T, I>(index);
}: place_decision_deposit(RawOrigin::Signed(caller), index)
verify {
assert!(is_not_confirming::<T>(index));
assert!(is_not_confirming::<T, I>(index));
}
refund_decision_deposit {
let (caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
assert_ok!(Referenda::<T>::cancel(T::CancelOrigin::successful_origin(), index));
let (caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
assert_ok!(Referenda::<T, I>::cancel(T::CancelOrigin::successful_origin(), index));
}: _(RawOrigin::Signed(caller), index)
verify {
assert_matches!(ReferendumInfoFor::<T>::get(index), Some(ReferendumInfo::Cancelled(_, _, None)));
assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Cancelled(_, _, None)));
}
cancel {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
}: _<T::Origin>(T::CancelOrigin::successful_origin(), index)
verify {
assert_matches!(ReferendumInfoFor::<T>::get(index), Some(ReferendumInfo::Cancelled(..)));
assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Cancelled(..)));
}
kill {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
}: _<T::Origin>(T::KillOrigin::successful_origin(), index)
verify {
assert_matches!(ReferendumInfoFor::<T>::get(index), Some(ReferendumInfo::Killed(..)));
assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Killed(..)));
}
one_fewer_deciding_queue_empty {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
skip_prepare_period::<T>(index);
nudge::<T>(index);
let track = Referenda::<T>::ensure_ongoing(index).unwrap().track;
assert_ok!(Referenda::<T>::cancel(T::CancelOrigin::successful_origin(), index));
assert_eq!(DecidingCount::<T>::get(&track), 1);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
skip_prepare_period::<T, I>(index);
nudge::<T, I>(index);
let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
assert_ok!(Referenda::<T, I>::cancel(T::CancelOrigin::successful_origin(), index));
assert_eq!(DecidingCount::<T, I>::get(&track), 1);
}: one_fewer_deciding(RawOrigin::Root, track)
verify {
assert_eq!(DecidingCount::<T>::get(&track), 0);
assert_eq!(DecidingCount::<T, I>::get(&track), 0);
}
one_fewer_deciding_failing {
let (_caller, index) = create_referendum::<T>();
let (_caller, index) = create_referendum::<T, I>();
// No spaces free in the queue.
let queued = fill_queue::<T>(index, 0, 90);
let track = Referenda::<T>::ensure_ongoing(index).unwrap().track;
assert_ok!(Referenda::<T>::cancel(T::CancelOrigin::successful_origin(), queued[0]));
assert_eq!(TrackQueue::<T>::get(&track).len() as u32, T::MaxQueued::get());
let deciding_count = DecidingCount::<T>::get(&track);
let queued = fill_queue::<T, I>(index, 0, 90);
let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
assert_ok!(Referenda::<T, I>::cancel(T::CancelOrigin::successful_origin(), queued[0]));
assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
let deciding_count = DecidingCount::<T, I>::get(&track);
}: one_fewer_deciding(RawOrigin::Root, track)
verify {
assert_eq!(DecidingCount::<T>::get(&track), deciding_count);
assert_eq!(TrackQueue::<T>::get(&track).len() as u32, T::MaxQueued::get() - 1);
assert!(queued.into_iter().skip(1).all(|i| Referenda::<T>::ensure_ongoing(i)
assert_eq!(DecidingCount::<T, I>::get(&track), deciding_count);
assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get() - 1);
assert!(queued.into_iter().skip(1).all(|i| Referenda::<T, I>::ensure_ongoing(i)
.unwrap()
.deciding
.map_or(true, |d| d.confirming.is_none())
@@ -295,18 +295,18 @@ benchmarks! {
}
one_fewer_deciding_passing {
let (_caller, index) = create_referendum::<T>();
let (_caller, index) = create_referendum::<T, I>();
// No spaces free in the queue.
let queued = fill_queue::<T>(index, 0, 0);
let track = Referenda::<T>::ensure_ongoing(index).unwrap().track;
assert_ok!(Referenda::<T>::cancel(T::CancelOrigin::successful_origin(), queued[0]));
assert_eq!(TrackQueue::<T>::get(&track).len() as u32, T::MaxQueued::get());
let deciding_count = DecidingCount::<T>::get(&track);
let queued = fill_queue::<T, I>(index, 0, 0);
let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
assert_ok!(Referenda::<T, I>::cancel(T::CancelOrigin::successful_origin(), queued[0]));
assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
let deciding_count = DecidingCount::<T, I>::get(&track);
}: one_fewer_deciding(RawOrigin::Root, track)
verify {
assert_eq!(DecidingCount::<T>::get(&track), deciding_count);
assert_eq!(TrackQueue::<T>::get(&track).len() as u32, T::MaxQueued::get() - 1);
assert!(queued.into_iter().skip(1).all(|i| Referenda::<T>::ensure_ongoing(i)
assert_eq!(DecidingCount::<T, I>::get(&track), deciding_count);
assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get() - 1);
assert!(queued.into_iter().skip(1).all(|i| Referenda::<T, I>::ensure_ongoing(i)
.unwrap()
.deciding
.map_or(true, |d| d.confirming.is_some())
@@ -315,43 +315,43 @@ benchmarks! {
nudge_referendum_requeued_insertion {
// First create our referendum and place the deposit. It will be failing.
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
fill_queue::<T>(index, 0, 90);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
fill_queue::<T, I>(index, 0, 90);
// Now nudge ours, with the track now full and the queue full of referenda with votes,
// ours will not be in the queue.
nudge::<T>(index);
let track = Referenda::<T>::ensure_ongoing(index).unwrap().track;
assert!(TrackQueue::<T>::get(&track).into_iter().all(|(i, _)| i != index));
nudge::<T, I>(index);
let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(i, _)| i != index));
// Now alter the voting, so that ours goes into pole-position and shifts others down.
make_passing::<T>(index);
make_passing::<T, I>(index);
}: nudge_referendum(RawOrigin::Root, index)
verify {
let t = TrackQueue::<T>::get(&track);
let t = TrackQueue::<T, I>::get(&track);
assert_eq!(t.len() as u32, T::MaxQueued::get());
assert_eq!(t[t.len() - 1].0, index);
}
nudge_referendum_requeued_slide {
// First create our referendum and place the deposit. It will be failing.
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
fill_queue::<T>(index, 1, 90);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
fill_queue::<T, I>(index, 1, 90);
// Now nudge ours, with the track now full, ours will be queued, but with no votes, it
// will have the worst position.
nudge::<T>(index);
let track = Referenda::<T>::ensure_ongoing(index).unwrap().track;
assert_eq!(TrackQueue::<T>::get(&track).len() as u32, T::MaxQueued::get());
assert_eq!(TrackQueue::<T>::get(&track)[0], (index, 0u32.into()));
nudge::<T, I>(index);
let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
assert_eq!(TrackQueue::<T, I>::get(&track)[0], (index, 0u32.into()));
// Now alter the voting, so that ours leap-frogs all into the best position.
make_passing::<T>(index);
make_passing::<T, I>(index);
}: nudge_referendum(RawOrigin::Root, index)
verify {
let t = TrackQueue::<T>::get(&track);
let t = TrackQueue::<T, I>::get(&track);
assert_eq!(t.len() as u32, T::MaxQueued::get());
assert_eq!(t[t.len() - 1].0, index);
}
@@ -362,159 +362,159 @@ benchmarks! {
// insertion at the beginning.
// First create our referendum and place the deposit. It will be failing.
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
fill_queue::<T>(index, 1, 0);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
fill_queue::<T, I>(index, 1, 0);
let track = Referenda::<T>::ensure_ongoing(index).unwrap().track;
assert_eq!(TrackQueue::<T>::get(&track).len() as u32, T::MaxQueued::get() - 1);
assert!(TrackQueue::<T>::get(&track).into_iter().all(|(_, v)| v > 0u32.into()));
let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get() - 1);
assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(_, v)| v > 0u32.into()));
// Then nudge ours, with the track now full, ours will be queued.
}: nudge_referendum(RawOrigin::Root, index)
verify {
assert_eq!(TrackQueue::<T>::get(&track).len() as u32, T::MaxQueued::get());
assert_eq!(TrackQueue::<T>::get(&track)[0], (index, 0u32.into()));
assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
assert_eq!(TrackQueue::<T, I>::get(&track)[0], (index, 0u32.into()));
}
nudge_referendum_not_queued {
// First create our referendum and place the deposit. It will be failing.
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
fill_queue::<T>(index, 0, 0);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
fill_queue::<T, I>(index, 0, 0);
let track = Referenda::<T>::ensure_ongoing(index).unwrap().track;
assert_eq!(TrackQueue::<T>::get(&track).len() as u32, T::MaxQueued::get());
assert!(TrackQueue::<T>::get(&track).into_iter().all(|(_, v)| v > 0u32.into()));
let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(_, v)| v > 0u32.into()));
// Then nudge ours, with the track now full, ours will be queued.
}: nudge_referendum(RawOrigin::Root, index)
verify {
assert_eq!(TrackQueue::<T>::get(&track).len() as u32, T::MaxQueued::get());
assert!(TrackQueue::<T>::get(&track).into_iter().all(|(i, _)| i != index));
assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(i, _)| i != index));
}
nudge_referendum_no_deposit {
let (_caller, index) = create_referendum::<T>();
skip_prepare_period::<T>(index);
let (_caller, index) = create_referendum::<T, I>();
skip_prepare_period::<T, I>(index);
}: nudge_referendum(RawOrigin::Root, index)
verify {
let status = Referenda::<T>::ensure_ongoing(index).unwrap();
let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
assert_matches!(status, ReferendumStatus { deciding: None, .. });
}
nudge_referendum_preparing {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
}: nudge_referendum(RawOrigin::Root, index)
verify {
let status = Referenda::<T>::ensure_ongoing(index).unwrap();
let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
assert_matches!(status, ReferendumStatus { deciding: None, .. });
}
nudge_referendum_timed_out {
let (_caller, index) = create_referendum::<T>();
skip_timeout_period::<T>(index);
let (_caller, index) = create_referendum::<T, I>();
skip_timeout_period::<T, I>(index);
}: nudge_referendum(RawOrigin::Root, index)
verify {
let info = ReferendumInfoFor::<T>::get(index).unwrap();
let info = ReferendumInfoFor::<T, I>::get(index).unwrap();
assert_matches!(info, ReferendumInfo::TimedOut(..));
}
nudge_referendum_begin_deciding_failing {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
skip_prepare_period::<T>(index);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
skip_prepare_period::<T, I>(index);
}: nudge_referendum(RawOrigin::Root, index)
verify {
assert!(is_not_confirming::<T>(index));
assert!(is_not_confirming::<T, I>(index));
}
nudge_referendum_begin_deciding_passing {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
make_passing::<T>(index);
skip_prepare_period::<T>(index);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
make_passing::<T, I>(index);
skip_prepare_period::<T, I>(index);
}: nudge_referendum(RawOrigin::Root, index)
verify {
assert!(is_confirming::<T>(index));
assert!(is_confirming::<T, I>(index));
}
nudge_referendum_begin_confirming {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
skip_prepare_period::<T>(index);
nudge::<T>(index);
assert!(!is_confirming::<T>(index));
make_passing::<T>(index);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
skip_prepare_period::<T, I>(index);
nudge::<T, I>(index);
assert!(!is_confirming::<T, I>(index));
make_passing::<T, I>(index);
}: nudge_referendum(RawOrigin::Root, index)
verify {
assert!(is_confirming::<T>(index));
assert!(is_confirming::<T, I>(index));
}
nudge_referendum_end_confirming {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
skip_prepare_period::<T>(index);
make_passing::<T>(index);
nudge::<T>(index);
assert!(is_confirming::<T>(index));
make_failing::<T>(index);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
skip_prepare_period::<T, I>(index);
make_passing::<T, I>(index);
nudge::<T, I>(index);
assert!(is_confirming::<T, I>(index));
make_failing::<T, I>(index);
}: nudge_referendum(RawOrigin::Root, index)
verify {
assert!(!is_confirming::<T>(index));
assert!(!is_confirming::<T, I>(index));
}
nudge_referendum_continue_not_confirming {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
skip_prepare_period::<T>(index);
nudge::<T>(index);
assert!(!is_confirming::<T>(index));
let old_alarm = alarm_time::<T>(index);
make_passing_after::<T>(index, Perbill::from_percent(50));
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
skip_prepare_period::<T, I>(index);
nudge::<T, I>(index);
assert!(!is_confirming::<T, I>(index));
let old_alarm = alarm_time::<T, I>(index);
make_passing_after::<T, I>(index, Perbill::from_percent(50));
}: nudge_referendum(RawOrigin::Root, index)
verify {
assert_ne!(old_alarm, alarm_time::<T>(index));
assert!(!is_confirming::<T>(index));
assert_ne!(old_alarm, alarm_time::<T, I>(index));
assert!(!is_confirming::<T, I>(index));
}
nudge_referendum_continue_confirming {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
make_passing::<T>(index);
skip_prepare_period::<T>(index);
nudge::<T>(index);
assert!(is_confirming::<T>(index));
let old_alarm = alarm_time::<T>(index);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
make_passing::<T, I>(index);
skip_prepare_period::<T, I>(index);
nudge::<T, I>(index);
assert!(is_confirming::<T, I>(index));
let old_alarm = alarm_time::<T, I>(index);
}: nudge_referendum(RawOrigin::Root, index)
verify {
assert!(is_confirming::<T>(index));
assert!(is_confirming::<T, I>(index));
}
nudge_referendum_approved {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
skip_prepare_period::<T>(index);
make_passing::<T>(index);
nudge::<T>(index);
skip_confirm_period::<T>(index);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
skip_prepare_period::<T, I>(index);
make_passing::<T, I>(index);
nudge::<T, I>(index);
skip_confirm_period::<T, I>(index);
}: nudge_referendum(RawOrigin::Root, index)
verify {
let info = ReferendumInfoFor::<T>::get(index).unwrap();
let info = ReferendumInfoFor::<T, I>::get(index).unwrap();
assert_matches!(info, ReferendumInfo::Approved(..));
}
nudge_referendum_rejected {
let (_caller, index) = create_referendum::<T>();
place_deposit::<T>(index);
skip_prepare_period::<T>(index);
make_failing::<T>(index);
nudge::<T>(index);
skip_decision_period::<T>(index);
let (_caller, index) = create_referendum::<T, I>();
place_deposit::<T, I>(index);
skip_prepare_period::<T, I>(index);
make_failing::<T, I>(index);
nudge::<T, I>(index);
skip_decision_period::<T, I>(index);
}: nudge_referendum(RawOrigin::Root, index)
verify {
let info = ReferendumInfoFor::<T>::get(index).unwrap();
let info = ReferendumInfoFor::<T, I>::get(index).unwrap();
assert_matches!(info, ReferendumInfo::Rejected(..));
}