Client Test

rev. 3d2cf9bfcccf2cb5e5660fe2685c9174956bfcad

Files changed:

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/json_enums.rs

@@ -201,201 +316,316 @@

             ::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::<JsonEnumsInput>()
             .ok_or("failed to downcast to JsonEnumsInput")?;
-209
         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(())
-216
+    }
-217
+}
-218
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-221
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_enums_test {
-225
     /// Serializes simple scalar properties
     /// Test ID: AwsJson11Enums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_enums_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-233
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_enums()
             .set_foo_enum1(::std::option::Option::Some(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum2(::std::option::Option::Some(
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum3(::std::option::Option::Some(
                 "1".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_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_foo_enum_set(::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_foo_enum_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "hi".to_owned(),
                     "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 );
                 ret.insert(
                     "zero".to_owned(),
                     "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 );
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/x-amz-json-1.1"), ("X-Amz-Target", "JsonProtocol.JsonEnums")];
         ::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    \"fooEnum1\": \"Foo\",\n    \"fooEnum2\": \"0\",\n    \"fooEnum3\": \"1\",\n    \"fooEnumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"fooEnumSet\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"fooEnumMap\": {\n        \"hi\": \"Foo\",\n        \"zero\": \"0\"\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");
-279
+    }
-280
     /// Serializes simple scalar properties
     /// Test ID: AwsJson11EnumsBasic
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_enums_basic_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-288
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_enums()
             .set_foo_enum1(::std::option::Option::Some(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum2(::std::option::Option::Some(
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),

↧ Expand context

             ))
             .set_foo_enum3(::std::option::Option::Some(
                 "1".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_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_foo_enum_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "hi".to_owned(),
                     "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 );
                 ret.insert(
                     "zero".to_owned(),
                     "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 );
                 ret
             }))

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/json_unions.rs

@@ -204,204 +534,534 @@

↥ Expand context

             ::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::<JsonUnionsInput>()
             .ok_or("failed to downcast to JsonUnionsInput")?;
-212
         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(())
-219
+    }
-220
+}
-221
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-224
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_unions_test {
-228
     /// Serializes a string union value
     /// Test ID: AwsJson11SerializeStringUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_string_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-236
         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.1"),
             ("X-Amz-Target", "JsonProtocol.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");
-259
+    }
-260
     /// Serializes a boolean union value
     /// Test ID: AwsJson11SerializeBooleanUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_boolean_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-268
         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.1"),
             ("X-Amz-Target", "JsonProtocol.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");
-291
+    }
-292
     /// Serializes a number union value
     /// Test ID: AwsJson11SerializeNumberUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_number_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-300
         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.1"),
             ("X-Amz-Target", "JsonProtocol.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");
-323
+    }
-324
     /// Serializes a blob union value
     /// Test ID: AwsJson11SerializeBlobUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_blob_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-332
         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.1"),
             ("X-Amz-Target", "JsonProtocol.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");
-357
+    }
-358
     /// Serializes a timestamp union value
     /// Test ID: AwsJson11SerializeTimestampUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_timestamp_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-366
         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.1"),
             ("X-Amz-Target", "JsonProtocol.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");
-391
+    }
-392
     /// Serializes an enum union value
     /// Test ID: AwsJson11SerializeEnumUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_enum_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-400
         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.1"),
             ("X-Amz-Target", "JsonProtocol.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");
-425
+    }
-426
     /// Serializes a list union value
     /// Test ID: AwsJson11SerializeListUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_list_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-434
         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.1"),
             ("X-Amz-Target", "JsonProtocol.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");
-460
+    }
-461
     /// Serializes a map union value
     /// Test ID: AwsJson11SerializeMapUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_map_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-469
         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.1"),
             ("X-Amz-Target", "JsonProtocol.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");
-497
+    }
-498
     /// Serializes a structure union value
     /// Test ID: AwsJson11SerializeStructureUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_serialize_structure_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-506
         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(),
             )))

↧ Expand context

             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.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");
-533
+    }
-534

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/kitchen_sink_operation.rs

@@ -210,210 +1288,1288 @@

↥ Expand context

         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<KitchenSinkOperationInput>()
             .ok_or("failed to downcast to KitchenSinkOperationInput")?;
-217
         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(())
-224
+    }
-225
+}
-226
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-229

 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod kitchen_sink_operation_test {
     use ::aws_smithy_protocol_test::FloatEquals;
-234
     /// Serializes string shapes
     /// Test ID: serializes_string_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_string_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-242
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_string(::std::option::Option::Some("abc xyz".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"String\":\"abc xyz\"}",
             ::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");
-267
+    }
-268
     /// Serializes string shapes with jsonvalue trait
     /// Test ID: serializes_string_shapes_with_jsonvalue_trait
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_string_shapes_with_jsonvalue_trait_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-276
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.kitchen_sink_operation()
         .set_json_value(
             ::std::option::Option::Some(
                 "{\"string\":\"value\",\"number\":1234.5,\"boolTrue\":true,\"boolFalse\":false,\"array\":[1,2,3,4],\"object\":{\"key\":\"value\"},\"null\":null}".to_owned()
-282
+            )
-283
+        )
         .send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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, "{\"JsonValue\":\"{\\\"string\\\":\\\"value\\\",\\\"number\\\":1234.5,\\\"boolTrue\\\":true,\\\"boolFalse\\\":false,\\\"array\\\":[1,2,3,4],\\\"object\\\":{\\\"key\\\":\\\"value\\\"},\\\"null\\\":null}\"}", ::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");
-301
+    }
-302
     /// Serializes integer shapes
     /// Test ID: serializes_integer_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_integer_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-310
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_integer(::std::option::Option::Some(1234))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Integer\":1234}",
             ::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");
-335
+    }
-336
     /// Serializes long shapes
     /// Test ID: serializes_long_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_long_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-344
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_long(::std::option::Option::Some(999999999999))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Long\":999999999999}",
             ::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");
-369
+    }
-370
     /// Serializes float shapes
     /// Test ID: serializes_float_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_float_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-378
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_float(::std::option::Option::Some(1234.5_f32))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Float\":1234.5}",
             ::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");
-403
+    }
-404
     /// Serializes double shapes
     /// Test ID: serializes_double_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_double_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-412
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_double(::std::option::Option::Some(1234.5_f64))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Double\":1234.5}",
             ::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");
-437
+    }
-438
     /// Serializes blob shapes
     /// Test ID: serializes_blob_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_blob_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-446
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("binary-value")))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Blob\":\"YmluYXJ5LXZhbHVl\"}",
             ::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");
-471
+    }
-472
     /// Serializes boolean shapes (true)
     /// Test ID: serializes_boolean_shapes_true
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_boolean_shapes_true_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-480
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_boolean(::std::option::Option::Some(true))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Boolean\":true}",
             ::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");
-505
+    }
-506
     /// Serializes boolean shapes (false)
     /// Test ID: serializes_boolean_shapes_false
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_boolean_shapes_false_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-514
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_boolean(::std::option::Option::Some(false))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Boolean\":false}",
             ::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");
-539
+    }
-540
     /// Serializes timestamp shapes
     /// Test ID: serializes_timestamp_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_timestamp_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-548
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 946845296, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Timestamp\":946845296}",
             ::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");
-575
+    }
-576
     /// Serializes timestamp shapes with iso8601 timestampFormat
     /// Test ID: serializes_timestamp_shapes_with_iso8601_timestampformat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_timestamp_shapes_with_iso8601_timestampformat_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-584
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_iso8601_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 946845296, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"Iso8601Timestamp\":\"2000-01-02T20:34:56Z\"}",
             ::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");
-611
+    }
-612
     /// Serializes timestamp shapes with httpdate timestampFormat
     /// Test ID: serializes_timestamp_shapes_with_httpdate_timestampformat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_timestamp_shapes_with_httpdate_timestampformat_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-620
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_httpdate_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 946845296, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"HttpdateTimestamp\":\"Sun, 02 Jan 2000 20:34:56 GMT\"}",
             ::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");
-647
+    }
-648
     /// Serializes timestamp shapes with unixTimestamp timestampFormat
     /// Test ID: serializes_timestamp_shapes_with_unixtimestamp_timestampformat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_timestamp_shapes_with_unixtimestamp_timestampformat_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-656
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_unix_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 946845296, 0_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"UnixTimestamp\":946845296}",
             ::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");
