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: tracer.rs
    path of file: ./repos/trippy/tests/sim
    
    the code of the file until where you have to start completion: use crate::simulation::{Response, Simulation, SingleHost};
use std::cell::RefCell;
use std::num::NonZeroUsize;
use std::sync::Arc;
use std::thread;
use std::time::Duration;
use tokio_util::sync::CancellationToken;
use tracing::info;
use trippy::tracing::{
    defaults, Builder, CompletionReason, MaxRounds, MultipathStrategy, PacketSize, PayloadPattern,
    PortDirection, PrivilegeMode, ProbeState, Protocol, TimeToLive, TraceId, TracerRound,
};

// The length of time to wait after the completion of the tracing before
// cancelling the network s
    
    fn validate_round(&self, round: &TracerRound<'_>, result: &RefCell<anyhow::Result<()>>) {
        assert_eq_result!(result, round.reason, CompletionReason::TargetFound);
        assert_eq_result!(result, TimeToLive(self.sim.latest_ttl()), round.largest_ttl);
        for hop in round
            .probes
            .iter()
            .filter(|p| matches!(p, ProbeState::Awaited(_) | ProbeState::Complete(_)))
            .take(round.largest_ttl.0 as usize)
        {
            match hop {
                ProbeState::Complete(complete) => {
                    info!(
                        "{} {} {}",
                        complete.round.0,
                        complete.ttl.0,
                        complete.host.to_string(),
                    );

                    let hop_index = usize::from(complete.ttl.0 - 1);
                    let sim_hop = &self.sim.hops[hop_index];
                    if let Response::NoResponse = sim_hop.resp {
                        error_result!(result, anyhow::anyhow!("expected Response::SingleHost"));
                    }
                    let expected_host = match sim_hop.resp {
                        Response::NoResponse => None,
                        Response::SingleHost(SingleHost { addr, .. }) => Some(addr),
                    };
                    assert_eq_result!(result, expected_host, Some(complete.host));
                    let expected_ttl = TimeToLive(self.sim.hops[hop_index].ttl);
                    assert_eq_result!(result, expected_ttl, complete.ttl);
                }
                ProbeState::Awaited(awaited) => {
                    info!("{} {} * * *", awaited.round.0, awaited.ttl.0);

                    let hop_index = usize::from(awaited.ttl.0 - 1);
                    let sim_hop = &self.sim.hops[hop_index];
                    if let Response::SingleHost(_) = sim_hop.resp {
                        error_result!(result, anyhow::anyhow!("expected Response::NoResponse"));
                    }
                    let expected_host = match sim_hop.resp {
                        Response::NoResponse => None,
                        Response::SingleHost(SingleHost { addr, .. }) => Some(addr),
                    };
                    assert_eq_result!(result, expected_host, None);
                    let expected_ttl = TimeToLive(self.sim.hops[hop_index].ttl);
                    assert_eq_result!(result, expected_ttl, awaited.ttl);
                }
                _ => {}
            }
        }
    }