Client Test

rev. 9f5fb9826a6af51ebfb3736d0a778b00ec7b08b3 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/http_response_code.rs

@@ -187,187 +294,295 @@

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpResponseCodeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpResponseCodeEndpointParamsInterceptor"
-190
+    }
-191
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<HttpResponseCodeInput>()
             .ok_or("failed to downcast to HttpResponseCodeInput")?;
-206

         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(())
-213
+    }
-214
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_response_code_request_test {
 mod http_response_code_test {
-+
     /// Binds the http response code to an output structure. Note that
     /// even though all members are bound outside of the payload, an
     /// empty JSON object is serialized in the response. However,
     /// clients should be able to handle an empty JSON object or an
     /// empty payload without failing to deserialize a response.
     /// Test ID: RestJsonHttpResponseCode
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_http_response_code_response() {
         let expected_output = crate::operation::http_response_code::HttpResponseCodeOutput::builder()
             .set_status(::std::option::Option::Some(201))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(201)
                 .body(::aws_smithy_types::body::SdkBody::from("{}"))
                 .unwrap(),
-237
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-241
         let op = crate::operation::http_response_code::HttpResponseCode::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-247
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_response_code::HttpResponseCodeOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.status, expected_output.status, "Unexpected value for `status`");
-259
+    }
     /// This test ensures that clients gracefully handle cases where
     /// the service responds with no payload rather than an empty JSON
     /// object.
     /// Test ID: RestJsonHttpResponseCodeWithNoPayload
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_http_response_code_with_no_payload_response() {
         let expected_output = crate::operation::http_response_code::HttpResponseCodeOutput::builder()
             .set_status(::std::option::Option::Some(201))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .status(201)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-275
+        )

↧ Expand context

         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-279
         let op = crate::operation::http_response_code::HttpResponseCode::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-285
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_response_code::HttpResponseCodeOutput>()
             .unwrap();

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/http_string_payload.rs

@@ -199,199 +287,288 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpStringPayloadEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpStringPayloadEndpointParamsInterceptor"
-202
+    }
-203
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<HttpStringPayloadInput>()
             .ok_or("failed to downcast to HttpStringPayloadInput")?;
-218

         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(())
