integration_tests.rs

			CrowdloanError::<Test>::InvalidParaId
		);
		assert_noop!(
			Crowdloan::dissolve(signed(2), ParaId::from(2001)),
			CrowdloanError::<Test>::NotReadyToDissolve
		);

		// Go way in the future when the para is offboarded
		run_to_block(lease_start_block + 1000);

		// Withdraw of contributions works
		assert_eq!(Balances::free_balance(&crowdloan_account), total);
		for i in 10..20 {
			assert_ok!(Crowdloan::withdraw(signed(i), account_id(i), ParaId::from(2001)));
		}
		assert_eq!(Balances::free_balance(&crowdloan_account), 0);

		// Dissolve returns the balance of the person who put a deposit for crowdloan
		assert_ok!(Crowdloan::dissolve(signed(1), ParaId::from(2001)));
		assert_eq!(Balances::reserved_balance(&account_id(1)), 0);
		assert_eq!(Balances::reserved_balance(&account_id(2)), para_id_deposit + code_deposit + 20);

		// Final deregister sets everything back to the start
		assert_ok!(Registrar::deregister(para_origin(2001).into(), ParaId::from(2001)));
		assert_eq!(Balances::reserved_balance(&account_id(2)), 0);
	})
}

#[test]
fn parachain_swap_works() {
	// This test will test a swap between two parachains works successfully.
	new_test_ext().execute_with(|| {
		assert!(System::block_number().is_one()); /* So events are emitted */

		const START_SESSION_INDEX: SessionIndex = 1;
		run_to_session(START_SESSION_INDEX);

		// User 1 and 2 will own paras
		Balances::make_free_balance_be(&account_id(1), 1_000_000_000);
		Balances::make_free_balance_be(&account_id(2), 1_000_000_000);
		// First register 2 on-demand parachains with different data
		let validation_code = test_validation_code(10);
		assert_ok!(Registrar::reserve(signed(1)));
		assert_ok!(Registrar::register(
			signed(1),
			ParaId::from(2000),
			test_genesis_head(10),
			validation_code.clone(),
		));
		conclude_pvf_checking::<Test>(&validation_code, VALIDATORS, START_SESSION_INDEX);

		let validation_code = test_validation_code(20);
		assert_ok!(Registrar::reserve(signed(2)));
		assert_ok!(Registrar::register(
			signed(2),
			ParaId::from(2001),
			test_genesis_head(20),
			validation_code.clone(),
		));
		conclude_pvf_checking::<Test>(&validation_code, VALIDATORS, START_SESSION_INDEX);

		// Paras should be onboarding
		assert_eq!(Paras::lifecycle(ParaId::from(2000)), Some(ParaLifecycle::Onboarding));
		assert_eq!(Paras::lifecycle(ParaId::from(2001)), Some(ParaLifecycle::Onboarding));

		assert_eq!(
			Balances::total_balance(&Crowdloan::fund_account_id(
				crowdloan::NextFundIndex::<Test>::get()
			)),
			0
		);

		// Start a new auction in the future
		let start_auction = |lease_period_index_start, winner, end| {
			let unique_id = winner - 1999u32;
			let starting_block = System::block_number();
			let duration = 99u32;
			assert_ok!(Auctions::new_auction(
				RuntimeOrigin::root(),
				duration,
				lease_period_index_start
			));

			// 2 sessions later they are on-demand parachains
			run_to_block(starting_block + 20);
			assert_eq!(Paras::lifecycle(ParaId::from(winner)), Some(ParaLifecycle::Parathread));

			// Open a crowdloan for Para 1 for slots 0-3
			assert_ok!(Crowdloan::create(
				signed(unique_id),
				ParaId::from(winner),
				1_000_000,                    // Cap
				lease_period_index_start + 0, // First Slot
				lease_period_index_start + 7, // Last Slot
				end,                          // Block End
				None,
			));
			let winner_fund = crowdloan::Funds::<Test>::get(ParaId::from(winner)).unwrap();
			let crowdloan_account = Crowdloan::fund_account_id(winner_fund.fund_index);

			// Bunch of contributions
			let mut total = 0;
			for i in (unique_id * 10)..(unique_id + 1) * 10 {
				Balances::make_free_balance_be(&account_id(i), 1_000_000_000);
				assert_ok!(Crowdloan::contribute(signed(i), ParaId::from(winner), 900 - i, None));
				total += 900 - i;
			}
			assert!(total > 0);
			assert_eq!(Balances::free_balance(&crowdloan_account), total);

			// Go to end of auction where everyone won their slots
			run_to_block(end);

			// Crowdloan is appropriately set
			assert!(crowdloan::Funds::<Test>::get(ParaId::from(winner)).is_some());

			// New leases will start on block lease period index * 100
			let lease_start_block = lease_period_index_start * 100;
			run_to_block(lease_start_block);
		};

		start_auction(4u32, 2000, 200);
		// Slots are won by Para 1
		assert!(!slots::Leases::<Test>::get(ParaId::from(2000)).is_empty());
		assert!(slots::Leases::<Test>::get(ParaId::from(2001)).is_empty());

		// 2 sessions later it is a parachain
		run_to_block(4 * 100 + 20);
		assert_eq!(Paras::lifecycle(ParaId::from(2000)), Some(ParaLifecycle::Parachain));
		assert_eq!(Paras::lifecycle(ParaId::from(2001)), Some(ParaLifecycle::Parathread));

		// Let's repeat the process now for another parachain.
		start_auction(6u32, 2001, 500);
		// Slots are won by Para 1
		assert!(!slots::Leases::<Test>::get(ParaId::from(2000)).is_empty());
		assert!(!slots::Leases::<Test>::get(ParaId::from(2001)).is_empty());

		// 2 sessions later it is a parachain
		run_to_block(6 * 100 + 20);
		assert_eq!(Paras::lifecycle(ParaId::from(2000)), Some(ParaLifecycle::Parachain));
		assert_eq!(Paras::lifecycle(ParaId::from(2001)), Some(ParaLifecycle::Parachain));

		// Currently we are on lease 6
		assert_eq!(
			<Slots as Leaser<_>>::lease_period_index(System::block_number()),
			Some((6u32, false))
		);

		// This means that parachain 1 should only have 6 slots left, and parachain 2 has all 8.
		assert_eq!(slots::Leases::<Test>::get(ParaId::from(2000)).len(), 6);
		assert_eq!(slots::Leases::<Test>::get(ParaId::from(2001)).len(), 8);

		let fund_2000 = crowdloan::Funds::<Test>::get(ParaId::from(2000)).unwrap();
		assert_eq!(fund_2000.fund_index, 0);
		assert_eq!(
			Balances::reserved_balance(&Crowdloan::fund_account_id(fund_2000.fund_index)),
			fund_2000.raised
		);

		let fund_2001 = crowdloan::Funds::<Test>::get(ParaId::from(2001)).unwrap();
		assert_eq!(fund_2001.fund_index, 1);
		assert_eq!(
			Balances::reserved_balance(&Crowdloan::fund_account_id(fund_2001.fund_index)),
			fund_2001.raised
		);

		assert_eq!(slots::Leases::<Test>::get(ParaId::from(2000)).len(), 6);
		assert_eq!(slots::Leases::<Test>::get(ParaId::from(2001)).len(), 8);

		// Now we swap them.
		assert_ok!(Registrar::swap(
			para_origin(2000).into(),
			ParaId::from(2000),
			ParaId::from(2001)
		));
		assert_ok!(Registrar::swap(
			para_origin(2001).into(),
			ParaId::from(2001),
			ParaId::from(2000)
		));
		assert!(contains_event(
			paras_registrar::Event::<Test>::Swapped {
				para_id: ParaId::from(2001),
				other_id: ParaId::from(2000)
			}
			.into()
		));

		// Crowdloan Swapped
		let fund_2000 = crowdloan::Funds::<Test>::get(ParaId::from(2000)).unwrap();
		assert_eq!(fund_2000.fund_index, 1);
		assert_eq!(
			Balances::reserved_balance(&Crowdloan::fund_account_id(fund_2000.fund_index)),
			fund_2000.raised
		);

		let fund_2001 = crowdloan::Funds::<Test>::get(ParaId::from(2001)).unwrap();
		assert_eq!(fund_2001.fund_index, 0);
		assert_eq!(
			Balances::reserved_balance(&Crowdloan::fund_account_id(fund_2001.fund_index)),
			fund_2001.raised
		);

		// Slots Swapped
		assert_eq!(slots::Leases::<Test>::get(ParaId::from(2000)).len(), 8);
		assert_eq!(slots::Leases::<Test>::get(ParaId::from(2001)).len(), 6);
	})
}