-683
+    }
-684
     /// Serializes list shapes
     /// Test ID: serializes_list_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_list_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-692
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_list_of_strings(::std::option::Option::Some(vec!["abc".to_owned(), "mno".to_owned(), "xyz".to_owned()]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"ListOfStrings\":[\"abc\",\"mno\",\"xyz\"]}",
             ::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");
-717
+    }
-718
     /// Serializes empty list shapes
     /// Test ID: serializes_empty_list_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_empty_list_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-726
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_list_of_strings(::std::option::Option::Some(vec![]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"ListOfStrings\":[]}",
             ::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");
-751
+    }
-752
     /// Serializes list of map shapes
     /// Test ID: serializes_list_of_map_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_list_of_map_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-760
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_list_of_maps_of_strings(::std::option::Option::Some(vec![
-765
+                {
                     let mut ret = ::std::collections::HashMap::new();
                     ret.insert("foo".to_owned(), "bar".to_owned());
                     ret
                 },
-770
+                {
                     let mut ret = ::std::collections::HashMap::new();
                     ret.insert("abc".to_owned(), "xyz".to_owned());
                     ret
                 },
-775
+                {
                     let mut ret = ::std::collections::HashMap::new();
                     ret.insert("red".to_owned(), "blue".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.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"ListOfMapsOfStrings\":[{\"foo\":\"bar\"},{\"abc\":\"xyz\"},{\"red\":\"blue\"}]}",
             ::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");
-801
+    }
-802
     /// Serializes list of structure shapes
     /// Test ID: serializes_list_of_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_list_of_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-810
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_list_of_structs(::std::option::Option::Some(vec![
                 crate::types::SimpleStruct::builder()
                     .set_value(::std::option::Option::Some("abc".to_owned()))
                     .build(),
                 crate::types::SimpleStruct::builder()
                     .set_value(::std::option::Option::Some("mno".to_owned()))
                     .build(),
                 crate::types::SimpleStruct::builder()
                     .set_value(::std::option::Option::Some("xyz".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.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"ListOfStructs\":[{\"Value\":\"abc\"},{\"Value\":\"mno\"},{\"Value\":\"xyz\"}]}",
             ::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");
-845
+    }
-846
     /// Serializes list of recursive structure shapes
     /// Test ID: serializes_list_of_recursive_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_list_of_recursive_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-854
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_recursive_list(::std::option::Option::Some(vec![crate::types::KitchenSink::builder()
                 .set_recursive_list(::std::option::Option::Some(vec![crate::types::KitchenSink::builder()
                     .set_recursive_list(::std::option::Option::Some(vec![crate::types::KitchenSink::builder()
                         .set_integer(::std::option::Option::Some(123))
                         .build()]))
                     .build()]))
                 .build()]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"RecursiveList\":[{\"RecursiveList\":[{\"RecursiveList\":[{\"Integer\":123}]}]}]}",
             ::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");
-885
+    }
-886
     /// Serializes map shapes
     /// Test ID: serializes_map_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_map_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-894
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_map_of_strings(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("abc".to_owned(), "xyz".to_owned());
                 ret.insert("mno".to_owned(), "hjk".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.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"MapOfStrings\":{\"abc\":\"xyz\",\"mno\":\"hjk\"}}",
             ::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");
-924
+    }
-925
     /// Serializes empty map shapes
     /// Test ID: serializes_empty_map_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_empty_map_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-933
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_map_of_strings(::std::option::Option::Some(::std::collections::HashMap::new()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"MapOfStrings\":{}}",
             ::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");
-958
+    }
-959
     /// Serializes map of list shapes
     /// Test ID: serializes_map_of_list_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_map_of_list_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-967
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_map_of_lists_of_strings(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("abc".to_owned(), vec!["abc".to_owned(), "xyz".to_owned()]);
                 ret.insert("mno".to_owned(), vec!["xyz".to_owned(), "abc".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.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"MapOfListsOfStrings\":{\"abc\":[\"abc\",\"xyz\"],\"mno\":[\"xyz\",\"abc\"]}}",
             ::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");
-997
+    }
-998
     /// Serializes map of structure shapes
     /// Test ID: serializes_map_of_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_map_of_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-1006
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_map_of_structs(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "key1".to_owned(),
                     crate::types::SimpleStruct::builder()
                         .set_value(::std::option::Option::Some("value-1".to_owned()))
                         .build(),
                 );
                 ret.insert(
                     "key2".to_owned(),
                     crate::types::SimpleStruct::builder()
                         .set_value(::std::option::Option::Some("value-2".to_owned()))
                         .build(),
                 );
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"MapOfStructs\":{\"key1\":{\"Value\":\"value-1\"},\"key2\":{\"Value\":\"value-2\"}}}",
             ::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");
-1046
+    }
-1047
     /// Serializes map of recursive structure shapes
     /// Test ID: serializes_map_of_recursive_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_map_of_recursive_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-1055
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_recursive_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "key1".to_owned(),
                     crate::types::KitchenSink::builder()
                         .set_recursive_map(::std::option::Option::Some({
                             let mut ret = ::std::collections::HashMap::new();
                             ret.insert(
                                 "key2".to_owned(),
                                 crate::types::KitchenSink::builder()
                                     .set_recursive_map(::std::option::Option::Some({
                                         let mut ret = ::std::collections::HashMap::new();
                                         ret.insert(
                                             "key3".to_owned(),
                                             crate::types::KitchenSink::builder()
                                                 .set_boolean(::std::option::Option::Some(false))
                                                 .build(),
                                         );
                                         ret
                                     }))
                                     .build(),
                             );
                             ret
                         }))
                         .build(),
                 );
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"RecursiveMap\":{\"key1\":{\"RecursiveMap\":{\"key2\":{\"RecursiveMap\":{\"key3\":{\"Boolean\":false}}}}}}}",
             ::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");
-1107
+    }
-1108
     /// Serializes structure shapes
     /// Test ID: serializes_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-1116
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_simple_struct(::std::option::Option::Some(
                 crate::types::SimpleStruct::builder()
                     .set_value(::std::option::Option::Some("abc".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.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"SimpleStruct\":{\"Value\":\"abc\"}}",
             ::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");
-1145
+    }
-1146
     /// Serializes structure members with locationName traits
     /// Test ID: serializes_structure_members_with_locationname_traits
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_structure_members_with_locationname_traits_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-1154
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_struct_with_json_name(::std::option::Option::Some(
                 crate::types::StructWithJsonName::builder()
                     .set_value(::std::option::Option::Some("some-value".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.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"StructWithJsonName\":{\"Value\":\"some-value\"}}",
             ::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");
-1183
+    }
-1184
     /// Serializes empty structure shapes
     /// Test ID: serializes_empty_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_empty_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-1192
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_simple_struct(::std::option::Option::Some(crate::types::SimpleStruct::builder().build()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"SimpleStruct\":{}}",
             ::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");
-1217
+    }
-1218
     /// Serializes structure which have no members
     /// Test ID: serializes_structure_which_have_no_members
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_structure_which_have_no_members_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-1226
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_empty_struct(::std::option::Option::Some(crate::types::EmptyStruct::builder().build()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
         ];
         ::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,
             "{\"EmptyStruct\":{}}",
             ::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");
-1251
+    }
-1252
     /// Serializes recursive structure shapes
     /// Test ID: serializes_recursive_structure_shapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn serializes_recursive_structure_shapes_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-1260
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .kitchen_sink_operation()
             .set_string(::std::option::Option::Some("top-value".to_owned()))
             .set_boolean(::std::option::Option::Some(false))
             .set_recursive_struct(::std::option::Option::Some(::std::boxed::Box::new(
                 crate::types::KitchenSink::builder()
                     .set_string(::std::option::Option::Some("nested-value".to_owned()))

↧ Expand context

                     .set_boolean(::std::option::Option::Some(true))
                     .set_recursive_list(::std::option::Option::Some(vec![
                         crate::types::KitchenSink::builder()
                             .set_string(::std::option::Option::Some("string-only".to_owned()))
                             .build(),
                         crate::types::KitchenSink::builder()
                             .set_recursive_struct(::std::option::Option::Some(::std::boxed::Box::new(
                                 crate::types::KitchenSink::builder()
                                     .set_map_of_strings(::std::option::Option::Some({
                                         let mut ret = ::std::collections::HashMap::new();
                                         ret.insert("color".to_owned(), "red".to_owned());
                                         ret.insert("size".to_owned(), "large".to_owned());
                                         ret
                                     }))
                                     .build(),
                             )))
                             .build(),
                     ]))
                     .build(),
             )))

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/null_operation.rs

@@ -206,206 +266,266 @@

↥ Expand context

             ::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::<NullOperationInput>()
             .ok_or("failed to downcast to NullOperationInput")?;
-214
         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(())
-221
+    }
-222
+}
-223
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-226
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod null_operation_test {
-230
     /// Null structure values are dropped
     /// Test ID: AwsJson11StructuresDontSerializeNullValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_structures_dont_serialize_null_values_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-238
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.null_operation().set_string(::std::option::Option::None).send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.NullOperation"),
         ];

↧ Expand context

         ::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,
             "{}",
             ::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");
-257
+    }
-258
     /// Null structure values are dropped
     /// Test ID: AwsJson11StructuresDontDeserializeNullValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_structures_dont_deserialize_null_values_response() {
         let expected_output = crate::operation::null_operation::NullOperationOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/operation_with_optional_input_output.rs

@@ -219,219 +307,307 @@

↥ Expand context

             ::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::<OperationWithOptionalInputOutputInput>()
             .ok_or("failed to downcast to OperationWithOptionalInputOutputInput")?;
-227
         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(())
-234
+    }
-235
+}
-236
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-239
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod operation_with_optional_input_output_test {
-243
     /// Can call operations with no input or output
     /// Test ID: can_call_operation_with_no_input_or_output
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn can_call_operation_with_no_input_or_output_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-251
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.operation_with_optional_input_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.OperationWithOptionalInputOutput"),
         ];
         ::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,
             "{}",
             ::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");
-270
+    }
-271
     /// Can invoke operations with optional input
     /// Test ID: can_call_operation_with_optional_input
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn can_call_operation_with_optional_input_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-279
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .operation_with_optional_input_output()
             .set_value(::std::option::Option::Some("Hi".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.OperationWithOptionalInputOutput"),
         ];
         ::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,
             "{\"Value\":\"Hi\"}",
             ::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");
-302
+    }
-303
+}
-304
 /// Error type for the `OperationWithOptionalInputOutputError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/put_and_get_inline_documents.rs

@@ -215,215 +275,275 @@

↥ Expand context

             ::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::<PutAndGetInlineDocumentsInput>()
             .ok_or("failed to downcast to PutAndGetInlineDocumentsInput")?;
-223
         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(())
-230
+    }
-231
+}
-232
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-235
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod put_and_get_inline_documents_test {
-239
     /// Serializes inline documents in a JSON request.
     /// Test ID: PutAndGetInlineDocumentsInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn put_and_get_inline_documents_input_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-247
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .put_and_get_inline_documents()
             .set_inline_document(::std::option::Option::Some({
                 let json_bytes = br#"{
                         "foo": "bar"
                     }"#;
                 let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();

↧ Expand context

                 ::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();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.PutAndGetInlineDocuments"),
         ];
         ::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    \"inlineDocument\": {\"foo\": \"bar\"}\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/put_with_content_encoding.rs

@@ -217,217 +305,305 @@

↥ Expand context

             ::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::<PutWithContentEncodingInput>()
             .ok_or("failed to downcast to PutWithContentEncodingInput")?;
-225
         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(())
-232
+    }
-233
+}
-234
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-237
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod put_with_content_encoding_test {
-241
     /// Compression algorithm encoding is appended to the Content-Encoding header.
     /// Test ID: SDKAppliedContentEncoding_awsJson1_1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn sdk_applied_content_encoding_aws_json1_1_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-249
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.put_with_content_encoding()
         .set_data(
             ::std::option::Option::Some(
                 "RjCEL3kBwqPivZUXGiyA5JCujtWgJAkKRlnTEsNYfBRGOS0f7LT6R3bCSOXeJ4auSHzQ4BEZZTklUyj5\n1HEojihShQC2jkQJrNdGOZNSW49yRO0XbnGmeczUHbZqZRelLFKW4xjru9uTuB8lFCtwoGgciFsgqTF8\n5HYcoqINTRxuAwGuRUMoNO473QT0BtCQoKUkAyVaypG0hBZdGNoJhunBfW0d3HWTYlzz9pXElyZhq3C1\n2PDB17GEoOYXmTxDecysmPOdo5z6T0HFhujfeJFIQQ8dirmXcG4F3v0bZdf6AZ3jsiVh6RnEXIPxPbOi\ngIXDWTMUr4Pg3f2LdYCM01eAb2qTdgsEN0MUDhEIfn68I2tnWvcozyUFpg1ez6pyWP8ssWVfFrckREIM\nMb0cTUVqSVSM8bnFiF9SoXM6ZoGMKfX1mT708OYk7SqZ1JlCTkecDJDoR5ED2q2MWKUGR6jjnEV0GtD8\nWJO6AcF0DptY9Hk16Bav3z6c5FeBvrGDrxTFVgRUk8SychzjrcqJ4qskwN8rL3zslC0oqobQRnLFOvwJ\nprSzBIwdH2yAuxokXAdVRa1u9NGNRvfWJfKkwbbVz8yV76RUF9KNhAUmwyYDrLnxNj8ROl8B7dv8Gans\n7Bit52wcdiJyjBW1pAodB7zqqVwtBx5RaSpF7kEMXexYXp9N0J1jlXzdeg5Wgg4pO7TJNr2joiPVAiFf\nefwMMCNBkYx2z7cRxVxCJZMXXzxSKMGgdTN24bJ5UgE0TxyV52RC0wGWG49S1x5jGrvmxKCIgYPs0w3Z\n0I3XcdB0WEj4x4xRztB9Cx2Mc4qFYQdzS9kOioAgNBti1rBySZ8lFZM2zqxvBsJTTJsmcKPr1crqiXjM\noVWdM4ObOO6QA7Pu4c1hT68CrTmbcecjFcxHkgsqdixnFtN6keMGL9Z2YMjZOjYYzbUEwLJqUVWalkIB\nBkgBRqZpzxx5nB5t0qDH35KjsfKM5cinQaFoRq9y9Z82xdCoKZOsUbxZkk1kVmy1jPDCBhkhixkc5PKS\nFoSKTbeK7kuCEZCtR9OfF2k2MqbygGFsFu2sgb1Zn2YdDbaRwRGeaLhswta09UNSMUo8aTixgoYVHxwy\nvraLB6olPSPegeLOnmBeWyKmEfPdbpdGm4ev4vA2AUFuLIeFz0LkCSN0NgQMrr8ALEm1UNpJLReg1ZAX\nzZh7gtQTZUaBVdMJokaJpLk6FPxSA6zkwB5TegSqhrFIsmvpY3VNWmTUq7H0iADdh3dRQ8Is97bTsbwu\nvAEOjh4FQ9wPSFzEtcSJeYQft5GfWYPisDImjjvHVFshFFkNy2nN18pJmhVPoJc456tgbdfEIdGhIADC\n6UPcSSzE1FxlPpILqZrp3i4NvvKoiOa4a8tnALd2XRHHmsvALn2Wmfu07b86gZlu4yOyuUFNoWI6tFvd\nbHnqSJYNQlFESv13gJw609DBzNnrIgBGYBAcDRrIGAnflRKwVDUnDFrUQmE8xNG6jRlyb1p2Y2RrfBtG\ncKqhuGNiT2DfxpY89ektZ98waPhJrFEPJToNH8EADzBorh3T0h4YP1IeLmaI7SOxeuVrk1kjRqMK0rUB\nlUJgJNtCE35jCyoHMwPQlyi78ZaVv8COVQ24zcGpw0MTy6JUsDzAC3jLNY6xCb40SZV9XzG7nWvXA5Ej\nYC1gTXxF4AtFexIdDZ4RJbtYMyXt8LsEJerwwpkfqvDwsiFuqYC6vIn9RoZO5kI0F35XtUITDQYKZ4eq\nWBV0itxTyyR5Rp6g30pZEmEqOusDaIh96CEmHpOBYAQZ7u1QTfzRdysIGMpzbx5gj9Dxm2PO1glWzY7P\nlVqQiBlXSGDOkBkrB6SkiAxknt9zsPdTTsf3r3nid4hdiPrZmGWNgjOO1khSxZSzBdltrCESNnQmlnP5\nZOHA0eSYXwy8j4od5ZmjA3IpFOEPW2MutMbxIbJpg5dIx2x7WxespftenRLgl3CxcpPDcnb9w8LCHBg7\nSEjrEer6Y8wVLFWsQiv6nTdCPZz9cGqwgtCaiHRy8lTWFgdfWd397vw9rduGld3uUFeFRGjYrphqEmHi\nhiG0GhE6wRFVUsGJtvOCYkVREvbEdxPFeJvlAvOcs9HKbtptlTusvYB86vR2bNcIY4f5JZu2X6sGa354\n7LRk0ps2zqYjat3hMR7XDC8KiKceBteFsXoDjfVxTYKelpedTxqWAafrKhaoAVuNM98PSnkuIWGzjSUC\nNsDJTt6vt1D1afBVPWVmnQ7ZQdtEtLIEwAWYjemAztreELIr1E9fPEILm1Ke4KctP9I0I72Dh4eylNZD\n0DEr2Hg7cWFckuZ0Av5d0IPRARXikEGDHl8uh12TXL9v2Uh0ZVSJMEYvxGSbZvkWz8TjWSk3hKA2a7GL\nJm3Ho7e1C34gE1XRGcEthxvURxt4OKBqN3ZNaMIuDTWinoQAutMcUqtm4MoL7RGPiCHUrvTwQPSirsmA\nQmOEu8nOpnP77Fivh9jLGx5ta7nL6jrsWUsBqiN1lzpdPYLRR4mUIAj6sNWiDEk4pkbHSMEcqbWw6Zl7\npsEyPDHalCNhWMA3RSK3skURzQDZ0oBV5W7vjVIZ4d3uCKsk6zrzEI9u5mx7p9RdNKodXfzqYt0ULdtc\n3RW0hIfw2KvrO3BD2QrtgAkfrFBGVvlJSUoh0MvLz8DeXxfuiuq9Ttu7wvsqVI4Piah6WNEXtHHGPJO3\nGhc75Bnv2To4VS2v8rmyKAPIIVTuYBHZN6sZ4FhFzbrslCIdk0eadaU60naqiNWU3CsxplIYGyeThmJ7\n9u4h6Y2OmiPZjFPS2bAzwgAozYTVefII9aEaWZ0hxHZeu1FW7r79dkdO73ZqRfas9u8Z7LLBPCw5pV0F\n5I0pHDgNb6MogoxF4NZJfVtIX1vCHhhVLrXjrYNJU2fD9Fw8kT8Ie2HDBJnqAvYKmryQ1r9ulo3Me3rH\nq9s2Y5uCDxu9iQNhnpwIm57WYGFeqd2fnQeY2IziD3Jgx0KSrmOH0jgi0RwJyfGXaORPq3bQQqljuACo\nkO6io9t5VI8PbNxSHTRbtYiPciUslbT0g7SpCLrRPOBRJ4DDk56pjghpeoUagJ5xJ4wjBzBuXnAGkNnP\nTfpiuz2r3oSBAi8sB9wiYK2z9sp4gZyQsqdVNzAEgKatOxBRBmJCBYpjO98ZQrF83XApPpfFg0ujB2PW\n1iYF9NkgwIKB5oB6KVTOmSKJk11mVermPgeugHbzdd2zUP6fP8fWbhseqk2t8ahGvqjs2CDHFIWXl5jc\nfCknbykE3ANt7lnAfJQ2ddduLGiqrX4HWx6jcWw08Es6BkleO0IDbaWrb95d5isvFlzJsf0TyDIXF4uq\nbBDCi0XPWqtRJ2iqmnJa2GbBe9GmAOWMkBFSilMyC4sR395WSDpD56fx0NGoU6cHrRu9xF2Bgh7RGSfl\nch2GXEeE02fDpSHFNvJBlOEqqfkIX6oCa6KY9NThqeIjYsT184XR2ZI7akXRaw1gMOGpk4FmUxk6WIuX\n4ei1SLQgSdl7OEdRtJklZ76eFrMbkJQ2TDhu8f7mVuiy53GUMIvCrP9xYGZGmCIDm2e4U2BDi3F7C5xK\n3bDZXwlQp6z4BSqTy2OVEWxXUJfjPMOL5Mc7AvDeKtxAS73pVIv0HgHIa4NBAdC7uLG0zXuu1FF6z2XY\nyUhk03fMZhYe7vVxsul3WE7U01fuN8z2y0eKwBW1RFBE1eKIaR9Y01sIWQWbSrfHfDrdZiElhmhHehfs\n0EfrR4sLYdQshJuvhTeKGJDaEhtPQwwJ9mUYGtuCL9RozWx1XI4bHNlzBTW0BVokYiJGlPe7wdxNzJD7\nJgS7Lwv6jGKngVf86imGZyzqwiteWFPdNUoWdTvUPSMO5xIUK9mo5QpwbBOAmyYzVq42o3Qs90N9khEV\nU36LB99fw8PtGHH5wsCHshfauwnNPj0blGXzke0kQ4JNCVH7Jtn0Y0aeejkSxFtwtxoYs6zHl1Lxxpsd\nsw5vBy49CEtoltDW367lVAwDjWdx20msGB7qJCkEDrzu7EXSO22782QX9NBRcN9ppX0C25I0FMA4Wnhz\n9zIpiXRrsTH35jzM8Cjt4EVLGNU3O0HuEvAer3cENnMJtngdrT86ox3fihMQbiuy4Bh4DEcP5in2VjbT\n3qbnoCNvOi8Fmmf7KlGlWAOceL5OHVE5lljjQEMzEQOCEgrk5mDKgwSBJQBNauIDSC1a5iEQjB8Xxp4C\nqeKyyWY9IOntNrtU5ny4lNprHJd36dKFeBLKcGCOvgHBXdOZloMF0YTRExw7hreEO9IoTGVHJ4teWsNr\nHdtagUHjkeZkdMMfnUGNv5aBNtFMqhcZH6EitEa9lGPkKBbJpoom3u8D8EHSIF1H5EZqqx9TLY5hWAIG\nPwJ4qwkpCGw5rCLVrjw7ARKukIFzNULANqjHUMcJ002TlUosJM4xJ4aAgckpLVGOGuPDhGAAexEcQmbg\nUsZdmqQrtuVUyyLteLbLbqtR6CTlcAIwY3xyMCmPgyefE0FEUODBoxQtRUuYTL9RC5o1sYb2PvcxUQfb\niJFi2CAl99pAzcckU2qVCxniARslIxM5pmMRGsQX9ZzYAfZrbg6ce6S74I8UMlgRQ2QVyvUjKKOE6IrJ\nLng370emHfe5m6LZULD5YiZutkD5ipjL2Bz77DvTE5kNPUhuoKBcTJcUgytfXAKUTWOcRKNlq0GImrxM\nJfr7AWbLFFNKGLeTrVDBwpcokJCv0zcOKWe8fd2xkeXkZTdmM66IgM27cyYmtQ6YF26Kd0qrWJeVZJV9\n3fyLYYvKN5csbRY2BHoYE5ERARRW65IrpkXMf48OrCXMtDIP0Z7wxI9DiTeKKeH4uuguhCJnwzR3WxLA\nVU6eBJEd7ZjS6JA83w7decq8uDI7LGKjcz1FySp3B7fE9DkHRGXxbsL7Fjar6vW2mAv8CuvI20B6jctp\n2yLDs24sPfB3sSxrrlhbuT1m6DZqiN0dl6umKx7NGZhmOTVGr20jfcxhqPQwTJfd7kel4rvxip4BqkvT\n7STy8knJ2BXGyJeNgwo1PXUZRDVy0LCTsSF1RFuRZe8cktHl9lgw8ntdPn1pVFL0MwJkJfdXBNUp5gNv\n50FTkrpo1t6wq4CVbcfj2XOrOzvBUzNH26sXGABI1gGxCdp2jEZrHgqQaWIaTJVTuguZhxqDvdYsrwFW\nYN58uuNcKHIrGdRSigyZInwQDYk0pjcqdSeU0WVU3Y9htzZBR7XRaCJr5YTZvq7fwermb5tuwb37lPLq\nB2IGg0iftkVbXaSyfCwVaRbfLBb88so0QqpmJGirFu8FcDiXOV1zTr8yW9XLdYQuUjh43xrXLdgsuYff\nCagInUk1eU1aLjVZoJRsNmStmOEpAqlYMwTvx7w6j2f421Cxr5cNZBIVlAxlXN2QiDqJ9v3sHhHkTanc\nlQuH8ptUyX8qncpBuXXBn7cSez9N0EoxCBl1GHUagbjstgJo4gzLvTmVIY6MiWYOBitzNUHfyqKwtKUr\nVoSCdZcGeA9lHUPA7PUprRRaT3m1hGKPyshtVS2ikG48w3oVerln1N1qGdtz46gZCrndw3LZ1B362RfW\nzDPuXbpsyLsRMTt1Rz1oKHRXp3iE41hkhQH6pxlvyCW2INnHt5XU8zRamOB3oW0udOhMpQFDjRkOcy06\nb4t0QTHvoRqmBna3WXzIMZyeK3GChF5eF8oDXRbjhk7BB6YKCgqwWUzEJ5K47HMSlhFkBUjaPRjdGM0z\nzOMwhW6b1NvSwP7XM1P5yi1oPvOspts1vr29SXqrMMrBhVogeodWyd69NqrO4jkyBxKmlXifoTowpfiY\n2cUCE0XMZqxUN39LCP09JqZifaEcBEo3mgtm1tWu5QR2GNq7UyQf4RIPSDOpDCAtwoPhRgdT1lJdcj4U\nlnH0wrJ8Uwu7c08L7ErnIrDATqCrOjpSbzGP1xHENABYONC4TknFPrJ8pe40A8fzGT0qBw9mAM1SKcHO\nfoiLcMC9AjHTqJzDG3xplSLPG9or2rMeq7Fzp9r0y7uJRMxgg51EbjfvYlH466A3ggvL2WQlDXjJqPW3\nBJGWAWDNN9LK8f46bADKPxakpkx23S9O47rGSXfDhVSIZsDympxWX1UOzWwMZRHkofVeKqizgbKkGgUT\nWykE9gRoRAOd9wfHZDYKa9i0LaPDiaUMvnU1gdBIqIoiVsdJ9swX47oxvMtOxtcS0zlD6llDkBuIiU5g\nPwRCYmtkkb25c8iRJXwGFPjI1wJ34I1z1ENicPdosPiUe9ZC2jnXIKzEdv01x2ER7DNDF3yxOwOhxNxI\nGqsmC92j25UQQFu9ZstOZ28AoCkuOYs0Uycm5u8jR1T39dMBwrko09rC65ENLnsxM8oebmyFCPiGJ1ED\n5Xqc9qZ237f1OnETAoEOwqUSvrdPTv56U7hV91EMTyC812MLQpr2710E3VVpsUCUMNhIxdt7UXZ1UNFb\njgzpZLXnf4DHrv6B7kq6UI50KMxcw1HZE2GpODfUTzNFLaqdrvzxKe5eUWdcojBaRbD4fFdVYJTElYDH\nNNVh6ofkoeWcs9CWGFmSBe0T4K8phFeygQg0prKMELNEy6qENzVtG9ZDcqj3a7L6ZLtvq50anWp7fAVu\nfwz55g4iM2Z2fA0pnwHDL7tt67zTxGITvsnJsZSpeq1EQsZcwtkBV9liu7Rl7jiVT1IIRtchB8TsTiaA\nwVHIQQ9RIOTiPQdKNqi1kC9iGlUqWK93gblNWlBw1eYB9Wk8FQogutwTf0caNMx8D4nPbANcmOOlskIy\nzALh15OlTrWnhP95rf08AN2J026zDE2DUF9k0eCevYBQIDjqKNW4XCZnjbHoIcKzbY5VzPbMs3ZyMz8K\nSucBmgPg6wrSK5ykbkapS5vuqvXc9GbjQJ8bPNzoxoWGyjbZvDs2OBrIqBmcQb2DLJ8v38McQ4mC4UsS\njf4PyfSCtpk274QZjvLCZbLiCBxQegk7jUU0NmTFJAcYCxd9xMWdlFkiszcltT2YzwuFFz7iA6aa4n5L\nHpBNfUA01GcAi1aCMYhmooS4zSlYcSOZkovMz36U3Fd9WtqIEOJLi7HMgHQDgNMdK6DTzAdHQtxerxVF\nHJnPrfNVG7270r3bp0bPnLNYLhObbAn6zqSAUeLtI2Y4KJDjBKCAh2vvYGbu0e2REYJWRj7MkGevsSSy\nb1kCXLt6tKGWAb7lt5c0xyJgUIJW7pdtnwgT0ZCa24BecCAwNnG5U2EwQbcjZGsFxqNGfaemd3oFEhES\nBaE0Fxms9UKTnMafu8wvZ2xymMrUduuRzOjDeX7oD5YsLC88V8CGMLxbbxIpt94KGykbr6e7L0R4oZl1\ntKMgFwQ2p9Txdbp0Y293LcsJymKizqI0F2xEp7y4SmWOJqHZtsbz80wVV9nv41CvtfxuSoGZJ5cNB7pI\nBgzNcQCeH3Jt0RaGGwboxxpuFbzilmkMFXxJm87tD4WNgu01nHfGCKeQcySEBZpVfJgi6sDFJ8uWnvKm\n9mPLHurtWzEfKqUEa1iC71bXjw5wrvhv9BYW8JSUELHmDquftQyKdq0DZXhULMHGQLf4e95WIaoA14LL\nbThz77kuhKULPTu2MNrBUKGorurhGugo5gs4ZUezSsUOe3KxYdrFMdGgny1GgTxMSMTp2RAZytKjv4kQ\nVx7XgzvpQLIbDjUPAkJv6lScwIRq1W3Ne0Rh0V6Bmn6U5uIuWnJjULmbaQiSODj3z0mAZvak0mSWIGwT\nTX83HztcC4W7e1f6a1thmcc5K61Icehla2hBELWPpixTkyC4eEVmk9Rq0m0ZXtx0JX2ZQXqXDEyePyMe\nJ70sdSzXk72zusqhY4yuOMGgbYNHqxOToK6NxujR7e4dV3Wk5JnSUthym8scjcPeCiKDNY4cHfTMnDXJ\n9zLVy01LtNKYpJ1s8FxVxigmxQNKEbIamxhx6yqwGC4aiISVOOUEjvNOdaUfXfUsE6jEwtwxyGxjlRK1\ncLyxXttq4QWN6PehgHv7jXykzPjInbEysebFvvPOOMdunmJvcCNMSvjUda8fL6xfGo0FDrLg8XZipd6S\noPVdYtyIM1Dg40KbBA3JuumPYtXuJaHrZnjZmdnM5OVo4ZNxktfCVT0c6bnD4bAeyn4bYt1ZPaX6hQHh\nJtvNYfpD0ONYlmqKuToQAMlz52Fh6bj45EbX89L5eLlSpWeyBlGotzriB0EPlclrGi5l2B5oPb1aB1ag\nyyYuu44l0F1oOVYnBIZsxIsHVITxi9lEuVPFkWASOUNuVQXfM4n5hxWR9qtuKnIcPsvbJsv1U10XlKh3\nKisqPhHU15xrCLr5gwFxPUKiNTLUBrkzgBOHXPVsHcLCiSD0YU56TRGfvEom43TWUKPPfl9Z54tgVQuT\njCRlaljAzeniQIcbbHZnn3f0HxbDG3DFYqWSxNrXabHhRsIOhhUHSPENyhGSTVO5t0XX5CdMspJPCd02\n3Oqv32ccbUK4O3YH6LEvp0WO3kSl5n50odVkI9B0i0iq4UPFGMkM8bEQJbgJoOH71P10vtdevJFQE4g2\nyhimiM53ZJRWgSZveHtENZc0Gjo0F9eioak9BnPpY1QxAFPC817svuhEstcU69bLCA4D1rO5R8AuIIBq\nyQJcifFLvbpAEYTLKJqysZrU8EEl3TSdC13A9hZvk4NC8VGEDAxcNrKw313dZp17kZPO5HSd1y6sljAW\nA9M1d6FMYV5SlBWf3WZNCUPS7qKNlda2YBsC6IUVB363f5RLGQOQHwbaijBSRCkrVoRxBHtc0Bd5J9V9\nP5uMTXkpZOxRcCQvImGgcmGuxxLb5zTqfS2xu7v3Sf3IIesSt9tVzcEcdbEvLGVJkLk4mb3G30DbIbri\nPZ09JkweDvMaQ3bxT2nfkz3Ilihkw9jqikkCCCz7E8h6z6KbhQErEW9VzJZzMCgJsyPjFam6iNwpe07S\nhyOvNVw2t9wpzL5xM11DvVzQwDaWEytNRHzDBs4KwEtpI2IpjUyVZHSwA0UGqqkzoCgrJFlNOvPlXqcS\nIcREouUIBmuttkrhPWJtSxOOgpsdvBR3kTOzAXNzSKxoaBAb0c5SDMUc6FIyGA8x5wg5DkUgjFUUodEt\nOYaB2VHVePW9mxHeBTdKWLzJow4ZZvjnoBuVigXljKCNh137ckV2y3Yg3Xi4UzJEI2V5Rw9AfnMs7xUw\nVHOFCg189maD3bmZAe7b4eaGZhyy4HVKjqCXmIH7vsEjRvbnfB0SQxxpuqBDJbHNCtW4vM643ZQQBVPP\na7oXSQIq9w2dHp0A7dtkocCZdQp9FKR9XdJAFIbVSHzIF1ZogeZlc0pXuNE0tagvD57xwDRFkAuoQyMu\nYDdZasXrpSmEE5UjHVkyYsISn8QsfXurzDybX468aoRoks654jjmRY5zi1oB8TcMdC2c3sicNaqfeuhd\nH1nPX7l4RpdqWMR7gGx9slXtG8S3KxpOi4qCD7yg3saD66nun4dzksQURoTUdXyrJR5UpHsfIlTF1aJa\nMdXyQtQnrkl00TeghQd00rRFZsCnhi0qrCSKiBfB2EVrd9RPpbgwJGZHuIQecdBmNetc2ylSEClqVBPR\nGOPPIxrnswEZjmnS0jxKW9VSM1QVxSPJnPFswCqT95SoKD6CP4xdX28WIUGiNaIKodXXJHEIsXBCxLsr\nPwWPCtoplC6hhpKmW5dQo92iCTyY2KioKzO8XR6FKm6qonMKVEwQNtlYE9c97KMtEnp25VOdMP46SQXS\nYsSVp7vm8LP87VYI8SOKcW3s2oedYFtt45rvDzoTF0GmS6wELQ9uo98HhjQAI1Dt91cgjJOwygNmLoZE\nX5K2zQiNA163uMCl5xzaBqY4YTL0wgALg3IFdYSp0RFYLWdt6IxoGI1tnoxcjlUEPo5eGIc3mS3SmaLn\nOdumfUQQ4Jgmgaa5anUVQsfBDrlAN5oaX7O0JO71SSPSWiHBsT9WIPy2J1Cace9ZZLRxblFPSXcvsuHh\nhvnhWQltEDAe7MgvkFQ8lGVFa8jhzijoF9kLmMhMILSzYnfXnZPNP7TlAAwlLHK1RqlpHskJqb6CPpGP\nQvOAhEMsM3zJ2KejZx0esxkjxA0ZufVvGAMN3vTUMplQaF4RiQkp9fzBXf3CMk01dWjOMMIEXTeKzIQe\nEcffzjixWU9FpAyGp2rVl4ETRgqljOGw4UgK31r0ZIEGnH0xGz1FtbW1OcQM008JVujRqulCucEMmntr\n".to_owned()
-255
+            )
-256
+        )
         .send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Encoding", "gzip")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         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");
-265
+    }
-266
     /// Compression algorithm encoding is appended to the Content-Encoding header, and the
     /// user-provided content-encoding is NOT in the Content-Encoding header since HTTP binding
     /// traits are ignored in the awsJson1_1 protocol.
     ///
     /// Test ID: SDKAppendsGzipAndIgnoresHttpProvidedEncoding_awsJson1_1
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn sdk_appends_gzip_and_ignores_http_provided_encoding_aws_json1_1_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-277
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.put_with_content_encoding()
         .set_encoding(
             ::std::option::Option::Some(
                 "custom".to_owned()
-283
+            )
-284
+        )
         .set_data(

↧ Expand context

             ::std::option::Option::Some(
                 "RjCEL3kBwqPivZUXGiyA5JCujtWgJAkKRlnTEsNYfBRGOS0f7LT6R3bCSOXeJ4auSHzQ4BEZZTklUyj5\n1HEojihShQC2jkQJrNdGOZNSW49yRO0XbnGmeczUHbZqZRelLFKW4xjru9uTuB8lFCtwoGgciFsgqTF8\n5HYcoqINTRxuAwGuRUMoNO473QT0BtCQoKUkAyVaypG0hBZdGNoJhunBfW0d3HWTYlzz9pXElyZhq3C1\n2PDB17GEoOYXmTxDecysmPOdo5z6T0HFhujfeJFIQQ8dirmXcG4F3v0bZdf6AZ3jsiVh6RnEXIPxPbOi\ngIXDWTMUr4Pg3f2LdYCM01eAb2qTdgsEN0MUDhEIfn68I2tnWvcozyUFpg1ez6pyWP8ssWVfFrckREIM\nMb0cTUVqSVSM8bnFiF9SoXM6ZoGMKfX1mT708OYk7SqZ1JlCTkecDJDoR5ED2q2MWKUGR6jjnEV0GtD8\nWJO6AcF0DptY9Hk16Bav3z6c5FeBvrGDrxTFVgRUk8SychzjrcqJ4qskwN8rL3zslC0oqobQRnLFOvwJ\nprSzBIwdH2yAuxokXAdVRa1u9NGNRvfWJfKkwbbVz8yV76RUF9KNhAUmwyYDrLnxNj8ROl8B7dv8Gans\n7Bit52wcdiJyjBW1pAodB7zqqVwtBx5RaSpF7kEMXexYXp9N0J1jlXzdeg5Wgg4pO7TJNr2joiPVAiFf\nefwMMCNBkYx2z7cRxVxCJZMXXzxSKMGgdTN24bJ5UgE0TxyV52RC0wGWG49S1x5jGrvmxKCIgYPs0w3Z\n0I3XcdB0WEj4x4xRztB9Cx2Mc4qFYQdzS9kOioAgNBti1rBySZ8lFZM2zqxvBsJTTJsmcKPr1crqiXjM\noVWdM4ObOO6QA7Pu4c1hT68CrTmbcecjFcxHkgsqdixnFtN6keMGL9Z2YMjZOjYYzbUEwLJqUVWalkIB\nBkgBRqZpzxx5nB5t0qDH35KjsfKM5cinQaFoRq9y9Z82xdCoKZOsUbxZkk1kVmy1jPDCBhkhixkc5PKS\nFoSKTbeK7kuCEZCtR9OfF2k2MqbygGFsFu2sgb1Zn2YdDbaRwRGeaLhswta09UNSMUo8aTixgoYVHxwy\nvraLB6olPSPegeLOnmBeWyKmEfPdbpdGm4ev4vA2AUFuLIeFz0LkCSN0NgQMrr8ALEm1UNpJLReg1ZAX\nzZh7gtQTZUaBVdMJokaJpLk6FPxSA6zkwB5TegSqhrFIsmvpY3VNWmTUq7H0iADdh3dRQ8Is97bTsbwu\nvAEOjh4FQ9wPSFzEtcSJeYQft5GfWYPisDImjjvHVFshFFkNy2nN18pJmhVPoJc456tgbdfEIdGhIADC\n6UPcSSzE1FxlPpILqZrp3i4NvvKoiOa4a8tnALd2XRHHmsvALn2Wmfu07b86gZlu4yOyuUFNoWI6tFvd\nbHnqSJYNQlFESv13gJw609DBzNnrIgBGYBAcDRrIGAnflRKwVDUnDFrUQmE8xNG6jRlyb1p2Y2RrfBtG\ncKqhuGNiT2DfxpY89ektZ98waPhJrFEPJToNH8EADzBorh3T0h4YP1IeLmaI7SOxeuVrk1kjRqMK0rUB\nlUJgJNtCE35jCyoHMwPQlyi78ZaVv8COVQ24zcGpw0MTy6JUsDzAC3jLNY6xCb40SZV9XzG7nWvXA5Ej\nYC1gTXxF4AtFexIdDZ4RJbtYMyXt8LsEJerwwpkfqvDwsiFuqYC6vIn9RoZO5kI0F35XtUITDQYKZ4eq\nWBV0itxTyyR5Rp6g30pZEmEqOusDaIh96CEmHpOBYAQZ7u1QTfzRdysIGMpzbx5gj9Dxm2PO1glWzY7P\nlVqQiBlXSGDOkBkrB6SkiAxknt9zsPdTTsf3r3nid4hdiPrZmGWNgjOO1khSxZSzBdltrCESNnQmlnP5\nZOHA0eSYXwy8j4od5ZmjA3IpFOEPW2MutMbxIbJpg5dIx2x7WxespftenRLgl3CxcpPDcnb9w8LCHBg7\nSEjrEer6Y8wVLFWsQiv6nTdCPZz9cGqwgtCaiHRy8lTWFgdfWd397vw9rduGld3uUFeFRGjYrphqEmHi\nhiG0GhE6wRFVUsGJtvOCYkVREvbEdxPFeJvlAvOcs9HKbtptlTusvYB86vR2bNcIY4f5JZu2X6sGa354\n7LRk0ps2zqYjat3hMR7XDC8KiKceBteFsXoDjfVxTYKelpedTxqWAafrKhaoAVuNM98PSnkuIWGzjSUC\nNsDJTt6vt1D1afBVPWVmnQ7ZQdtEtLIEwAWYjemAztreELIr1E9fPEILm1Ke4KctP9I0I72Dh4eylNZD\n0DEr2Hg7cWFckuZ0Av5d0IPRARXikEGDHl8uh12TXL9v2Uh0ZVSJMEYvxGSbZvkWz8TjWSk3hKA2a7GL\nJm3Ho7e1C34gE1XRGcEthxvURxt4OKBqN3ZNaMIuDTWinoQAutMcUqtm4MoL7RGPiCHUrvTwQPSirsmA\nQmOEu8nOpnP77Fivh9jLGx5ta7nL6jrsWUsBqiN1lzpdPYLRR4mUIAj6sNWiDEk4pkbHSMEcqbWw6Zl7\npsEyPDHalCNhWMA3RSK3skURzQDZ0oBV5W7vjVIZ4d3uCKsk6zrzEI9u5mx7p9RdNKodXfzqYt0ULdtc\n3RW0hIfw2KvrO3BD2QrtgAkfrFBGVvlJSUoh0MvLz8DeXxfuiuq9Ttu7wvsqVI4Piah6WNEXtHHGPJO3\nGhc75Bnv2To4VS2v8rmyKAPIIVTuYBHZN6sZ4FhFzbrslCIdk0eadaU60naqiNWU3CsxplIYGyeThmJ7\n9u4h6Y2OmiPZjFPS2bAzwgAozYTVefII9aEaWZ0hxHZeu1FW7r79dkdO73ZqRfas9u8Z7LLBPCw5pV0F\n5I0pHDgNb6MogoxF4NZJfVtIX1vCHhhVLrXjrYNJU2fD9Fw8kT8Ie2HDBJnqAvYKmryQ1r9ulo3Me3rH\nq9s2Y5uCDxu9iQNhnpwIm57WYGFeqd2fnQeY2IziD3Jgx0KSrmOH0jgi0RwJyfGXaORPq3bQQqljuACo\nkO6io9t5VI8PbNxSHTRbtYiPciUslbT0g7SpCLrRPOBRJ4DDk56pjghpeoUagJ5xJ4wjBzBuXnAGkNnP\nTfpiuz2r3oSBAi8sB9wiYK2z9sp4gZyQsqdVNzAEgKatOxBRBmJCBYpjO98ZQrF83XApPpfFg0ujB2PW\n1iYF9NkgwIKB5oB6KVTOmSKJk11mVermPgeugHbzdd2zUP6fP8fWbhseqk2t8ahGvqjs2CDHFIWXl5jc\nfCknbykE3ANt7lnAfJQ2ddduLGiqrX4HWx6jcWw08Es6BkleO0IDbaWrb95d5isvFlzJsf0TyDIXF4uq\nbBDCi0XPWqtRJ2iqmnJa2GbBe9GmAOWMkBFSilMyC4sR395WSDpD56fx0NGoU6cHrRu9xF2Bgh7RGSfl\nch2GXEeE02fDpSHFNvJBlOEqqfkIX6oCa6KY9NThqeIjYsT184XR2ZI7akXRaw1gMOGpk4FmUxk6WIuX\n4ei1SLQgSdl7OEdRtJklZ76eFrMbkJQ2TDhu8f7mVuiy53GUMIvCrP9xYGZGmCIDm2e4U2BDi3F7C5xK\n3bDZXwlQp6z4BSqTy2OVEWxXUJfjPMOL5Mc7AvDeKtxAS73pVIv0HgHIa4NBAdC7uLG0zXuu1FF6z2XY\nyUhk03fMZhYe7vVxsul3WE7U01fuN8z2y0eKwBW1RFBE1eKIaR9Y01sIWQWbSrfHfDrdZiElhmhHehfs\n0EfrR4sLYdQshJuvhTeKGJDaEhtPQwwJ9mUYGtuCL9RozWx1XI4bHNlzBTW0BVokYiJGlPe7wdxNzJD7\nJgS7Lwv6jGKngVf86imGZyzqwiteWFPdNUoWdTvUPSMO5xIUK9mo5QpwbBOAmyYzVq42o3Qs90N9khEV\nU36LB99fw8PtGHH5wsCHshfauwnNPj0blGXzke0kQ4JNCVH7Jtn0Y0aeejkSxFtwtxoYs6zHl1Lxxpsd\nsw5vBy49CEtoltDW367lVAwDjWdx20msGB7qJCkEDrzu7EXSO22782QX9NBRcN9ppX0C25I0FMA4Wnhz\n9zIpiXRrsTH35jzM8Cjt4EVLGNU3O0HuEvAer3cENnMJtngdrT86ox3fihMQbiuy4Bh4DEcP5in2VjbT\n3qbnoCNvOi8Fmmf7KlGlWAOceL5OHVE5lljjQEMzEQOCEgrk5mDKgwSBJQBNauIDSC1a5iEQjB8Xxp4C\nqeKyyWY9IOntNrtU5ny4lNprHJd36dKFeBLKcGCOvgHBXdOZloMF0YTRExw7hreEO9IoTGVHJ4teWsNr\nHdtagUHjkeZkdMMfnUGNv5aBNtFMqhcZH6EitEa9lGPkKBbJpoom3u8D8EHSIF1H5EZqqx9TLY5hWAIG\nPwJ4qwkpCGw5rCLVrjw7ARKukIFzNULANqjHUMcJ002TlUosJM4xJ4aAgckpLVGOGuPDhGAAexEcQmbg\nUsZdmqQrtuVUyyLteLbLbqtR6CTlcAIwY3xyMCmPgyefE0FEUODBoxQtRUuYTL9RC5o1sYb2PvcxUQfb\niJFi2CAl99pAzcckU2qVCxniARslIxM5pmMRGsQX9ZzYAfZrbg6ce6S74I8UMlgRQ2QVyvUjKKOE6IrJ\nLng370emHfe5m6LZULD5YiZutkD5ipjL2Bz77DvTE5kNPUhuoKBcTJcUgytfXAKUTWOcRKNlq0GImrxM\nJfr7AWbLFFNKGLeTrVDBwpcokJCv0zcOKWe8fd2xkeXkZTdmM66IgM27cyYmtQ6YF26Kd0qrWJeVZJV9\n3fyLYYvKN5csbRY2BHoYE5ERARRW65IrpkXMf48OrCXMtDIP0Z7wxI9DiTeKKeH4uuguhCJnwzR3WxLA\nVU6eBJEd7ZjS6JA83w7decq8uDI7LGKjcz1FySp3B7fE9DkHRGXxbsL7Fjar6vW2mAv8CuvI20B6jctp\n2yLDs24sPfB3sSxrrlhbuT1m6DZqiN0dl6umKx7NGZhmOTVGr20jfcxhqPQwTJfd7kel4rvxip4BqkvT\n7STy8knJ2BXGyJeNgwo1PXUZRDVy0LCTsSF1RFuRZe8cktHl9lgw8ntdPn1pVFL0MwJkJfdXBNUp5gNv\n50FTkrpo1t6wq4CVbcfj2XOrOzvBUzNH26sXGABI1gGxCdp2jEZrHgqQaWIaTJVTuguZhxqDvdYsrwFW\nYN58uuNcKHIrGdRSigyZInwQDYk0pjcqdSeU0WVU3Y9htzZBR7XRaCJr5YTZvq7fwermb5tuwb37lPLq\nB2IGg0iftkVbXaSyfCwVaRbfLBb88so0QqpmJGirFu8FcDiXOV1zTr8yW9XLdYQuUjh43xrXLdgsuYff\nCagInUk1eU1aLjVZoJRsNmStmOEpAqlYMwTvx7w6j2f421Cxr5cNZBIVlAxlXN2QiDqJ9v3sHhHkTanc\nlQuH8ptUyX8qncpBuXXBn7cSez9N0EoxCBl1GHUagbjstgJo4gzLvTmVIY6MiWYOBitzNUHfyqKwtKUr\nVoSCdZcGeA9lHUPA7PUprRRaT3m1hGKPyshtVS2ikG48w3oVerln1N1qGdtz46gZCrndw3LZ1B362RfW\nzDPuXbpsyLsRMTt1Rz1oKHRXp3iE41hkhQH6pxlvyCW2INnHt5XU8zRamOB3oW0udOhMpQFDjRkOcy06\nb4t0QTHvoRqmBna3WXzIMZyeK3GChF5eF8oDXRbjhk7BB6YKCgqwWUzEJ5K47HMSlhFkBUjaPRjdGM0z\nzOMwhW6b1NvSwP7XM1P5yi1oPvOspts1vr29SXqrMMrBhVogeodWyd69NqrO4jkyBxKmlXifoTowpfiY\n2cUCE0XMZqxUN39LCP09JqZifaEcBEo3mgtm1tWu5QR2GNq7UyQf4RIPSDOpDCAtwoPhRgdT1lJdcj4U\nlnH0wrJ8Uwu7c08L7ErnIrDATqCrOjpSbzGP1xHENABYONC4TknFPrJ8pe40A8fzGT0qBw9mAM1SKcHO\nfoiLcMC9AjHTqJzDG3xplSLPG9or2rMeq7Fzp9r0y7uJRMxgg51EbjfvYlH466A3ggvL2WQlDXjJqPW3\nBJGWAWDNN9LK8f46bADKPxakpkx23S9O47rGSXfDhVSIZsDympxWX1UOzWwMZRHkofVeKqizgbKkGgUT\nWykE9gRoRAOd9wfHZDYKa9i0LaPDiaUMvnU1gdBIqIoiVsdJ9swX47oxvMtOxtcS0zlD6llDkBuIiU5g\nPwRCYmtkkb25c8iRJXwGFPjI1wJ34I1z1ENicPdosPiUe9ZC2jnXIKzEdv01x2ER7DNDF3yxOwOhxNxI\nGqsmC92j25UQQFu9ZstOZ28AoCkuOYs0Uycm5u8jR1T39dMBwrko09rC65ENLnsxM8oebmyFCPiGJ1ED\n5Xqc9qZ237f1OnETAoEOwqUSvrdPTv56U7hV91EMTyC812MLQpr2710E3VVpsUCUMNhIxdt7UXZ1UNFb\njgzpZLXnf4DHrv6B7kq6UI50KMxcw1HZE2GpODfUTzNFLaqdrvzxKe5eUWdcojBaRbD4fFdVYJTElYDH\nNNVh6ofkoeWcs9CWGFmSBe0T4K8phFeygQg0prKMELNEy6qENzVtG9ZDcqj3a7L6ZLtvq50anWp7fAVu\nfwz55g4iM2Z2fA0pnwHDL7tt67zTxGITvsnJsZSpeq1EQsZcwtkBV9liu7Rl7jiVT1IIRtchB8TsTiaA\nwVHIQQ9RIOTiPQdKNqi1kC9iGlUqWK93gblNWlBw1eYB9Wk8FQogutwTf0caNMx8D4nPbANcmOOlskIy\nzALh15OlTrWnhP95rf08AN2J026zDE2DUF9k0eCevYBQIDjqKNW4XCZnjbHoIcKzbY5VzPbMs3ZyMz8K\nSucBmgPg6wrSK5ykbkapS5vuqvXc9GbjQJ8bPNzoxoWGyjbZvDs2OBrIqBmcQb2DLJ8v38McQ4mC4UsS\njf4PyfSCtpk274QZjvLCZbLiCBxQegk7jUU0NmTFJAcYCxd9xMWdlFkiszcltT2YzwuFFz7iA6aa4n5L\nHpBNfUA01GcAi1aCMYhmooS4zSlYcSOZkovMz36U3Fd9WtqIEOJLi7HMgHQDgNMdK6DTzAdHQtxerxVF\nHJnPrfNVG7270r3bp0bPnLNYLhObbAn6zqSAUeLtI2Y4KJDjBKCAh2vvYGbu0e2REYJWRj7MkGevsSSy\nb1kCXLt6tKGWAb7lt5c0xyJgUIJW7pdtnwgT0ZCa24BecCAwNnG5U2EwQbcjZGsFxqNGfaemd3oFEhES\nBaE0Fxms9UKTnMafu8wvZ2xymMrUduuRzOjDeX7oD5YsLC88V8CGMLxbbxIpt94KGykbr6e7L0R4oZl1\ntKMgFwQ2p9Txdbp0Y293LcsJymKizqI0F2xEp7y4SmWOJqHZtsbz80wVV9nv41CvtfxuSoGZJ5cNB7pI\nBgzNcQCeH3Jt0RaGGwboxxpuFbzilmkMFXxJm87tD4WNgu01nHfGCKeQcySEBZpVfJgi6sDFJ8uWnvKm\n9mPLHurtWzEfKqUEa1iC71bXjw5wrvhv9BYW8JSUELHmDquftQyKdq0DZXhULMHGQLf4e95WIaoA14LL\nbThz77kuhKULPTu2MNrBUKGorurhGugo5gs4ZUezSsUOe3KxYdrFMdGgny1GgTxMSMTp2RAZytKjv4kQ\nVx7XgzvpQLIbDjUPAkJv6lScwIRq1W3Ne0Rh0V6Bmn6U5uIuWnJjULmbaQiSODj3z0mAZvak0mSWIGwT\nTX83HztcC4W7e1f6a1thmcc5K61Icehla2hBELWPpixTkyC4eEVmk9Rq0m0ZXtx0JX2ZQXqXDEyePyMe\nJ70sdSzXk72zusqhY4yuOMGgbYNHqxOToK6NxujR7e4dV3Wk5JnSUthym8scjcPeCiKDNY4cHfTMnDXJ\n9zLVy01LtNKYpJ1s8FxVxigmxQNKEbIamxhx6yqwGC4aiISVOOUEjvNOdaUfXfUsE6jEwtwxyGxjlRK1\ncLyxXttq4QWN6PehgHv7jXykzPjInbEysebFvvPOOMdunmJvcCNMSvjUda8fL6xfGo0FDrLg8XZipd6S\noPVdYtyIM1Dg40KbBA3JuumPYtXuJaHrZnjZmdnM5OVo4ZNxktfCVT0c6bnD4bAeyn4bYt1ZPaX6hQHh\nJtvNYfpD0ONYlmqKuToQAMlz52Fh6bj45EbX89L5eLlSpWeyBlGotzriB0EPlclrGi5l2B5oPb1aB1ag\nyyYuu44l0F1oOVYnBIZsxIsHVITxi9lEuVPFkWASOUNuVQXfM4n5hxWR9qtuKnIcPsvbJsv1U10XlKh3\nKisqPhHU15xrCLr5gwFxPUKiNTLUBrkzgBOHXPVsHcLCiSD0YU56TRGfvEom43TWUKPPfl9Z54tgVQuT\njCRlaljAzeniQIcbbHZnn3f0HxbDG3DFYqWSxNrXabHhRsIOhhUHSPENyhGSTVO5t0XX5CdMspJPCd02\n3Oqv32ccbUK4O3YH6LEvp0WO3kSl5n50odVkI9B0i0iq4UPFGMkM8bEQJbgJoOH71P10vtdevJFQE4g2\nyhimiM53ZJRWgSZveHtENZc0Gjo0F9eioak9BnPpY1QxAFPC817svuhEstcU69bLCA4D1rO5R8AuIIBq\nyQJcifFLvbpAEYTLKJqysZrU8EEl3TSdC13A9hZvk4NC8VGEDAxcNrKw313dZp17kZPO5HSd1y6sljAW\nA9M1d6FMYV5SlBWf3WZNCUPS7qKNlda2YBsC6IUVB363f5RLGQOQHwbaijBSRCkrVoRxBHtc0Bd5J9V9\nP5uMTXkpZOxRcCQvImGgcmGuxxLb5zTqfS2xu7v3Sf3IIesSt9tVzcEcdbEvLGVJkLk4mb3G30DbIbri\nPZ09JkweDvMaQ3bxT2nfkz3Ilihkw9jqikkCCCz7E8h6z6KbhQErEW9VzJZzMCgJsyPjFam6iNwpe07S\nhyOvNVw2t9wpzL5xM11DvVzQwDaWEytNRHzDBs4KwEtpI2IpjUyVZHSwA0UGqqkzoCgrJFlNOvPlXqcS\nIcREouUIBmuttkrhPWJtSxOOgpsdvBR3kTOzAXNzSKxoaBAb0c5SDMUc6FIyGA8x5wg5DkUgjFUUodEt\nOYaB2VHVePW9mxHeBTdKWLzJow4ZZvjnoBuVigXljKCNh137ckV2y3Yg3Xi4UzJEI2V5Rw9AfnMs7xUw\nVHOFCg189maD3bmZAe7b4eaGZhyy4HVKjqCXmIH7vsEjRvbnfB0SQxxpuqBDJbHNCtW4vM643ZQQBVPP\na7oXSQIq9w2dHp0A7dtkocCZdQp9FKR9XdJAFIbVSHzIF1ZogeZlc0pXuNE0tagvD57xwDRFkAuoQyMu\nYDdZasXrpSmEE5UjHVkyYsISn8QsfXurzDybX468aoRoks654jjmRY5zi1oB8TcMdC2c3sicNaqfeuhd\nH1nPX7l4RpdqWMR7gGx9slXtG8S3KxpOi4qCD7yg3saD66nun4dzksQURoTUdXyrJR5UpHsfIlTF1aJa\nMdXyQtQnrkl00TeghQd00rRFZsCnhi0qrCSKiBfB2EVrd9RPpbgwJGZHuIQecdBmNetc2ylSEClqVBPR\nGOPPIxrnswEZjmnS0jxKW9VSM1QVxSPJnPFswCqT95SoKD6CP4xdX28WIUGiNaIKodXXJHEIsXBCxLsr\nPwWPCtoplC6hhpKmW5dQo92iCTyY2KioKzO8XR6FKm6qonMKVEwQNtlYE9c97KMtEnp25VOdMP46SQXS\nYsSVp7vm8LP87VYI8SOKcW3s2oedYFtt45rvDzoTF0GmS6wELQ9uo98HhjQAI1Dt91cgjJOwygNmLoZE\nX5K2zQiNA163uMCl5xzaBqY4YTL0wgALg3IFdYSp0RFYLWdt6IxoGI1tnoxcjlUEPo5eGIc3mS3SmaLn\nOdumfUQQ4Jgmgaa5anUVQsfBDrlAN5oaX7O0JO71SSPSWiHBsT9WIPy2J1Cace9ZZLRxblFPSXcvsuHh\nhvnhWQltEDAe7MgvkFQ8lGVFa8jhzijoF9kLmMhMILSzYnfXnZPNP7TlAAwlLHK1RqlpHskJqb6CPpGP\nQvOAhEMsM3zJ2KejZx0esxkjxA0ZufVvGAMN3vTUMplQaF4RiQkp9fzBXf3CMk01dWjOMMIEXTeKzIQe\nEcffzjixWU9FpAyGp2rVl4ETRgqljOGw4UgK31r0ZIEGnH0xGz1FtbW1OcQM008JVujRqulCucEMmntr\n".to_owned()
-288
+            )
-289
+        )
         .send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Encoding", "gzip")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         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");
-298
+    }
-299
+}
-300
 /// Error type for the `PutWithContentEncodingError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum PutWithContentEncodingError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/simple_scalar_properties.rs

@@ -216,216 +350,350 @@

↥ Expand context

         >,
         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")?;
-223
         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(())
-230
+    }
-231
+}
-232
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-235

 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod simple_scalar_properties_test {
     use ::aws_smithy_protocol_test::FloatEquals;
-240
     /// Supports handling NaN float values.
     /// Test ID: AwsJson11SupportsNaNFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_supports_na_n_float_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-248
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.SimpleScalarProperties"),
         ];
         ::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    \"floatValue\": \"NaN\",\n    \"doubleValue\": \"NaN\"\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");
-276
+    }
-277
     /// Supports handling Infinity float values.
     /// Test ID: AwsJson11SupportsInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_supports_infinity_float_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-285
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.SimpleScalarProperties"),
         ];
         ::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    \"floatValue\": \"Infinity\",\n    \"doubleValue\": \"Infinity\"\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");
