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)]

    /// Primitive ints should not be serialized when they are unset

    /// Test ID: SerPrimitiveInt

    #[::tokio::test]

    async fn ser_primitive_int_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.primitive_int_op().send().await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

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

        ::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,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

        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(), "/primitive-document", "path was incorrect");

    }

    /// Upper case error modeled lower case

    /// Test ID: ServiceLevelErrorClient

    #[::tokio::test]

    async fn service_level_error_client_response() {

        let expected_output = crate::types::error::ExtraError::builder().build();

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

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

                .header("X-Amzn-Errortype", "ExtraError")

                .status(500)

                .body(::aws_smithy_types::body::SdkBody::from(""))

                .unwrap(),

        )

        .unwrap();

        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)]

    /// Keys and values must be url encoded

    /// Test ID: UrlParamsKeyEncoding

    #[::tokio::test]

    async fn url_params_key_encoding_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

            .query_precedence()

            .set_foo(::std::option::Option::Some("&🐱".to_owned()))

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

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

                ret.insert("hello there".to_owned(), "how's your encoding?".to_owned());

                ret.insert("a & b & c".to_owned(), "better encode = this".to_owned());

                ret

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &[

            "bar=%26%F0%9F%90%B1",

            "hello%20there=how%27s%20your%20encoding%3F",

            "a%20%26%20b%20%26%20c=better%20encode%20%3D%20this",

        ];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        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(), "/Precedence", "path was incorrect");

    }

    /// Prefer named query parameters when serializing

    /// Test ID: RestJsonQueryPrecedenceForbid

    #[::tokio::test]

    async fn rest_json_query_precedence_forbid_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

            .query_precedence()

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

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

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

                ret.insert("bar".to_owned(), "fromMap".to_owned());

                ret.insert("qux".to_owned(), "alsoFromMap".to_owned());

                ret

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["bar=named", "qux=alsoFromMap"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        let forbid_params = &["bar=fromMap"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_query_params(&http_request, forbid_params));

        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(), "/Precedence", "path was incorrect");

    }

    /// Prefer named query parameters when serializing

    /// Test ID: RestJsonQueryPrecedence

    #[::tokio::test]

    async fn rest_json_query_precedence_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

            .query_precedence()

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

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

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

                ret.insert("bar".to_owned(), "fromMap".to_owned());

                ret.insert("qux".to_owned(), "alsoFromMap".to_owned());

                ret

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["bar=named", "qux=alsoFromMap"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        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(), "/Precedence", "path was incorrect");

    }

    /// Upper case error modeled lower case

    /// Test ID: ServiceLevelErrorClient

    #[::tokio::test]

    async fn service_level_error_client_response() {

        let expected_output = crate::types::error::ExtraError::builder().build();

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

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

                .header("X-Amzn-Errortype", "ExtraError")

                .status(500)

                .body(::aws_smithy_types::body::SdkBody::from(""))

                .unwrap(),

        )

        .unwrap();

        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)]

    /// Upper case error modeled lower case

    /// Test ID: ServiceLevelErrorClient

    #[::tokio::test]

    async fn service_level_error_client_response() {

        let expected_output = crate::types::error::ExtraError::builder().build();

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

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

                .header("X-Amzn-Errortype", "ExtraError")

                .status(500)

                .body(::aws_smithy_types::body::SdkBody::from(""))

                .unwrap(),

        )

        .unwrap();

        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)]

    /// Test ID: StringPayload

    #[::tokio::test]

    async fn string_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

            .string_payload()

            .set_payload(::std::option::Option::Some("rawstring".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "text/plain")];

        ::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,

            "rawstring",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

        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(), "/StringPayload", "path was incorrect");

    }

    /// Upper case error modeled lower case

    /// Test ID: ServiceLevelErrorClient

    #[::tokio::test]

    async fn service_level_error_client_response() {

        let expected_output = crate::types::error::ExtraError::builder().build();

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

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

                .header("X-Amzn-Errortype", "ExtraError")

                .status(500)

                .body(::aws_smithy_types::body::SdkBody::from(""))

                .unwrap(),

        )

        .unwrap();