#[test]
fn crowdloan_ending_period_bid() {
	new_test_ext().execute_with(|| {
		assert!(System::block_number().is_one()); /* So events are emitted */

		const START_SESSION_INDEX: SessionIndex = 1;
		run_to_session(START_SESSION_INDEX);

		// User 1 and 2 will own paras
		Balances::make_free_balance_be(&account_id(1), 1_000_000_000);
		Balances::make_free_balance_be(&account_id(2), 1_000_000_000);
		// First register 2 on-demand parachains
		let validation_code = test_validation_code(10);
		assert_ok!(Registrar::reserve(signed(1)));
		assert_ok!(Registrar::register(
			signed(1),
			ParaId::from(2000),
			test_genesis_head(10),
			validation_code.clone(),
		));
		conclude_pvf_checking::<Test>(&validation_code, VALIDATORS, START_SESSION_INDEX);

		let validation_code = test_validation_code(20);
		assert_ok!(Registrar::reserve(signed(2)));
		assert_ok!(Registrar::register(
			signed(2),
			ParaId::from(2001),
			test_genesis_head(20),
			validation_code.clone(),
		));
		conclude_pvf_checking::<Test>(&validation_code, VALIDATORS, START_SESSION_INDEX);

		// Paras should be onboarding
		assert_eq!(Paras::lifecycle(ParaId::from(2000)), Some(ParaLifecycle::Onboarding));
		assert_eq!(Paras::lifecycle(ParaId::from(2001)), Some(ParaLifecycle::Onboarding));

		// Start a new auction in the future
		let duration = 99u32;
		let ends_at = System::block_number() + duration;
		let lease_period_index_start = 4u32;
		assert_ok!(Auctions::new_auction(
			RuntimeOrigin::root(),
			duration,
			lease_period_index_start
		));

		// 2 sessions later they are on-demand parachains
		run_to_session(START_SESSION_INDEX + 2);
		assert_eq!(Paras::lifecycle(ParaId::from(2000)), Some(ParaLifecycle::Parathread));
		assert_eq!(Paras::lifecycle(ParaId::from(2001)), Some(ParaLifecycle::Parathread));

		// Open a crowdloan for Para 1 for slots 0-3
		assert_ok!(Crowdloan::create(
			signed(1),
			ParaId::from(2000),
			1_000_000,                    // Cap
			lease_period_index_start + 0, // First Slot
			lease_period_index_start + 3, // Last Slot
			200,                          // Block End
			None,
		));
		let fund = crowdloan::Funds::<Test>::get(ParaId::from(2000)).unwrap();
		let crowdloan_account = Crowdloan::fund_account_id(fund.fund_index);

		// Bunch of contributions
		let mut total = 0;
		for i in 10..20 {
			Balances::make_free_balance_be(&account_id(i), 1_000_000_000);
			assert_ok!(Crowdloan::contribute(signed(i), ParaId::from(2000), 900 - i, None));
			total += 900 - i;
		}
		assert!(total > 0);
		assert_eq!(Balances::free_balance(&crowdloan_account), total);

		// Bid for para 2 directly
		Balances::make_free_balance_be(&account_id(2), 1_000_000_000);
		assert_ok!(Auctions::bid(
			signed(2),
			ParaId::from(2001),
			1,                            // Auction Index
			lease_period_index_start + 0, // First Slot
			lease_period_index_start + 1, // Last slot
			900,                          // Amount
		));

		// Go to beginning of ending period
		run_to_block(ends_at);

		assert_eq!(Auctions::auction_status(ends_at), AuctionStatus::<u32>::EndingPeriod(0, 0));
		let mut winning = [(); SlotRange::SLOT_RANGE_COUNT].map(|_| None);

		winning[SlotRange::ZeroOne as u8 as usize] = Some((account_id(2), ParaId::from(2001), 900));
		winning[SlotRange::ZeroThree as u8 as usize] =
			Some((crowdloan_account.clone(), ParaId::from(2000), total));

		assert_eq!(auctions::Winning::<Test>::get(0), Some(winning));

		run_to_block(ends_at + 1);

		Balances::make_free_balance_be(&account_id(1234), 1_000_000_000);
		assert_ok!(Crowdloan::contribute(signed(1234), ParaId::from(2000), 900, None));

		// Data propagates correctly
		run_to_block(ends_at + 2);
		let mut winning = [(); SlotRange::SLOT_RANGE_COUNT].map(|_| None);
		winning[SlotRange::ZeroOne as u8 as usize] = Some((account_id(2), ParaId::from(2001), 900));
		winning[SlotRange::ZeroThree as u8 as usize] =
			Some((crowdloan_account.clone(), ParaId::from(2000), total + 900));
		assert_eq!(auctions::Winning::<Test>::get(2), Some(winning));
	})
}

