Client Test

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/flattened_xml_map_with_xml_name.rs

@@ -202,202 +263,265 @@

-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct FlattenedXmlMapWithXmlNameEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for FlattenedXmlMapWithXmlNameEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "FlattenedXmlMapWithXmlNameEndpointParamsInterceptor"
-212
+    }
-213
     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::<FlattenedXmlMapWithXmlNameInput>()
             .ok_or("failed to downcast to FlattenedXmlMapWithXmlNameInput")?;
-228
         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(())
-237
+    }
-238
+}
-239
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-242
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod flattened_xml_map_with_xml_name_test {

↧ Expand context

-246
     /// Serializes flattened XML maps in requests that have xmlName on members
     /// Test ID: FlattenedXmlMapWithXmlName
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn flattened_xml_map_with_xml_name_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .flattened_xml_map_with_xml_name()
             .set_my_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("a".to_owned(), "A".to_owned());
                 ret.insert("b".to_owned(), "B".to_owned());
                 ret

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/flattened_xml_map_with_xml_namespace.rs

@@ -200,200 +261,263 @@

↥ Expand context

-200
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-202
+    }
-203
+}
 #[derive(Debug)]
 struct FlattenedXmlMapWithXmlNamespaceEndpointParamsInterceptor;
-206
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for FlattenedXmlMapWithXmlNamespaceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "FlattenedXmlMapWithXmlNamespaceEndpointParamsInterceptor"
-210
+    }
-211
     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::<FlattenedXmlMapWithXmlNamespaceInput>()
             .ok_or("failed to downcast to FlattenedXmlMapWithXmlNamespaceInput")?;
-226
         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(())
-235
+    }
-236
+}
-237
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-240
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod flattened_xml_map_with_xml_namespace_test {

↧ Expand context

-244
     /// Serializes flattened XML maps in responses that have xmlNamespace and xmlName on members
     /// Test ID: RestXmlFlattenedXmlMapWithXmlNamespace
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_flattened_xml_map_with_xml_namespace_response() {
         let expected_output = crate::operation::flattened_xml_map_with_xml_namespace::FlattenedXmlMapWithXmlNamespaceOutput::builder()
             .set_my_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("a".to_owned(), "A".to_owned());
                 ret.insert("b".to_owned(), "B".to_owned());
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "application/xml")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<FlattenedXmlMapWithXmlNamespaceOutput>\n    <KVP xmlns=\"https://the-member.example.com\">\n        <K xmlns=\"https://the-key.example.com\">a</K>\n        <V xmlns=\"https://the-value.example.com\">A</V>\n    </KVP>\n    <KVP xmlns=\"https://the-member.example.com\">\n        <K xmlns=\"https://the-key.example.com\">b</K>\n        <V xmlns=\"https://the-value.example.com\">B</V>\n    </KVP>\n</FlattenedXmlMapWithXmlNamespaceOutput>"))
                     .unwrap()
                     ).unwrap();

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/fractional_seconds.rs

@@ -196,196 +257,259 @@

↥ Expand context

-196
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-198
+    }
-199
+}
 #[derive(Debug)]
 struct FractionalSecondsEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for FractionalSecondsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "FractionalSecondsEndpointParamsInterceptor"
-206
+    }
-207
     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::<FractionalSecondsInput>()
             .ok_or("failed to downcast to FractionalSecondsInput")?;
-222
         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(())
-231
+    }
-232
+}
-233
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-236
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod fractional_seconds_test {

↧ Expand context

-240
     /// Ensures that clients can correctly parse datetime timestamps with fractional seconds
     /// Test ID: RestXmlDateTimeWithFractionalSeconds
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_date_time_with_fractional_seconds_response() {
         let expected_output = crate::operation::fractional_seconds::FractionalSecondsOutput::builder()
             .set_datetime(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 946845296, 0.123_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "application/xml")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "<FractionalSecondsOutput>\n    <datetime>2000-01-02T20:34:56.123Z</datetime>\n</FractionalSecondsOutput>\n",
                 ))
                 .unwrap(),
-259
+        )

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/greeting_with_errors.rs

@@ -196,196 +257,259 @@

↥ Expand context

