pub fn session_to_block(n: u32) -> u32 {

    let block_number = crate::Period::get() * n;

    block_number + 1

}

pub fn run_to_session(n: u32) {

    run_to_block(session_to_block(n));

}

pub fn run_to_block(n: u32) -> BTreeMap<u32, RunSummary> {

    let current_block_number = System::block_number();

    assert!(

        current_block_number < n,

    let mut summaries = BTreeMap::new();

    while System::block_number() < n {

        let summary = run_block();

        let block_number = System::block_number();

        summaries.insert(block_number, summary);

    }

    summaries

}

pub fn insert_authorities_and_slot_digests(slot: u64) {

    let authorities =

        Runtime::para_id_authorities(ParachainInfo::get()).expect("authorities should be set");

    let authority: NimbusId = authorities[slot as usize % authorities.len()].clone();

    let pre_digest = Digest {

        logs: vec![

            DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode()),

            DigestItem::PreRuntime(NIMBUS_ENGINE_ID, authority.encode()),

        ],

    };

    System::reset_events();

    System::initialize(

        &(System::block_number() + 1),

        &System::parent_hash(),

        &pre_digest,

}

fn take_new_inherent_data() -> Option<MockInherentData> {

    let data: Option<MockInherentData> =

        frame_support::storage::unhashed::take(b"__mock_new_inherent_data");

    data

}

    fn assert_can_advance(&self, new_state: &RunBlockState) {

        match self {

            RunBlockState::Start(n) => {

                assert_eq!(

                    &RunBlockState::End(*n),

            RunBlockState::End(n) => {

                assert_eq!(

                    &RunBlockState::Start(*n + 1),

    }

fn advance_block_state_machine(new_state: RunBlockState) {

    if frame_support::storage::unhashed::exists(b"__mock_is_xcm_test") {

    }

    let old_state: RunBlockState =

        frame_support::storage::unhashed::get(b"__mock_debug_block_state").unwrap_or(

            RunBlockState::End(0),

    old_state.assert_can_advance(&new_state);

    frame_support::storage::unhashed::put(b"__mock_debug_block_state", &new_state);

}

pub fn start_block() -> RunSummary {

    let block_number = System::block_number();

    advance_block_state_machine(RunBlockState::Start(block_number + 1));

    let mut slot = current_slot() + 1;

    if block_number == 0 {

        // Hack to avoid breaking all tests. When the current block is 1, the slot number should be

        // 1. But all of our tests assume it will be 0. So use slot number = block_number - 1.

        slot = 0;

    }

    let maybe_mock_inherent = take_new_inherent_data();

    if let Some(mock_inherent_data) = maybe_mock_inherent {

    }

    insert_authorities_and_slot_digests(slot);

    CollatorAssignment::on_initialize(System::block_number());

    Session::on_initialize(System::block_number());

    Initializer::on_initialize(System::block_number());

    AuthorInherent::on_initialize(System::block_number());

    let author_id = current_author();

    let current_issuance = Balances::total_issuance();

    InflationRewards::on_initialize(System::block_number());

    let new_issuance = Balances::total_issuance();

    frame_support::storage::unhashed::put(

        &frame_support::storage::storage_prefix(b"AsyncBacking", b"SlotInfo"),

        &(Slot::from(slot), 1),

    pallet_author_inherent::Pallet::<Runtime>::kick_off_authorship_validation(None.into())

        .expect("author inherent to dispatch correctly");

    RunSummary {

        author_id,

        inflation: new_issuance - current_issuance,

    }

}

pub fn end_block() {

    let block_number = System::block_number();

    advance_block_state_machine(RunBlockState::End(block_number));

    CollatorAssignment::on_finalize(System::block_number());

    Session::on_finalize(System::block_number());

    Initializer::on_finalize(System::block_number());

    AuthorInherent::on_finalize(System::block_number());

    TransactionPayment::on_finalize(System::block_number());

}

pub fn run_block() -> RunSummary {

    end_block();

    start_block()

}

pub fn set_parachain_inherent_data(mock_inherent_data: MockInherentData) {

    let relay_sproof = RelayStateSproofBuilder {

        para_id: 100u32.into(),

        included_para_head: Some(HeadData(vec![1, 2, 3])),

        current_slot: (current_slot()).into(),

        additional_key_values: if mock_inherent_data.random_seed.is_some() {

            vec![]

        ..Default::default()

    let (relay_parent_storage_root, relay_chain_state) = relay_sproof.into_state_root_and_proof();

    let vfp = PersistedValidationData {

        relay_parent_number: 1u32,

        relay_parent_storage_root,

        ..Default::default()

    };

    let parachain_inherent_data = ParachainInherentData {

        validation_data: vfp,

        relay_chain_state,

        downward_messages: Default::default(),

        horizontal_messages: Default::default(),

        relay_parent_descendants: Default::default(),

        collator_peer_id: Default::default(),

    };

    frame_support::storage::unhashed::kill(&frame_support::storage::storage_prefix(

        b"ParachainSystem",

        b"ValidationData",

    ));

    assert_ok!(RuntimeCall::ParachainSystem(

        cumulus_pallet_parachain_system::Call::<Runtime>::set_validation_data {

            data: parachain_inherent_data

        }

    )

    .dispatch(inherent_origin()));

}

pub fn default_config() -> pallet_configuration::HostConfiguration {

    pallet_configuration::HostConfiguration {

        max_collators: 100,

        min_orchestrator_collators: 2,

        max_orchestrator_collators: 2,

        collators_per_container: 2,

        full_rotation_period: 0,

        ..Default::default()

    }

}

    fn default() -> Self {

        Self {

            balances: vec![

                // Alice gets 10k extra tokens for her mapping deposit

                (AccountId::from(ALICE), 210_000 * UNIT),

                (AccountId::from(BOB), 100_000 * UNIT),

            ],

            collators: vec![

                (AccountId::from(ALICE), 210 * UNIT),

                (AccountId::from(BOB), 100 * UNIT),

            ],

            sudo: Default::default(),

            para_ids: Default::default(),

            config: default_config(),

            own_para_id: Default::default(),

        }

    }

    pub fn with_balances(mut self, balances: Vec<(AccountId, Balance)>) -> Self {

        self.balances = balances;

        self

    }

    pub fn with_sudo(mut self, sudo: AccountId) -> Self {

        self.sudo = Some(sudo);

        self

    }

    pub fn with_collators(mut self, collators: Vec<(AccountId, Balance)>) -> Self {

        self.collators = collators;

        self

    }

    pub fn with_para_ids(mut self, para_ids: Vec<ParaRegistrationParams>) -> Self {

        self.para_ids = para_ids;

        self

    }

    pub fn with_empty_parachains(mut self, para_ids: Vec<u32>) -> Self {

        self.para_ids = para_ids

            .into_iter()

            .map(|para_id| ParaRegistrationParams {

                para_id,

                genesis_data: empty_genesis_data(),

                parathread_params: None,

            })

            .collect();

        self

    }

    pub fn with_config(mut self, config: pallet_configuration::HostConfiguration) -> Self {

        self.config = config;

        self

    }

    pub fn build_storage(self) -> sp_core::storage::Storage {

        let mut t = frame_system::GenesisConfig::<Runtime>::default()

            .build_storage()

            .unwrap();

        pallet_balances::GenesisConfig::<Runtime> {

            balances: self.balances,

            ..Default::default()

        }

        .assimilate_storage(&mut t)

        .unwrap();

            para_ids: self

                .para_ids

                .iter()

                .cloned()

                .map(|registered_para| {

                    (

                        registered_para.para_id.into(),

                        registered_para.genesis_data,

                        registered_para.parathread_params,

                    )

                })

                .collect(),

            phantom: Default::default(),

        .assimilate_storage(&mut t)

        .unwrap();

            para_id_credits: self

                .para_ids

                .clone()

                .into_iter()

                .map(|registered_para| {

                    (

                        registered_para.para_id.into(),

                        registered_para.block_production_credits,

                        registered_para.collator_assignment_credits,

                    )

                        .into()

                })

                .collect(),

        .assimilate_storage(&mut t)

        .unwrap();

        pallet_configuration::GenesisConfig::<Runtime> {

            config: self.config,

            ..Default::default()

        }

        .assimilate_storage(&mut t)

        .unwrap();

        if let Some(own_para_id) = self.own_para_id {

        }

        if !self.collators.is_empty() {

            let invulnerables: Vec<AccountId> = self

                .collators

                .clone()

                .into_iter()

                .map(|(account, _balance)| account)

                .collect();

            pallet_invulnerables::GenesisConfig::<Runtime> {

                invulnerables: invulnerables.clone(),

            }

            .assimilate_storage(&mut t)

            .unwrap();

            let keys: Vec<_> = self

                .collators

                .into_iter()

                .map(|(account, _balance)| {

                    let nimbus_id = get_aura_id_from_seed(&account.to_string());

                    (

                        account.clone(),

                        account,

                        crate::SessionKeys { nimbus: nimbus_id },

                    )

                })

                .collect();

            pallet_session::GenesisConfig::<Runtime> {

                keys,

                ..Default::default()

            }

            .assimilate_storage(&mut t)

            .unwrap();

        pallet_sudo::GenesisConfig::<Runtime> { key: self.sudo }

            .assimilate_storage(&mut t)

            .unwrap();

        t

    }

    pub fn build(self) -> sp_io::TestExternalities {

        let t = self.build_storage();

        let mut ext = sp_io::TestExternalities::new(t);

        ext.execute_with(|| {

            start_block();

            set_parachain_inherent_data(Default::default());

        });

        ext

    }

pub fn root_origin() -> <Runtime as frame_system::Config>::RuntimeOrigin {

    <Runtime as frame_system::Config>::RuntimeOrigin::root()

}

pub fn origin_of(account_id: AccountId) -> <Runtime as frame_system::Config>::RuntimeOrigin {

    <Runtime as frame_system::Config>::RuntimeOrigin::signed(account_id)

}

pub fn inherent_origin() -> <Runtime as frame_system::Config>::RuntimeOrigin {

    <Runtime as frame_system::Config>::RuntimeOrigin::none()

}

pub fn get_aura_id_from_seed(seed: &str) -> NimbusId {

    sp_core::sr25519::Pair::from_string(&format!("//{}", seed), None)

        .expect("static values are valid; qed")

        .public()

        .into()

}

pub fn current_collator_parachain_assignment(account: AccountId) -> Option<ParaId> {

    let assigned_collators = CollatorAssignment::collator_container_chain();

    let self_para_id = ParachainInfo::get();

    assigned_collators.para_id_of(&account, self_para_id)

}

pub fn future_collator_parachain_assignment(account: AccountId) -> Option<ParaId> {

    let assigned_collators = CollatorAssignment::pending_collator_container_chain();

    match assigned_collators {

        Some(assigned_collators) => {

            let self_para_id = ParachainInfo::get();

            assigned_collators.para_id_of(&account, self_para_id)

        None => current_collator_parachain_assignment(account),

}

pub fn parachain_collators(para_id: ParaId) -> Option<Vec<AccountId>> {

    let assigned_collators = CollatorAssignment::collator_container_chain();

    let self_para_id = ParachainInfo::get();

    if para_id == self_para_id {

        Some(assigned_collators.orchestrator_chain)

        assigned_collators.container_chains.get(&para_id).cloned()

}

pub fn get_orchestrator_current_author() -> Option<AccountId> {

    let slot: u64 = current_slot();

    let orchestrator_collators = parachain_collators(ParachainInfo::get())?;

    let author_index = slot % orchestrator_collators.len() as u64;

    let account = orchestrator_collators.get(author_index as usize)?;

    Some(account.clone())

}

pub fn set_author_noting_inherent_data(builder: ParaHeaderSproofBuilder) {

    let (relay_storage_root, relay_storage_proof) = builder.into_state_root_and_proof();

    frame_support::storage::unhashed::put(

        &frame_support::storage::storage_prefix(b"ParachainSystem", b"ValidationData"),

        &PersistedValidationData {

            parent_head: HeadData(Default::default()),

            relay_parent_number: 0u32,

            relay_parent_storage_root: relay_storage_root,

            max_pov_size: 0u32,

        },

    frame_support::storage::unhashed::put(

        &frame_support::storage::storage_prefix(b"ParachainSystem", b"RelayStateProof"),

        &relay_storage_proof,

    assert_ok!(RuntimeCall::AuthorNoting(

        pallet_author_noting::Call::<Runtime>::set_latest_author_data {

            data: tp_author_noting_inherent::OwnParachainInherentData {

                relay_storage_proof,

            }

        }

    )

    .dispatch(inherent_origin()));

}

pub fn empty_genesis_data() -> ContainerChainGenesisData {

    ContainerChainGenesisData {

        storage: Default::default(),

        name: Default::default(),

        id: Default::default(),

        fork_id: Default::default(),

        extensions: Default::default(),

        properties: Default::default(),

    }

}

pub fn current_slot() -> u64 {

    u64::from(

        pallet_async_backing::SlotInfo::<Runtime>::get()

            .unwrap_or_default()

            .0,

}

pub fn authorities() -> Vec<NimbusId> {

    let session_index = Session::current_index();

    AuthorityAssignment::collator_container_chain(session_index)

        .expect("authorities should be set")

        .orchestrator_chain

}

pub fn current_author() -> AccountId {

    let current_session = Session::current_index();

    let mapping =

        pallet_authority_mapping::Pallet::<Runtime>::authority_id_mapping(current_session)

            .expect("there is a mapping for the current session");

    let author = pallet_author_inherent::Author::<Runtime>::get()

        .expect("there should be a registered author");

    mapping

        .get(&author)

        .expect("there is a mapping for the current author")

        .clone()

}

pub fn block_credits_to_required_balance(number_of_blocks: u32, para_id: ParaId) -> Balance {

    let block_cost = BlockProductionCost::block_cost(&para_id).0;

    u128::from(number_of_blocks).saturating_mul(block_cost)

}

pub fn collator_assignment_credits_to_required_balance(

    number_of_sessions: u32,

    para_id: ParaId,

) -> Balance {

    let collator_assignment_cost = CollatorAssignmentCost::collator_assignment_cost(&para_id).0;

    u128::from(number_of_sessions).saturating_mul(collator_assignment_cost)

}