Client Test

            ::aws_smithy_runtime_api::client::interceptors::context::Output,

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

        >,

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

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

        let _input = context

            .input()

            .downcast_ref::<ChecksumRequiredInput>()

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

        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

        let expected_headers = [("Content-Md5", "JAJAqYA61wMhATGeQqRcMQ==")];

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

            "<ChecksumRequiredInput><field>hello</field></ChecksumRequiredInput>",

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

        ));

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

    }

}

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

#[non_exhaustive]

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

pub enum ChecksumRequiredError {

    /// 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 \

            ::aws_smithy_runtime_api::client::interceptors::context::Output,

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

        >,

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

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

        let _input = context

            .input()

            .downcast_ref::<EnumKeysInput>()

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

        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

                );

                ret

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

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

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

            body,

            "<XmlMapEnumKeys><data><entry><key>enumvalue</key><value>hello</value></entry></data></XmlMapEnumKeys>",

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

        ));

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

    }

    /// Test ID: DeserEnumMap

    #[::tokio::test]

    #[::tracing_test::traced_test]

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

        >,

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

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

        let _input = context

            .input()

            .downcast_ref::<PrimitiveIntOpXmlInput>()

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

        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.

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

        ));

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

    }

}

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

#[non_exhaustive]

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

pub enum PrimitiveIntOpXmlError {

    /// 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-PrimitiveIntOpXmlError) for what information is available for the error.")]

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

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

features = ["client"]

[dependencies.aws-smithy-runtime-api]

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

features = ["client", "http-02x"]

[dependencies.aws-smithy-types]

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

[dependencies.aws-smithy-xml]

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

[dependencies.http]

version = "0.2.9"

[dev-dependencies.aws-smithy-protocol-test]

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

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

# Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

[package]

name = "rest_xml_namespace"

version = "0.0.1"

authors = ["protocoltest@example.com"]

description = "test"

edition = "2021"

[package.metadata.smithy]

codegen-version = "ci"

[dependencies.aws-smithy-async]

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

[dependencies.aws-smithy-http]

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

[dependencies.aws-smithy-runtime]

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

        >,

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

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

        let _input = context

            .input()

            .downcast_ref::<SimpleScalarPropertiesInput>()

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

        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.

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

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

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

            .set_float_value(::std::option::Option::Some(5.5_f32))

            .set_double_value(::std::option::Option::Some(6.5_f64))

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

                crate::types::NestedWithNamespace::builder()

                    .set_attr_field(::std::option::Option::Some("nestedAttrValue".to_owned()))