features = ["client", "test-util"]

[dev-dependencies.aws-smithy-types]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"

[dev-dependencies.bytes]

version = "1.4.0"

[dev-dependencies.pretty_assertions]

version = "1.3.0"

[dev-dependencies.tokio]

version = "1.23.1"

features = ["macros", "test-util", "rt-multi-thread"]

[features]

test-util = ["aws-smithy-runtime/test-util"]

rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]

behavior-version-latest = []

rustls = ["aws-smithy-runtime/tls-rustls"]

default = ["rt-tokio", "rustls"]

        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 query string parameters with all supported types

    /// Test ID: AllQueryStringTypes

    #[::tokio::test]

    async fn all_query_string_types_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

            .all_query_string_types()

            .set_query_string(::std::option::Option::Some("Hello there".to_owned()))

            .set_query_string_list(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))

            .set_query_string_set(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))

        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(), "GET", "method was incorrect");

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

    }

    /// Handles query string maps

    /// Test ID: RestXmlQueryStringMap

    #[::tokio::test]

    async fn rest_xml_query_string_map_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

            .all_query_string_types()

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

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

                ret.insert("QueryParamsStringKeyA".to_owned(), "Foo".to_owned());

                ret.insert("QueryParamsStringKeyB".to_owned(), "Bar".to_owned());

                ret

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["QueryParamsStringKeyA=Foo", "QueryParamsStringKeyB=Bar"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        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(), "GET", "method was incorrect");

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

    }

    /// Handles escaping all required characters in the query string.

    /// Test ID: RestXmlQueryStringEscaping

    #[::tokio::test]

    async fn rest_xml_query_string_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

            .all_query_string_types()

            .set_query_string(::std::option::Option::Some(" %:/?#[]@!$&'()*+,;=😹".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["String=%20%25%3A%2F%3F%23%5B%5D%40%21%24%26%27%28%29%2A%2B%2C%3B%3D%F0%9F%98%B9"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        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(), "GET", "method was incorrect");

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

    }

    /// Supports handling NaN float query values.

    /// Test ID: RestXmlSupportsNaNFloatQueryValues

    #[::tokio::test]

    async fn rest_xml_supports_na_n_float_query_values_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

            .all_query_string_types()

            .set_query_float(::std::option::Option::Some(

                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),

            ))

            .set_query_double(::std::option::Option::Some(

                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),

            ))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["Float=NaN", "Double=NaN"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        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(), "GET", "method was incorrect");

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

    }

    /// Supports handling Infinity float query values.

    /// Test ID: RestXmlSupportsInfinityFloatQueryValues

    #[::tokio::test]

    async fn rest_xml_supports_infinity_float_query_values_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

            .all_query_string_types()

            .set_query_float(::std::option::Option::Some(

                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),

            ))

            .set_query_double(::std::option::Option::Some(

                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),

            ))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["Float=Infinity", "Double=Infinity"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        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(), "GET", "method was incorrect");

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

    }

    /// Supports handling -Infinity float query values.

    /// Test ID: RestXmlSupportsNegativeInfinityFloatQueryValues

    #[::tokio::test]

    async fn rest_xml_supports_negative_infinity_float_query_values_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

            .all_query_string_types()

            .set_query_float(::std::option::Option::Some(

                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),

            ))

            .set_query_double(::std::option::Option::Some(

                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),

            ))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["Float=-Infinity", "Double=-Infinity"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        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(), "GET", "method was incorrect");

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

    }

    /// Query values of 0 and false are serialized

    /// Test ID: RestXmlZeroAndFalseQueryValues

    #[::tokio::test]

    async fn rest_xml_zero_and_false_query_values_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

            .all_query_string_types()

            .set_query_integer(::std::option::Option::Some(0))

            .set_query_boolean(::std::option::Option::Some(false))

            .send()

        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 a payload using a wrapper name based on the xmlName

    /// Test ID: BodyWithXmlName

    #[::tokio::test]

    async fn body_with_xml_name_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

            .body_with_xml_name()

            .set_nested(::std::option::Option::Some(

                crate::types::PayloadWithXmlName::builder()

                    .set_name(::std::option::Option::Some("Phreddy".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 required_headers = &["Content-Length"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_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,

            "<Ahoy><nested><name>Phreddy</name></nested></Ahoy>",

            ::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(), "/BodyWithXmlName", "path was incorrect");

    }

    /// Serializes a payload using a wrapper name based on the xmlName

    /// Test ID: BodyWithXmlName

    #[::tokio::test]

    async fn body_with_xml_name_response() {

        let expected_output = crate::operation::body_with_xml_name::BodyWithXmlNameOutput::builder()

            .set_nested(::std::option::Option::Some(

                crate::types::PayloadWithXmlName::builder()

                    .set_name(::std::option::Option::Some("Phreddy".to_owned()))

                    .build(),

            ))

            .build();

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

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

        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)]

    /// Mixes constant and variable query string parameters

    /// Test ID: ConstantAndVariableQueryStringMissingOneValue

    #[::tokio::test]

    async fn constant_and_variable_query_string_missing_one_value_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

            .constant_and_variable_query_string()

            .set_baz(::std::option::Option::Some("bam".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["foo=bar", "baz=bam"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        let forbid_params = &["maybeSet"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_query_params(&http_request, forbid_params));

        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(), "GET", "method was incorrect");

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

    }

    /// Mixes constant and variable query string parameters

    /// Test ID: ConstantAndVariableQueryStringAllValues

    #[::tokio::test]

    async fn constant_and_variable_query_string_all_values_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

            .constant_and_variable_query_string()

            .set_baz(::std::option::Option::Some("bam".to_owned()))

            .set_maybe_set(::std::option::Option::Some("yes".to_owned()))

            .send()

        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)]

    /// Includes constant query string parameters

    /// Test ID: ConstantQueryString

    #[::tokio::test]

    async fn constant_query_string_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

            .constant_query_string()

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

            .send()

            .await;

        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)]

    /// Ensures that clients can correctly parse datetime (timestamps) with offsets

    /// Test ID: RestXmlDateTimeWithNegativeOffset

    #[::tokio::test]

    async fn rest_xml_date_time_with_negative_offset_response() {

        let expected_output = crate::operation::datetime_offsets::DatetimeOffsetsOutput::builder()

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

                1576540098, 0_f64,

            )))

            .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(

                    "<DatetimeOffsetsOutput>\n    <datetime>2019-12-16T22:48:18-01:00</datetime>\n</DatetimeOffsetsOutput>\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::datetime_offsets::DatetimeOffsets::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::datetime_offsets::DatetimeOffsetsOutput>()

            .unwrap();

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

    }

    /// Ensures that clients can correctly parse datetime (timestamps) with offsets

    /// Test ID: RestXmlDateTimeWithPositiveOffset

    #[::tokio::test]

    async fn rest_xml_date_time_with_positive_offset_response() {

        let expected_output = crate::operation::datetime_offsets::DatetimeOffsetsOutput::builder()

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

                1576540098, 0_f64,

            )))

            .build();

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

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

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

                .status(200)

        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 input serializes no payload

    /// Test ID: EmptyInputAndEmptyOutput

    #[::tokio::test]

    async fn empty_input_and_empty_output_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.empty_input_and_empty_output().send().await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        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(), "/EmptyInputAndEmptyOutput", "path was incorrect");

    }

    /// Empty output serializes no payload

    /// Test ID: EmptyInputAndEmptyOutput

    #[::tokio::test]

    async fn empty_input_and_empty_output_response() {

        let expected_output = crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput::builder().build();

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

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

                .status(200)

                .body(::aws_smithy_types::body::SdkBody::from(""))

                .unwrap(),

        )

        .unwrap();

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