git.delta.rocks / unique-network / refs/commits / 27949a33bc9d

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}, assert_err,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).agenda[0].is_some());323	});324}325326#[test]327fn scheduler_periodic_tasks_always_find_place() {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		run_to_block(24);361		assert_eq!(logger::log().len(), 6);362363		// The periodic task should be postponed364		assert_eq!(<Agenda<Test>>::get(29).agenda.len(), 1);365366		run_to_block(27); // will call on_initialize(28)367		assert_eq!(logger::log().len(), 6);368369		run_to_block(28); // will call on_initialize(29)370		assert_eq!(logger::log().len(), 7);371	});372}373374#[test]375fn scheduler_respects_priority_ordering() {376	let max_weight: Weight = <Test as Config>::MaximumWeight::get();377	new_test_ext().execute_with(|| {378		let call = RuntimeCall::Logger(LoggerCall::log {379			i: 42,380			weight: max_weight / 3,381		});382		assert_ok!(Scheduler::do_schedule(383			DispatchTime::At(4),384			None,385			1,386			root(),387			<ScheduledCall<Test>>::new(call).unwrap(),388		));389		let call = RuntimeCall::Logger(LoggerCall::log {390			i: 69,391			weight: max_weight / 3,392		});393		assert_ok!(Scheduler::do_schedule(394			DispatchTime::At(4),395			None,396			0,397			root(),398			<ScheduledCall<Test>>::new(call).unwrap(),399		));400		run_to_block(4);401		assert_eq!(logger::log(), vec![(root(), 69u32), (root(), 42u32)]);402	});403}404405#[test]406fn scheduler_respects_priority_ordering_with_soft_deadlines() {407	new_test_ext().execute_with(|| {408		let max_weight: Weight = <Test as Config>::MaximumWeight::get();409		let call = RuntimeCall::Logger(LoggerCall::log {410			i: 42,411			weight: max_weight / 5 * 2,412		});413		assert_ok!(Scheduler::do_schedule(414			DispatchTime::At(4),415			None,416			255,417			root(),418			<ScheduledCall<Test>>::new(call).unwrap(),419		));420		let call = RuntimeCall::Logger(LoggerCall::log {421			i: 69,422			weight: max_weight / 5 * 2,423		});424		assert_ok!(Scheduler::do_schedule(425			DispatchTime::At(4),426			None,427			127,428			root(),429			<ScheduledCall<Test>>::new(call).unwrap(),430		));431		let call = RuntimeCall::Logger(LoggerCall::log {432			i: 2600,433			weight: max_weight / 5 * 4,434		});435		assert_ok!(Scheduler::do_schedule(436			DispatchTime::At(4),437			None,438			126,439			root(),440			<ScheduledCall<Test>>::new(call).unwrap(),441		));442443		// 2600 does not fit with 69 or 42, but has higher priority, so will go through444		run_to_block(4);445		assert_eq!(logger::log(), vec![(root(), 2600u32)]);446		// 69 and 42 fit together447		run_to_block(5);448		assert_eq!(449			logger::log(),450			vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]451		);452	});453}454455#[test]456fn on_initialize_weight_is_correct() {457	new_test_ext().execute_with(|| {458		let call_weight = Weight::from_ref_time(25);459460		// Named461		let call = RuntimeCall::Logger(LoggerCall::log {462			i: 3,463			weight: call_weight + Weight::from_ref_time(1),464		});465		assert_ok!(Scheduler::do_schedule_named(466			[1u8; 32],467			DispatchTime::At(3),468			None,469			255,470			root(),471			<ScheduledCall<Test>>::new(call).unwrap(),472		));473		let call = RuntimeCall::Logger(LoggerCall::log {474			i: 42,475			weight: call_weight + Weight::from_ref_time(2),476		});477		// Anon Periodic478		assert_ok!(Scheduler::do_schedule(479			DispatchTime::At(2),480			Some((1000, 3)),481			128,482			root(),483			<ScheduledCall<Test>>::new(call).unwrap(),484		));485		let call = RuntimeCall::Logger(LoggerCall::log {486			i: 69,487			weight: call_weight + Weight::from_ref_time(3),488		});489		// Anon490		assert_ok!(Scheduler::do_schedule(491			DispatchTime::At(2),492			None,493			127,494			root(),495			<ScheduledCall<Test>>::new(call).unwrap(),496		));497		// Named Periodic498		let call = RuntimeCall::Logger(LoggerCall::log {499			i: 2600,500			weight: call_weight + Weight::from_ref_time(4),501		});502		assert_ok!(Scheduler::do_schedule_named(503			[2u8; 32],504			DispatchTime::At(1),505			Some((1000, 3)),506			126,507			root(),508			<ScheduledCall<Test>>::new(call).unwrap(),509		));510511		// Will include the named periodic only512		assert_eq!(513			Scheduler::on_initialize(1),514			TestWeightInfo::service_agendas_base()515				+ TestWeightInfo::service_agenda_base(1)516				+ <TestWeightInfo as MarginalWeightInfo>::service_task(None, true, true)517				+ TestWeightInfo::execute_dispatch_unsigned()518				+ call_weight + Weight::from_ref_time(4)519		);520		assert_eq!(IncompleteSince::<Test>::get(), None);521		assert_eq!(logger::log(), vec![(root(), 2600u32)]);522523		// Will include anon and anon periodic524		assert_eq!(525			Scheduler::on_initialize(2),526			TestWeightInfo::service_agendas_base()527				+ TestWeightInfo::service_agenda_base(2)528				+ <TestWeightInfo as MarginalWeightInfo>::service_task(None, false, true)529				+ TestWeightInfo::execute_dispatch_unsigned()530				+ call_weight + Weight::from_ref_time(3)531				+ <TestWeightInfo as MarginalWeightInfo>::service_task(None, false, false)532				+ TestWeightInfo::execute_dispatch_unsigned()533				+ call_weight + Weight::from_ref_time(2)534		);535		assert_eq!(IncompleteSince::<Test>::get(), None);536		assert_eq!(537			logger::log(),538			vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]539		);540541		// Will include named only542		assert_eq!(543			Scheduler::on_initialize(3),544			TestWeightInfo::service_agendas_base()545				+ TestWeightInfo::service_agenda_base(1)546				+ <TestWeightInfo as MarginalWeightInfo>::service_task(None, true, false)547				+ TestWeightInfo::execute_dispatch_unsigned()548				+ call_weight + Weight::from_ref_time(1)549		);550		assert_eq!(IncompleteSince::<Test>::get(), None);551		assert_eq!(552			logger::log(),553			vec![554				(root(), 2600u32),555				(root(), 69u32),556				(root(), 42u32),557				(root(), 3u32)558			]559		);560561		// Will contain none562		let actual_weight = Scheduler::on_initialize(4);563		assert_eq!(564			actual_weight,565			TestWeightInfo::service_agendas_base() + TestWeightInfo::service_agenda_base(0)566		);567	});568}569570#[test]571fn root_calls_works() {572	new_test_ext().execute_with(|| {573		let call = Box::new(RuntimeCall::Logger(LoggerCall::log {574			i: 69,575			weight: Weight::from_ref_time(10),576		}));577		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log {578			i: 42,579			weight: Weight::from_ref_time(10),580		}));581		assert_ok!(Scheduler::schedule_named(582			RuntimeOrigin::root(),583			[1u8; 32],584			4,585			None,586			Some(127),587			call,588		));589		assert_ok!(Scheduler::schedule(590			RuntimeOrigin::root(),591			4,592			None,593			Some(127),594			call2595		));596		run_to_block(3);597		// Scheduled calls are in the agenda.598		assert_eq!(Agenda::<Test>::get(4).agenda.len(), 2);599		assert!(logger::log().is_empty());600		assert_ok!(Scheduler::cancel_named(RuntimeOrigin::root(), [1u8; 32]));601		assert_ok!(Scheduler::cancel(RuntimeOrigin::root(), 4, 1));602		// Scheduled calls are made NONE, so should not effect state603		run_to_block(100);604		assert!(logger::log().is_empty());605	});606}607608#[test]609fn fails_to_schedule_task_in_the_past() {610	new_test_ext().execute_with(|| {611		run_to_block(3);612613		let call1 = Box::new(RuntimeCall::Logger(LoggerCall::log {614			i: 69,615			weight: Weight::from_ref_time(10),616		}));617		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log {618			i: 42,619			weight: Weight::from_ref_time(10),620		}));621		let call3 = Box::new(RuntimeCall::Logger(LoggerCall::log {622			i: 42,623			weight: Weight::from_ref_time(10),624		}));625626		assert_noop!(627			Scheduler::schedule_named(RuntimeOrigin::root(), [1u8; 32], 2, None, Some(127), call1),628			Error::<Test>::TargetBlockNumberInPast,629		);630631		assert_noop!(632			Scheduler::schedule(RuntimeOrigin::root(), 2, None, Some(127), call2),633			Error::<Test>::TargetBlockNumberInPast,634		);635636		assert_noop!(637			Scheduler::schedule(RuntimeOrigin::root(), 3, None, Some(127), call3),638			Error::<Test>::TargetBlockNumberInPast,639		);640	});641}642643#[test]644fn should_use_origin() {645	new_test_ext().execute_with(|| {646		let call = Box::new(RuntimeCall::Logger(LoggerCall::log {647			i: 69,648			weight: Weight::from_ref_time(10),649		}));650		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log {651			i: 42,652			weight: Weight::from_ref_time(10),653		}));654		assert_ok!(Scheduler::schedule_named(655			system::RawOrigin::Signed(1).into(),656			[1u8; 32],657			4,658			None,659			None,660			call,661		));662		assert_ok!(Scheduler::schedule(663			system::RawOrigin::Signed(1).into(),664			4,665			None,666			None,667			call2,668		));669		run_to_block(3);670		// Scheduled calls are in the agenda.671		assert_eq!(Agenda::<Test>::get(4).agenda.len(), 2);672		assert!(logger::log().is_empty());673		assert_ok!(Scheduler::cancel_named(674			system::RawOrigin::Signed(1).into(),675			[1u8; 32]676		));677		assert_ok!(Scheduler::cancel(system::RawOrigin::Signed(1).into(), 4, 1));678		// Scheduled calls are made NONE, so should not effect state679		run_to_block(100);680		assert!(logger::log().is_empty());681	});682}683684#[test]685fn should_check_origin() {686	new_test_ext().execute_with(|| {687		let call = Box::new(RuntimeCall::Logger(LoggerCall::log {688			i: 69,689			weight: Weight::from_ref_time(10),690		}));691		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log {692			i: 42,693			weight: Weight::from_ref_time(10),694		}));695		assert_noop!(696			Scheduler::schedule_named(697				system::RawOrigin::Signed(2).into(),698				[1u8; 32],699				4,700				None,701				None,702				call703			),704			BadOrigin705		);706		assert_noop!(707			Scheduler::schedule(system::RawOrigin::Signed(2).into(), 4, None, None, call2),708			BadOrigin709		);710	});711}712713#[test]714fn should_check_origin_for_cancel() {715	new_test_ext().execute_with(|| {716		let call = Box::new(RuntimeCall::Logger(LoggerCall::log_without_filter {717			i: 69,718			weight: Weight::from_ref_time(10),719		}));720		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log_without_filter {721			i: 42,722			weight: Weight::from_ref_time(10),723		}));724		assert_ok!(Scheduler::schedule_named(725			system::RawOrigin::Signed(1).into(),726			[1u8; 32],727			4,728			None,729			None,730			call,731		));732		assert_ok!(Scheduler::schedule(733			system::RawOrigin::Signed(1).into(),734			4,735			None,736			None,737			call2,738		));739		run_to_block(3);740		// Scheduled calls are in the agenda.741		assert_eq!(Agenda::<Test>::get(4).agenda.len(), 2);742		assert!(logger::log().is_empty());743		assert_noop!(744			Scheduler::cancel_named(system::RawOrigin::Signed(2).into(), [1u8; 32]),745			BadOrigin746		);747		assert_noop!(748			Scheduler::cancel(system::RawOrigin::Signed(2).into(), 4, 1),749			BadOrigin750		);751		assert_noop!(752			Scheduler::cancel_named(system::RawOrigin::Root.into(), [1u8; 32]),753			BadOrigin754		);755		assert_noop!(756			Scheduler::cancel(system::RawOrigin::Root.into(), 4, 1),757			BadOrigin758		);759		run_to_block(5);760		assert_eq!(761			logger::log(),762			vec![763				(system::RawOrigin::Signed(1).into(), 69u32),764				(system::RawOrigin::Signed(1).into(), 42u32)765			]766		);767	});768}769770/// Cancelling a call and then scheduling a second call for the same771/// block results in different addresses.772#[test]773fn schedule_does_not_resuse_addr() {774	new_test_ext().execute_with(|| {775		let call = RuntimeCall::Logger(LoggerCall::log {776			i: 42,777			weight: Weight::from_ref_time(10),778		});779780		// Schedule both calls.781		let addr_1 = Scheduler::do_schedule(782			DispatchTime::At(4),783			None,784			127,785			root(),786			<ScheduledCall<Test>>::new(call.clone()).unwrap(),787		)788		.unwrap();789		// Cancel the call.790		assert_ok!(Scheduler::do_cancel(None, addr_1));791		let addr_2 = Scheduler::do_schedule(792			DispatchTime::At(4),793			None,794			127,795			root(),796			<ScheduledCall<Test>>::new(call).unwrap(),797		)798		.unwrap();799800		// Should not re-use the address.801		assert!(addr_1 != addr_2);802	});803}804805#[test]806fn schedule_agenda_overflows() {807	let max: u32 = <Test as Config>::MaxScheduledPerBlock::get();808809	new_test_ext().execute_with(|| {810		let call = RuntimeCall::Logger(LoggerCall::log {811			i: 42,812			weight: Weight::from_ref_time(10),813		});814		let call = <ScheduledCall<Test>>::new(call).unwrap();815816		// Schedule the maximal number allowed per block.817		for _ in 0..max {818			Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call.clone()).unwrap();819		}820821		// One more time and it errors.822		assert_noop!(823			Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call,),824			<Error<Test>>::AgendaIsExhausted,825		);826827		run_to_block(4);828		// All scheduled calls are executed.829		assert_eq!(logger::log().len() as u32, max);830	});831}832833/// Cancelling and scheduling does not overflow the agenda but fills holes.834#[test]835fn cancel_and_schedule_fills_holes() {836	let max: u32 = <Test as Config>::MaxScheduledPerBlock::get();837	assert!(838		max > 3,839		"This test only makes sense for MaxScheduledPerBlock > 3"840	);841842	new_test_ext().execute_with(|| {843		let call = RuntimeCall::Logger(LoggerCall::log {844			i: 42,845			weight: Weight::from_ref_time(10),846		});847		let call = <ScheduledCall<Test>>::new(call).unwrap();848		let mut addrs = Vec::<_>::default();849850		// Schedule the maximal number allowed per block.851		for _ in 0..max {852			addrs.push(853				Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call.clone())854					.unwrap(),855			);856		}857		// Cancel three of them.858		for addr in addrs.into_iter().take(3) {859			Scheduler::do_cancel(None, addr).unwrap();860		}861		// Schedule three new ones.862		for i in 0..3 {863			let (_block, index) =864				Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call.clone())865					.unwrap();866			assert_eq!(i, index);867		}868869		run_to_block(4);870		// Maximum number of calls are executed.871		assert_eq!(logger::log().len() as u32, max);872	});873}874875#[test]876fn cannot_schedule_too_big_tasks() {877	new_test_ext().execute_with(|| {878		let call = Box::new(<<Test as Config>::RuntimeCall>::from(SystemCall::remark {879			remark: vec![0; EncodedCall::bound() - 4],880		}));881882		assert_ok!(Scheduler::schedule(RuntimeOrigin::root(), 4, None, Some(127), call));883884		let call = Box::new(<<Test as Config>::RuntimeCall>::from(SystemCall::remark {885			remark: vec![0; EncodedCall::bound() - 3],886		}));887888		assert_err!(Scheduler::schedule(RuntimeOrigin::root(), 4, None, Some(127), call), <Error<Test>>::TooBigScheduledCall);889	});890}