Client Test

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

@@ -151,151 +224,224 @@

-151
+}
 #[derive(Debug)]
 struct MalformedBlobRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedBlobRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_blob::MalformedBlobInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_blob::MalformedBlobInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedBlob").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-177
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_blob::MalformedBlobInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-186
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_malformed_blob::ser_malformed_blob_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-195
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-197
+    }
-198
+}
 #[derive(Debug)]
 struct MalformedBlobEndpointParamsInterceptor;
-201
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedBlobEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedBlobEndpointParamsInterceptor"

↧ Expand context

-205
+    }
-206
     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::<MalformedBlobInput>()
             .ok_or("failed to downcast to MalformedBlobInput")?;
-221
         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)
         })?;

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

@@ -181,181 +256,256 @@

↥ Expand context

                 let input_1 = &_input.boolean_in_path;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("boolean_in_path", "cannot be empty or unset"))?;
                 let mut boolean_in_path_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_1);
                 let boolean_in_path = boolean_in_path_encoder.encode();
                 if boolean_in_path.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "boolean_in_path",
                         "cannot be empty or unset",
                     ));
-192
+                }
                 ::std::write!(output, "/MalformedBoolean/{booleanInPath}", booleanInPath = boolean_in_path).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-195
+            }
             fn uri_query(
                 _input: &crate::operation::malformed_boolean::MalformedBooleanInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);

                 if let ::std::option::Option::Some(inner_2) = &_input.boolean_in_query {
-202
+                    {
                         query.push_kv("booleanInQuery", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-204
+                    }
-205
+                }
                 ::std::result::Result::Ok(())
-207
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_boolean::MalformedBooleanInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_malformed_boolean::ser_malformed_boolean_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-218
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_malformed_boolean::ser_malformed_boolean_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-227
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-229
+    }
-230
+}
 #[derive(Debug)]
 struct MalformedBooleanEndpointParamsInterceptor;
-233
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedBooleanEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedBooleanEndpointParamsInterceptor"

↧ Expand context

-237
+    }
-238
     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::<MalformedBooleanInput>()
             .ok_or("failed to downcast to MalformedBooleanInput")?;
-253
         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)
         })?;

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

@@ -175,175 +250,250 @@

↥ Expand context

                 let input_1 = &_input.byte_in_path;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("byte_in_path", "cannot be empty or unset"))?;
                 let mut byte_in_path_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_1);
                 let byte_in_path = byte_in_path_encoder.encode();
                 if byte_in_path.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "byte_in_path",
                         "cannot be empty or unset",
                     ));
-186
+                }
                 ::std::write!(output, "/MalformedByte/{byteInPath}", byteInPath = byte_in_path).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-189
+            }
             fn uri_query(
                 _input: &crate::operation::malformed_byte::MalformedByteInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);

                 if let ::std::option::Option::Some(inner_2) = &_input.byte_in_query {
-196
+                    {
                         query.push_kv("byteInQuery", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-198
+                    }
-199
+                }
                 ::std::result::Result::Ok(())
-201
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_byte::MalformedByteInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_malformed_byte::ser_malformed_byte_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-212
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_malformed_byte::ser_malformed_byte_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-221
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-223
+    }
-224
+}
 #[derive(Debug)]
 struct MalformedByteEndpointParamsInterceptor;
-227
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedByteEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedByteEndpointParamsInterceptor"

↧ Expand context

-231
+    }
-232
     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::<MalformedByteInput>()
             .ok_or("failed to downcast to MalformedByteInput")?;
-247
         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)
         })?;

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

@@ -157,157 +232,232 @@

↥ Expand context

-157
+}
 #[derive(Debug)]
 struct MalformedContentTypeWithBodyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedContentTypeWithBodyRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_content_type_with_body::MalformedContentTypeWithBodyInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_content_type_with_body::MalformedContentTypeWithBodyInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedContentTypeWithBody").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_content_type_with_body::MalformedContentTypeWithBodyInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-192
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_malformed_content_type_with_body::ser_malformed_content_type_with_body_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-203
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-205
+    }
-206
+}
 #[derive(Debug)]
 struct MalformedContentTypeWithBodyEndpointParamsInterceptor;
-209
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedContentTypeWithBodyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedContentTypeWithBodyEndpointParamsInterceptor"

↧ Expand context

-213
+    }
-214
     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::<MalformedContentTypeWithBodyInput>()
             .ok_or("failed to downcast to MalformedContentTypeWithBodyInput")?;