-313
+    }
-314
     /// Supports handling -Infinity float values.
     /// Test ID: AwsJson11SupportsNegativeInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_supports_negative_infinity_float_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-322
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .simple_scalar_properties()
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),

↧ Expand context

             ))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.SimpleScalarProperties"),
         ];
         ::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    \"floatValue\": \"-Infinity\",\n    \"doubleValue\": \"-Infinity\"\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");
-350
+    }

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/sparse_nulls_operation.rs

@@ -209,209 +305,305 @@

↥ Expand context

             ::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::<SparseNullsOperationInput>()
             .ok_or("failed to downcast to SparseNullsOperationInput")?;
-217
         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(())
-224
+    }
-225
+}
-226
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.

-229
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod sparse_nulls_operation_test {
-233
     /// Serializes null values in maps
     /// Test ID: AwsJson11SparseMapsSerializeNullValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_sparse_maps_serialize_null_values_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-241
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .sparse_nulls_operation()
             .set_sparse_string_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("foo".to_owned(), ::std::option::Option::None);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.SparseNullsOperation"),
         ];
         ::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    \"sparseStringMap\": {\n        \"foo\": null\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");
-268
+    }
-269
     /// Serializes null values in lists
     /// Test ID: AwsJson11SparseListsSerializeNull
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_sparse_lists_serialize_null_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-277
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .sparse_nulls_operation()
             .set_sparse_string_list(::std::option::Option::Some(vec![::std::option::Option::None]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "JsonProtocol.SparseNullsOperation"),
         ];
         ::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    \"sparseStringList\": [\n        null\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");
