Client Test

rev. 0b749be6d000fdc7ef59d1bc26f1dce00358d95c

Files changed:

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/datetime_offsets.rs

@@ -204,204 +301,301 @@

         let _input = context
             .input()
             .downcast_ref::<DatetimeOffsetsInput>()
             .ok_or("failed to downcast to DatetimeOffsetsInput")?;
-208
         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(())
-215
+    }
-216
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod datetime_offsets_test {
-220
     /// Ensures that clients can correctly parse datetime (timestamps) with offsets
     /// Test ID: Ec2QueryDateTimeWithNegativeOffset
     #[::tokio::test]

     #[::tracing_test::traced_test]
     async fn ec2_query_date_time_with_negative_offset_response() {
         let expected_output = crate::operation::datetime_offsets::DatetimeOffsetsOutput::builder()
             .set_datetime(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<DatetimeOffsetsResponse xmlns=\"https://example.com/\">\n    <datetime>2019-12-16T22:48:18-01:00</datetime>\n    <RequestId>requestid</RequestId>\n</DatetimeOffsetsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<DatetimeOffsetsResponse xmlns=\"https://example.com/\">\n    <datetime>2019-12-16T22:48:18-01:00</datetime>\n    <requestId>requestid</requestId>\n</DatetimeOffsetsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-239
         let op = crate::operation::datetime_offsets::DatetimeOffsets::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-245
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::datetime_offsets::DatetimeOffsetsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.datetime, expected_output.datetime, "Unexpected value for `datetime`");
-257
+    }
     /// Ensures that clients can correctly parse datetime (timestamps) with offsets
     /// Test ID: Ec2QueryDateTimeWithPositiveOffset
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_query_date_time_with_positive_offset_response() {
         let expected_output = crate::operation::datetime_offsets::DatetimeOffsetsOutput::builder()
             .set_datetime(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<DatetimeOffsetsResponse xmlns=\"https://example.com/\">\n    <datetime>2019-12-17T00:48:18+01:00</datetime>\n    <RequestId>requestid</RequestId>\n</DatetimeOffsetsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<DatetimeOffsetsResponse xmlns=\"https://example.com/\">\n    <datetime>2019-12-17T00:48:18+01:00</datetime>\n    <requestId>requestid</requestId>\n</DatetimeOffsetsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-276
         let op = crate::operation::datetime_offsets::DatetimeOffsets::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-282
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::datetime_offsets::DatetimeOffsetsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.datetime, expected_output.datetime, "Unexpected value for `datetime`");
-294
+    }
-295
+}
-296
 /// Error type for the `DatetimeOffsetsError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum DatetimeOffsetsError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/empty_input_and_empty_output.rs

@@ -231,231 +291,291 @@

↥ Expand context

     #[::tracing_test::traced_test]
     async fn ec2_query_empty_input_and_empty_output_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-235
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.empty_input_and_empty_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "Action=EmptyInputAndEmptyOutput&Version=2020-01-08",
             ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");

-251
+    }
     /// Empty output
     /// Test ID: Ec2QueryEmptyInputAndEmptyOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_query_empty_input_and_empty_output_response() {
         let expected_output = crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<EmptyInputAndEmptyOutputResponse xmlns=\"https://example.com/\">\n    <RequestId>requestid</RequestId>\n</EmptyInputAndEmptyOutputResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<EmptyInputAndEmptyOutputResponse xmlns=\"https://example.com/\">\n    <requestId>requestid</requestId>\n</EmptyInputAndEmptyOutputResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-266
         let op = crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutput::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-272
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput>()
             .unwrap();
-283
+    }
-284
+}
-285
 /// Error type for the `EmptyInputAndEmptyOutputError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum EmptyInputAndEmptyOutputError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

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

@@ -205,205 +265,265 @@

↥ Expand context

         let _input = context
             .input()
             .downcast_ref::<FractionalSecondsInput>()
             .ok_or("failed to downcast to FractionalSecondsInput")?;
-209
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-216
+    }
-217
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod fractional_seconds_test {
-221
     /// Ensures that clients can correctly parse datetime timestamps with fractional seconds
     /// Test ID: Ec2QueryDateTimeWithFractionalSeconds
     #[::tokio::test]

     #[::tracing_test::traced_test]
     async fn ec2_query_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", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<FractionalSecondsResponse xmlns=\"https://example.com/\">\n    <datetime>2000-01-02T20:34:56.123Z</datetime>\n    <RequestId>requestid</RequestId>\n</FractionalSecondsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<FractionalSecondsResponse xmlns=\"https://example.com/\">\n    <datetime>2000-01-02T20:34:56.123Z</datetime>\n    <requestId>requestid</requestId>\n</FractionalSecondsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-240
         let op = crate::operation::fractional_seconds::FractionalSeconds::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-246
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::fractional_seconds::FractionalSecondsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.datetime, expected_output.datetime, "Unexpected value for `datetime`");
-258
+    }
-259
+}
-260
 /// Error type for the `FractionalSecondsError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum FractionalSecondsError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

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