-196
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-198
+    }
-199
+}
 #[derive(Debug)]
 struct GreetingWithErrorsEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GreetingWithErrorsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GreetingWithErrorsEndpointParamsInterceptor"
-206
+    }
-207
     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::<GreetingWithErrorsInput>()
             .ok_or("failed to downcast to GreetingWithErrorsInput")?;
-222
         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(())
-231
+    }
-232
+}
-233
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-236
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod greeting_with_errors_test {

↧ Expand context

-240
     /// Ensures that operations with errors successfully know how to deserialize the successful response
     /// Test ID: GreetingWithErrors
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn greeting_with_errors_response() {
         let expected_output = crate::operation::greeting_with_errors::GreetingWithErrorsOutput::builder()
             .set_greeting(::std::option::Option::Some("Hello".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("X-Greeting", "Hello")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-255
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-259

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/http_empty_prefix_headers.rs

@@ -197,197 +258,260 @@

↥ Expand context

-197
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-199
+    }
-200
+}
 #[derive(Debug)]
 struct HttpEmptyPrefixHeadersEndpointParamsInterceptor;
-203
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpEmptyPrefixHeadersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpEmptyPrefixHeadersEndpointParamsInterceptor"
-207
+    }
-208
     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::<HttpEmptyPrefixHeadersInput>()
             .ok_or("failed to downcast to HttpEmptyPrefixHeadersInput")?;
-223
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-232
+    }
-233
+}
-234
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-237
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_empty_prefix_headers_test {

↧ Expand context

-241
     /// Serializes all request headers, using specific when present
     /// Test ID: HttpEmptyPrefixHeadersRequestClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn http_empty_prefix_headers_request_client_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-253
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_empty_prefix_headers()
             .set_prefix_headers(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x-foo".to_owned().to_ascii_lowercase(), "Foo".to_owned());
                 ret.insert("hello".to_owned().to_ascii_lowercase(), "Hello".to_owned());

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/http_enum_payload.rs

@@ -196,196 +257,259 @@

↥ Expand context

-196
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-198
+    }
-199
+}
 #[derive(Debug)]
 struct HttpEnumPayloadEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpEnumPayloadEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpEnumPayloadEndpointParamsInterceptor"
-206
+    }
-207
     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::<HttpEnumPayloadInput>()
             .ok_or("failed to downcast to HttpEnumPayloadInput")?;
-222
         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(())
-231
+    }
-232
+}
-233
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-236
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_enum_payload_test {

↧ Expand context

-240
     /// Test ID: RestXmlEnumPayloadRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_enum_payload_request_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-250
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_enum_payload()
             .set_payload(::std::option::Option::Some(
                 "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
             ))
             .send()
             .await;
         let _ = dbg!(result);

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/http_payload_traits.rs

@@ -202,202 +263,265 @@

↥ Expand context

-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct HttpPayloadTraitsEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPayloadTraitsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPayloadTraitsEndpointParamsInterceptor"
-212
+    }
-213
     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::<HttpPayloadTraitsInput>()
             .ok_or("failed to downcast to HttpPayloadTraitsInput")?;
-228
         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(())
-237
+    }
-238
+}
-239
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-242
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_traits_test {

↧ Expand context

-246
     /// Serializes a blob in the HTTP payload
     /// Test ID: HttpPayloadTraitsWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn http_payload_traits_with_blob_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_payload_traits()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")))
             .send()
             .await;
         let _ = dbg!(result);

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/http_payload_traits_with_media_type.rs

@@ -207,207 +268,270 @@

↥ Expand context

-207
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-209
+    }
-210
+}
 #[derive(Debug)]
 struct HttpPayloadTraitsWithMediaTypeEndpointParamsInterceptor;
-213
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPayloadTraitsWithMediaTypeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPayloadTraitsWithMediaTypeEndpointParamsInterceptor"
-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::<HttpPayloadTraitsWithMediaTypeInput>()
             .ok_or("failed to downcast to HttpPayloadTraitsWithMediaTypeInput")?;