-225
+    }
-226
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_string_payload_request_test {
 mod http_string_payload_test {
-+
     /// Test ID: RestJsonStringPayloadRequest
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_string_payload_request_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-237
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_string_payload()
             .set_payload(::std::option::Option::Some("rawstring".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "rawstring",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/StringPayload", "path was incorrect");
-255
+    }
     /// Test ID: RestJsonStringPayloadResponse
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_string_payload_response_response() {
         let expected_output = crate::operation::http_string_payload::HttpStringPayloadOutput::builder()
             .set_payload(::std::option::Option::Some("rawstring".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("rawstring"))
                 .unwrap(),
-268
+        )

↧ Expand context

         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-272
         let op = crate::operation::http_string_payload::HttpStringPayload::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-278
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_string_payload::HttpStringPayloadOutput>()
             .unwrap();

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/ignore_query_params_in_response.rs

@@ -193,193 +297,298 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for IgnoreQueryParamsInResponseEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "IgnoreQueryParamsInResponseEndpointParamsInterceptor"
-196
+    }
-197
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<IgnoreQueryParamsInResponseInput>()
             .ok_or("failed to downcast to IgnoreQueryParamsInResponseInput")?;
-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
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod ignore_query_params_in_response_request_test {
 mod ignore_query_params_in_response_test {
-+
     /// Query parameters must be ignored when serializing the output
     /// of an operation. As of January 2021, server implementations
     /// are expected to respond with a JSON object regardless of
     /// if the output parameters are empty.
     /// Test ID: RestJsonIgnoreQueryParamsInResponse
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_ignore_query_params_in_response_response() {
         let expected_output = crate::operation::ignore_query_params_in_response::IgnoreQueryParamsInResponseOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{}"))
                 .unwrap(),
-240
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-244
         let op = crate::operation::ignore_query_params_in_response::IgnoreQueryParamsInResponse::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-250
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::ignore_query_params_in_response::IgnoreQueryParamsInResponseOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.baz, expected_output.baz, "Unexpected value for `baz`");
-262
+    }
     /// This test is similar to RestJsonIgnoreQueryParamsInResponse,
     /// but it ensures that clients gracefully handle responses from
     /// the server that do not serialize an empty JSON object.
     /// Test ID: RestJsonIgnoreQueryParamsInResponseNoPayload
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_ignore_query_params_in_response_no_payload_response() {
         let expected_output = crate::operation::ignore_query_params_in_response::IgnoreQueryParamsInResponseOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-276
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

↧ Expand context

         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-280
         let op = crate::operation::ignore_query_params_in_response::IgnoreQueryParamsInResponse::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-286
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::ignore_query_params_in_response::IgnoreQueryParamsInResponseOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.baz, expected_output.baz, "Unexpected value for `baz`");
-298
+    }

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/input_and_output_with_headers.rs

@@ -194,194 +553,554 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InputAndOutputWithHeadersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "InputAndOutputWithHeadersEndpointParamsInterceptor"
-197
+    }
-198
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<InputAndOutputWithHeadersInput>()
             .ok_or("failed to downcast to InputAndOutputWithHeadersInput")?;
-213

         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(())
-220
+    }
-221
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod input_and_output_with_headers_request_test {
 mod input_and_output_with_headers_test {
     use ::aws_smithy_protocol_test::FloatEquals;
-+
     /// Tests requests with string header bindings
     /// Test ID: RestJsonInputAndOutputWithStringHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_string_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-234
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_string(::std::option::Option::Some("Hello".to_owned()))
             .set_header_string_list(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
             .set_header_string_set(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-String", "Hello"), ("X-StringList", "a, b, c"), ("X-StringSet", "a, b, c")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         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(), "/InputAndOutputWithHeaders", "path was incorrect");
-253
+    }
     /// Tests requests with string list header bindings that require quoting
     /// Test ID: RestJsonInputAndOutputWithQuotedStringHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_quoted_string_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-261
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_string_list(::std::option::Option::Some(vec!["b,c".to_owned(), "\"def\"".to_owned(), "a".to_owned()]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-StringList", "\"b,c\", \"\\\"def\\\"\", a")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         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(), "/InputAndOutputWithHeaders", "path was incorrect");
-278
+    }
     /// Tests requests with numeric header bindings
     /// Test ID: RestJsonInputAndOutputWithNumericHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_numeric_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-286
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_byte(::std::option::Option::Some(1))
             .set_header_short(::std::option::Option::Some(123))
             .set_header_integer(::std::option::Option::Some(123))
             .set_header_long(::std::option::Option::Some(123))
             .set_header_float(::std::option::Option::Some(1.1_f32))
             .set_header_double(::std::option::Option::Some(1.1_f64))
             .set_header_integer_list(::std::option::Option::Some(vec![1, 2, 3]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("X-Byte", "1"),
             ("X-Double", "1.1"),
             ("X-Float", "1.1"),
             ("X-Integer", "123"),
             ("X-IntegerList", "1, 2, 3"),
             ("X-Long", "123"),
             ("X-Short", "123"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         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(), "/InputAndOutputWithHeaders", "path was incorrect");
-317
+    }
     /// Tests requests with boolean header bindings
     /// Test ID: RestJsonInputAndOutputWithBooleanHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_boolean_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-325
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_true_bool(::std::option::Option::Some(true))
             .set_header_false_bool(::std::option::Option::Some(false))
             .set_header_boolean_list(::std::option::Option::Some(vec![true, false, true]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Boolean1", "true"), ("X-Boolean2", "false"), ("X-BooleanList", "true, false, true")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         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(), "/InputAndOutputWithHeaders", "path was incorrect");
-344
+    }
     /// Tests requests with timestamp header bindings
     /// Test ID: RestJsonInputAndOutputWithTimestampHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_timestamp_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-352
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_timestamp_list(::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-TimestampList", "Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         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(), "/InputAndOutputWithHeaders", "path was incorrect");
-372
+    }
     /// Tests requests with enum header bindings
     /// Test ID: RestJsonInputAndOutputWithEnumHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_enum_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-380
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_enum(::std::option::Option::Some(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_header_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "Bar".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "Baz".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 = [("X-Enum", "Foo"), ("X-EnumList", "Foo, Bar, Baz")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         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(), "/InputAndOutputWithHeaders", "path was incorrect");
-404
+    }
     /// Tests requests with intEnum header bindings
     /// Test ID: RestJsonInputAndOutputWithIntEnumHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_int_enum_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-412
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_integer_enum(::std::option::Option::Some(1))
             .set_header_integer_enum_list(::std::option::Option::Some(vec![1, 2, 3]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-IntegerEnum", "1"), ("X-IntegerEnumList", "1, 2, 3")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         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(), "/InputAndOutputWithHeaders", "path was incorrect");
-430
+    }
     /// Supports handling NaN float header values.
     /// Test ID: RestJsonSupportsNaNFloatHeaderInputs
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_na_n_float_header_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-438
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .set_header_double(::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 = [("X-Double", "NaN"), ("X-Float", "NaN")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         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(), "/InputAndOutputWithHeaders", "path was incorrect");
-460
+    }
     /// Supports handling Infinity float header values.
     /// Test ID: RestJsonSupportsInfinityFloatHeaderInputs
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_infinity_float_header_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-468
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .set_header_double(::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 = [("X-Double", "Infinity"), ("X-Float", "Infinity")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         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(), "/InputAndOutputWithHeaders", "path was incorrect");
-490
+    }
     /// Supports handling -Infinity float header values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatHeaderInputs
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_negative_infinity_float_header_inputs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-498
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .input_and_output_with_headers()
             .set_header_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .set_header_double(::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 = [("X-Double", "-Infinity"), ("X-Float", "-Infinity")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         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(), "/InputAndOutputWithHeaders", "path was incorrect");
-520
+    }
     /// Tests responses with string header bindings
     /// Test ID: RestJsonInputAndOutputWithStringHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_string_headers_response() {
         let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
             .set_header_string(::std::option::Option::Some("Hello".to_owned()))
             .set_header_string_list(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
             .set_header_string_set(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-String", "Hello")
                 .header("X-StringList", "a, b, c")

↧ Expand context

                 .header("X-StringSet", "a, b, c")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-539
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-543
         let op = crate::operation::input_and_output_with_headers::InputAndOutputWithHeaders::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-549
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)

@@ -609,610 +669,670 @@

↥ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.header_boolean_list,
             expected_output.header_boolean_list,
             "Unexpected value for `header_boolean_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_timestamp_list,
             expected_output.header_timestamp_list,
             "Unexpected value for `header_timestamp_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(
             parsed.header_enum_list,
             expected_output.header_enum_list,
             "Unexpected value for `header_enum_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum,
             expected_output.header_integer_enum,
             "Unexpected value for `header_integer_enum`"

         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum_list,
             expected_output.header_integer_enum_list,
             "Unexpected value for `header_integer_enum_list`"
         );
-636
+    }
     /// Tests responses with string list header bindings that require quoting
     /// Test ID: RestJsonInputAndOutputWithQuotedStringHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_quoted_string_headers_response() {
         let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
             .set_header_string_list(::std::option::Option::Some(vec!["b,c".to_owned(), "\"def\"".to_owned(), "a".to_owned()]))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-StringList", "\"b,c\", \"\\\"def\\\"\", a")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),

↧ Expand context

-651
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-655
         let op = crate::operation::input_and_output_with_headers::InputAndOutputWithHeaders::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-661
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput>()

@@ -721,722 +781,782 @@

↥ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.header_boolean_list,
             expected_output.header_boolean_list,
             "Unexpected value for `header_boolean_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_timestamp_list,
             expected_output.header_timestamp_list,
             "Unexpected value for `header_timestamp_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(
             parsed.header_enum_list,
             expected_output.header_enum_list,
             "Unexpected value for `header_enum_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum,
             expected_output.header_integer_enum,
             "Unexpected value for `header_integer_enum`"

         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum_list,
             expected_output.header_integer_enum_list,
             "Unexpected value for `header_integer_enum_list`"
         );
-748
+    }
     /// Tests responses with numeric header bindings
     /// Test ID: RestJsonInputAndOutputWithNumericHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_numeric_headers_response() {
         let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
             .set_header_byte(::std::option::Option::Some(1))
             .set_header_short(::std::option::Option::Some(123))
             .set_header_integer(::std::option::Option::Some(123))
             .set_header_long(::std::option::Option::Some(123))
             .set_header_float(::std::option::Option::Some(1.1_f32))
             .set_header_double(::std::option::Option::Some(1.1_f64))
             .set_header_integer_list(::std::option::Option::Some(vec![1, 2, 3]))
             .build();

↧ Expand context

         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-Byte", "1")
                 .header("X-Double", "1.1")
                 .header("X-Float", "1.1")
                 .header("X-Integer", "123")
                 .header("X-IntegerList", "1, 2, 3")
                 .header("X-Long", "123")
                 .header("X-Short", "123")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-775
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-779
         let op = crate::operation::input_and_output_with_headers::InputAndOutputWithHeaders::new();
         let config = op.config().expect("the operation has config");
         let de = config

@@ -845,846 +905,906 @@

↥ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.header_boolean_list,
             expected_output.header_boolean_list,
             "Unexpected value for `header_boolean_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_timestamp_list,
             expected_output.header_timestamp_list,
             "Unexpected value for `header_timestamp_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(
             parsed.header_enum_list,
             expected_output.header_enum_list,
             "Unexpected value for `header_enum_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum,
             expected_output.header_integer_enum,
             "Unexpected value for `header_integer_enum`"

         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum_list,
             expected_output.header_integer_enum_list,
             "Unexpected value for `header_integer_enum_list`"
         );