@@ -203,203 +340,340 @@

↥ Expand context

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GreetingWithErrorsInput>()
             .ok_or("failed to downcast to GreetingWithErrorsInput")?;
-209
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-216
+    }
-217
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod greeting_with_errors_test {
-221
     /// Ensures that operations with errors successfully know how to deserialize the successful response

     /// Test ID: Ec2GreetingWithErrors
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_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("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<GreetingWithErrorsResponse xmlns=\"https://example.com/\">\n    <greeting>Hello</greeting>\n    <RequestId>requestid</RequestId>\n</GreetingWithErrorsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<GreetingWithErrorsResponse xmlns=\"https://example.com/\">\n    <greeting>Hello</greeting>\n    <requestId>requestid</requestId>\n</GreetingWithErrorsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-238
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-244
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::greeting_with_errors::GreetingWithErrorsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.greeting, expected_output.greeting, "Unexpected value for `greeting`");
-256
+    }
     /// Parses simple XML errors
     /// Test ID: Ec2InvalidGreetingError
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_invalid_greeting_error_response() {
         let expected_output = crate::types::error::InvalidGreeting::builder()
             .set_message(::std::option::Option::Some("Hi".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(400)
                     .body(::aws_smithy_types::body::SdkBody::from("<Response>\n    <Errors>\n        <Error>\n            <Code>InvalidGreeting</Code>\n            <Message>Hi</Message>\n        </Error>\n    </Errors>\n    <RequestId>foo-id</RequestId>\n</Response>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<Response>\n    <Errors>\n        <Error>\n            <Code>InvalidGreeting</Code>\n            <Message>Hi</Message>\n        </Error>\n    </Errors>\n    <RequestID>foo-id</RequestID>\n</Response>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-273
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-279
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::InvalidGreeting(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-293
+        }
-294
+    }
     /// Test ID: Ec2ComplexError
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_complex_error_response() {
         let expected_output = crate::types::error::ComplexError::builder()
             .set_top_level(::std::option::Option::Some("Top level".to_owned()))
             .set_nested(::std::option::Option::Some(
                 crate::types::ComplexNestedErrorData::builder()
                     .set_foo(::std::option::Option::Some("bar".to_owned()))
                     .build(),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(400)
                     .body(::aws_smithy_types::body::SdkBody::from("<Response>\n    <Errors>\n        <Error>\n            <Code>ComplexError</Code>\n            <Message>Hi</Message>\n            <TopLevel>Top level</TopLevel>\n            <Nested>\n                <Foo>bar</Foo>\n            </Nested>\n        </Error>\n    </Errors>\n    <RequestId>foo-id</RequestId>\n</Response>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<Response>\n    <Errors>\n        <Error>\n            <Code>ComplexError</Code>\n            <Message>Hi</Message>\n            <TopLevel>Top level</TopLevel>\n            <Nested>\n                <Foo>bar</Foo>\n            </Nested>\n        </Error>\n    </Errors>\n    <RequestID>foo-id</RequestID>\n</Response>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-315
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-321
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::ComplexError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.top_level, expected_output.top_level, "Unexpected value for `top_level`");
             ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-336
+        }
-337
+    }
-338
+}
-339
 /// Error type for the `GreetingWithErrorsError` operation.

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/ignores_wrapping_xml_name.rs

@@ -209,209 +269,269 @@

↥ Expand context

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<IgnoresWrappingXmlNameInput>()
             .ok_or("failed to downcast to IgnoresWrappingXmlNameInput")?;
-215
         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(())
-222
+    }
-223
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod ignores_wrapping_xml_name_test {
-227
     /// The xmlName trait on the output structure is ignored in the ec2 protocol

     /// Test ID: Ec2IgnoresWrappingXmlName
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_ignores_wrapping_xml_name_response() {
         let expected_output = crate::operation::ignores_wrapping_xml_name::IgnoresWrappingXmlNameOutput::builder()
             .set_foo(::std::option::Option::Some("bar".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<IgnoresWrappingXmlNameResponse xmlns=\"https://example.com/\">\n    <foo>bar</foo>\n    <RequestId>requestid</RequestId>\n</IgnoresWrappingXmlNameResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<IgnoresWrappingXmlNameResponse xmlns=\"https://example.com/\">\n    <foo>bar</foo>\n    <requestId>requestid</requestId>\n</IgnoresWrappingXmlNameResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-244
         let op = crate::operation::ignores_wrapping_xml_name::IgnoresWrappingXmlName::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-250
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::ignores_wrapping_xml_name::IgnoresWrappingXmlNameOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
-262
+    }
-263
+}
-264
 /// Error type for the `IgnoresWrappingXmlNameError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum IgnoresWrappingXmlNameError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

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

@@ -227,227 +287,287 @@

↥ Expand context

         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
-229
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
         let result = client.no_input_and_output().send().await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "Action=NoInputAndOutput&Version=2020-01-08",
             ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
-245
+    }
     /// Empty output

     /// Test ID: Ec2QueryNoInputAndOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_query_no_input_and_output_response() {
         let expected_output = crate::operation::no_input_and_output::NoInputAndOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("Content-Type", "text/xml;charset=UTF-8")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "<NoInputAndOutputResponse xmlns=\"https://example.com/\">\n    <RequestId>requestid</RequestId>\n</NoInputAndOutputResponse>\n",
                     "<NoInputAndOutputResponse xmlns=\"https://example.com/\">\n    <requestId>requestid</requestId>\n</NoInputAndOutputResponse>\n",
                 ))
                 .unwrap(),
-260
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-264
         let op = crate::operation::no_input_and_output::NoInputAndOutput::new();
         let config = op.config().expect("the operation has config");
         let de = config

↧ Expand context

             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-270
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::no_input_and_output::NoInputAndOutputOutput>()
             .unwrap();
-281
+    }
-282
+}
-283
 /// Error type for the `NoInputAndOutputError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum NoInputAndOutputError {

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/recursive_xml_shapes.rs

@@ -222,222 +282,282 @@

↥ Expand context

     /// Serializes recursive structures
     /// Test ID: Ec2RecursiveShapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_recursive_shapes_response() {
         let expected_output = crate::operation::recursive_xml_shapes::RecursiveXmlShapesOutput::builder()
             .set_nested(::std::option::Option::Some(
                 crate::types::RecursiveXmlShapesOutputNested1::builder()
                     .set_foo(::std::option::Option::Some("Foo1".to_owned()))
                     .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
                         crate::types::RecursiveXmlShapesOutputNested2::builder()
                             .set_bar(::std::option::Option::Some("Bar1".to_owned()))
                             .set_recursive_member(::std::option::Option::Some(
                                 crate::types::RecursiveXmlShapesOutputNested1::builder()
                                     .set_foo(::std::option::Option::Some("Foo2".to_owned()))
                                     .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
                                         crate::types::RecursiveXmlShapesOutputNested2::builder()
                                             .set_bar(::std::option::Option::Some("Bar2".to_owned()))
                                             .build(),
                                     )))

                                     .build(),
                             ))
                             .build(),
                     )))
                     .build(),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<RecursiveXmlShapesResponse xmlns=\"https://example.com/\">\n    <nested>\n        <foo>Foo1</foo>\n        <nested>\n            <bar>Bar1</bar>\n            <recursiveMember>\n                <foo>Foo2</foo>\n                <nested>\n                    <bar>Bar2</bar>\n                </nested>\n            </recursiveMember>\n        </nested>\n    </nested>\n    <RequestId>requestid</RequestId>\n</RecursiveXmlShapesResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<RecursiveXmlShapesResponse xmlns=\"https://example.com/\">\n    <nested>\n        <foo>Foo1</foo>\n        <nested>\n            <bar>Bar1</bar>\n            <recursiveMember>\n                <foo>Foo2</foo>\n                <nested>\n                    <bar>Bar2</bar>\n                </nested>\n            </recursiveMember>\n        </nested>\n    </nested>\n    <requestId>requestid</requestId>\n</RecursiveXmlShapesResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-257
         let op = crate::operation::recursive_xml_shapes::RecursiveXmlShapes::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-263
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::recursive_xml_shapes::RecursiveXmlShapesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
-275
+    }
-276
+}
-277
 /// Error type for the `RecursiveXmlShapesError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum RecursiveXmlShapesError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/simple_scalar_xml_properties.rs