#[test]
fn auction_bid_requires_registered_para() {
	new_test_ext().execute_with(|| {
		assert!(System::block_number().is_one()); /* So events are emitted */

		const START_SESSION_INDEX: SessionIndex = 1;
		run_to_session(START_SESSION_INDEX);

		// Start a new auction in the future
		let duration = 99u32;
		let lease_period_index_start = 4u32;
		assert_ok!(Auctions::new_auction(
			RuntimeOrigin::root(),
			duration,
			lease_period_index_start
		));

		// Can't bid with non-registered paras
		Balances::make_free_balance_be(&account_id(1), 1_000_000_000);
		assert_noop!(
			Auctions::bid(
				signed(1),
				ParaId::from(2000),
				1,                            // Auction Index
				lease_period_index_start + 0, // First Slot
				lease_period_index_start + 1, // Last slot
				900,                          // Amount
			),
			AuctionsError::<Test>::ParaNotRegistered
		);

		// Now we register the para
		let validation_code = test_validation_code(10);
		assert_ok!(Registrar::reserve(signed(1)));
		assert_ok!(Registrar::register(
			signed(1),
			ParaId::from(2000),
			test_genesis_head(10),
			validation_code.clone(),
		));
		conclude_pvf_checking::<Test>(&validation_code, VALIDATORS, START_SESSION_INDEX);

		// Still can't bid until it is fully onboarded
		assert_noop!(
			Auctions::bid(
				signed(1),
				ParaId::from(2000),
				1,                            // Auction Index
				lease_period_index_start + 0, // First Slot
				lease_period_index_start + 1, // Last slot
				900,                          // Amount
			),
			AuctionsError::<Test>::ParaNotRegistered
		);

		// Onboarded on Session 2
		run_to_session(START_SESSION_INDEX + 2);

		// Success
		Balances::make_free_balance_be(&account_id(1), 1_000_000_000);
		assert_ok!(Auctions::bid(
			signed(1),
			ParaId::from(2000),
			1,                            // Auction Index
			lease_period_index_start + 0, // First Slot
			lease_period_index_start + 1, // Last slot
			900,                          // Amount
		));
	});
}