-229
         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)
         })?;

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

@@ -161,161 +236,236 @@

↥ Expand context

-161
+}
 #[derive(Debug)]
 struct MalformedContentTypeWithGenericStringRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedContentTypeWithGenericStringRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_content_type_with_generic_string::MalformedContentTypeWithGenericStringInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_content_type_with_generic_string::MalformedContentTypeWithGenericStringInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedContentTypeWithGenericString").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-187
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_content_type_with_generic_string::MalformedContentTypeWithGenericStringInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-196
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "text/plain");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "text/plain");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_malformed_content_type_with_generic_string_input::ser_payload_http_payload(input.payload)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-207
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-209
+    }
-210
+}
 #[derive(Debug)]
 struct MalformedContentTypeWithGenericStringEndpointParamsInterceptor;
-213
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedContentTypeWithGenericStringEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedContentTypeWithGenericStringEndpointParamsInterceptor"

↧ Expand context

-217
+    }
-218
     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::<MalformedContentTypeWithGenericStringInput>()
             .ok_or("failed to downcast to MalformedContentTypeWithGenericStringInput")?;
-233
         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)
         })?;

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

@@ -159,159 +234,234 @@

↥ Expand context

-159
+}
 #[derive(Debug)]
 struct MalformedContentTypeWithPayloadRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedContentTypeWithPayloadRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_content_type_with_payload::MalformedContentTypeWithPayloadInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_content_type_with_payload::MalformedContentTypeWithPayloadInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedContentTypeWithPayload").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-185
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_content_type_with_payload::MalformedContentTypeWithPayloadInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-194
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "image/jpeg");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "image/jpeg");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_malformed_content_type_with_payload_input::ser_payload_http_payload(input.payload)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-205
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-207
+    }
-208
+}
 #[derive(Debug)]
 struct MalformedContentTypeWithPayloadEndpointParamsInterceptor;
-211
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedContentTypeWithPayloadEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedContentTypeWithPayloadEndpointParamsInterceptor"

↧ Expand context

-215
+    }
-216
     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::<MalformedContentTypeWithPayloadInput>()
             .ok_or("failed to downcast to MalformedContentTypeWithPayloadInput")?;
-231
         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)
         })?;

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

@@ -159,159 +225,225 @@

↥ Expand context

-159
+}
 #[derive(Debug)]
 struct MalformedContentTypeWithoutBodyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedContentTypeWithoutBodyRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_content_type_without_body::MalformedContentTypeWithoutBodyInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_content_type_without_body::MalformedContentTypeWithoutBodyInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedContentTypeWithoutBody").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-185
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_content_type_without_body::MalformedContentTypeWithoutBodyInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-194
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-199
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-201
+    }
-202
+}
 #[derive(Debug)]
 struct MalformedContentTypeWithoutBodyEndpointParamsInterceptor;
-205

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedContentTypeWithoutBodyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedContentTypeWithoutBodyEndpointParamsInterceptor"
-209
+    }
-210
     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::<MalformedContentTypeWithoutBodyInput>()
             .ok_or("failed to downcast to MalformedContentTypeWithoutBodyInput")?;
-225

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

@@ -158,158 +225,225 @@

↥ Expand context

-158
+}
 #[derive(Debug)]
 struct MalformedContentTypeWithoutBodyEmptyInputRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedContentTypeWithoutBodyEmptyInputRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_content_type_without_body_empty_input::MalformedContentTypeWithoutBodyEmptyInputInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_content_type_without_body_empty_input::MalformedContentTypeWithoutBodyEmptyInputInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedContentTypeWithoutBodyEmptyInput").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-184
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_content_type_without_body_empty_input::MalformedContentTypeWithoutBodyEmptyInputInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_malformed_content_type_without_body_empty_input::ser_malformed_content_type_without_body_empty_input_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-194
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-199
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-201
+    }
-202
+}
 #[derive(Debug)]
 struct MalformedContentTypeWithoutBodyEmptyInputEndpointParamsInterceptor;
-205

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedContentTypeWithoutBodyEmptyInputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedContentTypeWithoutBodyEmptyInputEndpointParamsInterceptor"
-209
+    }
-210
     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::<MalformedContentTypeWithoutBodyEmptyInputInput>()
             .ok_or("failed to downcast to MalformedContentTypeWithoutBodyEmptyInputInput")?;
-225

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

@@ -181,181 +256,256 @@