-300
+    }
-301
     /// Deserializes null values in maps
     /// Test ID: AwsJson11SparseMapsDeserializeNullValues
     #[::tokio::test]
     #[::tracing_test::traced_test]

tmp-codegen-diff/codegen-client-test/misc/rust-client-codegen/Cargo.toml

@@ -16,16 +49,50 @@

↥ Expand context

 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime]
 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.bytes]
 version = "1.4.0"
 [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.pretty_assertions]
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]

 [dev-dependencies.tracing]
 version = "0.1"
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 test-util = ["aws-smithy-runtime/test-util"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default-https-client = ["aws-smithy-runtime/default-https-client"]
 gated-tests = []
 default = ["rt-tokio", "rustls"]
 default = ["rt-tokio", "rustls", "default-https-client"]
-49
-50

tmp-codegen-diff/codegen-client-test/naming_test_casing/rust-client-codegen/Cargo.toml

@@ -4,4 +37,38 @@

↥ Expand context

 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [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-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime]
 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.bytes]
 version = "1.4.0"
 [dependencies.http]
 version = "0.2.9"
 [features]
 test-util = ["aws-smithy-runtime/test-util"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default-https-client = ["aws-smithy-runtime/default-https-client"]
 gated-tests = []
 default = ["rt-tokio", "rustls"]
 default = ["rt-tokio", "rustls", "default-https-client"]
-37
-38

tmp-codegen-diff/codegen-client-test/naming_test_ops/rust-client-codegen/Cargo.toml

@@ -1,1 +52,53 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "naming_test_ops"
 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [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-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime]
 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.bytes]
 version = "1.4.0"
 [dependencies.http]
 version = "0.2.9"
 [dev-dependencies.aws-smithy-http-client]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-client"
 features = ["test-util"]
 [dev-dependencies.aws-smithy-protocol-test]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"
 [dev-dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client", "test-util"]
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing]
 version = "0.1"
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 test-util = ["aws-smithy-runtime/test-util"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default-https-client = ["aws-smithy-runtime/default-https-client"]
 gated-tests = []
 default = ["rt-tokio", "rustls"]
 default = ["rt-tokio", "rustls", "default-https-client"]
-52
-53

tmp-codegen-diff/codegen-client-test/naming_test_ops/rust-client-codegen/src/operation/reserved_words_as_members.rs

@@ -208,208 +268,268 @@

↥ Expand context

             ::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::<ReservedWordsAsMembersInput>()
             .ok_or("failed to downcast to ReservedWordsAsMembersInput")?;
-217
         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(())
-224
+    }
-225
+}
-226
 // The get_* functions below are generated from JMESPath expressions in the

 // operationContextParams trait. They target the operation's input shape.
-229
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod reserved_words_as_members_test {
-233
     /// Test ID: reserved_words
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn reserved_words_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-240
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .reserved_words_as_members()
             .set_as(::std::option::Option::Some(5))
             .set_async(::std::option::Option::Some(true))
             .send()
             .await;
         let _ = dbg!(result);

↧ Expand context

         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "Config.ReservedWordsAsMembers"),
         ];
         ::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,
             "{\"as\": 5, \"async\": true}",
             ::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");
-264
+    }
-265
+}
-266
 /// Error type for the `ReservedWordsAsMembersError` operation.
 #[non_exhaustive]

tmp-codegen-diff/codegen-client-test/naming_test_ops/rust-client-codegen/src/operation/structure_name_punning.rs

@@ -207,207 +267,267 @@

↥ Expand context

             ::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::<StructureNamePunningInput>()
             .ok_or("failed to downcast to StructureNamePunningInput")?;
-216
         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(())
-223
+    }
-224
+}
-225
 // The get_* functions below are generated from JMESPath expressions in the

 // operationContextParams trait. They target the operation's input shape.
-228
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod structure_name_punning_test {
-232
     /// Test ID: structure_punning
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn structure_punning_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-239
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .structure_name_punning()
             .set_regular_string(::std::option::Option::Some("hello!".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

↧ Expand context

         let expected_headers = [
             ("Content-Type", "application/x-amz-json-1.1"),
             ("X-Amz-Target", "Config.StructureNamePunning"),
         ];
         ::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,
             "{\"regular_string\": \"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(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
-262
+    }
-263
+}
-264
 /// Error type for the `StructureNamePunningError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]

tmp-codegen-diff/codegen-client-test/naming_test_structs/rust-client-codegen/Cargo.toml

@@ -4,4 +37,38 @@

↥ Expand context

 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [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-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime]
 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.bytes]
 version = "1.4.0"
 [dependencies.http]
 version = "0.2.9"
 [features]
 test-util = ["aws-smithy-runtime/test-util"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default-https-client = ["aws-smithy-runtime/default-https-client"]
 gated-tests = []
 default = ["rt-tokio", "rustls"]
 default = ["rt-tokio", "rustls", "default-https-client"]
-37
-38

tmp-codegen-diff/codegen-client-test/pokemon-service-awsjson-client/rust-client-codegen/Cargo.toml

@@ -13,13 +46,47 @@

↥ Expand context

 [dependencies.aws-smithy-eventstream]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-eventstream"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 features = ["event-stream"]
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime]
 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"
 features = ["http-body-0-4-x"]
 [dependencies.bytes]
 version = "1.4.0"
 [dependencies.http]
 version = "0.2.9"

 [dependencies.hyper]
 version = "0.14.26"
 features = ["stream"]
 [dependencies.tracing]
 version = "0.1"
 [features]
 test-util = ["aws-smithy-runtime/test-util"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default-https-client = ["aws-smithy-runtime/default-https-client"]
 gated-tests = []
 default = ["rt-tokio", "rustls"]
 default = ["rt-tokio", "rustls", "default-https-client"]
-46
-47

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14