-872
+    }
     /// Tests responses with boolean header bindings
     /// Test ID: RestJsonInputAndOutputWithBooleanHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_boolean_headers_response() {
         let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
             .set_header_true_bool(::std::option::Option::Some(true))
             .set_header_false_bool(::std::option::Option::Some(false))
             .set_header_boolean_list(::std::option::Option::Some(vec![true, false, true]))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-Boolean1", "true")
                 .header("X-Boolean2", "false")

↧ Expand context

                 .header("X-BooleanList", "true, false, true")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-891
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-895
         let op = crate::operation::input_and_output_with_headers::InputAndOutputWithHeaders::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-901
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)

@@ -961,962 +1021,1022 @@

↥ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.header_boolean_list,
             expected_output.header_boolean_list,
             "Unexpected value for `header_boolean_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_timestamp_list,
             expected_output.header_timestamp_list,
             "Unexpected value for `header_timestamp_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(
             parsed.header_enum_list,
             expected_output.header_enum_list,
             "Unexpected value for `header_enum_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum,
             expected_output.header_integer_enum,
             "Unexpected value for `header_integer_enum`"

         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum_list,
             expected_output.header_integer_enum_list,
             "Unexpected value for `header_integer_enum_list`"
         );
-988
+    }
     /// Tests responses with timestamp header bindings
     /// Test ID: RestJsonInputAndOutputWithTimestampHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_timestamp_headers_response() {
         let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
             .set_header_timestamp_list(::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ]))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-TimestampList", "Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT")

↧ Expand context

                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-1006
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1010
         let op = crate::operation::input_and_output_with_headers::InputAndOutputWithHeaders::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-1016
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });

@@ -1076,1077 +1136,1137 @@

↥ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.header_boolean_list,
             expected_output.header_boolean_list,
             "Unexpected value for `header_boolean_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_timestamp_list,
             expected_output.header_timestamp_list,
             "Unexpected value for `header_timestamp_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(
             parsed.header_enum_list,
             expected_output.header_enum_list,
             "Unexpected value for `header_enum_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum,
             expected_output.header_integer_enum,
             "Unexpected value for `header_integer_enum`"

         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum_list,
             expected_output.header_integer_enum_list,
             "Unexpected value for `header_integer_enum_list`"
         );
-1103
+    }
     /// Tests responses with enum header bindings
     /// Test ID: RestJsonInputAndOutputWithEnumHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_enum_headers_response() {
         let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
             .set_header_enum(::std::option::Option::Some(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_header_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "Bar".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "Baz".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))

↧ Expand context

             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-Enum", "Foo")
                 .header("X-EnumList", "Foo, Bar, Baz")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-1126
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1130
         let op = crate::operation::input_and_output_with_headers::InputAndOutputWithHeaders::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-1136
         let parsed = de.deserialize_streaming(&mut http_response);

@@ -1196,1197 +1256,1257 @@

↥ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.header_boolean_list,
             expected_output.header_boolean_list,
             "Unexpected value for `header_boolean_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_timestamp_list,
             expected_output.header_timestamp_list,
             "Unexpected value for `header_timestamp_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(
             parsed.header_enum_list,
             expected_output.header_enum_list,
             "Unexpected value for `header_enum_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum,
             expected_output.header_integer_enum,
             "Unexpected value for `header_integer_enum`"

         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum_list,
             expected_output.header_integer_enum_list,
             "Unexpected value for `header_integer_enum_list`"
         );
-1223
+    }
     /// Tests responses with intEnum header bindings
     /// Test ID: RestJsonInputAndOutputWithIntEnumHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_int_enum_headers_response() {
         let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
             .set_header_integer_enum(::std::option::Option::Some(1))
             .set_header_integer_enum_list(::std::option::Option::Some(vec![1, 2, 3]))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-IntegerEnum", "1")
                 .header("X-IntegerEnumList", "1, 2, 3")
                 .status(200)

↧ Expand context

                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-1240
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1244
         let op = crate::operation::input_and_output_with_headers::InputAndOutputWithHeaders::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-1250
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed

@@ -1310,1311 +1370,1371 @@

↥ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.header_boolean_list,
             expected_output.header_boolean_list,
             "Unexpected value for `header_boolean_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_timestamp_list,
             expected_output.header_timestamp_list,
             "Unexpected value for `header_timestamp_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(
             parsed.header_enum_list,
             expected_output.header_enum_list,
             "Unexpected value for `header_enum_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum,
             expected_output.header_integer_enum,
             "Unexpected value for `header_integer_enum`"

         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum_list,
             expected_output.header_integer_enum_list,
             "Unexpected value for `header_integer_enum_list`"
         );
-1337
+    }
     /// Supports handling NaN float header values.
     /// Test ID: RestJsonSupportsNaNFloatHeaderOutputs
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_na_n_float_header_outputs_response() {
         let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
             .set_header_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .set_header_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

↧ Expand context

             ::http::response::Builder::new()
                 .header("X-Double", "NaN")
                 .header("X-Float", "NaN")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-1358
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1362
         let op = crate::operation::input_and_output_with_headers::InputAndOutputWithHeaders::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-1368
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =

@@ -1428,1429 +1488,1489 @@

↥ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.header_boolean_list,
             expected_output.header_boolean_list,
             "Unexpected value for `header_boolean_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_timestamp_list,
             expected_output.header_timestamp_list,
             "Unexpected value for `header_timestamp_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(
             parsed.header_enum_list,
             expected_output.header_enum_list,
             "Unexpected value for `header_enum_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum,
             expected_output.header_integer_enum,
             "Unexpected value for `header_integer_enum`"

         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum_list,
             expected_output.header_integer_enum_list,
             "Unexpected value for `header_integer_enum_list`"
         );
-1455
+    }
     /// Supports handling Infinity float header values.
     /// Test ID: RestJsonSupportsInfinityFloatHeaderOutputs
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_infinity_float_header_outputs_response() {
         let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
             .set_header_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .set_header_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

↧ Expand context

             ::http::response::Builder::new()
                 .header("X-Double", "Infinity")
                 .header("X-Float", "Infinity")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-1476
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1480
         let op = crate::operation::input_and_output_with_headers::InputAndOutputWithHeaders::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-1486
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =

@@ -1546,1547 +1606,1607 @@

↥ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.header_boolean_list,
             expected_output.header_boolean_list,
             "Unexpected value for `header_boolean_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_timestamp_list,
             expected_output.header_timestamp_list,
             "Unexpected value for `header_timestamp_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(
             parsed.header_enum_list,
             expected_output.header_enum_list,
             "Unexpected value for `header_enum_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum,
             expected_output.header_integer_enum,
             "Unexpected value for `header_integer_enum`"

         );
         ::pretty_assertions::assert_eq!(
             parsed.header_integer_enum_list,
             expected_output.header_integer_enum_list,
             "Unexpected value for `header_integer_enum_list`"
         );