#[test]
fn gap_bids_work() {
	new_test_ext().execute_with(|| {
		assert!(System::block_number().is_one()); /* So events are emitted */

		const START_SESSION_INDEX: SessionIndex = 1;
		run_to_session(START_SESSION_INDEX);

		// Start a new auction in the future
		let duration = 99u32;
		let lease_period_index_start = 4u32;
		assert_ok!(Auctions::new_auction(
			RuntimeOrigin::root(),
			duration,
			lease_period_index_start
		));
		Balances::make_free_balance_be(&account_id(1), 1_000_000_000);
		Balances::make_free_balance_be(&account_id(2), 1_000_000_000);

		// Now register 2 paras
		let validation_code = test_validation_code(10);
		assert_ok!(Registrar::reserve(signed(1)));
		assert_ok!(Registrar::register(
			signed(1),
			ParaId::from(2000),
			test_genesis_head(10),
			validation_code.clone(),
		));
		assert_ok!(Registrar::reserve(signed(2)));
		assert_ok!(Registrar::register(
			signed(2),
			ParaId::from(2001),
			test_genesis_head(10),
			validation_code.clone(),
		));
		conclude_pvf_checking::<Test>(&validation_code, VALIDATORS, START_SESSION_INDEX);

		// Onboarded on Session 2
		run_to_session(START_SESSION_INDEX + 2);

		// Make bids
		Balances::make_free_balance_be(&account_id(10), 1_000_000_000);
		Balances::make_free_balance_be(&account_id(20), 1_000_000_000);
		// Slot 1 for 100 from 10
		assert_ok!(Auctions::bid(
			signed(10),
			ParaId::from(2000),
			1,                            // Auction Index
			lease_period_index_start + 0, // First Slot
			lease_period_index_start + 0, // Last slot
			100,                          // Amount
		));
		// Slot 4 for 400 from 10
		assert_ok!(Auctions::bid(
			signed(10),
			ParaId::from(2000),
			1,                            // Auction Index
			lease_period_index_start + 3, // First Slot
			lease_period_index_start + 3, // Last slot
			400,                          // Amount
		));

		// A bid for another para is counted separately.
		assert_ok!(Auctions::bid(
			signed(10),
			ParaId::from(2001),
			1,                            // Auction Index
			lease_period_index_start + 1, // First Slot
			lease_period_index_start + 1, // Last slot
			555,                          // Amount
		));
		assert_eq!(Balances::reserved_balance(&account_id(10)), 400 + 555);

		// Slot 2 for 800 from 20, overtaking 10's bid
		assert_ok!(Auctions::bid(
			signed(20),
			ParaId::from(2000),
			1,                            // Auction Index
			lease_period_index_start + 1, // First Slot
			lease_period_index_start + 1, // Last slot
			800,                          // Amount
		));
		// Slot 3 for 200 from 20
		assert_ok!(Auctions::bid(
			signed(20),
			ParaId::from(2000),
			1,                            // Auction Index
			lease_period_index_start + 2, // First Slot
			lease_period_index_start + 2, // Last slot
			200,                          // Amount
		));

		// Finish the auction
		run_to_block(130 + LeaseOffset::get());

		// Should have won the lease periods
		assert_eq!(
			slots::Leases::<Test>::get(ParaId::from(2000)),
			vec![
				// LP 1
				None,
				// LP 2
				None,
				// LP 3
				None,
				// LP 4
				Some((account_id(10), 100)),
				// LP 5
				Some((account_id(20), 800)),
				// LP 6
				Some((account_id(20), 200)),
				// LP 7
				Some((account_id(10), 400))
			],
		);
		// Appropriate amount is reserved (largest of the values)
		assert_eq!(Balances::reserved_balance(&account_id(10)), 400);
		// Appropriate amount is reserved (largest of the values)
		assert_eq!(Balances::reserved_balance(&account_id(20)), 800);

		// Progress through the leases and note the correct amount of balance is reserved.

		add_blocks(300 + LeaseOffset::get());
		assert_eq!(
			slots::Leases::<Test>::get(ParaId::from(2000)),
			vec![
				// LP 4
				Some((account_id(10), 100)),
				// LP 5
				Some((account_id(20), 800)),
				// LP 6
				Some((account_id(20), 200)),
				// LP 7
				Some((account_id(10), 400))
			],
		);
		// Nothing changed.
		assert_eq!(Balances::reserved_balance(&account_id(10)), 400);
		assert_eq!(Balances::reserved_balance(&account_id(20)), 800);

		// Lease period 4 is done, but nothing is unreserved since user 1 has a debt on lease 7
		add_blocks(100);
		assert_eq!(
			slots::Leases::<Test>::get(ParaId::from(2000)),
			vec![
				// LP 5
				Some((account_id(20), 800)),
				// LP 6
				Some((account_id(20), 200)),
				// LP 7
				Some((account_id(10), 400))
			],
		);
		// Nothing changed.
		assert_eq!(Balances::reserved_balance(&account_id(10)), 400);
		assert_eq!(Balances::reserved_balance(&account_id(20)), 800);

		// Lease period 5 is done, and 20 will unreserve down to 200.
		add_blocks(100);
		assert_eq!(
			slots::Leases::<Test>::get(ParaId::from(2000)),
			// --------- 6 -------------- 7 -------
			vec![Some((account_id(20), 200)), Some((account_id(10), 400))],
		);
		assert_eq!(Balances::reserved_balance(&account_id(10)), 400);
		assert_eq!(Balances::reserved_balance(&account_id(20)), 200);

		// Lease period 6 is done, and 20 will unreserve everything.
		add_blocks(100);
		assert_eq!(
			slots::Leases::<Test>::get(ParaId::from(2000)),
			// --------- 7 -------
			vec![Some((account_id(10), 400))],
		);
		assert_eq!(Balances::reserved_balance(&account_id(10)), 400);
		assert_eq!(Balances::reserved_balance(&account_id(20)), 0);

		// All leases are done. Everything is unreserved.
		add_blocks(100);
		assert_eq!(slots::Leases::<Test>::get(ParaId::from(2000)), vec![]);
		assert_eq!(Balances::reserved_balance(&account_id(10)), 0);
		assert_eq!(Balances::reserved_balance(&account_id(20)), 0);
	});
}

