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

    /// Serializes flattened XML maps in responses that have xmlNamespace and xmlName on members

    /// Test ID: RestXmlFlattenedXmlMapWithXmlNamespace

    #[::tokio::test]

    async fn rest_xml_flattened_xml_map_with_xml_namespace_response() {

        let expected_output = crate::operation::flattened_xml_map_with_xml_namespace::FlattenedXmlMapWithXmlNamespaceOutput::builder()

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

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

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

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

                ret

            }))

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

    /// Ensures that clients can correctly parse datetime timestamps with fractional seconds

    /// Test ID: RestXmlDateTimeWithFractionalSeconds

    #[::tokio::test]

    async fn rest_xml_date_time_with_fractional_seconds_response() {

        let expected_output = crate::operation::fractional_seconds::FractionalSecondsOutput::builder()

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

                946845296, 0.123_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)]

    /// Ensures that operations with errors successfully know how to deserialize the successful response

    /// Test ID: GreetingWithErrors

    #[::tokio::test]

    async fn greeting_with_errors_response() {

        let expected_output = crate::operation::greeting_with_errors::GreetingWithErrorsOutput::builder()

            .set_greeting(::std::option::Option::Some("Hello".to_owned()))

            .build();

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

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

                .header("X-Greeting", "Hello")

                .status(200)

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

                .unwrap(),

        )

        .unwrap();

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

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

        let op = crate::operation::greeting_with_errors::GreetingWithErrors::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::greeting_with_errors::GreetingWithErrorsOutput>()

            .unwrap();

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

    }

    /// Parses simple XML errors

    /// Test ID: InvalidGreetingError

    #[::tokio::test]

    async fn invalid_greeting_error_response() {

        let expected_output = crate::types::error::InvalidGreeting::builder()

            .set_message(::std::option::Option::Some("Hi".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(400)

                    .body(::aws_smithy_types::body::SdkBody::from("<ErrorResponse>\n   <Error>\n      <Type>Sender</Type>\n      <Code>InvalidGreeting</Code>\n      <Message>Hi</Message>\n      <AnotherSetting>setting</AnotherSetting>\n   </Error>\n   <RequestId>foo-id</RequestId>\n</ErrorResponse>\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::greeting_with_errors::GreetingWithErrors::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_err("should be error response");

        let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =

            parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();

        if let crate::operation::greeting_with_errors::GreetingWithErrorsError::InvalidGreeting(parsed) = parsed {

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

        } else {

            panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);

        }

    }

    /// Test ID: ComplexError

    #[::tokio::test]

    async fn complex_error_response() {

        let expected_output = crate::types::error::ComplexError::builder()

            .set_header(::std::option::Option::Some("Header".to_owned()))

            .set_top_level(::std::option::Option::Some("Top level".to_owned()))

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

                crate::types::ComplexNestedErrorData::builder()

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

                    .build(),

            ))

            .build();

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

    #[::tokio::test]

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

            .http_enum_payload()

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

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

            ))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

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

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

            body,

            "enumvalue",

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

    }

    /// Test ID: RestXmlEnumPayloadResponse

    #[::tokio::test]

    async fn rest_xml_enum_payload_response_response() {

        let expected_output = crate::operation::http_enum_payload::HttpEnumPayloadOutput::builder()

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

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

            ))

            .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("enumvalue"))

        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 blob in the HTTP payload

    /// Test ID: HttpPayloadTraitsWithBlob

    #[::tokio::test]

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

            .http_payload_traits()

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

            .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("X-Foo", "Foo")];

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

            "blobby blob blob",

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

    }

    /// Serializes an empty blob in the HTTP payload

    /// Test ID: HttpPayloadTraitsWithNoBlobBody

    #[::tokio::test]

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

            .http_payload_traits()

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

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("X-Foo", "Foo")];

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

    }

    /// Serializes a blob in the HTTP payload

    /// Test ID: HttpPayloadTraitsWithBlob

    #[::tokio::test]

    async fn http_payload_traits_with_blob_response() {

        let expected_output = crate::operation::http_payload_traits::HttpPayloadTraitsOutput::builder()

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

            .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")))

            .build();

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

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

                .header("X-Foo", "Foo")

                .status(200)

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

                .unwrap(),

        )

        .unwrap();

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

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

        let op = crate::operation::http_payload_traits::HttpPayloadTraits::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::http_payload_traits::HttpPayloadTraitsOutput>()

            .unwrap();

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

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

    }

    /// Serializes an empty blob in the HTTP payload

    /// Test ID: HttpPayloadTraitsWithNoBlobBody

    #[::tokio::test]

    async fn http_payload_traits_with_no_blob_body_response() {

        let expected_output = crate::operation::http_payload_traits::HttpPayloadTraitsOutput::builder()

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

            .build();

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

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

                .header("X-Foo", "Foo")

                .status(200)

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

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

    /// Serializes a blob in the HTTP payload with a content-type

    /// Test ID: HttpPayloadTraitsWithMediaTypeWithBlob

    #[::tokio::test]

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

            .http_payload_traits_with_media_type()

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

            .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

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

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

            "blobby blob blob",

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

    }

    /// Serializes a blob in the HTTP payload with a content-type

    /// Test ID: HttpPayloadTraitsWithMediaTypeWithBlob

    #[::tokio::test]

    async fn http_payload_traits_with_media_type_with_blob_response() {

        let expected_output = crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeOutput::builder()

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

            .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")))

            .build();

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

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

                .header("Content-Type", "text/plain")

                .header("X-Foo", "Foo")

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

    /// Serializes a structure in the payload using a wrapper name based on member xmlName

    /// Test ID: HttpPayloadWithMemberXmlName

    #[::tokio::test]

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

            .http_payload_with_member_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,

            "<Hola><name>Phreddy</name></Hola>",

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

    }

    /// Serializes a structure in the payload using a wrapper name based on member xmlName

    /// Test ID: HttpPayloadWithMemberXmlName

    #[::tokio::test]

    async fn http_payload_with_member_xml_name_response() {

        let expected_output = crate::operation::http_payload_with_member_xml_name::HttpPayloadWithMemberXmlNameOutput::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)]

    /// Serializes a structure in the payload

    /// Test ID: HttpPayloadWithStructure

    #[::tokio::test]

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

            .http_payload_with_structure()

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

                crate::types::NestedPayload::builder()

                    .set_greeting(::std::option::Option::Some("hello".to_owned()))

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

            "<NestedPayload>\n    <greeting>hello</greeting>\n    <name>Phreddy</name>\n</NestedPayload>\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(), "/HttpPayloadWithStructure", "path was incorrect");

    }

    /// Serializes a structure in the payload

    /// Test ID: HttpPayloadWithStructure

    #[::tokio::test]

    async fn http_payload_with_structure_response() {

        let expected_output = crate::operation::http_payload_with_structure::HttpPayloadWithStructureOutput::builder()

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

                crate::types::NestedPayload::builder()

                    .set_greeting(::std::option::Option::Some("hello".to_owned()))

                    .set_name(::std::option::Option::Some("Phreddy".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)]

    /// Serializes a union in the payload.

    /// Test ID: RestXmlHttpPayloadWithUnion

    #[::tokio::test]

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

            .http_payload_with_union()

            .set_nested(::std::option::Option::Some(crate::types::UnionPayload::Greeting("hello".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 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,

            "<UnionPayload>\n    <greeting>hello</greeting>\n</UnionPayload>",

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

    }

    /// No payload is sent if the union has no value.

    /// Test ID: RestXmlHttpPayloadWithUnsetUnion

    #[::tokio::test]

    async fn rest_xml_http_payload_with_unset_union_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.http_payload_with_union().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(), "PUT", "method was incorrect");

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

    }

    /// Serializes a union in the payload.

    /// Test ID: RestXmlHttpPayloadWithUnion

    #[::tokio::test]

    async fn rest_xml_http_payload_with_union_response() {

        let expected_output = crate::operation::http_payload_with_union::HttpPayloadWithUnionOutput::builder()

            .set_nested(::std::option::Option::Some(crate::types::UnionPayload::Greeting("hello".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(

                    "<UnionPayload>\n    <greeting>hello</greeting>\n</UnionPayload>",

                ))

                .unwrap(),

        )

        .unwrap();

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

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

        let op = crate::operation::http_payload_with_union::HttpPayloadWithUnion::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::http_payload_with_union::HttpPayloadWithUnionOutput>()

            .unwrap();

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

    }

    /// No payload is sent if the union has no value.

    /// Test ID: RestXmlHttpPayloadWithUnsetUnion

    #[::tokio::test]

    async fn rest_xml_http_payload_with_unset_union_response() {

        let expected_output = crate::operation::http_payload_with_union::HttpPayloadWithUnionOutput::builder().build();

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

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

                .header("Content-Length", "0")

                .status(200)

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

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

    /// Test ID: HttpPayloadWithXmlName

    #[::tokio::test]

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

            .http_payload_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,

            "<Hello><name>Phreddy</name></Hello>",

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

    }

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

    /// Test ID: HttpPayloadWithXmlName

    #[::tokio::test]

    async fn http_payload_with_xml_name_response() {

        let expected_output = crate::operation::http_payload_with_xml_name::HttpPayloadWithXmlNameOutput::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)]

    /// Serializes a structure in the payload using a wrapper with an XML namespace

    /// Test ID: HttpPayloadWithXmlNamespace

    #[::tokio::test]

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

            .http_payload_with_xml_namespace()

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

                crate::types::PayloadWithXmlNamespace::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,

            "<PayloadWithXmlNamespace xmlns=\"http://foo.com\">\n    <name>Phreddy</name>\n</PayloadWithXmlNamespace>",

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

    }

    /// Serializes a structure in the payload using a wrapper with an XML namespace

    /// Test ID: HttpPayloadWithXmlNamespace

    #[::tokio::test]

    async fn http_payload_with_xml_namespace_response() {

        let expected_output = crate::operation::http_payload_with_xml_namespace::HttpPayloadWithXmlNamespaceOutput::builder()

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

                crate::types::PayloadWithXmlNamespace::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()