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: inbound_http_route_status.rs
    path of file: ./repos/linkerd2/policy-test/tests
    
    the code of the file until where you have to start completion: use kube::ResourceExt;
use linkerd_policy_controller_k8s_api as k8s;
use linkerd_policy_test::{
    await_condition, await_route_status, create, find_route_condition, mk_route, with_temp_ns,
};

#[tokio::test(flavor = "current_thread")]
async fn inbound_accepted_parent() {
    with_temp_ns(|client, ns| async move {
        // Create a test 'Server'
        let server_name = "test-accepted-server";
        let server = k8s::policy::Server {
            metadata: k8s::ObjectMeta {
                namespace: Some(ns.to_string()),
                name: Some(server_name.to_string()),
                ..Default::default()
            },
            spec: k8s::policy::ServerSpec {
                selector: k8s::policy::server::Selector::Pod(k8s::labels::Selector::from_iter(
                    Some(("app", server_name)),
                )),
                port: k8s::policy::server::Port::Name("http".to_string()),
                proxy_protocol: Some(k8s::policy::server::ProxyProtocol::Http1),
            },
        };
        let server = create(&client, server).await;
        let srv_ref = vec![k8s::policy::httproute::ParentReference {
            group: Some("policy.linkerd.io".to_string()),
            kind: Some("Server".to_string()),
            namespace: server.namespace(),
            name: server.name_unchecked(),
            section_name: None,
            port: None,
        }];

        // Create a route that references the Server resource.
        let _route = create(&client, mk_route(&ns, "test-accepted-route", Some(srv_ref))).await;
        // Wait until route is updated with a status
        let statuses = await_route_status(&client, &ns, "test-accepted-route")
            .await
            .parents;

        let route_status = statuses
            .clone()
            .into_iter()
            .find(|route_status| route_status.parent_ref.name == server_name)
            .expect("must have at least one parent status");

        // Check sta
    
async fn inbound_multiple_parents() {
    with_temp_ns(|client, ns| async move {
        // Exercise accepted test with a valid, and an invalid parent reference
        let srv_refs = vec![
            k8s::policy::httproute::ParentReference {
                group: Some("policy.linkerd.io".to_string()),
                kind: Some("Server".to_string()),
                namespace: Some(ns.clone()),
                name: "test-valid-server".to_string(),
                section_name: None,
                port: None,
            },
            k8s::policy::httproute::ParentReference {
                group: Some("policy.linkerd.io".to_string()),
                kind: Some("Server".to_string()),
                namespace: Some(ns.clone()),
                name: "test-invalid-server".to_string(),
                section_name: None,
                port: None,
            },
        ];

        // Create only one of the parents
        let server = k8s::policy::Server {
            metadata: k8s::ObjectMeta {
                namespace: Some(ns.to_string()),
                name: Some("test-valid-server".to_string()),
                ..Default::default()
            },
            spec: k8s::policy::ServerSpec {
                selector: k8s::policy::server::Selector::Pod(k8s::labels::Selector::from_iter(
                    Some(("app", "test-valid-server")),
                )),
                port: k8s::policy::server::Port::Name("http".to_string()),
                proxy_protocol: Some(k8s::policy::server::ProxyProtocol::Http1),
            },
        };
        let _server = create(&client, server).await;

        // Create a route that references both parents.
        let _route = create(
            &client,
            mk_route(&ns, "test-multiple-parents-route", Some(srv_refs)),
        )
        .await;
        // Wait until route is updated with a status
        let parent_status = await_route_status(&client, &ns, "test-multiple-parents-route")
            .await
            .parents;

        // Find status for invalid parent and extract the condition
        let invalid_cond = find_route_condition(&parent_status, "test-invalid-server")
            .expect("must have at least one 'Accepted' condition set for invalid parent");
        // Route shouldn't be accepted
        assert_eq!(invalid_cond.status, "False");
        assert_eq!(invalid_cond.reason, "NoMatchingParent");

        // Find status for valid parent and extract the condition
        let valid_cond = find_route_condition(&parent_status, "test-valid-server")
            .expect("must have at least one 'Accepted' condition set for valid parent");
        assert_eq!(valid_cond.status, "True");
        assert_eq!(valid_cond.reason, "Accepted")
    })
    .await
}