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: tcp_errors.rs
    path of file: ./repos/linkerd2-proxy/linkerd/app/integration/src/tests/telemetry
    
    the code of the file until where you have to start completion: use super::*;
use std::time::SystemTime;

const TIMEOUT: Duration = Duration::from_millis(640); // 640ms ought to be enough for anybody.

const METRIC: &str = "inbound_tcp_errors_total";

struct Test {
    proxy: Option<proxy::Proxy>,
    identity: Option<identity::Identity>,
    set_env: Box<dyn FnMut(&mut TestEnv)>,
}

impl Default for Test {
    fn default() -> Self {
        Self {
            proxy: None,
            identity: None,
            set_env: Box::new(|_| {}),
        }
    }
}

impl Test {
    fn new(proxy: proxy::Proxy) -> Self {
        Self::default().with_proxy(proxy)
    }

    fn with_identity(self, identity: identity::Identity) -> Self {
        Self {
            identity: Some(identity),
            ..self
        }
    }

    fn with_proxy(self, proxy: proxy::Proxy) -> Self {
        Self {
            proxy: Some(proxy),
            ..self
        }
    }

    fn with_extra_env(self, set_env: impl FnMut(&mut TestEnv) + 'static) -> Self {
        Self {
            set_env: Box::new(set_env),
            ..self
        }
    }

    async fn run(mut self) -
    
async fn inbound_invalid_ip() {
    let _trace = trace_init();
    let srv = server::http2().route("/", "hello world").run().await;
    let fake_ip = SocketAddr::from(([127, 0, 0, 1], 9999));
    let (proxy, metrics) = Test::new(proxy::new().inbound(srv).inbound_ip(fake_ip))
        .with_extra_env(|env| {
            env.put(
                app::env::ENV_INBOUND_IPS,
                "10.5.1.42,10.5.8.167".to_string(),
            );
        })
        .run()
        .await;

    let client = client::tcp(proxy.inbound);
    let metric = metric(&proxy)
        .label("error", "unexpected")
        .label("target_addr", fake_ip);

    let tcp_client = client.connect().await;
    tcp_client.write(TcpFixture::HELLO_MSG).await;
    drop(tcp_client);

    metric.clone().value(1u64).assert_in(&metrics).await;

    // this connectiopn *would* time out, but it doesn't hit the timeout,
    // because the invalid target addr will already have been rejected.
    let tcp_client = client.connect().await;
    tokio::time::sleep(TIMEOUT + Duration::from_millis(15)) // just in case
        .await;
    drop(tcp_client);

    metric.clone().value(2u64).assert_in(&metrics).await;
}