↥ Expand context

                 let input_1 = &_input.double_in_path;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("double_in_path", "cannot be empty or unset"))?;
                 let mut double_in_path_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_1);
                 let double_in_path = double_in_path_encoder.encode();
                 if double_in_path.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "double_in_path",
                         "cannot be empty or unset",
                     ));
-192
+                }
                 ::std::write!(output, "/MalformedDouble/{doubleInPath}", doubleInPath = double_in_path).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-195
+            }
             fn uri_query(
                 _input: &crate::operation::malformed_double::MalformedDoubleInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);

                 if let ::std::option::Option::Some(inner_2) = &_input.double_in_query {
-202
+                    {
                         query.push_kv("doubleInQuery", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-204
+                    }
-205
+                }
                 ::std::result::Result::Ok(())
-207
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_double::MalformedDoubleInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_malformed_double::ser_malformed_double_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-218
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_malformed_double::ser_malformed_double_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-227
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-229
+    }
-230
+}
 #[derive(Debug)]
 struct MalformedDoubleEndpointParamsInterceptor;
-233
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedDoubleEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedDoubleEndpointParamsInterceptor"

↧ Expand context

-237
+    }
-238
     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::<MalformedDoubleInput>()
             .ok_or("failed to downcast to MalformedDoubleInput")?;
-253
         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)
         })?;

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

@@ -175,175 +250,250 @@

↥ Expand context

                 let input_1 = &_input.float_in_path;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("float_in_path", "cannot be empty or unset"))?;
                 let mut float_in_path_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_1);
                 let float_in_path = float_in_path_encoder.encode();
                 if float_in_path.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "float_in_path",
                         "cannot be empty or unset",
                     ));
-186
+                }
                 ::std::write!(output, "/MalformedFloat/{floatInPath}", floatInPath = float_in_path).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-189
+            }
             fn uri_query(
                 _input: &crate::operation::malformed_float::MalformedFloatInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);

                 if let ::std::option::Option::Some(inner_2) = &_input.float_in_query {
-196
+                    {
                         query.push_kv("floatInQuery", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-198
+                    }
-199
+                }
                 ::std::result::Result::Ok(())
-201
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_float::MalformedFloatInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_malformed_float::ser_malformed_float_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-212
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_malformed_float::ser_malformed_float_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-221
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-223
+    }
-224
+}
 #[derive(Debug)]
 struct MalformedFloatEndpointParamsInterceptor;
-227
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedFloatEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedFloatEndpointParamsInterceptor"

↧ Expand context

-231
+    }
-232
     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::<MalformedFloatInput>()
             .ok_or("failed to downcast to MalformedFloatInput")?;
-247
         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)
         })?;

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

@@ -181,181 +256,256 @@

↥ Expand context

                 let input_1 = &_input.integer_in_path;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("integer_in_path", "cannot be empty or unset"))?;
                 let mut integer_in_path_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_1);
                 let integer_in_path = integer_in_path_encoder.encode();
                 if integer_in_path.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "integer_in_path",
                         "cannot be empty or unset",
                     ));
-192
+                }
                 ::std::write!(output, "/MalformedInteger/{integerInPath}", integerInPath = integer_in_path).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-195
+            }
             fn uri_query(
                 _input: &crate::operation::malformed_integer::MalformedIntegerInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);

                 if let ::std::option::Option::Some(inner_2) = &_input.integer_in_query {
-202
+                    {
                         query.push_kv("integerInQuery", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-204
+                    }
-205
+                }
                 ::std::result::Result::Ok(())
-207
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_integer::MalformedIntegerInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_malformed_integer::ser_malformed_integer_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-218
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_malformed_integer::ser_malformed_integer_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-227
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-229
+    }
-230
+}
 #[derive(Debug)]
 struct MalformedIntegerEndpointParamsInterceptor;
-233
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedIntegerEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedIntegerEndpointParamsInterceptor"

↧ Expand context

-237
+    }
-238
     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::<MalformedIntegerInput>()
             .ok_or("failed to downcast to MalformedIntegerInput")?;
-253
         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)
         })?;

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

@@ -151,151 +224,224 @@

↥ Expand context

-151
+}
 #[derive(Debug)]
 struct MalformedListRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedListRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_list::MalformedListInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_list::MalformedListInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedList").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-177
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_list::MalformedListInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-186
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_malformed_list::ser_malformed_list_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-195
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-197
+    }
-198
+}
 #[derive(Debug)]
 struct MalformedListEndpointParamsInterceptor;