@@ -219,219 +279,279 @@

↥ Expand context

         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-222
+    }
-223
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod simple_scalar_xml_properties_test {
     use ::aws_smithy_protocol_test::FloatEquals;
-228
     /// Serializes simple scalar properties
     /// Test ID: Ec2SimpleScalarProperties
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_simple_scalar_properties_response() {
         let expected_output = crate::operation::simple_scalar_xml_properties::SimpleScalarXmlPropertiesOutput::builder()
             .set_string_value(::std::option::Option::Some("string".to_owned()))
             .set_empty_string_value(::std::option::Option::Some("".to_owned()))
             .set_true_boolean_value(::std::option::Option::Some(true))
             .set_false_boolean_value(::std::option::Option::Some(false))

             .set_byte_value(::std::option::Option::Some(1))
             .set_short_value(::std::option::Option::Some(2))
             .set_integer_value(::std::option::Option::Some(3))
             .set_long_value(::std::option::Option::Some(4))
             .set_float_value(::std::option::Option::Some(5.5_f32))
             .set_double_value(::std::option::Option::Some(6.5_f64))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<SimpleScalarXmlPropertiesResponse xmlns=\"https://example.com/\">\n    <stringValue>string</stringValue>\n    <emptyStringValue/>\n    <trueBooleanValue>true</trueBooleanValue>\n    <falseBooleanValue>false</falseBooleanValue>\n    <byteValue>1</byteValue>\n    <shortValue>2</shortValue>\n    <integerValue>3</integerValue>\n    <longValue>4</longValue>\n    <floatValue>5.5</floatValue>\n    <DoubleDribble>6.5</DoubleDribble>\n    <RequestId>requestid</RequestId>\n</SimpleScalarXmlPropertiesResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<SimpleScalarXmlPropertiesResponse xmlns=\"https://example.com/\">\n    <stringValue>string</stringValue>\n    <emptyStringValue/>\n    <trueBooleanValue>true</trueBooleanValue>\n    <falseBooleanValue>false</falseBooleanValue>\n    <byteValue>1</byteValue>\n    <shortValue>2</shortValue>\n    <integerValue>3</integerValue>\n    <longValue>4</longValue>\n    <floatValue>5.5</floatValue>\n    <DoubleDribble>6.5</DoubleDribble>\n    <requestId>requestid</requestId>\n</SimpleScalarXmlPropertiesResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-254
         let op = crate::operation::simple_scalar_xml_properties::SimpleScalarXmlProperties::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-260
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::simple_scalar_xml_properties::SimpleScalarXmlPropertiesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
         ::pretty_assertions::assert_eq!(
             parsed.empty_string_value,
             expected_output.empty_string_value,
             "Unexpected value for `empty_string_value`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.true_boolean_value,
             expected_output.true_boolean_value,

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_blobs.rs

@@ -191,191 +251,251 @@

↥ Expand context

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<XmlBlobsInput>()
             .ok_or("failed to downcast to XmlBlobsInput")?;
-197
         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(())
-204
+    }
-205
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_blobs_test {
-209
     /// Blobs are base64 encoded

     /// Test ID: Ec2XmlBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_xml_blobs_response() {
         let expected_output = crate::operation::xml_blobs::XmlBlobsOutput::builder()
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("value")))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlBlobsResponse xmlns=\"https://example.com/\">\n    <data>dmFsdWU=</data>\n    <RequestId>requestid</RequestId>\n</XmlBlobsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlBlobsResponse xmlns=\"https://example.com/\">\n    <data>dmFsdWU=</data>\n    <requestId>requestid</requestId>\n</XmlBlobsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-226
         let op = crate::operation::xml_blobs::XmlBlobs::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-232
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_blobs::XmlBlobsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.data, expected_output.data, "Unexpected value for `data`");
-244
+    }
-245
+}
-246
 /// Error type for the `XmlBlobsError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum XmlBlobsError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_empty_blobs.rs