-1573
+    }
     /// Supports handling -Infinity float header values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatHeaderOutputs
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_negative_infinity_float_header_outputs_response() {
         let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
             .set_header_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .set_header_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

↧ Expand context

             ::http::response::Builder::new()
                 .header("X-Double", "-Infinity")
                 .header("X-Float", "-Infinity")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-1594
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1598
         let op = crate::operation::input_and_output_with_headers::InputAndOutputWithHeaders::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-1604
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/json_blobs.rs

@@ -188,188 +280,281 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonBlobsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonBlobsEndpointParamsInterceptor"
-191
+    }
-192
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<JsonBlobsInput>()
             .ok_or("failed to downcast to JsonBlobsInput")?;
-207

         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(())
-214
+    }
-215
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_blobs_request_test {
 mod json_blobs_test {
-+
     /// Blobs are base64 encoded
     /// Test ID: RestJsonJsonBlobs
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_blobs_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-227
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_blobs()
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("value")))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"data\": \"dmFsdWU=\"\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(), "/JsonBlobs", "path was incorrect");
-247
+    }
     /// Blobs are base64 encoded
     /// Test ID: RestJsonJsonBlobs
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_blobs_response() {
         let expected_output = crate::operation::json_blobs::JsonBlobsOutput::builder()
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("value")))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"data\": \"dmFsdWU=\"\n}"))
                 .unwrap(),

↧ Expand context

-262
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-266
         let op = crate::operation::json_blobs::JsonBlobs::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-272
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_blobs::JsonBlobsOutput>()

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

@@ -188,188 +306,307 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonEnumsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonEnumsEndpointParamsInterceptor"
-191
+    }
-192
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<JsonEnumsInput>()
             .ok_or("failed to downcast to JsonEnumsInput")?;
-207

         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(())
-214
+    }
-215
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_enums_request_test {
 mod json_enums_test {
-+
     /// Serializes simple scalar properties
     /// Test ID: RestJsonJsonEnums
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_enums_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-227
         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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "{\n    \"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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonEnums", "path was incorrect");
-273
+    }
     /// Serializes simple scalar properties
     /// Test ID: RestJsonJsonEnums
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_enums_response() {
         let expected_output = crate::operation::json_enums::JsonEnumsOutput::builder()
             .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"),

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/json_int_enums.rs

@@ -191,191 +291,292 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonIntEnumsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonIntEnumsEndpointParamsInterceptor"
-194
+    }
-195
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<JsonIntEnumsInput>()
             .ok_or("failed to downcast to JsonIntEnumsInput")?;
-210

         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(())
-217
+    }
-218
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_int_enums_request_test {
 mod json_int_enums_test {
-+
     /// Serializes intEnums as integers
     /// Test ID: RestJsonJsonIntEnums
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_int_enums_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-230
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_int_enums()
             .set_integer_enum1(::std::option::Option::Some(1))
             .set_integer_enum2(::std::option::Option::Some(2))
             .set_integer_enum3(::std::option::Option::Some(3))
             .set_integer_enum_list(::std::option::Option::Some(vec![1, 2, 3]))
             .set_integer_enum_set(::std::option::Option::Some(vec![1, 2]))
             .set_integer_enum_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("abc".to_owned(), 1);
                 ret.insert("def".to_owned(), 2);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "{\n    \"integerEnum1\": 1,\n    \"integerEnum2\": 2,\n    \"integerEnum3\": 3,\n    \"integerEnumList\": [\n        1,\n        2,\n        3\n    ],\n    \"integerEnumSet\": [\n        1,\n        2\n    ],\n    \"integerEnumMap\": {\n        \"abc\": 1,\n        \"def\": 2\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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonIntEnums", "path was incorrect");
-258
+    }
     /// Serializes intEnums as integers
     /// Test ID: RestJsonJsonIntEnums
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_int_enums_response() {
         let expected_output = crate::operation::json_int_enums::JsonIntEnumsOutput::builder()
             .set_integer_enum1(::std::option::Option::Some(1))
             .set_integer_enum2(::std::option::Option::Some(2))
             .set_integer_enum3(::std::option::Option::Some(3))
             .set_integer_enum_list(::std::option::Option::Some(vec![1, 2, 3]))
             .set_integer_enum_set(::std::option::Option::Some(vec![1, 2]))
             .set_integer_enum_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("abc".to_owned(), 1);

↧ Expand context

                 ret.insert("def".to_owned(), 2);
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "application/json")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"integerEnum1\": 1,\n    \"integerEnum2\": 2,\n    \"integerEnum3\": 3,\n    \"integerEnumList\": [\n        1,\n        2,\n        3\n    ],\n    \"integerEnumSet\": [\n        1,\n        2\n    ],\n    \"integerEnumMap\": {\n        \"abc\": 1,\n        \"def\": 2\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-285
         let op = crate::operation::json_int_enums::JsonIntEnums::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-291
         let parsed = de.deserialize_streaming(&mut http_response);

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/json_lists.rs

@@ -188,188 +328,329 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonListsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonListsEndpointParamsInterceptor"
-191
+    }
-192
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<JsonListsInput>()
             .ok_or("failed to downcast to JsonListsInput")?;
-207

         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(())
