git.delta.rocks / unique-network / refs/commits / 90587283b7f1

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617// Original license:18// This file is part of Substrate.1920// Copyright (C) 2017-2022 Parity Technologies (UK) Ltd.21// SPDX-License-Identifier: Apache-2.02223// Licensed under the Apache License, Version 2.0 (the "License");24// you may not use this file except in compliance with the License.25// You may obtain a copy of the License at26//27// 	http://www.apache.org/licenses/LICENSE-2.028//29// Unless required by applicable law or agreed to in writing, software30// distributed under the License is distributed on an "AS IS" BASIS,31// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.32// See the License for the specific language governing permissions and33// limitations under the License.3435//! # Scheduler tests.3637use super::*;38use crate::mock::{39	logger, new_test_ext, root, run_to_block, LoggerCall, RuntimeCall, Scheduler, Test, *,40};41use frame_support::{42	assert_noop, assert_ok,43	traits::{Contains, OnInitialize},44};4546#[test]47fn basic_scheduling_works() {48	new_test_ext().execute_with(|| {49		let call = RuntimeCall::Logger(LoggerCall::log {50			i: 42,51			weight: Weight::from_ref_time(10),52		});53		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(54			&call55		));56		assert_ok!(Scheduler::do_schedule(57			DispatchTime::At(4),58			None,59			127,60			root(),61			<ScheduledCall<Test>>::new(call).unwrap(),62		));63		run_to_block(3);64		assert!(logger::log().is_empty());65		run_to_block(4);66		assert_eq!(logger::log(), vec![(root(), 42u32)]);67		run_to_block(100);68		assert_eq!(logger::log(), vec![(root(), 42u32)]);69	});70}7172#[test]73fn schedule_after_works() {74	new_test_ext().execute_with(|| {75		run_to_block(2);76		let call = RuntimeCall::Logger(LoggerCall::log {77			i: 42,78			weight: Weight::from_ref_time(10),79		});80		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(81			&call82		));83		// This will schedule the call 3 blocks after the next block... so block 3 + 3 = 684		assert_ok!(Scheduler::do_schedule(85			DispatchTime::After(3),86			None,87			127,88			root(),89			<ScheduledCall<Test>>::new(call).unwrap(),90		));91		run_to_block(5);92		assert!(logger::log().is_empty());93		run_to_block(6);94		assert_eq!(logger::log(), vec![(root(), 42u32)]);95		run_to_block(100);96		assert_eq!(logger::log(), vec![(root(), 42u32)]);97	});98}99100#[test]101fn schedule_after_zero_works() {102	new_test_ext().execute_with(|| {103		run_to_block(2);104		let call = RuntimeCall::Logger(LoggerCall::log {105			i: 42,106			weight: Weight::from_ref_time(10),107		});108		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(109			&call110		));111		assert_ok!(Scheduler::do_schedule(112			DispatchTime::After(0),113			None,114			127,115			root(),116			<ScheduledCall<Test>>::new(call).unwrap(),117		));118		// Will trigger on the next block.119		run_to_block(3);120		assert_eq!(logger::log(), vec![(root(), 42u32)]);121		run_to_block(100);122		assert_eq!(logger::log(), vec![(root(), 42u32)]);123	});124}125126#[test]127fn periodic_scheduling_works() {128	new_test_ext().execute_with(|| {129		// at #4, every 3 blocks, 3 times.130		assert_ok!(Scheduler::do_schedule(131			DispatchTime::At(4),132			Some((3, 3)),133			127,134			root(),135			<ScheduledCall<Test>>::new(RuntimeCall::Logger(logger::Call::log {136				i: 42,137				weight: Weight::from_ref_time(10)138			}))139			.unwrap()140		));141		run_to_block(3);142		assert!(logger::log().is_empty());143		run_to_block(4);144		assert_eq!(logger::log(), vec![(root(), 42u32)]);145		run_to_block(6);146		assert_eq!(logger::log(), vec![(root(), 42u32)]);147		run_to_block(7);148		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);149		run_to_block(9);150		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);151		run_to_block(10);152		assert_eq!(153			logger::log(),154			vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]155		);156		run_to_block(100);157		assert_eq!(158			logger::log(),159			vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]160		);161	});162}163164#[test]165fn cancel_named_scheduling_works_with_normal_cancel() {166	new_test_ext().execute_with(|| {167		// at #4.168		Scheduler::do_schedule_named(169			[1u8; 32],170			DispatchTime::At(4),171			None,172			127,173			root(),174			<ScheduledCall<Test>>::new(RuntimeCall::Logger(LoggerCall::log {175				i: 69,176				weight: Weight::from_ref_time(10),177			}))178			.unwrap(),179		)180		.unwrap();181		let i = Scheduler::do_schedule(182			DispatchTime::At(4),183			None,184			127,185			root(),186			<ScheduledCall<Test>>::new(RuntimeCall::Logger(LoggerCall::log {187				i: 42,188				weight: Weight::from_ref_time(10),189			}))190			.unwrap(),191		)192		.unwrap();193		run_to_block(3);194		assert!(logger::log().is_empty());195		assert_ok!(Scheduler::do_cancel_named(None, [1u8; 32]));196		assert_ok!(Scheduler::do_cancel(None, i));197		run_to_block(100);198		assert!(logger::log().is_empty());199	});200}201202#[test]203fn cancel_named_periodic_scheduling_works() {204	new_test_ext().execute_with(|| {205		// at #4, every 3 blocks, 3 times.206		Scheduler::do_schedule_named(207			[1u8; 32],208			DispatchTime::At(4),209			Some((3, 3)),210			127,211			root(),212			<ScheduledCall<Test>>::new(RuntimeCall::Logger(LoggerCall::log {213				i: 42,214				weight: Weight::from_ref_time(10),215			}))216			.unwrap(),217		)218		.unwrap();219		// same id results in error.220		assert!(Scheduler::do_schedule_named(221			[1u8; 32],222			DispatchTime::At(4),223			None,224			127,225			root(),226			<ScheduledCall<Test>>::new(RuntimeCall::Logger(LoggerCall::log {227				i: 69,228				weight: Weight::from_ref_time(10)229			}))230			.unwrap(),231		)232		.is_err());233		// different id is ok.234		Scheduler::do_schedule_named(235			[2u8; 32],236			DispatchTime::At(8),237			None,238			127,239			root(),240			<ScheduledCall<Test>>::new(RuntimeCall::Logger(LoggerCall::log {241				i: 69,242				weight: Weight::from_ref_time(10),243			}))244			.unwrap(),245		)246		.unwrap();247		run_to_block(3);248		assert!(logger::log().is_empty());249		run_to_block(4);250		assert_eq!(logger::log(), vec![(root(), 42u32)]);251		run_to_block(6);252		assert_ok!(Scheduler::do_cancel_named(None, [1u8; 32]));253		run_to_block(100);254		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);255	});256}257258#[test]259fn scheduler_respects_weight_limits() {260	let max_weight: Weight = <Test as Config>::MaximumWeight::get();261	new_test_ext().execute_with(|| {262		let call = RuntimeCall::Logger(LoggerCall::log {263			i: 42,264			weight: max_weight / 3 * 2,265		});266		assert_ok!(Scheduler::do_schedule(267			DispatchTime::At(4),268			None,269			127,270			root(),271			<ScheduledCall<Test>>::new(call).unwrap(),272		));273		let call = RuntimeCall::Logger(LoggerCall::log {274			i: 69,275			weight: max_weight / 3 * 2,276		});277		assert_ok!(Scheduler::do_schedule(278			DispatchTime::At(4),279			None,280			127,281			root(),282			<ScheduledCall<Test>>::new(call).unwrap(),283		));284		// 69 and 42 do not fit together285		run_to_block(4);286		assert_eq!(logger::log(), vec![(root(), 42u32)]);287		run_to_block(5);288		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);289	});290}291292/// Permanently overweight calls are not deleted but also not executed.293#[test]294fn scheduler_does_not_delete_permanently_overweight_call() {295	let max_weight: Weight = <Test as Config>::MaximumWeight::get();296	new_test_ext().execute_with(|| {297		let call = RuntimeCall::Logger(LoggerCall::log {298			i: 42,299			weight: max_weight,300		});301		assert_ok!(Scheduler::do_schedule(302			DispatchTime::At(4),303			None,304			127,305			root(),306			<ScheduledCall<Test>>::new(call).unwrap(),307		));308		// Never executes.309		run_to_block(100);310		assert_eq!(logger::log(), vec![]);311312		// Assert the `PermanentlyOverweight` event.313		assert_eq!(314			System::events().last().unwrap().event,315			crate::Event::PermanentlyOverweight {316				task: (4, 0),317				id: None318			}319			.into(),320		);321		// The call is still in the agenda.322		assert!(Agenda::<Test>::get(4)[0].is_some());323	});324}325326#[test]327fn scheduler_handles_periodic_failure() {328	let max_weight: Weight = <Test as Config>::MaximumWeight::get();329	let max_per_block = <Test as Config>::MaxScheduledPerBlock::get();330331	new_test_ext().execute_with(|| {332		let call = RuntimeCall::Logger(LoggerCall::log {333			i: 42,334			weight: (max_weight / 3) * 2,335		});336		let call = <ScheduledCall<Test>>::new(call).unwrap();337338		assert_ok!(Scheduler::do_schedule(339			DispatchTime::At(4),340			Some((4, u32::MAX)),341			127,342			root(),343			call.clone(),344		));345		// Executes 5 times till block 20.346		run_to_block(20);347		assert_eq!(logger::log().len(), 5);348349		// Block 28 will already be full.350		for _ in 0..max_per_block {351			assert_ok!(Scheduler::do_schedule(352				DispatchTime::At(28),353				None,354				120,355				root(),356				call.clone(),357			));358		}359360		// Going to block 24 will emit a `PeriodicFailed` event.361		run_to_block(24);362		assert_eq!(logger::log().len(), 6);363364		assert_eq!(365			System::events().last().unwrap().event,366			crate::Event::PeriodicFailed {367				task: (24, 0),368				id: None369			}370			.into(),371		);372	});373}374375#[test]376fn scheduler_respects_priority_ordering() {377	let max_weight: Weight = <Test as Config>::MaximumWeight::get();378	new_test_ext().execute_with(|| {379		let call = RuntimeCall::Logger(LoggerCall::log {380			i: 42,381			weight: max_weight / 3,382		});383		assert_ok!(Scheduler::do_schedule(384			DispatchTime::At(4),385			None,386			1,387			root(),388			<ScheduledCall<Test>>::new(call).unwrap(),389		));390		let call = RuntimeCall::Logger(LoggerCall::log {391			i: 69,392			weight: max_weight / 3,393		});394		assert_ok!(Scheduler::do_schedule(395			DispatchTime::At(4),396			None,397			0,398			root(),399			<ScheduledCall<Test>>::new(call).unwrap(),400		));401		run_to_block(4);402		assert_eq!(logger::log(), vec![(root(), 69u32), (root(), 42u32)]);403	});404}405406#[test]407fn scheduler_respects_priority_ordering_with_soft_deadlines() {408	new_test_ext().execute_with(|| {409		let max_weight: Weight = <Test as Config>::MaximumWeight::get();410		let call = RuntimeCall::Logger(LoggerCall::log {411			i: 42,412			weight: max_weight / 5 * 2,413		});414		assert_ok!(Scheduler::do_schedule(415			DispatchTime::At(4),416			None,417			255,418			root(),419			<ScheduledCall<Test>>::new(call).unwrap(),420		));421		let call = RuntimeCall::Logger(LoggerCall::log {422			i: 69,423			weight: max_weight / 5 * 2,424		});425		assert_ok!(Scheduler::do_schedule(426			DispatchTime::At(4),427			None,428			127,429			root(),430			<ScheduledCall<Test>>::new(call).unwrap(),431		));432		let call = RuntimeCall::Logger(LoggerCall::log {433			i: 2600,434			weight: max_weight / 5 * 4,435		});436		assert_ok!(Scheduler::do_schedule(437			DispatchTime::At(4),438			None,439			126,440			root(),441			<ScheduledCall<Test>>::new(call).unwrap(),442		));443444		// 2600 does not fit with 69 or 42, but has higher priority, so will go through445		run_to_block(4);446		assert_eq!(logger::log(), vec![(root(), 2600u32)]);447		// 69 and 42 fit together448		run_to_block(5);449		assert_eq!(450			logger::log(),451			vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]452		);453	});454}455456#[test]457fn on_initialize_weight_is_correct() {458	new_test_ext().execute_with(|| {459		let call_weight = Weight::from_ref_time(25);460461		// Named462		let call = RuntimeCall::Logger(LoggerCall::log {463			i: 3,464			weight: call_weight + Weight::from_ref_time(1),465		});466		assert_ok!(Scheduler::do_schedule_named(467			[1u8; 32],468			DispatchTime::At(3),469			None,470			255,471			root(),472			<ScheduledCall<Test>>::new(call).unwrap(),473		));474		let call = RuntimeCall::Logger(LoggerCall::log {475			i: 42,476			weight: call_weight + Weight::from_ref_time(2),477		});478		// Anon Periodic479		assert_ok!(Scheduler::do_schedule(480			DispatchTime::At(2),481			Some((1000, 3)),482			128,483			root(),484			<ScheduledCall<Test>>::new(call).unwrap(),485		));486		let call = RuntimeCall::Logger(LoggerCall::log {487			i: 69,488			weight: call_weight + Weight::from_ref_time(3),489		});490		// Anon491		assert_ok!(Scheduler::do_schedule(492			DispatchTime::At(2),493			None,494			127,495			root(),496			<ScheduledCall<Test>>::new(call).unwrap(),497		));498		// Named Periodic499		let call = RuntimeCall::Logger(LoggerCall::log {500			i: 2600,501			weight: call_weight + Weight::from_ref_time(4),502		});503		assert_ok!(Scheduler::do_schedule_named(504			[2u8; 32],505			DispatchTime::At(1),506			Some((1000, 3)),507			126,508			root(),509			<ScheduledCall<Test>>::new(call).unwrap(),510		));511512		// Will include the named periodic only513		assert_eq!(514			Scheduler::on_initialize(1),515			TestWeightInfo::service_agendas_base()516				+ TestWeightInfo::service_agenda_base(1)517				+ <TestWeightInfo as MarginalWeightInfo>::service_task(None, true, true)518				+ TestWeightInfo::execute_dispatch_unsigned()519				+ call_weight + Weight::from_ref_time(4)520		);521		assert_eq!(IncompleteSince::<Test>::get(), None);522		assert_eq!(logger::log(), vec![(root(), 2600u32)]);523524		// Will include anon and anon periodic525		assert_eq!(526			Scheduler::on_initialize(2),527			TestWeightInfo::service_agendas_base()528				+ TestWeightInfo::service_agenda_base(2)529				+ <TestWeightInfo as MarginalWeightInfo>::service_task(None, false, true)530				+ TestWeightInfo::execute_dispatch_unsigned()531				+ call_weight + Weight::from_ref_time(3)532				+ <TestWeightInfo as MarginalWeightInfo>::service_task(None, false, false)533				+ TestWeightInfo::execute_dispatch_unsigned()534				+ call_weight + Weight::from_ref_time(2)535		);536		assert_eq!(IncompleteSince::<Test>::get(), None);537		assert_eq!(538			logger::log(),539			vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]540		);541542		// Will include named only543		assert_eq!(544			Scheduler::on_initialize(3),545			TestWeightInfo::service_agendas_base()546				+ TestWeightInfo::service_agenda_base(1)547				+ <TestWeightInfo as MarginalWeightInfo>::service_task(None, true, false)548				+ TestWeightInfo::execute_dispatch_unsigned()549				+ call_weight + Weight::from_ref_time(1)550		);551		assert_eq!(IncompleteSince::<Test>::get(), None);552		assert_eq!(553			logger::log(),554			vec![555				(root(), 2600u32),556				(root(), 69u32),557				(root(), 42u32),558				(root(), 3u32)559			]560		);561562		// Will contain none563		let actual_weight = Scheduler::on_initialize(4);564		assert_eq!(565			actual_weight,566			TestWeightInfo::service_agendas_base() + TestWeightInfo::service_agenda_base(0)567		);568	});569}570571#[test]572fn root_calls_works() {573	new_test_ext().execute_with(|| {574		let call = Box::new(RuntimeCall::Logger(LoggerCall::log {575			i: 69,576			weight: Weight::from_ref_time(10),577		}));578		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log {579			i: 42,580			weight: Weight::from_ref_time(10),581		}));582		assert_ok!(Scheduler::schedule_named(583			RuntimeOrigin::root(),584			[1u8; 32],585			4,586			None,587			Some(127),588			call,589		));590		assert_ok!(Scheduler::schedule(591			RuntimeOrigin::root(),592			4,593			None,594			Some(127),595			call2596		));597		run_to_block(3);598		// Scheduled calls are in the agenda.599		assert_eq!(Agenda::<Test>::get(4).len(), 2);600		assert!(logger::log().is_empty());601		assert_ok!(Scheduler::cancel_named(RuntimeOrigin::root(), [1u8; 32]));602		assert_ok!(Scheduler::cancel(RuntimeOrigin::root(), 4, 1));603		// Scheduled calls are made NONE, so should not effect state604		run_to_block(100);605		assert!(logger::log().is_empty());606	});607}608609#[test]610fn fails_to_schedule_task_in_the_past() {611	new_test_ext().execute_with(|| {612		run_to_block(3);613614		let call1 = Box::new(RuntimeCall::Logger(LoggerCall::log {615			i: 69,616			weight: Weight::from_ref_time(10),617		}));618		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log {619			i: 42,620			weight: Weight::from_ref_time(10),621		}));622		let call3 = Box::new(RuntimeCall::Logger(LoggerCall::log {623			i: 42,624			weight: Weight::from_ref_time(10),625		}));626627		assert_noop!(628			Scheduler::schedule_named(RuntimeOrigin::root(), [1u8; 32], 2, None, Some(127), call1),629			Error::<Test>::TargetBlockNumberInPast,630		);631632		assert_noop!(633			Scheduler::schedule(RuntimeOrigin::root(), 2, None, Some(127), call2),634			Error::<Test>::TargetBlockNumberInPast,635		);636637		assert_noop!(638			Scheduler::schedule(RuntimeOrigin::root(), 3, None, Some(127), call3),639			Error::<Test>::TargetBlockNumberInPast,640		);641	});642}643644#[test]645fn should_use_origin() {646	new_test_ext().execute_with(|| {647		let call = Box::new(RuntimeCall::Logger(LoggerCall::log {648			i: 69,649			weight: Weight::from_ref_time(10),650		}));651		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log {652			i: 42,653			weight: Weight::from_ref_time(10),654		}));655		assert_ok!(Scheduler::schedule_named(656			system::RawOrigin::Signed(1).into(),657			[1u8; 32],658			4,659			None,660			None,661			call,662		));663		assert_ok!(Scheduler::schedule(664			system::RawOrigin::Signed(1).into(),665			4,666			None,667			None,668			call2,669		));670		run_to_block(3);671		// Scheduled calls are in the agenda.672		assert_eq!(Agenda::<Test>::get(4).len(), 2);673		assert!(logger::log().is_empty());674		assert_ok!(Scheduler::cancel_named(675			system::RawOrigin::Signed(1).into(),676			[1u8; 32]677		));678		assert_ok!(Scheduler::cancel(system::RawOrigin::Signed(1).into(), 4, 1));679		// Scheduled calls are made NONE, so should not effect state680		run_to_block(100);681		assert!(logger::log().is_empty());682	});683}684685#[test]686fn should_check_origin() {687	new_test_ext().execute_with(|| {688		let call = Box::new(RuntimeCall::Logger(LoggerCall::log {689			i: 69,690			weight: Weight::from_ref_time(10),691		}));692		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log {693			i: 42,694			weight: Weight::from_ref_time(10),695		}));696		assert_noop!(697			Scheduler::schedule_named(698				system::RawOrigin::Signed(2).into(),699				[1u8; 32],700				4,701				None,702				None,703				call704			),705			BadOrigin706		);707		assert_noop!(708			Scheduler::schedule(system::RawOrigin::Signed(2).into(), 4, None, None, call2),709			BadOrigin710		);711	});712}713714#[test]715fn should_check_origin_for_cancel() {716	new_test_ext().execute_with(|| {717		let call = Box::new(RuntimeCall::Logger(LoggerCall::log_without_filter {718			i: 69,719			weight: Weight::from_ref_time(10),720		}));721		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log_without_filter {722			i: 42,723			weight: Weight::from_ref_time(10),724		}));725		assert_ok!(Scheduler::schedule_named(726			system::RawOrigin::Signed(1).into(),727			[1u8; 32],728			4,729			None,730			None,731			call,732		));733		assert_ok!(Scheduler::schedule(734			system::RawOrigin::Signed(1).into(),735			4,736			None,737			None,738			call2,739		));740		run_to_block(3);741		// Scheduled calls are in the agenda.742		assert_eq!(Agenda::<Test>::get(4).len(), 2);743		assert!(logger::log().is_empty());744		assert_noop!(745			Scheduler::cancel_named(system::RawOrigin::Signed(2).into(), [1u8; 32]),746			BadOrigin747		);748		assert_noop!(749			Scheduler::cancel(system::RawOrigin::Signed(2).into(), 4, 1),750			BadOrigin751		);752		assert_noop!(753			Scheduler::cancel_named(system::RawOrigin::Root.into(), [1u8; 32]),754			BadOrigin755		);756		assert_noop!(757			Scheduler::cancel(system::RawOrigin::Root.into(), 4, 1),758			BadOrigin759		);760		run_to_block(5);761		assert_eq!(762			logger::log(),763			vec![764				(system::RawOrigin::Signed(1).into(), 69u32),765				(system::RawOrigin::Signed(1).into(), 42u32)766			]767		);768	});769}770771/// Cancelling a call and then scheduling a second call for the same772/// block results in different addresses.773#[test]774fn schedule_does_not_resuse_addr() {775	new_test_ext().execute_with(|| {776		let call = RuntimeCall::Logger(LoggerCall::log {777			i: 42,778			weight: Weight::from_ref_time(10),779		});780781		// Schedule both calls.782		let addr_1 = Scheduler::do_schedule(783			DispatchTime::At(4),784			None,785			127,786			root(),787			<ScheduledCall<Test>>::new(call.clone()).unwrap(),788		)789		.unwrap();790		// Cancel the call.791		assert_ok!(Scheduler::do_cancel(None, addr_1));792		let addr_2 = Scheduler::do_schedule(793			DispatchTime::At(4),794			None,795			127,796			root(),797			<ScheduledCall<Test>>::new(call).unwrap(),798		)799		.unwrap();800801		// Should not re-use the address.802		assert!(addr_1 != addr_2);803	});804}805806#[test]807fn schedule_agenda_overflows() {808	let max: u32 = <Test as Config>::MaxScheduledPerBlock::get();809810	new_test_ext().execute_with(|| {811		let call = RuntimeCall::Logger(LoggerCall::log {812			i: 42,813			weight: Weight::from_ref_time(10),814		});815		let call = <ScheduledCall<Test>>::new(call).unwrap();816817		// Schedule the maximal number allowed per block.818		for _ in 0..max {819			Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call.clone()).unwrap();820		}821822		// One more time and it errors.823		assert_noop!(824			Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call,),825			<Error<Test>>::AgendaIsExhausted,826		);827828		run_to_block(4);829		// All scheduled calls are executed.830		assert_eq!(logger::log().len() as u32, max);831	});832}833834/// Cancelling and scheduling does not overflow the agenda but fills holes.835#[test]836fn cancel_and_schedule_fills_holes() {837	let max: u32 = <Test as Config>::MaxScheduledPerBlock::get();838	assert!(839		max > 3,840		"This test only makes sense for MaxScheduledPerBlock > 3"841	);842843	new_test_ext().execute_with(|| {844		let call = RuntimeCall::Logger(LoggerCall::log {845			i: 42,846			weight: Weight::from_ref_time(10),847		});848		let call = <ScheduledCall<Test>>::new(call).unwrap();849		let mut addrs = Vec::<_>::default();850851		// Schedule the maximal number allowed per block.852		for _ in 0..max {853			addrs.push(854				Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call.clone())855					.unwrap(),856			);857		}858		// Cancel three of them.859		for addr in addrs.into_iter().take(3) {860			Scheduler::do_cancel(None, addr).unwrap();861		}862		// Schedule three new ones.863		for i in 0..3 {864			let (_block, index) =865				Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call.clone())866					.unwrap();867			assert_eq!(i, index);868		}869870		run_to_block(4);871		// Maximum number of calls are executed.872		assert_eq!(logger::log().len() as u32, max);873	});874}