@@ -202,202 +297,297 @@

↥ Expand context

         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<XmlEmptyBlobsInput>()
             .ok_or("failed to downcast to XmlEmptyBlobsInput")?;
-208
         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(())
-215
+    }
-216
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_empty_blobs_test {
-220
     /// Empty blobs are deserialized as empty string

     /// Test ID: Ec2XmlEmptyBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_xml_empty_blobs_response() {
         let expected_output = crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput::builder()
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("")))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlEmptyBlobsResponse xmlns=\"https://example.com/\">\n    <data></data>\n    <RequestId>requestid</RequestId>\n</XmlEmptyBlobsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlEmptyBlobsResponse xmlns=\"https://example.com/\">\n    <data></data>\n    <requestId>requestid</requestId>\n</XmlEmptyBlobsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-237
         let op = crate::operation::xml_empty_blobs::XmlEmptyBlobs::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-243
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.data, expected_output.data, "Unexpected value for `data`");
-255
+    }
     /// Empty self closed blobs are deserialized as empty string
     /// Test ID: Ec2XmlEmptySelfClosedBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_xml_empty_self_closed_blobs_response() {
         let expected_output = crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput::builder()
             .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("")))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlEmptyBlobsResponse xmlns=\"https://example.com/\">\n    <data/>\n    <RequestId>requestid</RequestId>\n</XmlEmptyBlobsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlEmptyBlobsResponse xmlns=\"https://example.com/\">\n    <data/>\n    <requestId>requestid</requestId>\n</XmlEmptyBlobsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-272
         let op = crate::operation::xml_empty_blobs::XmlEmptyBlobs::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-278
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.data, expected_output.data, "Unexpected value for `data`");
-290
+    }
-291
+}
-292
 /// Error type for the `XmlEmptyBlobsError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum XmlEmptyBlobsError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_enums.rs

