Client Test

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<DocumentTypeInput>()

            .ok_or("failed to downcast to DocumentTypeInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

                        [

                            1,

                            2

                        ],

                        {

                            "foo": {

                                "baz": [

                                    3,

                                    4

                                ]

                            }

                        }

                    ]"#;

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

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

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<DocumentTypeAsMapValueInput>()

            .ok_or("failed to downcast to DocumentTypeAsMapValueInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

                                "o": 2

                            }"#;

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

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

                });

                ret.insert("bar".to_owned(), {

                    let json_bytes = br#"[

                                "b",

                                "a",

                                "r"

                            ]"#;

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

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

                });

                ret.insert("baz".to_owned(), {

                    let json_bytes = br#""BAZ""#;

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

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

                });

                ret

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<DocumentTypeAsPayloadInput>()

            .ok_or("failed to downcast to DocumentTypeAsPayloadInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

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

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "\"hello\"",

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

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

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

    }

    /// Serializes a document as the target of the httpPayload trait.

    /// Test ID: DocumentTypeAsPayloadOutput

    #[::tokio::test]

            .input()

            .downcast_ref::<EmptyInputAndEmptyOutputInput>()

            .ok_or("failed to downcast to EmptyInputAndEmptyOutputInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod empty_input_and_empty_output_test {

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

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

    }

    /// As of January 2021, server implementations are expected to

    /// respond with a JSON object regardless of if the output

    /// parameters are empty.

    /// Test ID: RestJsonEmptyInputAndEmptyOutput

    #[::tokio::test]

    #[::tracing_test::traced_test]

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

                .status(200)

                .body(::aws_smithy_types::body::SdkBody::from("{}"))

                .unwrap(),

        )

        .unwrap();

        let endpoint_prefix = ::aws_smithy_runtime_api::client::endpoint::EndpointPrefix::new("foo.").map_err(|err| {

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

        })?;

        cfg.interceptor_state().store_put(endpoint_prefix);

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod endpoint_operation_test {

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

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

        ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "foo.example.com");

    }

}

/// Error type for the `EndpointOperationError` operation.

#[non_exhaustive]

#[derive(::std::fmt::Debug)]

pub enum EndpointOperationError {

    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

    variable wildcard pattern and check `.code()`:

     \

       `err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`

     \

    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-EndpointOperationError) for what information is available for the error.")]

    Unhandled(crate::error::sealed_unhandled::Unhandled),

}

impl EndpointOperationError {

        }

        .map_err(|err| ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint prefix could not be built", err))?;

        cfg.interceptor_state().store_put(endpoint_prefix);

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod endpoint_with_host_label_operation_test {

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "{\"label\": \"bar\"}",

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

        ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "foo.bar.example.com");

    }

}

/// Error type for the `EndpointWithHostLabelOperationError` operation.

#[non_exhaustive]

#[derive(::std::fmt::Debug)]

pub enum EndpointWithHostLabelOperationError {

    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

    variable wildcard pattern and check `.code()`:

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<HostWithPathOperationInput>()

            .ok_or("failed to downcast to HostWithPathOperationInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

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

    }

}

/// Error type for the `HostWithPathOperationError` operation.

#[non_exhaustive]

#[derive(::std::fmt::Debug)]

pub enum HostWithPathOperationError {

    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

    variable wildcard pattern and check `.code()`:

     \

       `err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`

     \

    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-HostWithPathOperationError) for what information is available for the error.")]

    Unhandled(crate::error::sealed_unhandled::Unhandled),

}

impl HostWithPathOperationError {

    /// Creates the `HostWithPathOperationError::Unhandled` variant from any error type.

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<HttpChecksumRequiredInput>()

            .ok_or("failed to downcast to HttpChecksumRequiredInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        let expected_headers = [("Content-MD5", "iB0/3YSo7maijL0IGOgA9g=="), ("Content-Type", "application/json")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "{\n    \"foo\":\"base64 encoded md5 checksum\"\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(), "/HttpChecksumRequired", "path was incorrect");

    }

}

/// Error type for the `HttpChecksumRequiredError` operation.

#[non_exhaustive]

#[derive(::std::fmt::Debug)]

pub enum HttpChecksumRequiredError {

    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

        let _input = context

            .input()

            .downcast_ref::<HttpEmptyPrefixHeadersInput>()

            .ok_or("failed to downcast to HttpEmptyPrefixHeadersInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod http_empty_prefix_headers_test {

            }))

            .set_specific_header(::std::option::Option::Some("There".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("hello", "There"), ("x-foo", "Foo")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

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

    }

    /// Deserializes all response headers with the same for prefix and specific

    /// Test ID: RestJsonHttpEmptyPrefixHeadersResponseClient

    #[::tokio::test]

    #[::tracing_test::traced_test]

        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<HttpEnumPayloadInput>()

            .ok_or("failed to downcast to HttpEnumPayloadInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "text/plain")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "enumvalue",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

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

    }

    /// Test ID: RestJsonEnumPayloadResponse

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_enum_payload_response_response() {

        let expected_output = crate::operation::http_enum_payload::HttpEnumPayloadOutput::builder()

            .set_payload(::std::option::Option::Some(

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<HttpPayloadTraitsInput>()

            .ok_or("failed to downcast to HttpPayloadTraitsInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        let expected_headers = [("X-Foo", "Foo")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());

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

    }

    /// Serializes a blob in the HTTP payload

    /// Test ID: RestJsonHttpPayloadTraitsWithBlob

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_http_payload_traits_with_blob_response() {

        let expected_output = crate::operation::http_payload_traits::HttpPayloadTraitsOutput::builder()

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

            .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")))

            .build();

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

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<HttpPayloadTraitsWithMediaTypeInput>()

            .ok_or("failed to downcast to HttpPayloadTraitsWithMediaTypeInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "text/plain"), ("X-Foo", "Foo")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let required_headers = &["Content-Length"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "blobby blob blob",

            ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),

        ));

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

    }

    /// Serializes a blob in the HTTP payload with a content-type

    /// Test ID: RestJsonHttpPayloadTraitsWithMediaTypeWithBlob

    #[::tokio::test]

    #[::tracing_test::traced_test]

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<HttpPayloadWithStructureInput>()

            .ok_or("failed to downcast to HttpPayloadWithStructureInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

            ))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

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

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let required_headers = &["Content-Length"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "{\n    \"greeting\": \"hello\",\n    \"name\": \"Phreddy\"\n}",

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

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

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

    }

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<HttpPayloadWithUnionInput>()

            .ok_or("failed to downcast to HttpPayloadWithUnionInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

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

    }

    /// Serializes a union in the payload.

    /// Test ID: RestJsonHttpPayloadWithUnion

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_http_payload_with_union_response() {

        let expected_output = crate::operation::http_payload_with_union::HttpPayloadWithUnionOutput::builder()

            .set_nested(::std::option::Option::Some(crate::types::UnionPayload::Greeting("hello".to_owned())))

            .build();

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

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

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

                .status(200)

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

                .unwrap(),

        )

        .unwrap();

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<HttpPrefixHeadersInput>()

            .ok_or("failed to downcast to HttpPrefixHeadersInput")?;

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

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]