Client Test

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Tests how timestamp request headers are serialized

    /// Test ID: TimestampFormatHeaders

    #[::tokio::test]

    async fn timestamp_format_headers_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .timestamp_format_headers()

            .set_member_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .set_member_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .set_member_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .set_default_format(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .set_target_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .set_target_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .set_target_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [

            ("X-defaultFormat", "Mon, 16 Dec 2019 23:48:18 GMT"),

            ("X-memberDateTime", "2019-12-16T23:48:18Z"),

            ("X-memberEpochSeconds", "1576540098"),

            ("X-memberHttpDate", "Mon, 16 Dec 2019 23:48:18 GMT"),

            ("X-targetDateTime", "2019-12-16T23:48:18Z"),

            ("X-targetEpochSeconds", "1576540098"),

            ("X-targetHttpDate", "Mon, 16 Dec 2019 23:48:18 GMT"),

        ];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body

        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/TimestampFormatHeaders", "path was incorrect");

    }

    /// Tests how timestamp response headers are serialized

    /// Test ID: TimestampFormatHeaders

    #[::tokio::test]

    async fn timestamp_format_headers_response() {

        let expected_output = crate::operation::timestamp_format_headers::TimestampFormatHeadersOutput::builder()

            .set_member_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .set_member_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .set_member_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Serializes XML attributes on the synthesized document

    /// Test ID: XmlAttributes

    #[::tokio::test]

    async fn xml_attributes_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .xml_attributes()

            .set_foo(::std::option::Option::Some("hi".to_owned()))

            .set_attr(::std::option::Option::Some("test".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/xml")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "<XmlAttributesRequest test=\"test\">\n    <foo>hi</foo>\n</XmlAttributesRequest>\n",

            ::aws_smithy_protocol_test::MediaType::from("application/xml"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/XmlAttributes", "path was incorrect");

    }

    /// Serializes XML attributes with escaped characters on the synthesized document

    /// Test ID: XmlAttributesWithEscaping

    #[::tokio::test]

    async fn xml_attributes_with_escaping_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .xml_attributes()

            .set_foo(::std::option::Option::Some("hi".to_owned()))

            .set_attr(::std::option::Option::Some("<test&mock>".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/xml")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "<XmlAttributesRequest test=\"&lt;test&amp;mock&gt;\">\n    <foo>hi</foo>\n</XmlAttributesRequest>\n",

            ::aws_smithy_protocol_test::MediaType::from("application/xml"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/XmlAttributes", "path was incorrect");

    }

    /// Serializes simple scalar properties

    /// Test ID: XmlAttributes

    #[::tokio::test]

    async fn xml_attributes_response() {

        let expected_output = crate::operation::xml_attributes::XmlAttributesOutput::builder()

            .set_foo(::std::option::Option::Some("hi".to_owned()))

            .set_attr(::std::option::Option::Some("test".to_owned()))

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

            ::http::response::Builder::new()

                .header("Content-Type", "application/xml")

                .status(200)

                .body(::aws_smithy_types::body::SdkBody::from(

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Serializes XML attributes on the synthesized document

    /// Test ID: XmlAttributesOnPayload

    #[::tokio::test]

    async fn xml_attributes_on_payload_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .xml_attributes_on_payload()

            .set_payload(::std::option::Option::Some(

                crate::types::XmlAttributesPayloadRequest::builder()

                    .set_foo(::std::option::Option::Some("hi".to_owned()))

                    .set_attr(::std::option::Option::Some("test".to_owned()))

                    .build(),

            ))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/xml")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "<XmlAttributesPayloadRequest test=\"test\">\n    <foo>hi</foo>\n</XmlAttributesPayloadRequest>\n",

            ::aws_smithy_protocol_test::MediaType::from("application/xml"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/XmlAttributesOnPayload", "path was incorrect");

    }

    /// Serializes simple scalar properties

    /// Test ID: XmlAttributesOnPayload

    #[::tokio::test]

    async fn xml_attributes_on_payload_response() {

        let expected_output = crate::operation::xml_attributes_on_payload::XmlAttributesOnPayloadOutput::builder()

            .set_payload(::std::option::Option::Some(

                crate::types::XmlAttributesPayloadResponse::builder()

                    .set_foo(::std::option::Option::Some("hi".to_owned()))

                    .set_attr(::std::option::Option::Some("test".to_owned()))

                    .build(),

            ))

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Blobs are base64 encoded

    /// Test ID: XmlBlobs

    #[::tokio::test]

    async fn xml_blobs_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .xml_blobs()

            .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("value")))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/xml")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "<XmlBlobsRequest>\n    <data>dmFsdWU=</data>\n</XmlBlobsRequest>\n",

            ::aws_smithy_protocol_test::MediaType::from("application/xml"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/XmlBlobs", "path was incorrect");

    }

    /// Blobs are base64 encoded

    /// Test ID: XmlBlobs

    #[::tokio::test]

    async fn xml_blobs_response() {

        let expected_output = crate::operation::xml_blobs::XmlBlobsOutput::builder()

            .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("value")))

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

            ::http::response::Builder::new()

                .header("Content-Type", "application/xml")

                .status(200)

                .body(::aws_smithy_types::body::SdkBody::from(

                    "<XmlBlobsResponse>\n    <data>dmFsdWU=</data>\n</XmlBlobsResponse>\n",

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Empty blobs are deserialized as empty string

    /// Test ID: XmlEmptyBlobs

    #[::tokio::test]

    async fn xml_empty_blobs_response() {

        let expected_output = crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput::builder()

            .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("")))

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

            ::http::response::Builder::new()

                .header("Content-Type", "application/xml")

                .status(200)

                .body(::aws_smithy_types::body::SdkBody::from(

                    "<XmlEmptyBlobsResponse>\n    <data></data>\n</XmlEmptyBlobsResponse>\n",

                ))

                .unwrap(),

        )

        .unwrap();

        use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

        use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;

        let op = crate::operation::xml_empty_blobs::XmlEmptyBlobs::new();

        let config = op.config().expect("the operation has config");

        let de = config

            .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

            .expect("the config must have a deserializer");

        let parsed = de.deserialize_streaming(&mut http_response);

        let parsed = parsed.unwrap_or_else(|| {

            let http_response =

                http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));

            de.deserialize_nonstreaming(&http_response)

        });

        let parsed = parsed

            .expect("should be successful response")

            .downcast::<crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput>()

            .unwrap();

        ::pretty_assertions::assert_eq!(parsed.data, expected_output.data, "Unexpected value for `data`");

    }

    /// Empty self closed blobs are deserialized as empty string

    /// Test ID: XmlEmptySelfClosedBlobs

    #[::tokio::test]

    async fn xml_empty_self_closed_blobs_response() {

        let expected_output = crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput::builder()

            .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("")))

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

            ::http::response::Builder::new()

                .header("Content-Type", "application/xml")

                .status(200)

                .body(::aws_smithy_types::body::SdkBody::from(

                    "<XmlEmptyBlobsResponse>\n    <data/>\n</XmlEmptyBlobsResponse>\n",

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Serializes Empty XML lists

    /// Test ID: XmlEmptyLists

    #[::tokio::test]

    async fn xml_empty_lists_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .xml_empty_lists()

            .set_string_list(::std::option::Option::Some(vec![]))

            .set_string_set(::std::option::Option::Some(vec![]))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/xml")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "<XmlEmptyListsRequest>\n        <stringList></stringList>\n        <stringSet></stringSet>\n</XmlEmptyListsRequest>\n",

            ::aws_smithy_protocol_test::MediaType::from("application/xml"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/XmlEmptyLists", "path was incorrect");

    }

    /// Deserializes Empty XML lists

    /// Test ID: XmlEmptyLists

    #[::tokio::test]

    async fn xml_empty_lists_response() {

        let expected_output = crate::operation::xml_empty_lists::XmlEmptyListsOutput::builder()

            .set_string_list(::std::option::Option::Some(vec![]))

            .set_string_set(::std::option::Option::Some(vec![]))

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

            ::http::response::Builder::new()

                .header("Content-Type", "application/xml")

                .status(200)

                .body(::aws_smithy_types::body::SdkBody::from(

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Serializes Empty XML maps

    /// Test ID: XmlEmptyMaps

    #[::tokio::test]

    async fn xml_empty_maps_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .xml_empty_maps()

            .set_my_map(::std::option::Option::Some(::std::collections::HashMap::new()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/xml")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "<XmlEmptyMapsRequest>\n    <myMap></myMap>\n</XmlEmptyMapsRequest>\n",

            ::aws_smithy_protocol_test::MediaType::from("application/xml"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/XmlEmptyMaps", "path was incorrect");

    }

    /// Deserializes Empty XML maps

    /// Test ID: XmlEmptyMaps

    #[::tokio::test]

    async fn xml_empty_maps_response() {

        let expected_output = crate::operation::xml_empty_maps::XmlEmptyMapsOutput::builder()

            .set_my_map(::std::option::Option::Some(::std::collections::HashMap::new()))

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

            ::http::response::Builder::new()

                .header("Content-Type", "application/xml")

                .status(200)

                .body(::aws_smithy_types::body::SdkBody::from(

                    "<XmlEmptyMapsResponse>\n    <myMap></myMap>\n</XmlEmptyMapsResponse>\n",

                ))

                .unwrap(),

        )

        .unwrap();

        use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

        use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;

        let op = crate::operation::xml_empty_maps::XmlEmptyMaps::new();

        let config = op.config().expect("the operation has config");

        let de = config

            .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

            .expect("the config must have a deserializer");

        let parsed = de.deserialize_streaming(&mut http_response);

        let parsed = parsed.unwrap_or_else(|| {

            let http_response =

                http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));

            de.deserialize_nonstreaming(&http_response)

        });

        let parsed = parsed

            .expect("should be successful response")

            .downcast::<crate::operation::xml_empty_maps::XmlEmptyMapsOutput>()

            .unwrap();

        ::pretty_assertions::assert_eq!(parsed.my_map, expected_output.my_map, "Unexpected value for `my_map`");

    }

    /// Deserializes Empty Self-closed XML maps

    /// Test ID: XmlEmptySelfClosedMaps

    #[::tokio::test]

    async fn xml_empty_self_closed_maps_response() {

        let expected_output = crate::operation::xml_empty_maps::XmlEmptyMapsOutput::builder()

            .set_my_map(::std::option::Option::Some(::std::collections::HashMap::new()))

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

            ::http::response::Builder::new()

                .header("Content-Type", "application/xml")

                .status(200)

                .body(::aws_smithy_types::body::SdkBody::from(

                    "<XmlEmptyMapsResponse>\n    <myMap/>\n</XmlEmptyMapsResponse>\n",

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Serializes xml empty strings

    /// Test ID: XmlEmptyStrings

    #[::tokio::test]

    async fn xml_empty_strings_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .xml_empty_strings()

            .set_empty_string(::std::option::Option::Some("".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/xml")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "<XmlEmptyStringsRequest>\n    <emptyString></emptyString>\n</XmlEmptyStringsRequest>\n",

            ::aws_smithy_protocol_test::MediaType::from("application/xml"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/XmlEmptyStrings", "path was incorrect");

    }

    /// Deserializes xml empty strings

    /// Test ID: XmlEmptyStrings

    #[::tokio::test]

    async fn xml_empty_strings_response() {

        let expected_output = crate::operation::xml_empty_strings::XmlEmptyStringsOutput::builder()

            .set_empty_string(::std::option::Option::Some("".to_owned()))

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

            ::http::response::Builder::new()

                .header("Content-Type", "application/xml")

                .status(200)

                .body(::aws_smithy_types::body::SdkBody::from(

                    "<XmlEmptyStringsResponse>\n    <emptyString></emptyString>\n</XmlEmptyStringsResponse>\n",

                ))

                .unwrap(),

        )

        .unwrap();

        use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

        use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;

        let op = crate::operation::xml_empty_strings::XmlEmptyStrings::new();

        let config = op.config().expect("the operation has config");

        let de = config

            .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

            .expect("the config must have a deserializer");

        let parsed = de.deserialize_streaming(&mut http_response);

        let parsed = parsed.unwrap_or_else(|| {

            let http_response =

                http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));

            de.deserialize_nonstreaming(&http_response)

        });

        let parsed = parsed

            .expect("should be successful response")

            .downcast::<crate::operation::xml_empty_strings::XmlEmptyStringsOutput>()

            .unwrap();

        ::pretty_assertions::assert_eq!(parsed.empty_string, expected_output.empty_string, "Unexpected value for `empty_string`");

    }

    /// Empty self closed string are deserialized as empty string

    /// Test ID: XmlEmptySelfClosedStrings

    #[::tokio::test]

    async fn xml_empty_self_closed_strings_response() {

        let expected_output = crate::operation::xml_empty_strings::XmlEmptyStringsOutput::builder()

            .set_empty_string(::std::option::Option::Some("".to_owned()))

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

            ::http::response::Builder::new()

                .header("Content-Type", "application/xml")

                .status(200)

                .body(::aws_smithy_types::body::SdkBody::from(

                    "<XmlEmptyStringsResponse>\n    <emptyString/>\n</XmlEmptyStringsResponse>\n",

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Serializes simple scalar properties

    /// Test ID: XmlEnums

    #[::tokio::test]

    async fn xml_enums_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .xml_enums()

            .set_foo_enum1(::std::option::Option::Some(

                "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),

            ))

            .set_foo_enum2(::std::option::Option::Some(

                "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),

            ))

            .set_foo_enum3(::std::option::Option::Some(

                "1".parse::<crate::types::FooEnum>().expect("static value validated to member"),

            ))

            .set_foo_enum_list(::std::option::Option::Some(vec![

                "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),

                "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),

            ]))

            .set_foo_enum_set(::std::option::Option::Some(vec![

                "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),

                "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),

            ]))

            .set_foo_enum_map(::std::option::Option::Some({

                let mut ret = ::std::collections::HashMap::new();

                ret.insert(

                    "hi".to_owned(),

                    "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),

                );

                ret.insert(

                    "zero".to_owned(),

                    "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),

                );

                ret

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/xml")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(

        ::aws_smithy_protocol_test::validate_body(body, "<XmlEnumsRequest>\n    <fooEnum1>Foo</fooEnum1>\n    <fooEnum2>0</fooEnum2>\n    <fooEnum3>1</fooEnum3>\n    <fooEnumList>\n        <member>Foo</member>\n        <member>0</member>\n    </fooEnumList>\n    <fooEnumSet>\n        <member>Foo</member>\n        <member>0</member>\n    </fooEnumSet>\n    <fooEnumMap>\n        <entry>\n            <key>hi</key>\n            <value>Foo</value>\n        </entry>\n        <entry>\n            <key>zero</key>\n            <value>0</value>\n        </entry>\n    </fooEnumMap>\n</XmlEnumsRequest>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))

        );

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/XmlEnums", "path was incorrect");

    }

    /// Serializes simple scalar properties

    /// Test ID: XmlEnums

    #[::tokio::test]

    async fn xml_enums_response() {

        let expected_output = crate::operation::xml_enums::XmlEnumsOutput::builder()

            .set_foo_enum1(::std::option::Option::Some(

                "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),

            ))

            .set_foo_enum2(::std::option::Option::Some(

                "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),

            ))

            .set_foo_enum3(::std::option::Option::Some(

                "1".parse::<crate::types::FooEnum>().expect("static value validated to member"),

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Serializes simple scalar properties

    /// Test ID: XmlIntEnums

    #[::tokio::test]

    async fn xml_int_enums_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .xml_int_enums()

            .set_int_enum1(::std::option::Option::Some(1))

            .set_int_enum2(::std::option::Option::Some(2))

            .set_int_enum3(::std::option::Option::Some(3))

            .set_int_enum_list(::std::option::Option::Some(vec![1, 2]))

            .set_int_enum_set(::std::option::Option::Some(vec![1, 2]))

            .set_int_enum_map(::std::option::Option::Some({

                let mut ret = ::std::collections::HashMap::new();

                ret.insert("a".to_owned(), 1);

                ret.insert("b".to_owned(), 2);

                ret

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/xml")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(

        ::aws_smithy_protocol_test::validate_body(body, "<XmlIntEnumsRequest>\n    <intEnum1>1</intEnum1>\n    <intEnum2>2</intEnum2>\n    <intEnum3>3</intEnum3>\n    <intEnumList>\n        <member>1</member>\n        <member>2</member>\n    </intEnumList>\n    <intEnumSet>\n        <member>1</member>\n        <member>2</member>\n    </intEnumSet>\n    <intEnumMap>\n        <entry>\n            <key>a</key>\n            <value>1</value>\n        </entry>\n        <entry>\n            <key>b</key>\n            <value>2</value>\n        </entry>\n    </intEnumMap>\n</XmlIntEnumsRequest>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))

        );

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/XmlIntEnums", "path was incorrect");

    }

    /// Serializes simple scalar properties

    /// Test ID: XmlIntEnums

    #[::tokio::test]

    async fn xml_int_enums_response() {

        let expected_output = crate::operation::xml_int_enums::XmlIntEnumsOutput::builder()

            .set_int_enum1(::std::option::Option::Some(1))

            .set_int_enum2(::std::option::Option::Some(2))

            .set_int_enum3(::std::option::Option::Some(3))

            .set_int_enum_list(::std::option::Option::Some(vec![1, 2]))

            .set_int_enum_set(::std::option::Option::Some(vec![1, 2]))

            .set_int_enum_map(::std::option::Option::Some({

                let mut ret = ::std::collections::HashMap::new();

                ret.insert("a".to_owned(), 1);

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Tests for XML list serialization

    /// Test ID: XmlLists

    #[::tokio::test]

    async fn xml_lists_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .xml_lists()

            .set_string_list(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))

            .set_string_set(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))

            .set_integer_list(::std::option::Option::Some(vec![1, 2]))