@@ -219,219 +279,279 @@

↥ Expand context

             .set_foo_enum2(::std::option::Option::Some(
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum3(::std::option::Option::Some(
                 "1".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ))
             .set_foo_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .set_foo_enum_set(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .set_foo_enum_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "hi".to_owned(),
                     "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 );

                 ret.insert(
                     "zero".to_owned(),
                     "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 );
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlEnumsResponse xmlns=\"https://example.com/\">\n    <fooEnum1>Foo</fooEnum1>\n    <fooEnum2>0</fooEnum2>\n    <fooEnum3>1</fooEnum3>\n    <fooEnumList>\n        <member>Foo</member>\n        <member>0</member>\n    </fooEnumList>\n    <fooEnumSet>\n        <member>Foo</member>\n        <member>0</member>\n    </fooEnumSet>\n    <fooEnumMap>\n        <entry>\n            <key>hi</key>\n            <value>Foo</value>\n        </entry>\n        <entry>\n            <key>zero</key>\n            <value>0</value>\n        </entry>\n    </fooEnumMap>\n    <RequestId>requestid</RequestId>\n</XmlEnumsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlEnumsResponse xmlns=\"https://example.com/\">\n    <fooEnum1>Foo</fooEnum1>\n    <fooEnum2>0</fooEnum2>\n    <fooEnum3>1</fooEnum3>\n    <fooEnumList>\n        <member>Foo</member>\n        <member>0</member>\n    </fooEnumList>\n    <fooEnumSet>\n        <member>Foo</member>\n        <member>0</member>\n    </fooEnumSet>\n    <fooEnumMap>\n        <entry>\n            <key>hi</key>\n            <value>Foo</value>\n        </entry>\n        <entry>\n            <key>zero</key>\n            <value>0</value>\n        </entry>\n    </fooEnumMap>\n    <requestId>requestid</requestId>\n</XmlEnumsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-254
         let op = crate::operation::xml_enums::XmlEnums::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-260
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_enums::XmlEnumsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.foo_enum1, expected_output.foo_enum1, "Unexpected value for `foo_enum1`");
         ::pretty_assertions::assert_eq!(parsed.foo_enum2, expected_output.foo_enum2, "Unexpected value for `foo_enum2`");
         ::pretty_assertions::assert_eq!(parsed.foo_enum3, expected_output.foo_enum3, "Unexpected value for `foo_enum3`");
         ::pretty_assertions::assert_eq!(
             parsed.foo_enum_list,
             expected_output.foo_enum_list,
             "Unexpected value for `foo_enum_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.foo_enum_set, expected_output.foo_enum_set, "Unexpected value for `foo_enum_set`");

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_int_enums.rs

@@ -212,212 +272,272 @@

↥ Expand context

         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-215
+    }
-216
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_int_enums_test {
-220
     /// Serializes simple scalar properties
     /// Test ID: Ec2XmlIntEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_xml_int_enums_response() {
         let expected_output = crate::operation::xml_int_enums::XmlIntEnumsOutput::builder()
             .set_int_enum1(::std::option::Option::Some(1))
             .set_int_enum2(::std::option::Option::Some(2))
             .set_int_enum3(::std::option::Option::Some(3))
             .set_int_enum_list(::std::option::Option::Some(vec![1, 2]))
             .set_int_enum_set(::std::option::Option::Some(vec![1, 2]))

             .set_int_enum_map(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("a".to_owned(), 1);
                 ret.insert("b".to_owned(), 2);
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlIntEnumsResponse xmlns=\"https://example.com/\">\n    <intEnum1>1</intEnum1>\n    <intEnum2>2</intEnum2>\n    <intEnum3>3</intEnum3>\n    <intEnumList>\n        <member>1</member>\n        <member>2</member>\n    </intEnumList>\n    <intEnumSet>\n        <member>1</member>\n        <member>2</member>\n    </intEnumSet>\n    <intEnumMap>\n        <entry>\n            <key>a</key>\n            <value>1</value>\n        </entry>\n        <entry>\n            <key>b</key>\n            <value>2</value>\n        </entry>\n    </intEnumMap>\n    <RequestId>requestid</RequestId>\n</XmlIntEnumsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlIntEnumsResponse xmlns=\"https://example.com/\">\n    <intEnum1>1</intEnum1>\n    <intEnum2>2</intEnum2>\n    <intEnum3>3</intEnum3>\n    <intEnumList>\n        <member>1</member>\n        <member>2</member>\n    </intEnumList>\n    <intEnumSet>\n        <member>1</member>\n        <member>2</member>\n    </intEnumSet>\n    <intEnumMap>\n        <entry>\n            <key>a</key>\n            <value>1</value>\n        </entry>\n        <entry>\n            <key>b</key>\n            <value>2</value>\n        </entry>\n    </intEnumMap>\n    <requestId>requestid</requestId>\n</XmlIntEnumsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-247
         let op = crate::operation::xml_int_enums::XmlIntEnums::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-253
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_int_enums::XmlIntEnumsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.int_enum1, expected_output.int_enum1, "Unexpected value for `int_enum1`");
         ::pretty_assertions::assert_eq!(parsed.int_enum2, expected_output.int_enum2, "Unexpected value for `int_enum2`");
         ::pretty_assertions::assert_eq!(parsed.int_enum3, expected_output.int_enum3, "Unexpected value for `int_enum3`");
         ::pretty_assertions::assert_eq!(
             parsed.int_enum_list,
             expected_output.int_enum_list,
             "Unexpected value for `int_enum_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.int_enum_set, expected_output.int_enum_set, "Unexpected value for `int_enum_set`");

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_lists.rs

@@ -222,222 +282,282 @@

↥ Expand context

                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ]))
             .set_enum_list(::std::option::Option::Some(vec![
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
                 "0".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             ]))
             .set_int_enum_list(::std::option::Option::Some(vec![1, 2]))
             .set_nested_string_list(::std::option::Option::Some(vec![
                 vec!["foo".to_owned(), "bar".to_owned()],
                 vec!["baz".to_owned(), "qux".to_owned()],
             ]))
             .set_renamed_list_members(::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]))
             .set_flattened_list(::std::option::Option::Some(vec!["hi".to_owned(), "bye".to_owned()]))
             .set_flattened_list2(::std::option::Option::Some(vec!["yep".to_owned(), "nope".to_owned()]))
             .set_flattened_list_with_member_namespace(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned()]))
             .set_flattened_list_with_namespace(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned()]))
             .set_structure_list(::std::option::Option::Some(vec![
                 crate::types::StructureListMember::builder()
                     .set_a(::std::option::Option::Some("1".to_owned()))
                     .set_b(::std::option::Option::Some("2".to_owned()))

                     .build(),
                 crate::types::StructureListMember::builder()
                     .set_a(::std::option::Option::Some("3".to_owned()))
                     .set_b(::std::option::Option::Some("4".to_owned()))
                     .build(),
             ]))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlListsResponse xmlns=\"https://example.com/\">\n    <stringList>\n        <member>foo</member>\n        <member>bar</member>\n    </stringList>\n    <stringSet>\n        <member>foo</member>\n        <member>bar</member>\n    </stringSet>\n    <integerList>\n        <member>1</member>\n        <member>2</member>\n    </integerList>\n    <booleanList>\n        <member>true</member>\n        <member>false</member>\n    </booleanList>\n    <timestampList>\n        <member>2014-04-29T18:30:38Z</member>\n        <member>2014-04-29T18:30:38Z</member>\n    </timestampList>\n    <enumList>\n        <member>Foo</member>\n        <member>0</member>\n    </enumList>\n    <intEnumList>\n        <member>1</member>\n        <member>2</member>\n    </intEnumList>\n    <nestedStringList>\n        <member>\n            <member>foo</member>\n            <member>bar</member>\n        </member>\n        <member>\n            <member>baz</member>\n            <member>qux</member>\n        </member>\n    </nestedStringList>\n    <renamed>\n        <item>foo</item>\n        <item>bar</item>\n    </renamed>\n    <flattenedList>hi</flattenedList>\n    <flattenedList>bye</flattenedList>\n    <customName>yep</customName>\n    <customName>nope</customName>\n    <flattenedListWithMemberNamespace xmlns=\"https://xml-member.example.com\">a</flattenedListWithMemberNamespace>\n    <flattenedListWithMemberNamespace xmlns=\"https://xml-member.example.com\">b</flattenedListWithMemberNamespace>\n    <flattenedListWithNamespace>a</flattenedListWithNamespace>\n    <flattenedListWithNamespace>b</flattenedListWithNamespace>\n    <myStructureList>\n        <item>\n            <value>1</value>\n            <other>2</other>\n        </item>\n        <item>\n            <value>3</value>\n            <other>4</other>\n        </item>\n    </myStructureList>\n    <RequestId>requestid</RequestId>\n</XmlListsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlListsResponse xmlns=\"https://example.com/\">\n    <stringList>\n        <member>foo</member>\n        <member>bar</member>\n    </stringList>\n    <stringSet>\n        <member>foo</member>\n        <member>bar</member>\n    </stringSet>\n    <integerList>\n        <member>1</member>\n        <member>2</member>\n    </integerList>\n    <booleanList>\n        <member>true</member>\n        <member>false</member>\n    </booleanList>\n    <timestampList>\n        <member>2014-04-29T18:30:38Z</member>\n        <member>2014-04-29T18:30:38Z</member>\n    </timestampList>\n    <enumList>\n        <member>Foo</member>\n        <member>0</member>\n    </enumList>\n    <intEnumList>\n        <member>1</member>\n        <member>2</member>\n    </intEnumList>\n    <nestedStringList>\n        <member>\n            <member>foo</member>\n            <member>bar</member>\n        </member>\n        <member>\n            <member>baz</member>\n            <member>qux</member>\n        </member>\n    </nestedStringList>\n    <renamed>\n        <item>foo</item>\n        <item>bar</item>\n    </renamed>\n    <flattenedList>hi</flattenedList>\n    <flattenedList>bye</flattenedList>\n    <customName>yep</customName>\n    <customName>nope</customName>\n    <flattenedListWithMemberNamespace xmlns=\"https://xml-member.example.com\">a</flattenedListWithMemberNamespace>\n    <flattenedListWithMemberNamespace xmlns=\"https://xml-member.example.com\">b</flattenedListWithMemberNamespace>\n    <flattenedListWithNamespace>a</flattenedListWithNamespace>\n    <flattenedListWithNamespace>b</flattenedListWithNamespace>\n    <myStructureList>\n        <item>\n            <value>1</value>\n            <other>2</other>\n        </item>\n        <item>\n            <value>3</value>\n            <other>4</other>\n        </item>\n    </myStructureList>\n    <requestId>requestid</requestId>\n</XmlListsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-257
         let op = crate::operation::xml_lists::XmlLists::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-263
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_lists::XmlListsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.string_list, expected_output.string_list, "Unexpected value for `string_list`");
         ::pretty_assertions::assert_eq!(parsed.string_set, expected_output.string_set, "Unexpected value for `string_set`");
         ::pretty_assertions::assert_eq!(parsed.integer_list, expected_output.integer_list, "Unexpected value for `integer_list`");
         ::pretty_assertions::assert_eq!(parsed.boolean_list, expected_output.boolean_list, "Unexpected value for `boolean_list`");
         ::pretty_assertions::assert_eq!(
             parsed.timestamp_list,
             expected_output.timestamp_list,
             "Unexpected value for `timestamp_list`"
         );

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_namespaces.rs

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