-214
+    }
-215
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_lists_request_test {
 mod json_lists_test {
-+
     /// Serializes JSON lists
     /// Test ID: RestJsonLists
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_lists_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-227
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_lists()
             .set_string_list(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_string_set(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_integer_list(::std::option::Option::Some(vec![1, 2]))
             .set_boolean_list(::std::option::Option::Some(vec![true, false]))
             .set_timestamp_list(::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ]))
             .set_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .set_int_enum_list(::std::option::Option::Some(vec![1, 2]))
             .set_nested_string_list(::std::option::Option::Some(vec![
                 vec!["foo".to_owned(), "bar".to_owned()],
                 vec!["baz".to_owned(), "qux".to_owned()],
             ]))
             .set_structure_list(::std::option::Option::Some(vec![
                 crate::types::StructureListMember::builder()
                     .set_a(::std::option::Option::Some("1".to_owned()))
                     .set_b(::std::option::Option::Some("2".to_owned()))
                     .build(),
                 crate::types::StructureListMember::builder()
                     .set_a(::std::option::Option::Some("3".to_owned()))
                     .set_b(::std::option::Option::Some("4".to_owned()))
                     .build(),
             ]))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "{\n    \"stringList\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"stringSet\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"integerList\": [\n        1,\n        2\n    ],\n    \"booleanList\": [\n        true,\n        false\n    ],\n    \"timestampList\": [\n        1398796238,\n        1398796238\n    ],\n    \"enumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"intEnumList\": [\n        1,\n        2\n    ],\n    \"nestedStringList\": [\n        [\n            \"foo\",\n            \"bar\"\n        ],\n        [\n            \"baz\",\n            \"qux\"\n        ]\n    ],\n    \"myStructureList\": [\n        {\n            \"value\": \"1\",\n            \"other\": \"2\"\n        },\n        {\n            \"value\": \"3\",\n            \"other\": \"4\"\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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonLists", "path was incorrect");
-271
+    }
     /// Serializes empty JSON lists
     /// Test ID: RestJsonListsEmpty
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_lists_empty_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-279
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.json_lists().set_string_list(::std::option::Option::Some(vec![])).send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"stringList\": []\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonLists", "path was incorrect");
-295
+    }
     /// Serializes JSON lists
     /// Test ID: RestJsonLists
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_lists_response() {
         let expected_output = crate::operation::json_lists::JsonListsOutput::builder()
             .set_string_list(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_string_set(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_integer_list(::std::option::Option::Some(vec![1, 2]))
             .set_boolean_list(::std::option::Option::Some(vec![true, false]))
             .set_timestamp_list(::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ]))

↧ Expand context

             .set_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .set_int_enum_list(::std::option::Option::Some(vec![1, 2]))
             .set_nested_string_list(::std::option::Option::Some(vec![
                 vec!["foo".to_owned(), "bar".to_owned()],
                 vec!["baz".to_owned(), "qux".to_owned()],
             ]))
             .set_structure_list(::std::option::Option::Some(vec![
                 crate::types::StructureListMember::builder()
                     .set_a(::std::option::Option::Some("1".to_owned()))
                     .set_b(::std::option::Option::Some("2".to_owned()))
                     .build(),
                 crate::types::StructureListMember::builder()
                     .set_a(::std::option::Option::Some("3".to_owned()))
                     .set_b(::std::option::Option::Some("4".to_owned()))
                     .build(),
             ]))
             .build();

@@ -353,354 +413,414 @@

↥ Expand context

             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.string_list, expected_output.string_list, "Unexpected value for `string_list`");
         ::pretty_assertions::assert_eq!(parsed.string_set, expected_output.string_set, "Unexpected value for `string_set`");
         ::pretty_assertions::assert_eq!(parsed.integer_list, expected_output.integer_list, "Unexpected value for `integer_list`");
         ::pretty_assertions::assert_eq!(parsed.boolean_list, expected_output.boolean_list, "Unexpected value for `boolean_list`");
         ::pretty_assertions::assert_eq!(
             parsed.timestamp_list,
             expected_output.timestamp_list,
             "Unexpected value for `timestamp_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.enum_list, expected_output.enum_list, "Unexpected value for `enum_list`");
         ::pretty_assertions::assert_eq!(
             parsed.int_enum_list,
             expected_output.int_enum_list,
             "Unexpected value for `int_enum_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.nested_string_list,
             expected_output.nested_string_list,
             "Unexpected value for `nested_string_list`"

         );
         ::pretty_assertions::assert_eq!(
             parsed.structure_list,
             expected_output.structure_list,
             "Unexpected value for `structure_list`"
         );
-380
+    }
     /// Serializes empty JSON lists
     /// Test ID: RestJsonListsEmpty
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_lists_empty_response() {
         let expected_output = crate::operation::json_lists::JsonListsOutput::builder()
             .set_string_list(::std::option::Option::Some(vec![]))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"stringList\": []\n}"))
                 .unwrap(),

↧ Expand context

-395
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-399
         let op = crate::operation::json_lists::JsonLists::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-405
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_lists::JsonListsOutput>()

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/json_maps.rs

@@ -184,184 +359,360 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonMapsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonMapsEndpointParamsInterceptor"
-187
+    }
-188
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<JsonMapsInput>()
             .ok_or("failed to downcast to JsonMapsInput")?;
-203

         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(())
-210
+    }
-211
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_maps_request_test {
 mod json_maps_test {
-+
     /// Serializes JSON maps
     /// Test ID: RestJsonJsonMaps
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_maps_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-223
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_maps()
             .set_dense_struct_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("there".to_owned()))
                         .build(),
                 );
                 ret.insert(
                     "baz".to_owned(),
                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("bye".to_owned()))
                         .build(),
                 );
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(body, "{\n    \"denseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\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(), "/JsonMaps", "path was incorrect");
-256
+    }
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RestJsonSerializesZeroValuesInMaps
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_zero_values_in_maps_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-264
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_maps()
             .set_dense_number_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), 0);
                 ret
             }))
             .set_dense_boolean_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), false);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"denseNumberMap\": {\n        \"x\": 0\n    },\n    \"denseBooleanMap\": {\n        \"x\": false\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(), "/JsonMaps", "path was incorrect");
-293
+    }
     /// A request that contains a dense map of sets.
     /// Test ID: RestJsonSerializesDenseSetMap
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_dense_set_map_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-301
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_maps()
             .set_dense_set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), vec![]);
                 ret.insert("y".to_owned(), vec!["a".to_owned(), "b".to_owned()]);
                 ret
             }))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\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(), "/JsonMaps", "path was incorrect");
-326
+    }
     /// Deserializes JSON maps
     /// Test ID: RestJsonJsonMaps
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_maps_response() {
         let expected_output = crate::operation::json_maps::JsonMapsOutput::builder()
             .set_dense_struct_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("there".to_owned()))
                         .build(),
                 );

↧ Expand context

                 ret.insert(
                     "baz".to_owned(),
                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("bye".to_owned()))
                         .build(),
                 );
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "application/json")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"denseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\n        }\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-358
         let op = crate::operation::json_maps::JsonMaps::new();
         let config = op.config().expect("the operation has config");

@@ -373,374 +433,434 @@

↥ Expand context

             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.dense_struct_map,
             expected_output.dense_struct_map,
             "Unexpected value for `dense_struct_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_number_map,
             expected_output.dense_number_map,
             "Unexpected value for `dense_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_boolean_map,
             expected_output.dense_boolean_map,
             "Unexpected value for `dense_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_string_map,
             expected_output.dense_string_map,
             "Unexpected value for `dense_string_map`"

         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_set_map,
             expected_output.dense_set_map,
             "Unexpected value for `dense_set_map`"
         );
-400
+    }
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RestJsonDeserializesZeroValuesInMaps
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserializes_zero_values_in_maps_response() {
         let expected_output = crate::operation::json_maps::JsonMapsOutput::builder()
             .set_dense_number_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), 0);
                 ret
             }))
             .set_dense_boolean_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), false);

↧ Expand context

                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"denseNumberMap\": {\n        \"x\": 0\n    },\n    \"denseBooleanMap\": {\n        \"x\": false\n    }\n}",
                 ))
                 .unwrap(),
