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 query lists. All EC2 lists are flattened.

    /// Test ID: Ec2Lists

    #[::tokio::test]

    async fn ec2_lists_request() {

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

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

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

        let result = client

            .query_lists()

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

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

                crate::types::GreetingStruct::builder()

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

                    .build(),

                crate::types::GreetingStruct::builder()

                    .set_hi(::std::option::Option::Some("hola".to_owned()))

                    .build(),

            ]))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=QueryLists&Version=2020-01-08&ListArg.1=foo&ListArg.2=bar&ListArg.3=baz&ComplexListArg.1.Hi=hello&ComplexListArg.2.Hi=hola",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Does not serialize empty query lists.

    /// Test ID: Ec2EmptyQueryLists

    #[::tokio::test]

    async fn ec2_empty_query_lists_request() {

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

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

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

        let result = client.query_lists().set_list_arg(::std::option::Option::Some(vec![])).send().await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=QueryLists&Version=2020-01-08",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// An xmlName trait in the member of a list has no effect on the list serialization.

    /// Test ID: Ec2ListArgWithXmlNameMember

    #[::tokio::test]

    async fn ec2_list_arg_with_xml_name_member_request() {

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

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

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

        let result = client

            .query_lists()

            .set_list_arg_with_xml_name_member(::std::option::Option::Some(vec!["A".to_owned(), "B".to_owned()]))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=QueryLists&Version=2020-01-08&ListArgWithXmlNameMember.1=A&ListArgWithXmlNameMember.2=B",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Changes the name of the list using the xmlName trait

    /// Test ID: Ec2ListMemberWithXmlName

    #[::tokio::test]

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

            .query_lists()

            .set_list_arg_with_xml_name(::std::option::Option::Some(vec!["A".to_owned(), "B".to_owned()]))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=QueryLists&Version=2020-01-08&Hi.1=A&Hi.2=B",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Nested structure with a list member

    /// Test ID: Ec2ListNestedStructWithList

    #[::tokio::test]

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

            .query_lists()

            .set_nested_with_list(::std::option::Option::Some(

                crate::types::NestedStructWithList::builder()

                    .set_list_arg(::std::option::Option::Some(vec!["A".to_owned(), "B".to_owned()]))

        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 timestamps

    /// Test ID: Ec2TimestampsInput

    #[::tokio::test]

    async fn ec2_timestamps_input_request() {

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

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

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

        let result = client

            .query_timestamps()

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

                1422172800, 0_f64,

            )))

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

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

        })?;

        cfg.interceptor_state()

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

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

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Serializes recursive structures

    /// Test ID: Ec2RecursiveShapes

    #[::tokio::test]

    async fn ec2_recursive_shapes_response() {

        let expected_output = crate::operation::recursive_xml_shapes::RecursiveXmlShapesOutput::builder()

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

                crate::types::RecursiveXmlShapesOutputNested1::builder()

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

                    .set_nested(::std::option::Option::Some(::std::boxed::Box::new(

                        crate::types::RecursiveXmlShapesOutputNested2::builder()

                            .set_bar(::std::option::Option::Some("Bar1".to_owned()))

                            .set_recursive_member(::std::option::Option::Some(

                                crate::types::RecursiveXmlShapesOutputNested1::builder()

        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 strings

    /// Test ID: Ec2SimpleInputParamsStrings

    #[::tokio::test]

    async fn ec2_simple_input_params_strings_request() {

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

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

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

        let result = client

            .simple_input_params()

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

            .set_bar(::std::option::Option::Some("val2".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=SimpleInputParams&Version=2020-01-08&Foo=val1&Bar=val2",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Serializes booleans that are true

    /// Test ID: Ec2SimpleInputParamsStringAndBooleanTrue

    #[::tokio::test]

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

            .simple_input_params()

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

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

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=SimpleInputParams&Version=2020-01-08&Foo=val1&Baz=true",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Serializes booleans that are false

    /// Test ID: Ec2SimpleInputParamsStringsAndBooleanFalse

    #[::tokio::test]

    async fn ec2_simple_input_params_strings_and_boolean_false_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.simple_input_params().set_baz(::std::option::Option::Some(false)).send().await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=SimpleInputParams&Version=2020-01-08&Baz=false",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Serializes integers

    /// Test ID: Ec2SimpleInputParamsInteger

    #[::tokio::test]

    async fn ec2_simple_input_params_integer_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.simple_input_params().set_bam(::std::option::Option::Some(10)).send().await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=SimpleInputParams&Version=2020-01-08&Bam=10",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Serializes floats

    /// Test ID: Ec2SimpleInputParamsFloat

    #[::tokio::test]

    async fn ec2_simple_input_params_float_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.simple_input_params().set_boo(::std::option::Option::Some(10.8_f64)).send().await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=SimpleInputParams&Version=2020-01-08&Boo=10.8",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Blobs are base64 encoded in the query string

    /// Test ID: Ec2SimpleInputParamsBlob

    #[::tokio::test]

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

            .simple_input_params()

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

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=SimpleInputParams&Version=2020-01-08&Qux=dmFsdWU%3D",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Serializes enums in the query string

    /// Test ID: Ec2Enums

    #[::tokio::test]

    async fn ec2_enums_request() {

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

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

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

        let result = client

            .simple_input_params()

            .set_foo_enum(::std::option::Option::Some(

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

            ))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=SimpleInputParams&Version=2020-01-08&FooEnum=Foo",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Serializes query using ec2QueryName trait.

    /// Test ID: Ec2Query

    #[::tokio::test]

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

            .simple_input_params()

            .set_has_query_name(::std::option::Option::Some("Hi".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=SimpleInputParams&Version=2020-01-08&HasQueryName=Hi",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// ec2QueryName trait is preferred over xmlName.

    /// Test ID: Ec2QueryIsPreferred

    #[::tokio::test]

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

            .simple_input_params()

            .set_has_query_and_xml_name(::std::option::Option::Some("Hi".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=SimpleInputParams&Version=2020-01-08&HasQueryAndXmlName=Hi",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// xmlName is used with the ec2 protocol, but the first character is uppercased

    /// Test ID: Ec2XmlNameIsUppercased

    #[::tokio::test]

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

            .simple_input_params()

            .set_uses_xml_name(::std::option::Option::Some("Hi".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=SimpleInputParams&Version=2020-01-08&UsesXmlName=Hi",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Supports handling NaN float values.

    /// Test ID: Ec2QuerySupportsNaNFloatInputs

    #[::tokio::test]

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

            .simple_input_params()

            .set_float_value(::std::option::Option::Some(

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

            ))

            .set_boo(::std::option::Option::Some(

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

            ))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=SimpleInputParams&Version=2020-01-08&FloatValue=NaN&Boo=NaN",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Supports handling Infinity float values.

    /// Test ID: Ec2QuerySupportsInfinityFloatInputs

    #[::tokio::test]

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

            .simple_input_params()

            .set_float_value(::std::option::Option::Some(

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

            ))

            .set_boo(::std::option::Option::Some(

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

            ))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];

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

            "Action=SimpleInputParams&Version=2020-01-08&FloatValue=Infinity&Boo=Infinity",

            ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),

        ));

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

    }

    /// Supports handling -Infinity float values.

    /// Test ID: Ec2QuerySupportsNegativeInfinityFloatInputs

    #[::tokio::test]

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

            .simple_input_params()

            .set_float_value(::std::option::Option::Some(

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

            ))

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

    use ::aws_smithy_protocol_test::FloatEquals;

    /// Serializes simple scalar properties

    /// Test ID: Ec2SimpleScalarProperties

    #[::tokio::test]

    async fn ec2_simple_scalar_properties_response() {

        let expected_output = crate::operation::simple_scalar_xml_properties::SimpleScalarXmlPropertiesOutput::builder()

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

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

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

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

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

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

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

            .set_long_value(::std::option::Option::Some(4))

        assert!(

            parsed.double_value.float_equals(&expected_output.double_value),

            "Unexpected value for `double_value` {:?} vs. {:?}",

            expected_output.double_value,

            parsed.double_value

        );

    }

    /// Supports handling NaN float values.

    /// Test ID: Ec2QuerySupportsNaNFloatOutputs

    #[::tokio::test]

    async fn ec2_query_supports_na_n_float_outputs_response() {

        let expected_output = crate::operation::simple_scalar_xml_properties::SimpleScalarXmlPropertiesOutput::builder()

            .set_float_value(::std::option::Option::Some(

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

            ))

            .set_double_value(::std::option::Option::Some(

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

            ))

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()

        assert!(

            parsed.double_value.float_equals(&expected_output.double_value),

            "Unexpected value for `double_value` {:?} vs. {:?}",

            expected_output.double_value,

            parsed.double_value

        );

    }

    /// Supports handling Infinity float values.

    /// Test ID: Ec2QuerySupportsInfinityFloatOutputs

    #[::tokio::test]

    async fn ec2_query_supports_infinity_float_outputs_response() {

        let expected_output = crate::operation::simple_scalar_xml_properties::SimpleScalarXmlPropertiesOutput::builder()

            .set_float_value(::std::option::Option::Some(

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

            ))

            .set_double_value(::std::option::Option::Some(

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

            ))

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()

        assert!(

            parsed.double_value.float_equals(&expected_output.double_value),

            "Unexpected value for `double_value` {:?} vs. {:?}",

            expected_output.double_value,

            parsed.double_value

        );

    }

    /// Supports handling -Infinity float values.

    /// Test ID: Ec2QuerySupportsNegativeInfinityFloatOutputs

    #[::tokio::test]

    async fn ec2_query_supports_negative_infinity_float_outputs_response() {

        let expected_output = crate::operation::simple_scalar_xml_properties::SimpleScalarXmlPropertiesOutput::builder()

            .set_float_value(::std::option::Option::Some(

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

            ))

            .set_double_value(::std::option::Option::Some(

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

            ))

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

    /// Blobs are base64 encoded

    /// Test ID: Ec2XmlBlobs

    #[::tokio::test]

    async fn ec2_xml_blobs_response() {

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

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

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()

        .header("Content-Type", "text/xml;charset=UTF-8")

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<XmlBlobsResponse xmlns=\"https://example.com/\">\n    <data>dmFsdWU=</data>\n    <RequestId>requestid</RequestId>\n</XmlBlobsResponse>\n"))

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

    /// Empty blobs are deserialized as empty string

    /// Test ID: Ec2XmlEmptyBlobs

    #[::tokio::test]

    async fn ec2_xml_empty_blobs_response() {

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

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

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()

        .header("Content-Type", "text/xml;charset=UTF-8")

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<XmlEmptyBlobsResponse xmlns=\"https://example.com/\">\n    <data></data>\n    <RequestId>requestid</RequestId>\n</XmlEmptyBlobsResponse>\n"))

                    .unwrap()

                    ).unwrap();

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

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

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

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

        let de = config

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

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

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

        let parsed = parsed.unwrap_or_else(|| {

            let http_response =

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

            de.deserialize_nonstreaming(&http_response)

        });

        let parsed = parsed

            .expect("should be successful response")

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

            .unwrap();

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

    }

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

    /// Test ID: Ec2XmlEmptySelfClosedBlobs

    #[::tokio::test]

    async fn ec2_xml_empty_self_closed_blobs_response() {

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

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

            .build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()

        .header("Content-Type", "text/xml;charset=UTF-8")

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<XmlEmptyBlobsResponse xmlns=\"https://example.com/\">\n    <data/>\n    <RequestId>requestid</RequestId>\n</XmlEmptyBlobsResponse>\n"))

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