Client Test

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

    /// Test ID: reserved_words

    #[::tokio::test]

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

            .reserved_words_as_members()

            .set_as(::std::option::Option::Some(5))

            .set_async(::std::option::Option::Some(true))

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

    /// Test ID: structure_punning

    #[::tokio::test]

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

            .structure_name_punning()

            .set_regular_string(::std::option::Option::Some("hello!".to_owned()))

            .send()

            .await;

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

    /// Test ID: BasicQueryCompatTest

    #[::tokio::test]

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

            .operation()

            .set_message(::std::option::Option::Some("hello!".to_owned()))

            .send()

            .await;

[dev-dependencies.aws-smithy-runtime]

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

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

[dev-dependencies.aws-smithy-types]

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

[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: RestJsonAllQueryStringTypes

    #[::tokio::test]

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

    #[::tokio::test]

    async fn rest_json_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_string_list(::std::option::Option::Some({

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

                ret.insert("QueryParamsStringKeyA".to_owned(), vec!["Foo".to_owned()]);

                ret.insert("QueryParamsStringKeyB".to_owned(), vec!["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: RestJsonQueryStringEscaping

    #[::tokio::test]

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

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

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

                ret.insert("String".to_owned(), vec![" %:/?#[]@!$&'()*+,;=😹".to_owned()]);

                ret

            }))

            .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: RestJsonSupportsNaNFloatQueryValues

    #[::tokio::test]

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

            ))

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

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

                ret.insert("Float".to_owned(), vec!["NaN".to_owned()]);

                ret.insert("Double".to_owned(), vec!["NaN".to_owned()]);

                ret

            }))

            .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: RestJsonSupportsInfinityFloatQueryValues

    #[::tokio::test]

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

            ))

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

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

                ret.insert("Float".to_owned(), vec!["Infinity".to_owned()]);

                ret.insert("Double".to_owned(), vec!["Infinity".to_owned()]);

                ret

            }))

            .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: RestJsonSupportsNegativeInfinityFloatQueryValues

    #[::tokio::test]

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

            ))

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

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

                ret.insert("Float".to_owned(), vec!["-Infinity".to_owned()]);

                ret.insert("Double".to_owned(), vec!["-Infinity".to_owned()]);

                ret

            }))

            .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: RestJsonZeroAndFalseQueryValues

    #[::tokio::test]

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

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

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

    #[::tokio::test]

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

    #[::tokio::test]

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

    #[::tokio::test]

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

    #[::tokio::test]

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

                .status(200)

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

                    "      {\n          \"datetime\": \"2019-12-16T22:48:18-01:00\"\n      }\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: RestJsonDateTimeWithPositiveOffset

    #[::tokio::test]

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

                .status(200)

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

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

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

        })?;

        cfg.interceptor_state()

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

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

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Serializes document types as part of the JSON request payload with no escaping.

    /// Test ID: DocumentTypeInputWithObject

    #[::tokio::test]

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

            .document_type()

            .set_string_value(::std::option::Option::Some("string".to_owned()))

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

                let json_bytes = br#"{

                        "foo": "bar"

                    }"#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

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

            "{\n    \"stringValue\": \"string\",\n    \"documentValue\": {\n        \"foo\": \"bar\"\n    }\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(), "PUT", "method was incorrect");

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

    }

    /// Serializes document types using a string.

    /// Test ID: DocumentInputWithString

    #[::tokio::test]

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

            .document_type()

            .set_string_value(::std::option::Option::Some("string".to_owned()))

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

                let json_bytes = br#""hello""#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

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

            "{\n    \"stringValue\": \"string\",\n    \"documentValue\": \"hello\"\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(), "PUT", "method was incorrect");

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

    }

    /// Serializes document types using a number.

    /// Test ID: DocumentInputWithNumber

    #[::tokio::test]

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

            .document_type()

            .set_string_value(::std::option::Option::Some("string".to_owned()))

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

                let json_bytes = br#"10"#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

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

            "{\n    \"stringValue\": \"string\",\n    \"documentValue\": 10\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(), "PUT", "method was incorrect");

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

    }

    /// Serializes document types using a boolean.

    /// Test ID: DocumentInputWithBoolean

    #[::tokio::test]

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

            .document_type()

            .set_string_value(::std::option::Option::Some("string".to_owned()))

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

                let json_bytes = br#"true"#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

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

            "{\n    \"stringValue\": \"string\",\n    \"documentValue\": true\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(), "PUT", "method was incorrect");

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

    }

    /// Serializes document types using a list.

    /// Test ID: DocumentInputWithList

    #[::tokio::test]

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

            .document_type()

            .set_string_value(::std::option::Option::Some("string".to_owned()))

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

                let json_bytes = br#"[

                        true,

                        "hi",

                        [

                            1,

                            2

                        ],

                        {

                            "foo": {

                                "baz": [

                                    3,

                                    4

                                ]

                            }

                        }

                    ]"#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

            .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, "{\n    \"stringValue\": \"string\",\n    \"documentValue\": [\n        true,\n        \"hi\",\n        [\n            1,\n            2\n        ],\n        {\n            \"foo\": {\n                \"baz\": [\n                    3,\n                    4\n                ]\n            }\n        }\n    ]\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(), "PUT", "method was incorrect");

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

    }

    /// Serializes documents as part of the JSON response payload with no escaping.

    /// Test ID: DocumentOutput

    #[::tokio::test]

    async fn document_output_response() {

        let expected_output = crate::operation::document_type::DocumentTypeOutput::builder()

            .set_string_value(::std::option::Option::Some("string".to_owned()))

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

                let json_bytes = br#"{

                        "foo": "bar"

                    }"#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

            .build();

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

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

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

                .status(200)

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

                    "{\n    \"stringValue\": \"string\",\n    \"documentValue\": {\n        \"foo\": \"bar\"\n    }\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::document_type::DocumentType::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::document_type::DocumentTypeOutput>()

            .unwrap();

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

        ::pretty_assertions::assert_eq!(

            parsed.document_value,

            expected_output.document_value,

            "Unexpected value for `document_value`"

        );

    }

    /// Document types can be JSON scalars too.

    /// Test ID: DocumentOutputString

    #[::tokio::test]

    async fn document_output_string_response() {

        let expected_output = crate::operation::document_type::DocumentTypeOutput::builder()

            .set_string_value(::std::option::Option::Some("string".to_owned()))

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

                let json_bytes = br#""hello""#;

                let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

                ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")

            }))

            .build();

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

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

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

                .status(200)

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

                    "{\n    \"stringValue\": \"string\",\n    \"documentValue\": \"hello\"\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::document_type::DocumentType::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::document_type::DocumentTypeOutput>()

            .unwrap();

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

        ::pretty_assertions::assert_eq!(

            parsed.document_value,

            expected_output.document_value,

            "Unexpected value for `document_value`"

        );