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 a payload targeting an empty blob

    /// Test ID: RestJsonHttpWithEmptyBlobPayload

    #[::tokio::test]

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

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

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

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

    }

    /// Serializes a payload targeting a blob

    /// Test ID: RestJsonTestPayloadBlob

    #[::tokio::test]

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

            .test_payload_blob()

            .set_content_type(::std::option::Option::Some("image/jpg".to_owned()))

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

            .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 targeting an empty structure

    /// Test ID: RestJsonHttpWithEmptyStructurePayload

    #[::tokio::test]

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

            .test_payload_structure()

            .set_payload_config(::std::option::Option::Some(crate::types::PayloadConfig::builder().build()))

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

            "{}",

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

        ));

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

    }

    /// Serializes a payload targeting a structure

    /// Test ID: RestJsonTestPayloadStructure

    #[::tokio::test]

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

            .test_payload_structure()

            .set_payload_config(::std::option::Option::Some(

                crate::types::PayloadConfig::builder().set_data(::std::option::Option::Some(25)).build(),

            ))

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

            "{\"data\": 25\n}",

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

        ));

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

    }

    /// Serializes an request with header members but no payload

    /// Test ID: RestJsonHttpWithHeadersButNoPayload

    #[::tokio::test]

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

            .test_payload_structure()

            .set_test_id(::std::option::Option::Some("t-12345".to_owned()))

            .set_payload_config(::std::option::Option::Some(crate::types::PayloadConfig::builder().build()))

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

    /// Tests how timestamp request headers are serialized

    /// Test ID: RestJsonTimestampFormatHeaders

    #[::tokio::test]

    async fn rest_json_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: RestJsonTimestampFormatHeaders

    #[::tokio::test]

    async fn rest_json_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)]

    /// A unit type input serializes no payload. When clients do not

    /// need to serialize any data in the payload, they should omit

    /// a payload altogether.

    /// Test ID: RestJsonUnitInputAndOutput

    #[::tokio::test]

    async fn rest_json_unit_input_and_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.unit_input_and_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(), "/UnitInputAndOutput", "path was incorrect");

    }

    /// When an operation defines Unit output, the service will respond

    /// with an empty payload, and may optionally include the content-type

    /// header.

    /// Test ID: RestJsonUnitInputAndOutputNoOutput

    #[::tokio::test]

    async fn rest_json_unit_input_and_output_no_output_response() {

        let expected_output = crate::operation::unit_input_and_output::UnitInputAndOutputOutput::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;

[dev-dependencies.aws-smithy-protocol-test]

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

[dev-dependencies.aws-smithy-runtime]

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

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

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

    /// Upper case error modeled lower case. See: https://github.com/smithy-lang/smithy-rs/blob/6c21fb0eb377c7120a8179f4537ba99a4b50ba96/rust-runtime/inlineable/src/json_errors.rs#L51-L51

    /// Test ID: UpperErrorModeledLower

    #[::tokio::test]

    async fn upper_error_modeled_lower_response() {

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

            .set_message(::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-Amzn-Errortype", "CaseInsensitiveError")

                .status(500)

                .body(::aws_smithy_types::body::SdkBody::from("{\"Message\": \"hello\"}"))

                .unwrap(),

        )

        .unwrap();

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

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

        let op = crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperation::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::case_insensitive_error_operation::CaseInsensitiveErrorOperationError =

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

        if let crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::CaseInsensitiveError(parsed) = parsed {

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

        } else {

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

        }

    }

    /// 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: EmptyStructWithContentOnWire

    #[::tokio::test]

    async fn empty_struct_with_content_on_wire_response() {

        let expected_output = crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpOutput::builder()

            .set_empty(::std::option::Option::Some(crate::types::EmptyStruct::builder().build()))

            .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("{\"empty\": {\"value\":\"not actually empty\"}}"))

                .unwrap(),

        )

        .unwrap();

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

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

        let op = crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOp::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::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpOutput>()

            .unwrap();

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

    }

    /// 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: EnumQueryRequest

    #[::tokio::test]

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

            .enum_query()

            .set_enum(::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 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(), "/foo/enumvalue", "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)]

    /// Test ID: EscapedStringValuesRequest

    #[::tokio::test]

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

            .escaped_string_values()

            .set_enum(::std::option::Option::Some(

                "has\"quotes"

                    .parse::<crate::types::EnumWithEscapedChars>()

                    .expect("static value validated to member"),

            ))

            .set_some_string(::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/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,

            "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}",

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

    }

    /// Test ID: EscapedStringValuesResponse

    #[::tokio::test]

    async fn escaped_string_values_response_response() {

        let expected_output = crate::operation::escaped_string_values::EscapedStringValuesOutput::builder()

            .set_enum(::std::option::Option::Some(

                "has\"quotes"

                    .parse::<crate::types::EnumWithEscapedChars>()

                    .expect("static value validated to member"),

            ))

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

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

                    "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}",

                ))

                .unwrap(),

        )

        .unwrap();

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

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

        let op = crate::operation::escaped_string_values::EscapedStringValues::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::escaped_string_values::EscapedStringValuesOutput>()

            .unwrap();

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

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

    }

    /// 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: RestJsonEnumPayloadRequest2

    #[::tokio::test]

    async fn rest_json_enum_payload_request2_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_payload2()

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

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

    }

    /// Test ID: RestJsonEnumPayloadResponse2

    #[::tokio::test]

    async fn rest_json_enum_payload_response2_response() {

        let expected_output = crate::operation::http_enum_payload2::HttpEnumPayload2Output::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()

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

                .status(200)

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

                .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_enum_payload2::HttpEnumPayload2::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_enum_payload2::HttpEnumPayload2Output>()

            .unwrap();

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

    }

    /// 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: RestJsonStringPayloadRequest2

    #[::tokio::test]

    async fn rest_json_string_payload_request2_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_string_payload2()

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

            "rawstring",

            ::aws_smithy_protocol_test::MediaType::from("text/plain"),

        ));

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

    }

    /// Test ID: RestJsonStringPayloadResponse2

    #[::tokio::test]

    async fn rest_json_string_payload_response2_response() {

        let expected_output = crate::operation::http_string_payload2::HttpStringPayload2Output::builder()

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

            .build();

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

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

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

                .status(200)

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

                .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_string_payload2::HttpStringPayload2::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);