↥ Expand context

             .ok_or("failed to downcast to XmlNamespacesInput")?;
-208
         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(())
-215
+    }
-216
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_namespaces_test {
-220
     /// Serializes XML namespaces
     /// Test ID: Ec2XmlNamespaces
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_xml_namespaces_response() {
         let expected_output = crate::operation::xml_namespaces::XmlNamespacesOutput::builder()

             .set_nested(::std::option::Option::Some(
                 crate::types::XmlNamespaceNested::builder()
                     .set_foo(::std::option::Option::Some("Foo".to_owned()))
                     .set_values(::std::option::Option::Some(vec!["Bar".to_owned(), "Baz".to_owned()]))
                     .build(),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlNamespacesResponse xmlns=\"https://example.com/\">\n    <nested>\n        <foo xmlns:baz=\"http://baz.com\">Foo</foo>\n        <values xmlns=\"http://qux.com\">\n            <member xmlns=\"http://bux.com\">Bar</member>\n            <member xmlns=\"http://bux.com\">Baz</member>\n        </values>\n    </nested>\n    <RequestId>requestid</RequestId>\n</XmlNamespacesResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlNamespacesResponse xmlns=\"https://example.com/\">\n    <nested>\n        <foo xmlns:baz=\"http://baz.com\">Foo</foo>\n        <values xmlns=\"http://qux.com\">\n            <member xmlns=\"http://bux.com\">Bar</member>\n            <member xmlns=\"http://bux.com\">Baz</member>\n        </values>\n    </nested>\n    <requestId>requestid</requestId>\n</XmlNamespacesResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-242
         let op = crate::operation::xml_namespaces::XmlNamespaces::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-248
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_namespaces::XmlNamespacesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
-260
+    }
-261
+}
-262
 /// Error type for the `XmlNamespacesError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum XmlNamespacesError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/operation/xml_timestamps.rs

@@ -204,204 +618,618 @@

↥ Expand context

         let _input = context
             .input()
             .downcast_ref::<XmlTimestampsInput>()
             .ok_or("failed to downcast to XmlTimestampsInput")?;
-208
         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(())
-215
+    }
-216
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod xml_timestamps_test {
-220
     /// Tests how normal timestamps are serialized
     /// Test ID: Ec2XmlTimestamps
     #[::tokio::test]

     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_normal(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <normal>2014-04-29T18:30:38Z</normal>\n    <RequestId>requestid</RequestId>\n</XmlTimestampsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <normal>2014-04-29T18:30:38Z</normal>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-239
         let op = crate::operation::xml_timestamps::XmlTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-245
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-279
+    }
     /// Ensures that the timestampFormat of date-time works like normal timestamps
     /// Test ID: Ec2XmlTimestampsWithDateTimeFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_with_date_time_format_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <dateTime>2014-04-29T18:30:38Z</dateTime>\n    <RequestId>requestid</RequestId>\n</XmlTimestampsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <dateTime>2014-04-29T18:30:38Z</dateTime>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-298
         let op = crate::operation::xml_timestamps::XmlTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-304
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-338
+    }
     /// Ensures that the timestampFormat of date-time on the target shape works like normal timestamps
     /// Test ID: Ec2XmlTimestampsWithDateTimeOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_with_date_time_on_target_format_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_date_time_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <dateTimeOnTarget>2014-04-29T18:30:38Z</dateTimeOnTarget>\n    <RequestId>requestid</RequestId>\n</XmlTimestampsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <dateTimeOnTarget>2014-04-29T18:30:38Z</dateTimeOnTarget>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-357
         let op = crate::operation::xml_timestamps::XmlTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-363
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-397
+    }
     /// Ensures that the timestampFormat of epoch-seconds works
     /// Test ID: Ec2XmlTimestampsWithEpochSecondsFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_with_epoch_seconds_format_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <epochSeconds>1398796238</epochSeconds>\n    <RequestId>requestid</RequestId>\n</XmlTimestampsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <epochSeconds>1398796238</epochSeconds>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-416
         let op = crate::operation::xml_timestamps::XmlTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-422
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-456
+    }
     /// Ensures that the timestampFormat of epoch-seconds on the target shape works
     /// Test ID: Ec2XmlTimestampsWithEpochSecondsOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_with_epoch_seconds_on_target_format_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_epoch_seconds_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <epochSecondsOnTarget>1398796238</epochSecondsOnTarget>\n    <RequestId>requestid</RequestId>\n</XmlTimestampsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <epochSecondsOnTarget>1398796238</epochSecondsOnTarget>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-475
         let op = crate::operation::xml_timestamps::XmlTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-481
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-515
+    }
     /// Ensures that the timestampFormat of http-date works
     /// Test ID: Ec2XmlTimestampsWithHttpDateFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_with_http_date_format_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <httpDate>Tue, 29 Apr 2014 18:30:38 GMT</httpDate>\n    <RequestId>requestid</RequestId>\n</XmlTimestampsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <httpDate>Tue, 29 Apr 2014 18:30:38 GMT</httpDate>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-534
         let op = crate::operation::xml_timestamps::XmlTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-540
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-574
+    }
     /// Ensures that the timestampFormat of http-date on the target shape works
     /// Test ID: Ec2XmlTimestampsWithHttpDateOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn ec2_xml_timestamps_with_http_date_on_target_format_response() {
         let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
             .set_http_date_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .header("Content-Type", "text/xml;charset=UTF-8")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <httpDateOnTarget>Tue, 29 Apr 2014 18:30:38 GMT</httpDateOnTarget>\n    <RequestId>requestid</RequestId>\n</XmlTimestampsResponse>\n"))
                     .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n    <httpDateOnTarget>Tue, 29 Apr 2014 18:30:38 GMT</httpDateOnTarget>\n    <requestId>requestid</requestId>\n</XmlTimestampsResponse>\n"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-593
         let op = crate::operation::xml_timestamps::XmlTimestamps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");

↧ Expand context

-599
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,
             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,

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