-426
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-430
         let op = crate::operation::json_maps::JsonMaps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

@@ -445,446 +505,506 @@

↥ Expand context

             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.dense_struct_map,
             expected_output.dense_struct_map,
             "Unexpected value for `dense_struct_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_number_map,
             expected_output.dense_number_map,
             "Unexpected value for `dense_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_boolean_map,
             expected_output.dense_boolean_map,
             "Unexpected value for `dense_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_string_map,
             expected_output.dense_string_map,
             "Unexpected value for `dense_string_map`"

         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_set_map,
             expected_output.dense_set_map,
             "Unexpected value for `dense_set_map`"
         );
-472
+    }
     /// A response that contains a dense map of sets.
     /// Test ID: RestJsonDeserializesDenseSetMap
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserializes_dense_set_map_response() {
         let expected_output = crate::operation::json_maps::JsonMapsOutput::builder()
             .set_dense_set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), vec![]);
                 ret.insert("y".to_owned(), vec!["a".to_owned(), "b".to_owned()]);
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

↧ Expand context

             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\n    }\n}",
                 ))
                 .unwrap(),
-494
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-498
         let op = crate::operation::json_maps::JsonMaps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-504
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {

@@ -514,515 +574,575 @@

↥ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.dense_struct_map,
             expected_output.dense_struct_map,
             "Unexpected value for `dense_struct_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_number_map,
             expected_output.dense_number_map,
             "Unexpected value for `dense_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_boolean_map,
             expected_output.dense_boolean_map,
             "Unexpected value for `dense_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_string_map,
             expected_output.dense_string_map,
             "Unexpected value for `dense_string_map`"
         );

         ::pretty_assertions::assert_eq!(
             parsed.dense_set_map,
             expected_output.dense_set_map,
             "Unexpected value for `dense_set_map`"
         );
-540
+    }
     /// Clients SHOULD tolerate seeing a null value in a dense map, and they SHOULD
     /// drop the null key-value pair.
     /// Test ID: RestJsonDeserializesDenseSetMapAndSkipsNull
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserializes_dense_set_map_and_skips_null_response() {
         let expected_output = crate::operation::json_maps::JsonMapsOutput::builder()
             .set_dense_set_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), vec![]);
                 ret.insert("y".to_owned(), vec!["a".to_owned(), "b".to_owned()]);
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

↧ Expand context

             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"],\n        \"z\": null\n    }\n}",
                 ))
                 .unwrap(),
-563
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-567
         let op = crate::operation::json_maps::JsonMaps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-573
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/json_timestamps.rs

@@ -191,191 +526,527 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonTimestampsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonTimestampsEndpointParamsInterceptor"
-194
+    }
-195
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<JsonTimestampsInput>()
             .ok_or("failed to downcast to JsonTimestampsInput")?;
-210

         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(())
-217
+    }
-218
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_timestamps_request_test {
 mod json_timestamps_test {
-+
     /// Tests how normal timestamps are serialized
     /// Test ID: RestJsonJsonTimestamps
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-230
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_normal(::std::option::Option::Some(::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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"normal\": 1398796238\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(), "/JsonTimestamps", "path was incorrect");
-252
+    }
     /// Ensures that the timestampFormat of date-time works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeFormat
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_date_time_format_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-260
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_date_time(::std::option::Option::Some(::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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"dateTime\": \"2014-04-29T18:30:38Z\"\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(), "/JsonTimestamps", "path was incorrect");
-282
+    }
     /// Ensures that the timestampFormat of date-time on the target shape works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeOnTargetFormat
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_date_time_on_target_format_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-290
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_date_time_on_target(::std::option::Option::Some(::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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"dateTimeOnTarget\": \"2014-04-29T18:30:38Z\"\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(), "/JsonTimestamps", "path was incorrect");
-312
+    }
     /// Ensures that the timestampFormat of epoch-seconds works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsFormat
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_epoch_seconds_format_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-320
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_epoch_seconds(::std::option::Option::Some(::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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"epochSeconds\": 1398796238\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(), "/JsonTimestamps", "path was incorrect");
-342
+    }
     /// Ensures that the timestampFormat of epoch-seconds on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsOnTargetFormat
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_epoch_seconds_on_target_format_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-350
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_epoch_seconds_on_target(::std::option::Option::Some(::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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"epochSecondsOnTarget\": 1398796238\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(), "/JsonTimestamps", "path was incorrect");
-372
+    }
     /// Ensures that the timestampFormat of http-date works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateFormat
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_http_date_format_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-380
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_http_date(::std::option::Option::Some(::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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"httpDate\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\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(), "/JsonTimestamps", "path was incorrect");
-402
+    }
     /// Ensures that the timestampFormat of http-date on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateOnTargetFormat
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_http_date_on_target_format_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-410
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_timestamps()
             .set_http_date_on_target(::std::option::Option::Some(::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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"httpDateOnTarget\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\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(), "/JsonTimestamps", "path was incorrect");
-432
+    }
     /// Tests how normal timestamps are serialized
     /// Test ID: RestJsonJsonTimestamps
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_response() {
         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_normal(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"normal\": 1398796238\n}"))
                 .unwrap(),
-449
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-453
         let op = crate::operation::json_timestamps::JsonTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-459
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-493
+    }
     /// Ensures that the timestampFormat of date-time works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeFormat
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_date_time_format_response() {
         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)

↧ Expand context

                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"dateTime\": \"2014-04-29T18:30:38Z\"\n}",
                 ))
                 .unwrap(),
-512
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-516
         let op = crate::operation::json_timestamps::JsonTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-522
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)

@@ -529,530 +589,590 @@

↥ Expand context

             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );

         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-556
+    }
     /// Ensures that the timestampFormat of date-time on the target shape works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeOnTargetFormat
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_date_time_on_target_format_response() {
         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_date_time_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)

↧ Expand context

                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"dateTimeOnTarget\": \"2014-04-29T18:30:38Z\"\n}",
                 ))
                 .unwrap(),
-575
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-579
         let op = crate::operation::json_timestamps::JsonTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-585
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)

@@ -592,593 +774,775 @@

↥ Expand context

             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );

         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-619
+    }
     /// Ensures that the timestampFormat of epoch-seconds works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsFormat
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_epoch_seconds_format_response() {
         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"epochSeconds\": 1398796238\n}"))
                 .unwrap(),
-636
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-640
         let op = crate::operation::json_timestamps::JsonTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-646
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-680
+    }
     /// Ensures that the timestampFormat of epoch-seconds on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsOnTargetFormat
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_epoch_seconds_on_target_format_response() {
         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_epoch_seconds_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"epochSecondsOnTarget\": 1398796238\n}"))
                 .unwrap(),
-697
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-701
         let op = crate::operation::json_timestamps::JsonTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-707
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-741
+    }
     /// Ensures that the timestampFormat of http-date works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateFormat
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_http_date_format_response() {
         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)

↧ Expand context

                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"httpDate\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}",
                 ))
                 .unwrap(),
-760
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-764
         let op = crate::operation::json_timestamps::JsonTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-770
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)

@@ -777,778 +837,838 @@

↥ Expand context

             .expect("should be successful response")
             .downcast::<crate::operation::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );

         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-804
+    }
     /// Ensures that the timestampFormat of http-date on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateOnTargetFormat
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_http_date_on_target_format_response() {
         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_http_date_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)

↧ Expand context

                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"httpDateOnTarget\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}",
                 ))
                 .unwrap(),
-823
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-827
         let op = crate::operation::json_timestamps::JsonTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-833
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)

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

@@ -188,188 +919,920 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonUnionsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonUnionsEndpointParamsInterceptor"
-191
+    }
-192
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<JsonUnionsInput>()
             .ok_or("failed to downcast to JsonUnionsInput")?;
-207

         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(())
-214
+    }
-215
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_unions_request_test {
 mod json_unions_test {
-+
     /// Serializes a string union value
     /// Test ID: RestJsonSerializeStringUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_string_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-227
         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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonUnions", "path was incorrect");
-247
+    }
     /// Serializes a boolean union value
     /// Test ID: RestJsonSerializeBooleanUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_boolean_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-255
         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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonUnions", "path was incorrect");
-275
+    }
     /// Serializes a number union value
     /// Test ID: RestJsonSerializeNumberUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_number_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-283
         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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonUnions", "path was incorrect");
-303
+    }
     /// Serializes a blob union value
     /// Test ID: RestJsonSerializeBlobUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_blob_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-311
         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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonUnions", "path was incorrect");
-333
+    }
     /// Serializes a timestamp union value
     /// Test ID: RestJsonSerializeTimestampUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_timestamp_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-341
         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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonUnions", "path was incorrect");
-363
+    }
     /// Serializes an enum union value
     /// Test ID: RestJsonSerializeEnumUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_enum_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-371
         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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonUnions", "path was incorrect");
-393
+    }
     /// Serializes a list union value
     /// Test ID: RestJsonSerializeListUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_list_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-401
         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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonUnions", "path was incorrect");
-424
+    }
     /// Serializes a map union value
     /// Test ID: RestJsonSerializeMapUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_map_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-432
         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/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonUnions", "path was incorrect");
-457
+    }
     /// Serializes a structure union value
     /// Test ID: RestJsonSerializeStructureUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_structure_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-465
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .json_unions()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
                 crate::types::GreetingStruct::builder()
                     .set_hi(::std::option::Option::Some("hello".to_owned()))
                     .build(),
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonUnions", "path was incorrect");
-489
+    }
     /// Serializes a renamed structure union value
     /// Test ID: RestJsonSerializeRenamedStructureUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_renamed_structure_union_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-497
         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::RenamedStructureValue(
                 crate::types::RenamedGreeting::builder()
                     .set_salutation(::std::option::Option::Some("hello!".to_owned()))
                     .build(),
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/json")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "{\n    \"contents\": {\n        \"renamedStructureValue\": {\n            \"salutation\": \"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(), "PUT", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/JsonUnions", "path was incorrect");
-521
+    }
     /// Deserializes a string union value
     /// Test ID: RestJsonDeserializeStringUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_string_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StringValue("foo".to_owned())))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"stringValue\": \"foo\"\n    }\n}",
                 ))
                 .unwrap(),
-538
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-542
         let op = crate::operation::json_unions::JsonUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-548
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-560
+    }
     /// Deserializes a boolean union value
     /// Test ID: RestJsonDeserializeBooleanUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_boolean_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::BooleanValue(true)))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"booleanValue\": true\n    }\n}",
                 ))
                 .unwrap(),
-577
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-581
         let op = crate::operation::json_unions::JsonUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-587
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-599
+    }
     /// Deserializes a number union value
     /// Test ID: RestJsonDeserializeNumberUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_number_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::NumberValue(1)))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"numberValue\": 1\n    }\n}",
                 ))
                 .unwrap(),
-616
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-620
         let op = crate::operation::json_unions::JsonUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-626
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-638
+    }
     /// Deserializes a blob union value
     /// Test ID: RestJsonDeserializeBlobUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_blob_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::BlobValue(
                 ::aws_smithy_types::Blob::new("foo"),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"blobValue\": \"Zm9v\"\n    }\n}",
                 ))
                 .unwrap(),
-657
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-661
         let op = crate::operation::json_unions::JsonUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-667
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-679
+    }
     /// Deserializes a timestamp union value
     /// Test ID: RestJsonDeserializeTimestampUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_timestamp_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::TimestampValue(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"timestampValue\": 1398796238\n    }\n}",
                 ))
                 .unwrap(),
-698
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-702
         let op = crate::operation::json_unions::JsonUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-708
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-720
+    }
     /// Deserializes an enum union value
     /// Test ID: RestJsonDeserializeEnumUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_enum_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::EnumValue(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"enumValue\": \"Foo\"\n    }\n}",
                 ))
                 .unwrap(),
-739
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-743
         let op = crate::operation::json_unions::JsonUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-749
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-761
+    }
     /// Deserializes a list union value
     /// Test ID: RestJsonDeserializeListUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_list_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::ListValue(vec![
                 "foo".to_owned(),
                 "bar".to_owned(),
             ])))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"listValue\": [\"foo\", \"bar\"]\n    }\n}",
                 ))
                 .unwrap(),
-781
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-785
         let op = crate::operation::json_unions::JsonUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-791
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-803
+    }
     /// Deserializes a map union value
     /// Test ID: RestJsonDeserializeMapUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_map_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .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
             })))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "application/json")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"contents\": {\n        \"mapValue\": {\n            \"foo\": \"bar\",\n            \"spam\": \"eggs\"\n        }\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-825
         let op = crate::operation::json_unions::JsonUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-831
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-843
+    }
     /// Deserializes a structure union value
     /// Test ID: RestJsonDeserializeStructureUnionValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_structure_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
                 crate::types::GreetingStruct::builder()
                     .set_hi(::std::option::Option::Some("hello".to_owned()))
                     .build(),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"structureValue\": {\n            \"hi\": \"hello\"\n        }\n    }\n}",
                 ))
                 .unwrap(),
-864
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-868
         let op = crate::operation::json_unions::JsonUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-874
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-886
+    }
     /// Ignores an unrecognized __type property
     /// Test ID: RestJsonDeserializeIgnoreType
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_ignore_type_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
                 crate::types::GreetingStruct::builder()
                     .set_hi(::std::option::Option::Some("hello".to_owned()))
                     .build(),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "application/json")

↧ Expand context

         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"contents\": {\n        \"__type\": \"aws.protocoltests.json10#MyUnion\",\n        \"structureValue\": {\n            \"hi\": \"hello\"\n        }\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-907
         let op = crate::operation::json_unions::JsonUnions::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-913
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/media_type_header.rs

