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

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

    #[::tokio::test]

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

    /// Parses simple JSON errors

    /// Test ID: AwsJson10InvalidGreetingError

    #[::tokio::test]

    async fn aws_json10_invalid_greeting_error_response() {

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

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

            .build();

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

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

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

                .status(400)

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

                    "{\n    \"__type\": \"aws.protocoltests.json10#InvalidGreeting\",\n    \"Message\": \"Hi\"\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);

        }

    }

    /// Parses a complex error with no message member

    /// Test ID: AwsJson10ComplexError

    #[::tokio::test]

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

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

        .status(400)

                    .body(::aws_smithy_types::body::SdkBody::from("{\n    \"__type\": \"aws.protocoltests.json10#ComplexError\",\n    \"TopLevel\": \"Top level\",\n    \"Nested\": {\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::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::ComplexError(parsed) = parsed {

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

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

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

        } else {

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

        }

    }

    /// Parses a complex error with an empty body

    /// Test ID: AwsJson10EmptyComplexError

    #[::tokio::test]

    async fn aws_json10_empty_complex_error_response() {

        let expected_output = crate::types::error::ComplexError::builder().build();

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

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

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

                .status(400)

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

                    "{\n    \"__type\": \"aws.protocoltests.json10#ComplexError\"\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::ComplexError(parsed) = parsed {

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

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

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

        } else {

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

        }

    }

    /// Serializes the X-Amzn-ErrorType header. For an example service, see Amazon EKS.

    /// Test ID: AwsJson10FooErrorUsingXAmznErrorType

    #[::tokio::test]

    async fn aws_json10_foo_error_using_x_amzn_error_type_response() {

        let expected_output = crate::types::error::FooError::builder().build();

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

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

                .header("X-Amzn-Errortype", "FooError")

                .status(500)

                .body(::aws_smithy_types::body::SdkBody::from(vec![]))

                .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::FooError(parsed) = parsed {

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

        } else {

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

        }

    }

    /// Some X-Amzn-Errortype headers contain URLs. Clients need to split the URL on ':' and take only the first half of the string. For example, 'ValidationException:http://internal.amazon.com/coral/com.amazon.coral.validate/'

    /// is to be interpreted as 'ValidationException'.

    ///

    /// For an example service see Amazon Polly.

    /// Test ID: AwsJson10FooErrorUsingXAmznErrorTypeWithUri

    #[::tokio::test]

    async fn aws_json10_foo_error_using_x_amzn_error_type_with_uri_response() {

        let expected_output = crate::types::error::FooError::builder().build();

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

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

                .header("X-Amzn-Errortype", "FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/")

                .status(500)

                .body(::aws_smithy_types::body::SdkBody::from(vec![]))

                .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::FooError(parsed) = parsed {

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

        } else {

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

        }

    }

    /// X-Amzn-Errortype might contain a URL and a namespace. Client should extract only the shape name. This is a pathalogical case that might not actually happen in any deployed AWS service.

    /// Test ID: AwsJson10FooErrorUsingXAmznErrorTypeWithUriAndNamespace

    #[::tokio::test]

    async fn aws_json10_foo_error_using_x_amzn_error_type_with_uri_and_namespace_response() {

        let expected_output = crate::types::error::FooError::builder().build();

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

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

                .header(

                    "X-Amzn-Errortype",

                    "aws.protocoltests.json10#FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/",

                )

                .status(500)

                .body(::aws_smithy_types::body::SdkBody::from(vec![]))

                .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::FooError(parsed) = parsed {

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

        } else {

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

        }

    }

    /// This example uses the 'code' property in the output rather than X-Amzn-Errortype. Some services do this though it's preferable to send the X-Amzn-Errortype. Client implementations must first check for the X-Amzn-Errortype and then check for a top-level 'code' property.

    ///

    /// For example service see Amazon S3 Glacier.

    /// Test ID: AwsJson10FooErrorUsingCode

    #[::tokio::test]

    async fn aws_json10_foo_error_using_code_response() {

        let expected_output = crate::types::error::FooError::builder().build();

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

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

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

                .status(500)

                .body(::aws_smithy_types::body::SdkBody::from("{\n    \"code\": \"FooError\"\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::FooError(parsed) = parsed {

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

        } else {

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

        }

    }

    /// Some services serialize errors using code, and it might contain a namespace. Clients should just take the last part of the string after '#'.

    /// Test ID: AwsJson10FooErrorUsingCodeAndNamespace

    #[::tokio::test]

    async fn aws_json10_foo_error_using_code_and_namespace_response() {

        let expected_output = crate::types::error::FooError::builder().build();

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

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

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

                .status(500)

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

                    "{\n    \"code\": \"aws.protocoltests.json10#FooError\"\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::FooError(parsed) = parsed {

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

        } else {

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

        }

    }

    /// Some services serialize errors using code, and it might contain a namespace. It also might contain a URI. Clients should just take the last part of the string after '#' and before ":". This is a pathalogical case that might not occur in any deployed AWS service.

    /// Test ID: AwsJson10FooErrorUsingCodeUriAndNamespace

    #[::tokio::test]

    async fn aws_json10_foo_error_using_code_uri_and_namespace_response() {

        let expected_output = crate::types::error::FooError::builder().build();

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

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

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

                .status(500)

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

                    "{\n    \"code\": \"aws.protocoltests.json10#FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/\"\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::FooError(parsed) = parsed {

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

        } else {

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

        }

    }

    /// Some services serialize errors using __type.

    /// Test ID: AwsJson10FooErrorWithDunderType

    #[::tokio::test]

    async fn aws_json10_foo_error_with_dunder_type_response() {

        let expected_output = crate::types::error::FooError::builder().build();

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

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

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

                .status(500)

                .body(::aws_smithy_types::body::SdkBody::from("{\n    \"__type\": \"FooError\"\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::FooError(parsed) = parsed {

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

        } else {

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

        }

    }

    /// Some services serialize errors using __type, and it might contain a namespace. Clients should just take the last part of the string after '#'.

    /// Test ID: AwsJson10FooErrorWithDunderTypeAndNamespace

    #[::tokio::test]

    async fn aws_json10_foo_error_with_dunder_type_and_namespace_response() {

        let expected_output = crate::types::error::FooError::builder().build();

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

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

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

                .status(500)

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

                    "{\n    \"__type\": \"aws.protocoltests.json10#FooError\"\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::FooError(parsed) = parsed {

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

        } else {

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

        }

    }

    /// Some services serialize errors using __type, and it might contain a namespace. It also might contain a URI. Clients should just take the last part of the string after '#' and before ":". This is a pathalogical case that might not occur in any deployed AWS service.

    /// Test ID: AwsJson10FooErrorWithDunderTypeUriAndNamespace

    #[::tokio::test]

    async fn aws_json10_foo_error_with_dunder_type_uri_and_namespace_response() {

        let expected_output = crate::types::error::FooError::builder().build();

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

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

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

                .status(500)

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

                    "{\n    \"__type\": \"aws.protocoltests.json10#FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/\"\n}",

                ))

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

    /// Custom endpoints supplied by users can have paths

    /// Test ID: AwsJson10HostWithPath

    #[::tokio::test]

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

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

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

        })?;

        cfg.interceptor_state()

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

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

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

    /// Serializes a string union value

    /// Test ID: AwsJson10SerializeStringUnionValue

    #[::tokio::test]

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

            .json_unions()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::StringValue("foo".to_owned())))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];

        ::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    \"contents\": {\n        \"stringValue\": \"foo\"\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(), "POST", "method was incorrect");

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

    }

    /// Serializes a boolean union value

    /// Test ID: AwsJson10SerializeBooleanUnionValue

    #[::tokio::test]

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

            .json_unions()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::BooleanValue(true)))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];

        ::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    \"contents\": {\n        \"booleanValue\": true\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(), "POST", "method was incorrect");

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

    }

    /// Serializes a number union value

    /// Test ID: AwsJson10SerializeNumberUnionValue

    #[::tokio::test]

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

            .json_unions()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::NumberValue(1)))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];

        ::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    \"contents\": {\n        \"numberValue\": 1\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(), "POST", "method was incorrect");

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

    }

    /// Serializes a blob union value

    /// Test ID: AwsJson10SerializeBlobUnionValue

    #[::tokio::test]

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

            .json_unions()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::BlobValue(

                ::aws_smithy_types::Blob::new("foo"),

            )))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];

        ::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    \"contents\": {\n        \"blobValue\": \"Zm9v\"\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(), "POST", "method was incorrect");

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

    }

    /// Serializes a timestamp union value

    /// Test ID: AwsJson10SerializeTimestampUnionValue

    #[::tokio::test]

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

            .json_unions()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::TimestampValue(

                ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),

            )))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];

        ::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    \"contents\": {\n        \"timestampValue\": 1398796238\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(), "POST", "method was incorrect");

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

    }

    /// Serializes an enum union value

    /// Test ID: AwsJson10SerializeEnumUnionValue

    #[::tokio::test]

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

            .json_unions()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::EnumValue(

                "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-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];

        ::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    \"contents\": {\n        \"enumValue\": \"Foo\"\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(), "POST", "method was incorrect");

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

    }

    /// Serializes an intEnum union value

    /// Test ID: AwsJson10SerializeIntEnumUnionValue

    #[::tokio::test]

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

            .json_unions()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::IntEnumValue(1)))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];

        ::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    \"contents\": {\n        \"intEnumValue\": 1\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(), "POST", "method was incorrect");

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

    }

    /// Serializes a list union value

    /// Test ID: AwsJson10SerializeListUnionValue

    #[::tokio::test]

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

            .json_unions()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::ListValue(vec![

                "foo".to_owned(),

                "bar".to_owned(),

            ])))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];

        ::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    \"contents\": {\n        \"listValue\": [\"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(), "POST", "method was incorrect");

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

    }

    /// Serializes a map union value

    /// Test ID: AwsJson10SerializeMapUnionValue

    #[::tokio::test]

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

            .json_unions()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::MapValue({

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

                ret.insert("foo".to_owned(), "bar".to_owned());

                ret.insert("spam".to_owned(), "eggs".to_owned());

                ret

            })))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];

        ::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    \"contents\": {\n        \"mapValue\": {\n            \"foo\": \"bar\",\n            \"spam\": \"eggs\"\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(), "POST", "method was incorrect");

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

    }

    /// Serializes a structure union value

    /// Test ID: AwsJson10SerializeStructureUnionValue

    #[::tokio::test]

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

            .json_unions()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(

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

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

                    .build(),

            )))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];

        ::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    \"contents\": {\n        \"structureValue\": {\n            \"hi\": \"hello\"\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(), "POST", "method was incorrect");

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

    }

    /// Deserializes a string union value

    /// Test ID: AwsJson10DeserializeStringUnionValue

    #[::tokio::test]

    async fn aws_json10_deserialize_string_union_value_response() {

        let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::StringValue("foo".to_owned())))

            .build();

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

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

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

                .status(200)

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

                    "{\n    \"contents\": {\n        \"stringValue\": \"foo\"\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::json_unions::JsonUnions::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::json_unions::JsonUnionsOutput>()

            .unwrap();

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

    }

    /// Deserializes a boolean union value

    /// Test ID: AwsJson10DeserializeBooleanUnionValue

    #[::tokio::test]

    async fn aws_json10_deserialize_boolean_union_value_response() {

        let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::BooleanValue(true)))

            .build();

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

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

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

                .status(200)

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

                    "{\n    \"contents\": {\n        \"booleanValue\": true\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::json_unions::JsonUnions::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::json_unions::JsonUnionsOutput>()

            .unwrap();

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

    }

    /// Deserializes a number union value

    /// Test ID: AwsJson10DeserializeNumberUnionValue

    #[::tokio::test]

    async fn aws_json10_deserialize_number_union_value_response() {

        let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::NumberValue(1)))

            .build();

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

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

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

                .status(200)

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

                    "{\n    \"contents\": {\n        \"numberValue\": 1\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::json_unions::JsonUnions::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::json_unions::JsonUnionsOutput>()

            .unwrap();

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

    }

    /// Deserializes a blob union value

    /// Test ID: AwsJson10DeserializeBlobUnionValue

    #[::tokio::test]

    async fn aws_json10_deserialize_blob_union_value_response() {

        let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::BlobValue(

                ::aws_smithy_types::Blob::new("foo"),

            )))

            .build();

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

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

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

                .status(200)

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

                    "{\n    \"contents\": {\n        \"blobValue\": \"Zm9v\"\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::json_unions::JsonUnions::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::json_unions::JsonUnionsOutput>()

            .unwrap();

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

    }

    /// Deserializes a timestamp union value

    /// Test ID: AwsJson10DeserializeTimestampUnionValue

    #[::tokio::test]

    async fn aws_json10_deserialize_timestamp_union_value_response() {

        let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::TimestampValue(

                ::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", "application/x-amz-json-1.0")

                .status(200)

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

                    "{\n    \"contents\": {\n        \"timestampValue\": 1398796238\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::json_unions::JsonUnions::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::json_unions::JsonUnionsOutput>()

            .unwrap();

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

    }

    /// Deserializes an enum union value

    /// Test ID: AwsJson10DeserializeEnumUnionValue

    #[::tokio::test]

    async fn aws_json10_deserialize_enum_union_value_response() {

        let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()

            .set_contents(::std::option::Option::Some(crate::types::MyUnion::EnumValue(

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

            )))

            .build();

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

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

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

                .status(200)

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

                    "{\n    \"contents\": {\n        \"enumValue\": \"Foo\"\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::json_unions::JsonUnions::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");