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: partition.rs
    path of file: ./repos/holochain/crates/holochain/src/sweettest/sweet_topos/fact
    
    the code of the file until where you have to start completion: use crate::sweettest::sweet_topos::network::NetworkTopology;
use contrafact::Fact;
use contrafact::Generator;
use contrafact::Mutation;
use rand::Rng;

/// Fact:
/// - The network has a specific number of partitions.
/// - The network is partitioned as strictly as possible. This means that there
///  are no edges between nodes in different partitions.
/// - The partition generation process has a specific efficiency. More efficient
/// partitioning means that the partitions heal more quickly which can lead to
/// one or a few partitions dominating the network. Less efficient partitioning
/// means that the partitions heal more slowly which can lead to a more even
/// distribution of partitions.
#[derive(Clone, Debug)]
pub struct StrictlyPartitionedNetworkFact {
    /// The number of partitions in the network.
    pub partitions: usize,
    /// The efficiency of the partitioning process. This is a number between 0
    /// and 1. The higher the number, the more efficient the partitioning
    /// process.
    pub efficiency: f64,
}

impl<'a> Fact<'a, NetworkTopology> for StrictlyPartitionedNetworkFact {
    fn mutate(
        &mut self,
        g: &mut Generator<'a>,
        mut graph: NetworkTopology,
    ) -> Mutation<NetworkTopology> {
        let mut rng = super::rng_from_generator(g);
        let efficiency_cutoff = (self.efficiency * u64::MAX as f64) as u64;

        // Remove edges until the graph is partitioned into the desired number of
        // partitions. The edges are removed randomly, so this is not the most
        /
    
    fn test_sweet_topos_strictly_partitioned_network_dozen_nodes_three_partitions() {
        crate::big_stack_test!(
            async move {
                let mut g = unstructured_noise().into();
                let mut size_fact = SizedNetworkFact {
                    nodes: 12,
                    agents: 1..=2,
                };
                let mut partition_fact = StrictlyPartitionedNetworkFact {
                    partitions: 3,
                    efficiency: 0.2,
                };
                // let facts = facts![size_fact, partition_fact];
                let mut graph = NetworkTopology::default();
                graph = size_fact.mutate(&mut g, graph).unwrap();
                tracing::info!(
                    "{:?}",
                    Dot::with_config(
                        graph.as_ref(),
                        &[
                            //     Config::GraphContentOnly,
                            Config::NodeNoLabel,
                            Config::EdgeNoLabel,
                        ],
                    )
                );
                graph = partition_fact.mutate(&mut g, graph).unwrap();
                assert_eq!(connected_components(graph.as_ref()), 3);

                tracing::info!(
                    "{:?}",
                    Dot::with_config(
                        graph.as_ref(),
                        &[
                            //     Config::GraphContentOnly,
                            Config::NodeNoLabel,
                            Config::EdgeNoLabel,
                        ],
                    )
                );
            },
            3_000_000
        );
    }