-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)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-242
+    }
-243
+}
-244
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-247
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_traits_with_media_type_test {

↧ Expand context

-251
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: HttpPayloadTraitsWithMediaTypeWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn http_payload_traits_with_media_type_with_blob_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-262
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_payload_traits_with_media_type()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")))
             .send()
             .await;
         let _ = dbg!(result);

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/http_payload_with_member_xml_name.rs

@@ -202,202 +263,265 @@

↥ Expand context

-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct HttpPayloadWithMemberXmlNameEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPayloadWithMemberXmlNameEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPayloadWithMemberXmlNameEndpointParamsInterceptor"
-212
+    }
-213
     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::<HttpPayloadWithMemberXmlNameInput>()
             .ok_or("failed to downcast to HttpPayloadWithMemberXmlNameInput")?;
-228
         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(())
-237
+    }
-238
+}
-239
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-242
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_with_member_xml_name_test {

↧ Expand context

-246
     /// Serializes a structure in the payload using a wrapper name based on member xmlName
     /// Test ID: HttpPayloadWithMemberXmlName
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn http_payload_with_member_xml_name_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_payload_with_member_xml_name()
             .set_nested(::std::option::Option::Some(
                 crate::types::PayloadWithXmlName::builder()
                     .set_name(::std::option::Option::Some("Phreddy".to_owned()))
                     .build(),
             ))

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/http_payload_with_structure.rs

@@ -202,202 +263,265 @@

↥ Expand context

-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct HttpPayloadWithStructureEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPayloadWithStructureEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPayloadWithStructureEndpointParamsInterceptor"
-212
+    }
-213
     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::<HttpPayloadWithStructureInput>()
             .ok_or("failed to downcast to HttpPayloadWithStructureInput")?;
-228
         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(())
-237
+    }
-238
+}
-239
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-242
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_with_structure_test {

↧ Expand context

-246
     /// Serializes a structure in the payload
     /// Test ID: HttpPayloadWithStructure
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn http_payload_with_structure_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_payload_with_structure()
             .set_nested(::std::option::Option::Some(
                 crate::types::NestedPayload::builder()
                     .set_greeting(::std::option::Option::Some("hello".to_owned()))
                     .set_name(::std::option::Option::Some("Phreddy".to_owned()))
                     .build(),

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/http_payload_with_union.rs

@@ -202,202 +263,265 @@

↥ Expand context

-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct HttpPayloadWithUnionEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPayloadWithUnionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPayloadWithUnionEndpointParamsInterceptor"
-212
+    }
-213
     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::<HttpPayloadWithUnionInput>()
             .ok_or("failed to downcast to HttpPayloadWithUnionInput")?;
-228
         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(())
-237
+    }
-238
+}
-239
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-242
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_with_union_test {

↧ Expand context

-246
     /// Serializes a union in the payload.
     /// Test ID: RestXmlHttpPayloadWithUnion
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_http_payload_with_union_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_payload_with_union()
             .set_nested(::std::option::Option::Some(crate::types::UnionPayload::Greeting("hello".to_owned())))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/http_payload_with_xml_name.rs

@@ -202,202 +263,265 @@

↥ Expand context

-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct HttpPayloadWithXmlNameEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPayloadWithXmlNameEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPayloadWithXmlNameEndpointParamsInterceptor"
-212
+    }
-213
     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::<HttpPayloadWithXmlNameInput>()
             .ok_or("failed to downcast to HttpPayloadWithXmlNameInput")?;
-228
         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(())
-237
+    }
-238
+}
-239
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-242
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_with_xml_name_test {

↧ Expand context

-246
     /// Serializes a structure in the payload using a wrapper name based on xmlName
     /// Test ID: HttpPayloadWithXmlName
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn http_payload_with_xml_name_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_payload_with_xml_name()
             .set_nested(::std::option::Option::Some(
                 crate::types::PayloadWithXmlName::builder()
                     .set_name(::std::option::Option::Some("Phreddy".to_owned()))
                     .build(),
             ))

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/http_payload_with_xml_namespace.rs

@@ -202,202 +263,265 @@

↥ Expand context

-202
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-204
+    }
-205
+}
 #[derive(Debug)]
 struct HttpPayloadWithXmlNamespaceEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPayloadWithXmlNamespaceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPayloadWithXmlNamespaceEndpointParamsInterceptor"
