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 XML lists

    /// Test ID: QueryQueryXmlMapsXmlName

    #[::tokio::test]

    async fn query_query_xml_maps_xml_name_response() {

        let expected_output = crate::operation::xml_maps_xml_name::XmlMapsXmlNameOutput::builder()

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

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

                ret.insert(

                    "foo".to_owned(),

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

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

                        .build(),

                );

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

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

        })?;

        cfg.interceptor_state()

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

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

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Serializes XML namespaces

    /// Test ID: QueryXmlNamespaces

    #[::tokio::test]

    async fn query_xml_namespaces_response() {

        let expected_output = crate::operation::xml_namespaces::XmlNamespacesOutput::builder()

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

                crate::types::XmlNamespaceNested::builder()

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

                    .set_values(::std::option::Option::Some(vec!["Bar".to_owned(), "Baz".to_owned()]))

                    .build(),

            ))

            .build();

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

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

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

        })?;

        cfg.interceptor_state()

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

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

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Tests how normal timestamps are serialized

    /// Test ID: QueryXmlTimestamps

    #[::tokio::test]

    async fn query_xml_timestamps_response() {

        let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()

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

                1398796238, 0_f64,

            )))

            .build();

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

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

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <XmlTimestampsResult>\n        <normal>2014-04-29T18:30:38Z</normal>\n    </XmlTimestampsResult>\n</XmlTimestampsResponse>\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_timestamps::XmlTimestamps::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_timestamps::XmlTimestampsOutput>()

            .unwrap();

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

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

        ::pretty_assertions::assert_eq!(

            parsed.date_time_on_target,

            expected_output.date_time_on_target,

            "Unexpected value for `date_time_on_target`"

        );

        ::pretty_assertions::assert_eq!(

            parsed.epoch_seconds,

            expected_output.epoch_seconds,

            "Unexpected value for `epoch_seconds`"

        );

        ::pretty_assertions::assert_eq!(

            parsed.epoch_seconds_on_target,

            expected_output.epoch_seconds_on_target,

            "Unexpected value for `epoch_seconds_on_target`"

        );

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

        ::pretty_assertions::assert_eq!(

            parsed.http_date_on_target,

            expected_output.http_date_on_target,

            "Unexpected value for `http_date_on_target`"

        );

    }

    /// Ensures that the timestampFormat of date-time works like normal timestamps

    /// Test ID: QueryXmlTimestampsWithDateTimeFormat

    #[::tokio::test]

    async fn query_xml_timestamps_with_date_time_format_response() {

        let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()

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

                1398796238, 0_f64,

            )))

            .build();

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

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

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <XmlTimestampsResult>\n        <dateTime>2014-04-29T18:30:38Z</dateTime>\n    </XmlTimestampsResult>\n</XmlTimestampsResponse>\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_timestamps::XmlTimestamps::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_timestamps::XmlTimestampsOutput>()

            .unwrap();

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

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

        ::pretty_assertions::assert_eq!(

            parsed.date_time_on_target,

            expected_output.date_time_on_target,

            "Unexpected value for `date_time_on_target`"

        );

        ::pretty_assertions::assert_eq!(

            parsed.epoch_seconds,

            expected_output.epoch_seconds,

            "Unexpected value for `epoch_seconds`"

        );

        ::pretty_assertions::assert_eq!(

            parsed.epoch_seconds_on_target,

            expected_output.epoch_seconds_on_target,

            "Unexpected value for `epoch_seconds_on_target`"

        );

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

        ::pretty_assertions::assert_eq!(

            parsed.http_date_on_target,

            expected_output.http_date_on_target,

            "Unexpected value for `http_date_on_target`"

        );

    }

    /// Ensures that the timestampFormat of date-time on the target shape works like normal timestamps

    /// Test ID: QueryXmlTimestampsWithDateTimeOnTargetFormat

    #[::tokio::test]

    async fn query_xml_timestamps_with_date_time_on_target_format_response() {

        let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()

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

                1398796238, 0_f64,

            )))

            .build();

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

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

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <XmlTimestampsResult>\n        <dateTimeOnTarget>2014-04-29T18:30:38Z</dateTimeOnTarget>\n    </XmlTimestampsResult>\n</XmlTimestampsResponse>\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_timestamps::XmlTimestamps::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_timestamps::XmlTimestampsOutput>()

            .unwrap();

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

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

        ::pretty_assertions::assert_eq!(

            parsed.date_time_on_target,

            expected_output.date_time_on_target,

            "Unexpected value for `date_time_on_target`"

        );

        ::pretty_assertions::assert_eq!(

            parsed.epoch_seconds,

            expected_output.epoch_seconds,

            "Unexpected value for `epoch_seconds`"

        );

        ::pretty_assertions::assert_eq!(

            parsed.epoch_seconds_on_target,

            expected_output.epoch_seconds_on_target,

            "Unexpected value for `epoch_seconds_on_target`"

        );

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

        ::pretty_assertions::assert_eq!(

            parsed.http_date_on_target,

            expected_output.http_date_on_target,

            "Unexpected value for `http_date_on_target`"

        );

    }

    /// Ensures that the timestampFormat of epoch-seconds works

    /// Test ID: QueryXmlTimestampsWithEpochSecondsFormat

    #[::tokio::test]

    async fn query_xml_timestamps_with_epoch_seconds_format_response() {

        let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()

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

                1398796238, 0_f64,

            )))

            .build();

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

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

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <XmlTimestampsResult>\n        <epochSeconds>1398796238</epochSeconds>\n    </XmlTimestampsResult>\n</XmlTimestampsResponse>\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_timestamps::XmlTimestamps::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_timestamps::XmlTimestampsOutput>()

            .unwrap();

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

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

        ::pretty_assertions::assert_eq!(

            parsed.date_time_on_target,

            expected_output.date_time_on_target,

            "Unexpected value for `date_time_on_target`"

        );

        ::pretty_assertions::assert_eq!(

            parsed.epoch_seconds,

            expected_output.epoch_seconds,

            "Unexpected value for `epoch_seconds`"

        );

        ::pretty_assertions::assert_eq!(

            parsed.epoch_seconds_on_target,

            expected_output.epoch_seconds_on_target,

            "Unexpected value for `epoch_seconds_on_target`"

        );

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

        ::pretty_assertions::assert_eq!(

            parsed.http_date_on_target,

            expected_output.http_date_on_target,

            "Unexpected value for `http_date_on_target`"

        );

    }

    /// Ensures that the timestampFormat of epoch-seconds on the target shape works

    /// Test ID: QueryXmlTimestampsWithEpochSecondsOnTargetFormat

    #[::tokio::test]

    async fn query_xml_timestamps_with_epoch_seconds_on_target_format_response() {

        let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()

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

                1398796238, 0_f64,

            )))

            .build();

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

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

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <XmlTimestampsResult>\n        <epochSecondsOnTarget>1398796238</epochSecondsOnTarget>\n    </XmlTimestampsResult>\n</XmlTimestampsResponse>\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_timestamps::XmlTimestamps::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_timestamps::XmlTimestampsOutput>()

            .unwrap();

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

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

        ::pretty_assertions::assert_eq!(

            parsed.date_time_on_target,

            expected_output.date_time_on_target,

            "Unexpected value for `date_time_on_target`"

        );

        ::pretty_assertions::assert_eq!(

            parsed.epoch_seconds,

            expected_output.epoch_seconds,

            "Unexpected value for `epoch_seconds`"

        );

        ::pretty_assertions::assert_eq!(

            parsed.epoch_seconds_on_target,

            expected_output.epoch_seconds_on_target,

            "Unexpected value for `epoch_seconds_on_target`"

        );

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

        ::pretty_assertions::assert_eq!(

            parsed.http_date_on_target,

            expected_output.http_date_on_target,

            "Unexpected value for `http_date_on_target`"

        );

    }

    /// Ensures that the timestampFormat of http-date works

    /// Test ID: QueryXmlTimestampsWithHttpDateFormat

    #[::tokio::test]

    async fn query_xml_timestamps_with_http_date_format_response() {

        let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()

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

                1398796238, 0_f64,

            )))

            .build();

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

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

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <XmlTimestampsResult>\n        <httpDate>Tue, 29 Apr 2014 18:30:38 GMT</httpDate>\n    </XmlTimestampsResult>\n</XmlTimestampsResponse>\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_timestamps::XmlTimestamps::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_timestamps::XmlTimestampsOutput>()

            .unwrap();

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

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

        ::pretty_assertions::assert_eq!(

            parsed.date_time_on_target,

            expected_output.date_time_on_target,

            "Unexpected value for `date_time_on_target`"

        );

        ::pretty_assertions::assert_eq!(

            parsed.epoch_seconds,

            expected_output.epoch_seconds,

            "Unexpected value for `epoch_seconds`"

        );

        ::pretty_assertions::assert_eq!(

            parsed.epoch_seconds_on_target,

            expected_output.epoch_seconds_on_target,

            "Unexpected value for `epoch_seconds_on_target`"

        );

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

        ::pretty_assertions::assert_eq!(

            parsed.http_date_on_target,

            expected_output.http_date_on_target,

            "Unexpected value for `http_date_on_target`"

        );

    }

    /// Ensures that the timestampFormat of http-date on the target shape works

    /// Test ID: QueryXmlTimestampsWithHttpDateOnTargetFormat

    #[::tokio::test]

    async fn query_xml_timestamps_with_http_date_on_target_format_response() {

        let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()

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

                1398796238, 0_f64,

            )))

            .build();

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

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

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <XmlTimestampsResult>\n        <httpDateOnTarget>Tue, 29 Apr 2014 18:30:38 GMT</httpDateOnTarget>\n    </XmlTimestampsResult>\n</XmlTimestampsResponse>\n"))

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

[dev-dependencies.aws-smithy-types]

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

[dev-dependencies.bytes]

version = "1.4.0"

[dev-dependencies.pretty_assertions]

version = "1.3.0"

[dev-dependencies.tokio]

version = "1.23.1"

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

[features]

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

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

behavior-version-latest = []

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

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

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

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

        })?;

        cfg.interceptor_state()

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

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

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

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

    /// Test ID: Ec2QueryDateTimeWithNegativeOffset

    #[::tokio::test]

    async fn ec2_query_date_time_with_negative_offset_response() {

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

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

                1576540098, 0_f64,

            )))

            .build();

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

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

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<DatetimeOffsetsResponse xmlns=\"https://example.com/\">\n    <datetime>2019-12-16T22:48:18-01:00</datetime>\n    <RequestId>requestid</RequestId>\n</DatetimeOffsetsResponse>\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: Ec2QueryDateTimeWithPositiveOffset

    #[::tokio::test]

    async fn ec2_query_date_time_with_positive_offset_response() {

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

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

                1576540098, 0_f64,

            )))

            .build();

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

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

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<DatetimeOffsetsResponse xmlns=\"https://example.com/\">\n    <datetime>2019-12-17T00:48:18+01:00</datetime>\n    <RequestId>requestid</RequestId>\n</DatetimeOffsetsResponse>\n"))

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

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

        })?;

        cfg.interceptor_state()

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

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

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Empty input serializes no extra query params

    /// Test ID: Ec2QueryEmptyInputAndEmptyOutput

    #[::tokio::test]

    async fn ec2_query_empty_input_and_empty_output_request() {

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

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

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

        let result = client.empty_input_and_empty_output().send().await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let 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=EmptyInputAndEmptyOutput&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");

    }

    /// Empty output

    /// Test ID: Ec2QueryEmptyInputAndEmptyOutput

    #[::tokio::test]

    async fn ec2_query_empty_input_and_empty_output_response() {

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

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

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

        .status(200)

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

                    .unwrap()

                    ).unwrap();

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

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

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

    /// Operations can prepend to the given host if they define the

    /// endpoint trait.

    /// Test ID: Ec2QueryEndpointTrait

    #[::tokio::test]

    async fn ec2_query_endpoint_trait_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.endpoint_operation().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 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)]

    /// Operations can prepend to the given host if they define the

    /// endpoint trait, and can use the host label trait to define

    /// further customization based on user input.

    /// Test ID: Ec2QueryEndpointTraitWithHostLabel

    #[::tokio::test]

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

            .endpoint_with_host_label_operation()

            .set_label(::std::option::Option::Some("bar".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 fractional seconds

    /// Test ID: Ec2QueryDateTimeWithFractionalSeconds

    #[::tokio::test]

    async fn ec2_query_date_time_with_fractional_seconds_response() {

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

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

                946845296, 0.123_f64,

            )))

            .build();

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

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

        .status(200)

                    .body(::aws_smithy_types::body::SdkBody::from("<FractionalSecondsResponse xmlns=\"https://example.com/\">\n    <datetime>2000-01-02T20:34:56.123Z</datetime>\n    <RequestId>requestid</RequestId>\n</FractionalSecondsResponse>\n"))

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

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

        })?;

        cfg.interceptor_state()

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

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

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

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

    /// Test ID: Ec2GreetingWithErrors

    #[::tokio::test]

    async fn ec2_greeting_with_errors_response() {

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

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

            .build();

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

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

        .status(200)

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

                    .unwrap()

                    ).unwrap();

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

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

        let op = crate::operation::greeting_with_errors::GreetingWithErrors::new();

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

        let de = config

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

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

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

        let parsed = parsed.unwrap_or_else(|| {

            let http_response =

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

            de.deserialize_nonstreaming(&http_response)

        });

        let parsed = parsed

            .expect("should be successful response")

            .downcast::<crate::operation::greeting_with_errors::GreetingWithErrorsOutput>()

            .unwrap();

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

    }

    /// Parses simple XML errors

    /// Test ID: Ec2InvalidGreetingError

    #[::tokio::test]

    async fn ec2_invalid_greeting_error_response() {

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

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

            .build();

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

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

        .status(400)

                    .body(::aws_smithy_types::body::SdkBody::from("<Response>\n    <Errors>\n        <Error>\n            <Code>InvalidGreeting</Code>\n            <Message>Hi</Message>\n        </Error>\n    </Errors>\n    <RequestId>foo-id</RequestId>\n</Response>\n"))

                    .unwrap()

                    ).unwrap();

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

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

        let op = crate::operation::greeting_with_errors::GreetingWithErrors::new();

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

        let de = config

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

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

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

        let parsed = parsed.unwrap_or_else(|| {

            let http_response =

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

            de.deserialize_nonstreaming(&http_response)

        });

        let parsed = parsed.expect_err("should be error response");

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

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

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

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

        } else {

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

        }

    }

    /// Test ID: Ec2ComplexError

    #[::tokio::test]

    async fn ec2_complex_error_response() {

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

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

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

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

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

                    .build(),

            ))

            .build();

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

    /// Custom endpoints supplied by users can have paths

    /// Test ID: Ec2QueryHostWithPath

    #[::tokio::test]

    async fn ec2_query_host_with_path_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/custom");

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

        let result = client.host_with_path_operation().send().await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();