@@ -188,188 +277,278 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MediaTypeHeaderEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MediaTypeHeaderEndpointParamsInterceptor"
-191
+    }
-192
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<MediaTypeHeaderInput>()
             .ok_or("failed to downcast to MediaTypeHeaderInput")?;
-207

         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(())
-214
+    }
-215
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod media_type_header_request_test {
 mod media_type_header_test {
-+
     /// Headers that target strings with a mediaType are base64 encoded
     /// Test ID: MediaTypeHeaderInputBase64
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn media_type_header_input_base64_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-227
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .media_type_header()
             .set_json(::std::option::Option::Some("true".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Json", "dHJ1ZQ==")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/MediaTypeHeader", "path was incorrect");
-244
+    }
     /// Headers that target strings with a mediaType are base64 encoded
     /// Test ID: MediaTypeHeaderOutputBase64
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn media_type_header_output_base64_response() {
         let expected_output = crate::operation::media_type_header::MediaTypeHeaderOutput::builder()
             .set_json(::std::option::Option::Some("true".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-Json", "dHJ1ZQ==")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),

↧ Expand context

-259
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-263
         let op = crate::operation::media_type_header::MediaTypeHeader::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-269
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::media_type_header::MediaTypeHeaderOutput>()

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/no_input_and_no_output.rs

@@ -193,193 +280,281 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NoInputAndNoOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NoInputAndNoOutputEndpointParamsInterceptor"
-196
+    }
-197
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<NoInputAndNoOutputInput>()
             .ok_or("failed to downcast to NoInputAndNoOutputInput")?;
-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
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod no_input_and_no_output_request_test {
 mod no_input_and_no_output_test {
-+
     /// No input serializes no payload. When clients do not need to
     /// serialize any data in the payload, they should omit a payload
     /// altogether.
     /// Test ID: RestJsonNoInputAndNoOutput
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_no_output_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-234
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.no_input_and_no_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         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(), "/NoInputAndNoOutput", "path was incorrect");
-245
+    }
     /// When an operation does not define output, the service will respond
     /// with an empty payload, and may optionally include the content-type
     /// header.
     /// Test ID: RestJsonNoInputAndNoOutput
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_no_output_response() {
         let expected_output = crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-259
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

↧ Expand context

         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-263
         let op = crate::operation::no_input_and_no_output::NoInputAndNoOutput::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-269
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput>()
             .unwrap();
-280
+    }
-281
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/no_input_and_output.rs

@@ -187,187 +309,310 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NoInputAndOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NoInputAndOutputEndpointParamsInterceptor"
-190
+    }
-191
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<NoInputAndOutputInput>()
             .ok_or("failed to downcast to NoInputAndOutputInput")?;
-206

         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(())
-213
+    }
-214
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod no_input_and_output_request_test {
 mod no_input_and_output_test {
-+
     /// No input serializes no payload. When clients do not need to
     /// serialize any data in the payload, they should omit a payload
     /// altogether.
     /// Test ID: RestJsonNoInputAndOutput
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_output_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-228
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.no_input_and_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         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(), "/NoInputAndOutputOutput", "path was incorrect");
-239
+    }
     /// Operations that define output and do not bind anything to
     /// the payload return a JSON object in the response.
     /// Test ID: RestJsonNoInputAndOutputWithJson
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_output_with_json_response() {
         let expected_output = crate::operation::no_input_and_output::NoInputAndOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{}"))
                 .unwrap(),
-253
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-257
         let op = crate::operation::no_input_and_output::NoInputAndOutput::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-263
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::no_input_and_output::NoInputAndOutputOutput>()
             .unwrap();
-274
+    }
     /// This test is similar to RestJsonNoInputAndOutputWithJson, but
     /// it ensures that clients can gracefully handle responses that
     /// omit a JSON payload.
     /// Test ID: RestJsonNoInputAndOutputNoPayload
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_output_no_payload_response() {
         let expected_output = crate::operation::no_input_and_output::NoInputAndOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-288
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

↧ Expand context

         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-292
         let op = crate::operation::no_input_and_output::NoInputAndOutput::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-298
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::no_input_and_output::NoInputAndOutputOutput>()
             .unwrap();
-309
+    }
-310
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/null_and_empty_headers_client.rs

@@ -194,194 +258,259 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NullAndEmptyHeadersClientEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NullAndEmptyHeadersClientEndpointParamsInterceptor"
-197
+    }
-198
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<NullAndEmptyHeadersClientInput>()
             .ok_or("failed to downcast to NullAndEmptyHeadersClientInput")?;
-213

         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(())
-220
+    }
-221
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod null_and_empty_headers_client_request_test {
 mod null_and_empty_headers_client_test {
-+
     /// Do not send null values, empty strings, or empty lists over the wire in headers
     /// Test ID: RestJsonNullAndEmptyHeaders
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_null_and_empty_headers_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-233
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .null_and_empty_headers_client()
             .set_a(::std::option::Option::None)
             .set_b(::std::option::Option::Some("".to_owned()))
             .set_c(::std::option::Option::Some(vec![]))

↧ Expand context

             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let forbidden_headers = &["X-A", "X-B", "X-C"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/NullAndEmptyHeadersClient", "path was incorrect");
-252
+    }
-253
+}
-254
 /// Error type for the `NullAndEmptyHeadersClientError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum NullAndEmptyHeadersClientError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/omits_null_serializes_empty_string.rs

@@ -213,213 +300,301 @@

↥ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for OmitsNullSerializesEmptyStringEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "OmitsNullSerializesEmptyStringEndpointParamsInterceptor"
-216
+    }
-217
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::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::<OmitsNullSerializesEmptyStringInput>()
             .ok_or("failed to downcast to OmitsNullSerializesEmptyStringInput")?;
-232

         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(())
-239
+    }
-240
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod omits_null_serializes_empty_string_request_test {
 mod omits_null_serializes_empty_string_test {
-+
     /// Omits null query values
     /// Test ID: RestJsonOmitsNullQuery
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_omits_null_query_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-252
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .omits_null_serializes_empty_string()
             .set_null_value(::std::option::Option::None)
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/OmitsNullSerializesEmptyString", "path was incorrect");
-267
+    }
     /// Serializes empty query strings
     /// Test ID: RestJsonSerializesEmptyQueryValue
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_empty_query_value_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-275
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .omits_null_serializes_empty_string()
             .set_empty_string(::std::option::Option::Some("".to_owned()))
             .send()
             .await;

↧ Expand context

         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["Empty="];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/OmitsNullSerializesEmptyString", "path was incorrect");
-292
+    }
-293
+}
-294
 /// Error type for the `OmitsNullSerializesEmptyStringError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum OmitsNullSerializesEmptyStringError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:

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