-212
+    }
-213
     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::<HttpPayloadWithXmlNamespaceInput>()
             .ok_or("failed to downcast to HttpPayloadWithXmlNamespaceInput")?;
-228
         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(())
-237
+    }
-238
+}
-239
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-242
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_with_xml_namespace_test {

↧ Expand context

-246
     /// Serializes a structure in the payload using a wrapper with an XML namespace
     /// Test ID: HttpPayloadWithXmlNamespace
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn http_payload_with_xml_namespace_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-257
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_payload_with_xml_namespace()
             .set_nested(::std::option::Option::Some(
                 crate::types::PayloadWithXmlNamespace::builder()
                     .set_name(::std::option::Option::Some("Phreddy".to_owned()))
                     .build(),
             ))

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/http_payload_with_xml_namespace_and_prefix.rs

@@ -206,206 +267,269 @@

↥ Expand context

-206
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-208
+    }
-209
+}
 #[derive(Debug)]
 struct HttpPayloadWithXmlNamespaceAndPrefixEndpointParamsInterceptor;
-212
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPayloadWithXmlNamespaceAndPrefixEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPayloadWithXmlNamespaceAndPrefixEndpointParamsInterceptor"
-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::<HttpPayloadWithXmlNamespaceAndPrefixInput>()
             .ok_or("failed to downcast to HttpPayloadWithXmlNamespaceAndPrefixInput")?;
-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(())
-241
+    }
-242
+}
-243
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-246
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_with_xml_namespace_and_prefix_test {

↧ Expand context

-250
     /// Serializes a structure in the payload using a wrapper with an XML namespace
     /// Test ID: HttpPayloadWithXmlNamespaceAndPrefix
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn http_payload_with_xml_namespace_and_prefix_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-261
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_payload_with_xml_namespace_and_prefix()
             .set_nested(::std::option::Option::Some(
                 crate::types::PayloadWithXmlNamespaceAndPrefix::builder()
                     .set_name(::std::option::Option::Some("Phreddy".to_owned()))
                     .build(),
             ))

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/http_prefix_headers.rs

@@ -197,197 +258,260 @@

↥ Expand context

-197
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-199
+    }
-200
+}
 #[derive(Debug)]
 struct HttpPrefixHeadersEndpointParamsInterceptor;
-203
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPrefixHeadersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPrefixHeadersEndpointParamsInterceptor"
-207
+    }
-208
     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::<HttpPrefixHeadersInput>()
             .ok_or("failed to downcast to HttpPrefixHeadersInput")?;
-223
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
-+
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
-+
         ::std::result::Result::Ok(())
-232
+    }
-233
+}
-234
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-237
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_prefix_headers_test {

↧ Expand context

-241
     /// Adds headers by prefix
     /// Test ID: HttpPrefixHeadersArePresent
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn http_prefix_headers_are_present_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-252
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_prefix_headers()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_foo_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("abc".to_owned().to_ascii_lowercase(), "Abc value".to_owned());
                 ret.insert("def".to_owned().to_ascii_lowercase(), "Def value".to_owned());

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/http_request_with_float_labels.rs

@@ -220,220 +281,283 @@

↥ Expand context

-220
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-222
+    }
-223
+}
 #[derive(Debug)]
 struct HttpRequestWithFloatLabelsEndpointParamsInterceptor;
-226
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpRequestWithFloatLabelsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpRequestWithFloatLabelsEndpointParamsInterceptor"
-230
+    }
-231
     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::<HttpRequestWithFloatLabelsInput>()
             .ok_or("failed to downcast to HttpRequestWithFloatLabelsInput")?;
-246
         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(())
-255
+    }
-256
+}
-257
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-260
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_float_labels_test {

↧ Expand context

-264
     /// Supports handling NaN float label values.
     /// Test ID: RestXmlSupportsNaNFloatLabels
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_xml_supports_na_n_float_labels_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .auth_scheme_resolver(crate::config::auth::NoAuthSchemeResolver)
             .endpoint_url("https://example.com");
-275
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client
             .http_request_with_float_labels()
             .set_float(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .set_double(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),

Client Test

Files changed: