You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: mod.rs
    path of file: ./repos/tikv/components/backup-stream/tests/integration
    
    the code of the file until where you have to start completion: // Copyright 2022 TiKV Project Authors. Licensed under Apache-2.0.

#![feature(custom_test_frameworks)]
#![test_runner(test_util::run_tests)]

#[path = "../suite.rs"]
mod suite;

mod all {
    use std::time::{Duration, Instant};

    use backup_stream::{
        errors::Error, router::TaskSelector, GetCheckpointResult, RegionCheckpointOperation,
        RegionSet, Task,
    };
    use futures::{Stream, StreamExt};
    use pd_client::PdClient;
    use test_raftstore::IsolationFilterFactory;
    use tikv::config::BackupStreamConfig;
    use tikv_util::{box_err, defer, info, HandyRwLock};
    use tokio::time::timeout;
    use txn_types::{Key, TimeStamp};

    use super::suite::{
        make_record_key, make_split_key_at_record, mutation, run_async_test, SuiteBuilder,
    };

    
    fn network_partition() {
        let mut suite = SuiteBuilder::new_named("network_partition")
            .nodes(3)
            .build();
        let stream = suite.flush_stream(true);
        suite.must_register_task(1, "network_partition");
        let leader = suite.cluster.leader_of_region(1).unwrap();
        let round1 = run_async_test(suite.write_records(0, 64, 1));

        suite
            .cluster
            .add_send_filter(IsolationFilterFactory::new(leader.store_id));
        suite.cluster.reset_leader_of_region(1);
        suite
            .cluster
            .must_wait_for_leader_expire(leader.store_id, 1);
        let leader2 = suite.cluster.leader_of_region(1).unwrap();
        assert_ne!(leader.store_id, leader2.store_id, "leader not switched.");
        let ts = suite.tso();
        suite.must_kv_prewrite(
            1,
            vec![mutation(make_record_key(1, 778), b"generator".to_vec())],
            make_record_key(1, 778),
            ts,
        );
        suite.sync();
        suite.force_flush_files("network_partition");
        suite.wait_for_flush();

        let cps = run_async_test(collect_all_current(stream, Duration::from_secs(2)));
        assert!(
            cps.iter()
                .flat_map(|(_s, cp)| cp.events.iter().map(|resp| resp.checkpoint))
                .all(|cp| cp <= ts.into_inner()),
            "ts={} cps={:?}",
            ts,
            cps
        );
        suite.check_for_write_records(
            suite.flushed_files.path(),
            round1.iter().map(|k| k.as_slice()),
        )
    }