// This test verifies that if a parachain already has won some lease periods, that it cannot bid for
// any of those same lease periods again.
#[test]
fn cant_bid_on_existing_lease_periods() {
	new_test_ext().execute_with(|| {
		assert!(System::block_number().is_one()); /* So events are emitted */

		const START_SESSION_INDEX: SessionIndex = 1;
		run_to_session(START_SESSION_INDEX);

		Balances::make_free_balance_be(&account_id(1), 1_000_000_000);
		// First register an on-demand parachain
		let validation_code = test_validation_code(10);
		assert_ok!(Registrar::reserve(signed(1)));
		assert_ok!(Registrar::register(
			signed(1),
			ParaId::from(2000),
			test_genesis_head(10),
			validation_code.clone(),
		));
		conclude_pvf_checking::<Test>(&validation_code, VALIDATORS, START_SESSION_INDEX);

		// Start a new auction in the future
		let starting_block = System::block_number();
		let duration = 99u32;
		let lease_period_index_start = 4u32;
		assert_ok!(Auctions::new_auction(
			RuntimeOrigin::root(),
			duration,
			lease_period_index_start
		));

		// 2 sessions later they are on-demand parachains
		run_to_session(START_SESSION_INDEX + 2);

		// Open a crowdloan for Para 1 for slots 0-3
		assert_ok!(Crowdloan::create(
			signed(1),
			ParaId::from(2000),
			1_000_000,                    // Cap
			lease_period_index_start + 0, // First Slot
			lease_period_index_start + 1, // Last Slot
			400,                          // Long block end
			None,
		));
		let fund = crowdloan::Funds::<Test>::get(ParaId::from(2000)).unwrap();
		let crowdloan_account = Crowdloan::fund_account_id(fund.fund_index);

		// Bunch of contributions
		let mut total = 0;
		for i in 10..20 {
			Balances::make_free_balance_be(&account_id(i), 1_000_000_000);
			assert_ok!(Crowdloan::contribute(signed(i), ParaId::from(2000), 900 - i, None));
			total += 900 - i;
		}
		assert!(total > 0);
		assert_eq!(Balances::free_balance(&crowdloan_account), total);

		// Finish the auction.
		run_to_block(starting_block + 110);

		// Appropriate Paras should have won slots
		assert_eq!(
			slots::Leases::<Test>::get(ParaId::from(2000)),
			// -- 1 --- 2 --- 3 ------------- 4 ------------------------ 5 -------------
			vec![
				None,
				None,
				None,
				Some((crowdloan_account.clone(), 8855)),
				Some((crowdloan_account.clone(), 8855))
			],
		);

		// Let's start another auction for the same range
		let starting_block = System::block_number();
		let duration = 99u32;
		let lease_period_index_start = 4u32;
		assert_ok!(Auctions::new_auction(
			RuntimeOrigin::root(),
			duration,
			lease_period_index_start
		));

		// Poke the crowdloan into `NewRaise`
		assert_ok!(Crowdloan::poke(signed(1), ParaId::from(2000)));
		assert_eq!(crowdloan::NewRaise::<Test>::get(), vec![ParaId::from(2000)]);

		// Beginning of ending block.
		run_to_block(starting_block + 100);

		// Bids cannot be made which intersect
		assert_noop!(
			Auctions::bid(
				RuntimeOrigin::signed(crowdloan_account.clone()),
				ParaId::from(2000),
				2,
				lease_period_index_start + 0,
				lease_period_index_start + 1,
				100,
			),
			AuctionsError::<Test>::AlreadyLeasedOut,
		);

		assert_noop!(
			Auctions::bid(
				RuntimeOrigin::signed(crowdloan_account.clone()),
				ParaId::from(2000),
				2,
				lease_period_index_start + 1,
				lease_period_index_start + 2,
				100,
			),
			AuctionsError::<Test>::AlreadyLeasedOut,
		);

		assert_noop!(
			Auctions::bid(
				RuntimeOrigin::signed(crowdloan_account.clone()),
				ParaId::from(2000),
				2,
				lease_period_index_start - 1,
				lease_period_index_start + 0,
				100,
			),
			AuctionsError::<Test>::AlreadyLeasedOut,
		);

		assert_noop!(
			Auctions::bid(
				RuntimeOrigin::signed(crowdloan_account.clone()),
				ParaId::from(2000),
				2,
				lease_period_index_start + 0,
				lease_period_index_start + 0,
				100,
			),
			AuctionsError::<Test>::AlreadyLeasedOut,
		);

		assert_noop!(
			Auctions::bid(
				RuntimeOrigin::signed(crowdloan_account.clone()),
				ParaId::from(2000),
				2,
				lease_period_index_start + 1,
				lease_period_index_start + 1,
				100,
			),
			AuctionsError::<Test>::AlreadyLeasedOut,
		);

		assert_noop!(
			Auctions::bid(
				RuntimeOrigin::signed(crowdloan_account.clone()),
				ParaId::from(2000),
				2,
				lease_period_index_start - 1,
				lease_period_index_start + 5,
				100,
			),
			AuctionsError::<Test>::AlreadyLeasedOut,
		);

		// Will work when not overlapping
		assert_ok!(Auctions::bid(
			RuntimeOrigin::signed(crowdloan_account.clone()),
			ParaId::from(2000),
			2,
			lease_period_index_start + 2,
			lease_period_index_start + 3,
			100,
		));
	});
}