                    .build(),

            ))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/xml"), ("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");

        ::aws_smithy_protocol_test::assert_ok(

        ::aws_smithy_protocol_test::validate_body(body, "<SimpleScalarPropertiesInputOutput xmlns=\"https://example.com\">\n    <stringValue>string</stringValue>\n    <trueBooleanValue>true</trueBooleanValue>\n    <falseBooleanValue>false</falseBooleanValue>\n    <byteValue>1</byteValue>\n    <shortValue>2</shortValue>\n    <integerValue>3</integerValue>\n    <longValue>4</longValue>\n    <floatValue>5.5</floatValue>\n    <DoubleDribble>6.5</DoubleDribble>\n    <Nested xmlns:xsi=\"https://example.com\" xsi:someName=\"nestedAttrValue\"></Nested>\n</SimpleScalarPropertiesInputOutput>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))

        );

# Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

[package]

name = "rpcv2cbor"

version = "0.0.1"

authors = ["protocoltest@example.com"]

description = "test"

edition = "2021"

[package.metadata.smithy]

codegen-version = "ci"

[dependencies.aws-smithy-async]

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

[dependencies.aws-smithy-cbor]

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

[dependencies.aws-smithy-http]

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

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

        >,

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

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

        let _input = context

            .input()

            .downcast_ref::<EmptyInputOutputInput>()

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

        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.

        ];

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

        let forbidden_headers = &["X-Amz-Target"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_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,

            "v/8=",

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

        ));

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

    }

    /// When output structure is empty we write CBOR equivalent of {}

    /// Test ID: empty_output

    #[::tokio::test]

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

        >,

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

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

        let _input = context

            .input()

            .downcast_ref::<NoInputOutputInput>()

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

        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.

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

    }

    /// A `Content-Type` header should not be set if the response body is empty.

    /// Test ID: no_output

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn no_output_response() {

        let expected_output = crate::operation::no_input_output::NoInputOutputOutput::builder().build();

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

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

                .header("smithy-protocol", "rpc-v2-cbor")

                .status(200)

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

                .unwrap(),

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

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

        let _input = context

            .input()

            .downcast_ref::<OperationWithDefaultsInput>()

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

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

                    .set_default_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(1, 0_f64)))

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

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

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

                    .set_default_integer(::std::option::Option::Some(20))

                    .set_default_long(::std::option::Option::Some(200))

                    .set_default_float(::std::option::Option::Some(2.0_f32))

                    .set_default_double(::std::option::Option::Some(2.0_f64))

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

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

                        ret.insert("name".to_owned(), "Jack".to_owned());

                        ret

                    }))

                    .set_default_enum(::std::option::Option::Some(

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

                    ))

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

                    .set_empty_string(::std::option::Option::Some("foo".to_owned()))

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

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

                    .set_zero_float(::std::option::Option::Some(1.0_f32))

                    .set_zero_double(::std::option::Option::Some(1.0_f64))

                    .build(),

            ))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [

            ("Accept", "application/cbor"),

            ("Content-Type", "application/cbor"),

            ("smithy-protocol", "rpc-v2-cbor"),

        ];

        ::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, "v2hkZWZhdWx0c7dtZGVmYXVsdFN0cmluZ2NieWVuZGVmYXVsdEJvb2xlYW71a2RlZmF1bHRMaXN0gWFhcGRlZmF1bHRUaW1lc3RhbXDB+z/wAAAAAAAAa2RlZmF1bHRCbG9iQmhpa2RlZmF1bHRCeXRlAmxkZWZhdWx0U2hvcnQCbmRlZmF1bHRJbnRlZ2VyFGtkZWZhdWx0TG9uZxjIbGRlZmF1bHRGbG9hdPpAAAAAbWRlZmF1bHREb3VibGX7QAAAAAAAAABqZGVmYXVsdE1hcKFkbmFtZWRKYWNra2RlZmF1bHRFbnVtY0JBUm5kZWZhdWx0SW50RW51bQJrZW1wdHlTdHJpbmdjZm9vbGZhbHNlQm9vbGVhbvVpZW1wdHlCbG9iQmhpaHplcm9CeXRlAWl6ZXJvU2hvcnQBa3plcm9JbnRlZ2VyAWh6ZXJvTG9uZwFpemVyb0Zsb2F0+j+AAABqemVyb0RvdWJsZfs/8AAAAAAAAP8=", ::aws_smithy_protocol_test::MediaType::from("application/cbor"))

        );

        let expected_headers = [

            ("Accept", "application/cbor"),

            ("Content-Type", "application/cbor"),

            ("smithy-protocol", "rpc-v2-cbor"),

        ];

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

            "v3ZjbGllbnRPcHRpb25hbERlZmF1bHRzoP8=",

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

        ));

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

    }

    /// Client populates default values when missing in response.

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

        >,

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

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

        let _input = context

            .input()

            .downcast_ref::<OptionalInputOutputInput>()

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

        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.

        ];

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

        let forbidden_headers = &["X-Amz-Target"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_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,

            "v/8=",

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

        ));

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

    }

    /// When output is empty we write CBOR equivalent of {}

    /// Test ID: optional_output

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn optional_output_response() {

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

        >,

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

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

        let _input = context

            .input()

            .downcast_ref::<RecursiveShapesInput>()

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

        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.

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

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

                                crate::types::RecursiveShapesInputOutputNested1::builder()

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

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

                                        crate::types::RecursiveShapesInputOutputNested2::builder()

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

                                            .build(),

                                    )))

                                    .build(),

                            ))

                            .build(),

                    )))

                    .build(),

            ))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

        >,

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

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

        let _input = context

            .input()

            .downcast_ref::<RpcV2CborDenseMapsInput>()

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

        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.

            }))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [

            ("Accept", "application/cbor"),

            ("Content-Type", "application/cbor"),

            ("smithy-protocol", "rpc-v2-cbor"),

        ];

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

            "oWtkZW5zZVNldE1hcKJheIBheYJhYWFi",

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

        ));

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

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

        >,

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

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

        let _input = context

            .input()

            .downcast_ref::<RpcV2CborListsInput>()

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

        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.

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

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

            ]))

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

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

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

            ]))

            .set_int_enum_list(::std::option::Option::Some(vec![1, 2]))

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

                vec!["foo".to_owned(), "bar".to_owned()],

                vec!["baz".to_owned(), "qux".to_owned()],

            ]))

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

                crate::types::StructureListMember::builder()

                    .set_a(::std::option::Option::Some("1".to_owned()))

                    .set_b(::std::option::Option::Some("2".to_owned()))

                    .build(),

                crate::types::StructureListMember::builder()

                    .set_a(::std::option::Option::Some("3".to_owned()))

                    .set_b(::std::option::Option::Some("4".to_owned()))

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

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

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

            ]))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [

            ("Accept", "application/cbor"),

            ("Content-Type", "application/cbor"),

            ("smithy-protocol", "rpc-v2-cbor"),

        ];

        ::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, "v2pzdHJpbmdMaXN0gmNmb29jYmFyaXN0cmluZ1NldIJjZm9vY2JhcmtpbnRlZ2VyTGlzdIIBAmtib29sZWFuTGlzdIL19G10aW1lc3RhbXBMaXN0gsH7QdTX+/OAAADB+0HU1/vzgAAAaGVudW1MaXN0gmNGb29hMGtpbnRFbnVtTGlzdIIBAnBuZXN0ZWRTdHJpbmdMaXN0goJjZm9vY2JhcoJjYmF6Y3F1eG1zdHJ1Y3R1cmVMaXN0gqJhYWExYWJhMqJhYWEzYWJhNGhibG9iTGlzdIJDZm9vQ2Jhcv8=", ::aws_smithy_protocol_test::MediaType::from("application/cbor"))

        );

        let expected_headers = [

            ("Accept", "application/cbor"),

            ("Content-Type", "application/cbor"),

            ("smithy-protocol", "rpc-v2-cbor"),

        ];

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

            "oWpzdHJpbmdMaXN0gA==",

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

        ));

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

    }

    /// Serializes RpcV2 Cbor lists

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

        >,

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

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

        let _input = context

            .input()

            .downcast_ref::<RpcV2CborSparseMapsInput>()

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

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