-201
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedListEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedListEndpointParamsInterceptor"

↧ Expand context

-205
+    }
-206
     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::<MalformedListInput>()
             .ok_or("failed to downcast to MalformedListInput")?;
-221
         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)
         })?;

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

@@ -175,175 +250,250 @@

↥ Expand context

                 let input_1 = &_input.long_in_path;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("long_in_path", "cannot be empty or unset"))?;
                 let mut long_in_path_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_1);
                 let long_in_path = long_in_path_encoder.encode();
                 if long_in_path.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "long_in_path",
                         "cannot be empty or unset",
                     ));
-186
+                }
                 ::std::write!(output, "/MalformedLong/{longInPath}", longInPath = long_in_path).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-189
+            }
             fn uri_query(
                 _input: &crate::operation::malformed_long::MalformedLongInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);

                 if let ::std::option::Option::Some(inner_2) = &_input.long_in_query {
-196
+                    {
                         query.push_kv("longInQuery", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-198
+                    }
-199
+                }
                 ::std::result::Result::Ok(())
-201
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_long::MalformedLongInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_malformed_long::ser_malformed_long_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-212
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_malformed_long::ser_malformed_long_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-221
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-223
+    }
-224
+}
 #[derive(Debug)]
 struct MalformedLongEndpointParamsInterceptor;
-227
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedLongEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedLongEndpointParamsInterceptor"

↧ Expand context

-231
+    }
-232
     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::<MalformedLongInput>()
             .ok_or("failed to downcast to MalformedLongInput")?;
-247
         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)
         })?;

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

@@ -151,151 +224,224 @@

↥ Expand context

-151
+}
 #[derive(Debug)]
 struct MalformedMapRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedMapRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_map::MalformedMapInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_map::MalformedMapInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedMap").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-177
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_map::MalformedMapInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-186
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_malformed_map::ser_malformed_map_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-195
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-197
+    }
-198
+}
 #[derive(Debug)]
 struct MalformedMapEndpointParamsInterceptor;
-201
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedMapEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedMapEndpointParamsInterceptor"

↧ Expand context

-205
+    }
-206
     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::<MalformedMapInput>()
             .ok_or("failed to downcast to MalformedMapInput")?;
-221
         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)
         })?;

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

@@ -157,157 +232,232 @@

↥ Expand context

-157
+}
 #[derive(Debug)]
 struct MalformedRequestBodyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MalformedRequestBodyRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::malformed_request_body::MalformedRequestBodyInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::malformed_request_body::MalformedRequestBodyInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/MalformedRequestBody").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_request_body::MalformedRequestBodyInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-192
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_malformed_request_body::ser_malformed_request_body_input(
             &input,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-203
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-205
+    }
-206
+}
 #[derive(Debug)]
 struct MalformedRequestBodyEndpointParamsInterceptor;
-209
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedRequestBodyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedRequestBodyEndpointParamsInterceptor"

↧ Expand context

-213
+    }
-214
     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::<MalformedRequestBodyInput>()
             .ok_or("failed to downcast to MalformedRequestBodyInput")?;
-229
         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)
         })?;

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

@@ -175,175 +250,250 @@

↥ Expand context

                 let input_1 = &_input.short_in_path;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("short_in_path", "cannot be empty or unset"))?;
                 let mut short_in_path_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_1);
                 let short_in_path = short_in_path_encoder.encode();
                 if short_in_path.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "short_in_path",
                         "cannot be empty or unset",
                     ));
-186
+                }
                 ::std::write!(output, "/MalformedShort/{shortInPath}", shortInPath = short_in_path).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-189
+            }
             fn uri_query(
                 _input: &crate::operation::malformed_short::MalformedShortInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);

                 if let ::std::option::Option::Some(inner_2) = &_input.short_in_query {
-196
+                    {
                         query.push_kv("shortInQuery", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-198
+                    }
-199
+                }
                 ::std::result::Result::Ok(())
-201
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::malformed_short::MalformedShortInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_malformed_short::ser_malformed_short_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-212
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_malformed_short::ser_malformed_short_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-221
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-223
+    }
-224
+}
 #[derive(Debug)]
 struct MalformedShortEndpointParamsInterceptor;
-227
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MalformedShortEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MalformedShortEndpointParamsInterceptor"

↧ Expand context

-231
+    }
-232
     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::<MalformedShortInput>()
             .ok_or("failed to downcast to MalformedShortInput")?;
-247
         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)
         })?;

Client Test

Files changed: