Client Test

Client Test

rev. 9f5fb9826a6af51ebfb3736d0a778b00ec7b08b3

Files changed:

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

@@ -274,274 +338,339 @@
  294    294   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  295    295   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  296    296   
        })?;
  297    297   
        cfg.interceptor_state()
  298    298   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  299    299   
        ::std::result::Result::Ok(())
  300    300   
    }
  301    301   
}
  302    302   
#[allow(unreachable_code, unused_variables)]
  303    303   
#[cfg(test)]
  304         -
mod http_request_with_labels_and_timestamp_format_request_test {
         304  +
mod http_request_with_labels_and_timestamp_format_test {
         305  +
  305    306   
    /// Serializes different timestamp formats in URI labels
  306    307   
    /// Test ID: HttpRequestWithLabelsAndTimestampFormat
  307    308   
    #[::tokio::test]
  308         -
    #[allow(unused_mut)]
         309  +
    #[::tracing_test::traced_test]
  309    310   
    async fn http_request_with_labels_and_timestamp_format_request() {
  310    311   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  311    312   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  312    313   
  313    314   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  314    315   
        let result = client
  315    316   
            .http_request_with_labels_and_timestamp_format()
  316    317   
            .set_member_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
  317    318   
                1576540098, 0_f64,
  318    319   
            )))

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

@@ -187,187 +251,252 @@
  207    207   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  208    208   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  209    209   
        })?;
  210    210   
        cfg.interceptor_state()
  211    211   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  212    212   
        ::std::result::Result::Ok(())
  213    213   
    }
  214    214   
}
  215    215   
#[allow(unreachable_code, unused_variables)]
  216    216   
#[cfg(test)]
  217         -
mod http_response_code_request_test {
         217  +
mod http_response_code_test {
         218  +
  218    219   
    /// Binds the http response code to an output structure.
  219    220   
    /// Test ID: RestXmlHttpResponseCode
  220    221   
    #[::tokio::test]
  221         -
    #[allow(unused_mut)]
         222  +
    #[::tracing_test::traced_test]
  222    223   
    async fn rest_xml_http_response_code_response() {
  223    224   
        let expected_output = crate::operation::http_response_code::HttpResponseCodeOutput::builder()
  224    225   
            .set_status(::std::option::Option::Some(201))
  225    226   
            .build();
  226    227   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
  227    228   
            ::http::response::Builder::new()
  228    229   
                .header("Content-Type", "application/xml")
  229    230   
                .status(201)
  230    231   
                .body(::aws_smithy_types::body::SdkBody::from(""))
  231    232   
                .unwrap(),

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

@@ -193,193 +281,282 @@
  213    213   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  214    214   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  215    215   
        })?;
  216    216   
        cfg.interceptor_state()
  217    217   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  218    218   
        ::std::result::Result::Ok(())
  219    219   
    }
  220    220   
}
  221    221   
#[allow(unreachable_code, unused_variables)]
  222    222   
#[cfg(test)]
  223         -
mod http_string_payload_request_test {
         223  +
mod http_string_payload_test {
         224  +
  224    225   
    /// Test ID: RestXmlStringPayloadRequest
  225    226   
    #[::tokio::test]
  226         -
    #[allow(unused_mut)]
         227  +
    #[::tracing_test::traced_test]
  227    228   
    async fn rest_xml_string_payload_request_request() {
  228    229   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  229    230   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  230    231   
  231    232   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  232    233   
        let result = client
  233    234   
            .http_string_payload()
  234    235   
            .set_payload(::std::option::Option::Some("rawstring".to_owned()))
  235    236   
            .send()
  236    237   
            .await;
  237    238   
        let _ = dbg!(result);
  238    239   
        let http_request = request_receiver.expect_request();
  239    240   
        let body = http_request.body().bytes().expect("body should be strict");
  240    241   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
  241    242   
            body,
  242    243   
            "rawstring",
  243    244   
            ::aws_smithy_protocol_test::MediaType::from("unknown"),
  244    245   
        ));
  245    246   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  246    247   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  247    248   
        ::pretty_assertions::assert_eq!(uri.path(), "/StringPayload", "path was incorrect");
  248    249   
    }
  249    250   
    /// Test ID: RestXmlStringPayloadResponse
  250    251   
    #[::tokio::test]
  251         -
    #[allow(unused_mut)]
         252  +
    #[::tracing_test::traced_test]
  252    253   
    async fn rest_xml_string_payload_response_response() {
  253    254   
        let expected_output = crate::operation::http_string_payload::HttpStringPayloadOutput::builder()
  254    255   
            .set_payload(::std::option::Option::Some("rawstring".to_owned()))
  255    256   
            .build();
  256    257   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
  257    258   
            ::http::response::Builder::new()
  258    259   
                .status(200)
  259    260   
                .body(::aws_smithy_types::body::SdkBody::from("rawstring"))
  260    261   
                .unwrap(),
  261    262   
        )

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

@@ -193,193 +257,258 @@
  213    213   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  214    214   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  215    215   
        })?;
  216    216   
        cfg.interceptor_state()
  217    217   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  218    218   
        ::std::result::Result::Ok(())
  219    219   
    }
  220    220   
}
  221    221   
#[allow(unreachable_code, unused_variables)]
  222    222   
#[cfg(test)]
  223         -
mod ignore_query_params_in_response_request_test {
         223  +
mod ignore_query_params_in_response_test {
         224  +
  224    225   
    /// Query parameters must be ignored when serializing the output of an operation
  225    226   
    /// Test ID: IgnoreQueryParamsInResponse
  226    227   
    #[::tokio::test]
  227         -
    #[allow(unused_mut)]
         228  +
    #[::tracing_test::traced_test]
  228    229   
    async fn ignore_query_params_in_response_response() {
  229    230   
        let expected_output = crate::operation::ignore_query_params_in_response::IgnoreQueryParamsInResponseOutput::builder()
  230    231   
            .set_baz(::std::option::Option::Some("bam".to_owned()))
  231    232   
            .build();
  232    233   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
  233    234   
            ::http::response::Builder::new()
  234    235   
                .header("Content-Type", "application/xml")
  235    236   
                .status(200)
  236    237   
                .body(::aws_smithy_types::body::SdkBody::from(
  237    238   
                    "<IgnoreQueryParamsInResponseOutput><baz>bam</baz></IgnoreQueryParamsInResponseOutput>",

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

@@ -194,194 +502,503 @@
  214    214   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  215    215   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  216    216   
        })?;
  217    217   
        cfg.interceptor_state()
  218    218   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  219    219   
        ::std::result::Result::Ok(())
  220    220   
    }
  221    221   
}
  222    222   
#[allow(unreachable_code, unused_variables)]
  223    223   
#[cfg(test)]
  224         -
mod input_and_output_with_headers_request_test {
         224  +
mod input_and_output_with_headers_test {
  225    225   
    use ::aws_smithy_protocol_test::FloatEquals;
         226  +
  226    227   
    /// Tests requests with string header bindings
  227    228   
    /// Test ID: InputAndOutputWithStringHeaders
  228    229   
    #[::tokio::test]
  229         -
    #[allow(unused_mut)]
         230  +
    #[::tracing_test::traced_test]
  230    231   
    async fn input_and_output_with_string_headers_request() {
  231    232   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  232    233   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  233    234   
  234    235   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  235    236   
        let result = client
  236    237   
            .input_and_output_with_headers()
  237    238   
            .set_header_string(::std::option::Option::Some("Hello".to_owned()))
  238    239   
            .set_header_string_list(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
  239    240   
            .set_header_string_set(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
  240    241   
            .send()
  241    242   
            .await;
  242    243   
        let _ = dbg!(result);
  243    244   
        let http_request = request_receiver.expect_request();
  244    245   
        let expected_headers = [("X-String", "Hello"), ("X-StringList", "a, b, c"), ("X-StringSet", "a, b, c")];
  245    246   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  246    247   
        let body = http_request.body().bytes().expect("body should be strict");
  247    248   
        // No body
  248    249   
        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
  249    250   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  250    251   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  251    252   
        ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
  252    253   
    }
  253    254   
    /// Tests requests with numeric header bindings
  254    255   
    /// Test ID: InputAndOutputWithNumericHeaders
  255    256   
    #[::tokio::test]
  256         -
    #[allow(unused_mut)]
         257  +
    #[::tracing_test::traced_test]
  257    258   
    async fn input_and_output_with_numeric_headers_request() {
  258    259   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  259    260   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  260    261   
  261    262   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  262    263   
        let result = client
  263    264   
            .input_and_output_with_headers()
  264    265   
            .set_header_byte(::std::option::Option::Some(1))
  265    266   
            .set_header_short(::std::option::Option::Some(123))
  266    267   
            .set_header_integer(::std::option::Option::Some(123))
  267    268   
            .set_header_long(::std::option::Option::Some(123))
  268    269   
            .set_header_float(::std::option::Option::Some(1.1_f32))
  269    270   
            .set_header_double(::std::option::Option::Some(1.1_f64))
  270    271   
            .set_header_integer_list(::std::option::Option::Some(vec![1, 2, 3]))
  271    272   
            .send()
  272    273   
            .await;
  273    274   
        let _ = dbg!(result);
  274    275   
        let http_request = request_receiver.expect_request();
  275    276   
        let expected_headers = [
  276    277   
            ("X-Byte", "1"),
  277    278   
            ("X-Double", "1.1"),
  278    279   
            ("X-Float", "1.1"),
  279    280   
            ("X-Integer", "123"),
  280    281   
            ("X-IntegerList", "1, 2, 3"),
  281    282   
            ("X-Long", "123"),
  282    283   
            ("X-Short", "123"),
  283    284   
        ];
  284    285   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  285    286   
        let body = http_request.body().bytes().expect("body should be strict");
  286    287   
        // No body
  287    288   
        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
  288    289   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  289    290   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  290    291   
        ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
  291    292   
    }
  292    293   
    /// Tests requests with boolean header bindings
  293    294   
    /// Test ID: InputAndOutputWithBooleanHeaders
  294    295   
    #[::tokio::test]
  295         -
    #[allow(unused_mut)]
         296  +
    #[::tracing_test::traced_test]
  296    297   
    async fn input_and_output_with_boolean_headers_request() {
  297    298   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  298    299   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  299    300   
  300    301   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  301    302   
        let result = client
  302    303   
            .input_and_output_with_headers()
  303    304   
            .set_header_true_bool(::std::option::Option::Some(true))
  304    305   
            .set_header_false_bool(::std::option::Option::Some(false))
  305    306   
            .set_header_boolean_list(::std::option::Option::Some(vec![true, false, true]))
  306    307   
            .send()
  307    308   
            .await;
  308    309   
        let _ = dbg!(result);
  309    310   
        let http_request = request_receiver.expect_request();
  310    311   
        let expected_headers = [("X-Boolean1", "true"), ("X-Boolean2", "false"), ("X-BooleanList", "true, false, true")];
  311    312   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  312    313   
        let body = http_request.body().bytes().expect("body should be strict");
  313    314   
        // No body
  314    315   
        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
  315    316   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  316    317   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  317    318   
        ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
  318    319   
    }
  319    320   
    /// Tests requests with timestamp header bindings
  320    321   
    /// Test ID: InputAndOutputWithTimestampHeaders
  321    322   
    #[::tokio::test]
  322         -
    #[allow(unused_mut)]
         323  +
    #[::tracing_test::traced_test]
  323    324   
    async fn input_and_output_with_timestamp_headers_request() {
  324    325   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  325    326   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  326    327   
  327    328   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  328    329   
        let result = client
  329    330   
            .input_and_output_with_headers()
  330    331   
            .set_header_timestamp_list(::std::option::Option::Some(vec![
  331    332   
                ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
  332    333   
                ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
  333    334   
            ]))
  334    335   
            .send()
  335    336   
            .await;
  336    337   
        let _ = dbg!(result);
  337    338   
        let http_request = request_receiver.expect_request();
  338    339   
        let expected_headers = [("X-TimestampList", "Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT")];
  339    340   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  340    341   
        let body = http_request.body().bytes().expect("body should be strict");
  341    342   
        // No body
  342    343   
        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
  343    344   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  344    345   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  345    346   
        ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
  346    347   
    }
  347    348   
    /// Tests requests with enum header bindings
  348    349   
    /// Test ID: InputAndOutputWithEnumHeaders
  349    350   
    #[::tokio::test]
  350         -
    #[allow(unused_mut)]
         351  +
    #[::tracing_test::traced_test]
  351    352   
    async fn input_and_output_with_enum_headers_request() {
  352    353   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  353    354   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  354    355   
  355    356   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  356    357   
        let result = client
  357    358   
            .input_and_output_with_headers()
  358    359   
            .set_header_enum(::std::option::Option::Some(
  359    360   
                "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
  360    361   
            ))
  361    362   
            .set_header_enum_list(::std::option::Option::Some(vec![
  362    363   
                "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
  363    364   
                "Bar".parse::<crate::types::FooEnum>().expect("static value validated to member"),
  364    365   
                "Baz".parse::<crate::types::FooEnum>().expect("static value validated to member"),
  365    366   
            ]))
  366    367   
            .send()
  367    368   
            .await;
  368    369   
        let _ = dbg!(result);
  369    370   
        let http_request = request_receiver.expect_request();
  370    371   
        let expected_headers = [("X-Enum", "Foo"), ("X-EnumList", "Foo, Bar, Baz")];
  371    372   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  372    373   
        let body = http_request.body().bytes().expect("body should be strict");
  373    374   
        // No body
  374    375   
        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
  375    376   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  376    377   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  377    378   
        ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
  378    379   
    }
  379    380   
    /// Supports handling NaN float header values.
  380    381   
    /// Test ID: RestXmlSupportsNaNFloatHeaderInputs
  381    382   
    #[::tokio::test]
  382         -
    #[allow(unused_mut)]
         383  +
    #[::tracing_test::traced_test]
  383    384   
    async fn rest_xml_supports_na_n_float_header_inputs_request() {
  384    385   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  385    386   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  386    387   
  387    388   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  388    389   
        let result = client
  389    390   
            .input_and_output_with_headers()
  390    391   
            .set_header_float(::std::option::Option::Some(
  391    392   
                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
  392    393   
            ))
  393    394   
            .set_header_double(::std::option::Option::Some(
  394    395   
                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
  395    396   
            ))
  396    397   
            .send()
  397    398   
            .await;
  398    399   
        let _ = dbg!(result);
  399    400   
        let http_request = request_receiver.expect_request();
  400    401   
        let expected_headers = [("X-Double", "NaN"), ("X-Float", "NaN")];
  401    402   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  402    403   
        let body = http_request.body().bytes().expect("body should be strict");
  403    404   
        // No body
  404    405   
        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
  405    406   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  406    407   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  407    408   
        ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
  408    409   
    }
  409    410   
    /// Supports handling Infinity float header values.
  410    411   
    /// Test ID: RestXmlSupportsInfinityFloatHeaderInputs
  411    412   
    #[::tokio::test]
  412         -
    #[allow(unused_mut)]
         413  +
    #[::tracing_test::traced_test]
  413    414   
    async fn rest_xml_supports_infinity_float_header_inputs_request() {
  414    415   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  415    416   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  416    417   
  417    418   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  418    419   
        let result = client
  419    420   
            .input_and_output_with_headers()
  420    421   
            .set_header_float(::std::option::Option::Some(
  421    422   
                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
  422    423   
            ))
  423    424   
            .set_header_double(::std::option::Option::Some(
  424    425   
                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
  425    426   
            ))
  426    427   
            .send()
  427    428   
            .await;
  428    429   
        let _ = dbg!(result);
  429    430   
        let http_request = request_receiver.expect_request();
  430    431   
        let expected_headers = [("X-Double", "Infinity"), ("X-Float", "Infinity")];
  431    432   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  432    433   
        let body = http_request.body().bytes().expect("body should be strict");
  433    434   
        // No body
  434    435   
        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
  435    436   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  436    437   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  437    438   
        ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
  438    439   
    }
  439    440   
    /// Supports handling -Infinity float header values.
  440    441   
    /// Test ID: RestXmlSupportsNegativeInfinityFloatHeaderInputs
  441    442   
    #[::tokio::test]
  442         -
    #[allow(unused_mut)]
         443  +
    #[::tracing_test::traced_test]
  443    444   
    async fn rest_xml_supports_negative_infinity_float_header_inputs_request() {
  444    445   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  445    446   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  446    447   
  447    448   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  448    449   
        let result = client
  449    450   
            .input_and_output_with_headers()
  450    451   
            .set_header_float(::std::option::Option::Some(
  451    452   
                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
  452    453   
            ))
  453    454   
            .set_header_double(::std::option::Option::Some(
  454    455   
                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
  455    456   
            ))
  456    457   
            .send()
  457    458   
            .await;
  458    459   
        let _ = dbg!(result);
  459    460   
        let http_request = request_receiver.expect_request();
  460    461   
        let expected_headers = [("X-Double", "-Infinity"), ("X-Float", "-Infinity")];
  461    462   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  462    463   
        let body = http_request.body().bytes().expect("body should be strict");
  463    464   
        // No body
  464    465   
        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
  465    466   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  466    467   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  467    468   
        ::pretty_assertions::assert_eq!(uri.path(), "/InputAndOutputWithHeaders", "path was incorrect");
  468    469   
    }
  469    470   
    /// Tests responses with string header bindings
  470    471   
    /// Test ID: InputAndOutputWithStringHeaders
  471    472   
    #[::tokio::test]
  472         -
    #[allow(unused_mut)]
         473  +
    #[::tracing_test::traced_test]
  473    474   
    async fn input_and_output_with_string_headers_response() {
  474    475   
        let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
  475    476   
            .set_header_string(::std::option::Option::Some("Hello".to_owned()))
  476    477   
            .set_header_string_list(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
  477    478   
            .set_header_string_set(::std::option::Option::Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]))
  478    479   
            .build();
  479    480   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
  480    481   
            ::http::response::Builder::new()
  481    482   
                .header("X-String", "Hello")
  482    483   
                .header("X-StringList", "a, b, c")
@@ -548,549 +608,609 @@
  568    569   
        ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
  569    570   
        ::pretty_assertions::assert_eq!(
  570    571   
            parsed.header_enum_list,
  571    572   
            expected_output.header_enum_list,
  572    573   
            "Unexpected value for `header_enum_list`"
  573    574   
        );
  574    575   
    }
  575    576   
    /// Tests responses with numeric header bindings
  576    577   
    /// Test ID: InputAndOutputWithNumericHeaders
  577    578   
    #[::tokio::test]
  578         -
    #[allow(unused_mut)]
         579  +
    #[::tracing_test::traced_test]
  579    580   
    async fn input_and_output_with_numeric_headers_response() {
  580    581   
        let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
  581    582   
            .set_header_byte(::std::option::Option::Some(1))
  582    583   
            .set_header_short(::std::option::Option::Some(123))
  583    584   
            .set_header_integer(::std::option::Option::Some(123))
  584    585   
            .set_header_long(::std::option::Option::Some(123))
  585    586   
            .set_header_float(::std::option::Option::Some(1.1_f32))
  586    587   
            .set_header_double(::std::option::Option::Some(1.1_f64))
  587    588   
            .set_header_integer_list(::std::option::Option::Some(vec![1, 2, 3]))
  588    589   
            .build();
@@ -662,663 +722,723 @@
  682    683   
        ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
  683    684   
        ::pretty_assertions::assert_eq!(
  684    685   
            parsed.header_enum_list,
  685    686   
            expected_output.header_enum_list,
  686    687   
            "Unexpected value for `header_enum_list`"
  687    688   
        );
  688    689   
    }
  689    690   
    /// Tests responses with boolean header bindings
  690    691   
    /// Test ID: InputAndOutputWithBooleanHeaders
  691    692   
    #[::tokio::test]
  692         -
    #[allow(unused_mut)]
         693  +
    #[::tracing_test::traced_test]
  693    694   
    async fn input_and_output_with_boolean_headers_response() {
  694    695   
        let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
  695    696   
            .set_header_true_bool(::std::option::Option::Some(true))
  696    697   
            .set_header_false_bool(::std::option::Option::Some(false))
  697    698   
            .set_header_boolean_list(::std::option::Option::Some(vec![true, false, true]))
  698    699   
            .build();
  699    700   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
  700    701   
            ::http::response::Builder::new()
  701    702   
                .header("X-Boolean1", "true")
  702    703   
                .header("X-Boolean2", "false")
@@ -768,769 +828,829 @@
  788    789   
        ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
  789    790   
        ::pretty_assertions::assert_eq!(
  790    791   
            parsed.header_enum_list,
  791    792   
            expected_output.header_enum_list,
  792    793   
            "Unexpected value for `header_enum_list`"
  793    794   
        );
  794    795   
    }
  795    796   
    /// Tests responses with timestamp header bindings
  796    797   
    /// Test ID: InputAndOutputWithTimestampHeaders
  797    798   
    #[::tokio::test]
  798         -
    #[allow(unused_mut)]
         799  +
    #[::tracing_test::traced_test]
  799    800   
    async fn input_and_output_with_timestamp_headers_response() {
  800    801   
        let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
  801    802   
            .set_header_timestamp_list(::std::option::Option::Some(vec![
  802    803   
                ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
  803    804   
                ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
  804    805   
            ]))
  805    806   
            .build();
  806    807   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
  807    808   
            ::http::response::Builder::new()
  808    809   
                .header("X-TimestampList", "Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT")
@@ -873,874 +933,934 @@
  893    894   
        ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
  894    895   
        ::pretty_assertions::assert_eq!(
  895    896   
            parsed.header_enum_list,
  896    897   
            expected_output.header_enum_list,
  897    898   
            "Unexpected value for `header_enum_list`"
  898    899   
        );
  899    900   
    }
  900    901   
    /// Tests responses with enum header bindings
  901    902   
    /// Test ID: InputAndOutputWithEnumHeaders
  902    903   
    #[::tokio::test]
  903         -
    #[allow(unused_mut)]
         904  +
    #[::tracing_test::traced_test]
  904    905   
    async fn input_and_output_with_enum_headers_response() {
  905    906   
        let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
  906    907   
            .set_header_enum(::std::option::Option::Some(
  907    908   
                "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
  908    909   
            ))
  909    910   
            .set_header_enum_list(::std::option::Option::Some(vec![
  910    911   
                "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
  911    912   
                "Bar".parse::<crate::types::FooEnum>().expect("static value validated to member"),
  912    913   
                "Baz".parse::<crate::types::FooEnum>().expect("static value validated to member"),
  913    914   
            ]))
@@ -983,984 +1043,1044 @@
 1003   1004   
        ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
 1004   1005   
        ::pretty_assertions::assert_eq!(
 1005   1006   
            parsed.header_enum_list,
 1006   1007   
            expected_output.header_enum_list,
 1007   1008   
            "Unexpected value for `header_enum_list`"
 1008   1009   
        );
 1009   1010   
    }
 1010   1011   
    /// Supports handling NaN float header values.
 1011   1012   
    /// Test ID: RestXmlSupportsNaNFloatHeaderOutputs
 1012   1013   
    #[::tokio::test]
 1013         -
    #[allow(unused_mut)]
        1014  +
    #[::tracing_test::traced_test]
 1014   1015   
    async fn rest_xml_supports_na_n_float_header_outputs_response() {
 1015   1016   
        let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
 1016   1017   
            .set_header_float(::std::option::Option::Some(
 1017   1018   
                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
 1018   1019   
            ))
 1019   1020   
            .set_header_double(::std::option::Option::Some(
 1020   1021   
                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
 1021   1022   
            ))
 1022   1023   
            .build();
 1023   1024   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
@@ -1091,1092 +1151,1152 @@
 1111   1112   
        ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
 1112   1113   
        ::pretty_assertions::assert_eq!(
 1113   1114   
            parsed.header_enum_list,
 1114   1115   
            expected_output.header_enum_list,
 1115   1116   
            "Unexpected value for `header_enum_list`"
 1116   1117   
        );
 1117   1118   
    }
 1118   1119   
    /// Supports handling Infinity float header values.
 1119   1120   
    /// Test ID: RestXmlSupportsInfinityFloatHeaderOutputs
 1120   1121   
    #[::tokio::test]
 1121         -
    #[allow(unused_mut)]
        1122  +
    #[::tracing_test::traced_test]
 1122   1123   
    async fn rest_xml_supports_infinity_float_header_outputs_response() {
 1123   1124   
        let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
 1124   1125   
            .set_header_float(::std::option::Option::Some(
 1125   1126   
                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
 1126   1127   
            ))
 1127   1128   
            .set_header_double(::std::option::Option::Some(
 1128   1129   
                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
 1129   1130   
            ))
 1130   1131   
            .build();
 1131   1132   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
@@ -1199,1200 +1259,1260 @@
 1219   1220   
        ::pretty_assertions::assert_eq!(parsed.header_enum, expected_output.header_enum, "Unexpected value for `header_enum`");
 1220   1221   
        ::pretty_assertions::assert_eq!(
 1221   1222   
            parsed.header_enum_list,
 1222   1223   
            expected_output.header_enum_list,
 1223   1224   
            "Unexpected value for `header_enum_list`"
 1224   1225   
        );
 1225   1226   
    }
 1226   1227   
    /// Supports handling -Infinity float header values.
 1227   1228   
    /// Test ID: RestXmlSupportsNegativeInfinityFloatHeaderOutputs
 1228   1229   
    #[::tokio::test]
 1229         -
    #[allow(unused_mut)]
        1230  +
    #[::tracing_test::traced_test]
 1230   1231   
    async fn rest_xml_supports_negative_infinity_float_header_outputs_response() {
 1231   1232   
        let expected_output = crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersOutput::builder()
 1232   1233   
            .set_header_float(::std::option::Option::Some(
 1233   1234   
                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
 1234   1235   
            ))
 1235   1236   
            .set_header_double(::std::option::Option::Some(
 1236   1237   
                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
 1237   1238   
            ))
 1238   1239   
            .build();
 1239   1240   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

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

@@ -191,191 +382,383 @@
  211    211   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  212    212   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  213    213   
        })?;
  214    214   
        cfg.interceptor_state()
  215    215   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  216    216   
        ::std::result::Result::Ok(())
  217    217   
    }
  218    218   
}
  219    219   
#[allow(unreachable_code, unused_variables)]
  220    220   
#[cfg(test)]
  221         -
mod nested_xml_maps_request_test {
         221  +
mod nested_xml_maps_test {
         222  +
  222    223   
    /// Tests requests with nested maps.
  223    224   
    /// Test ID: NestedXmlMapRequest
  224    225   
    #[::tokio::test]
  225         -
    #[allow(unused_mut)]
         226  +
    #[::tracing_test::traced_test]
  226    227   
    async fn nested_xml_map_request_request() {
  227    228   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  228    229   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  229    230   
  230    231   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  231    232   
        let result = client
  232    233   
            .nested_xml_maps()
  233    234   
            .set_nested_map(::std::option::Option::Some({
  234    235   
                let mut ret = ::std::collections::HashMap::new();
  235    236   
                ret.insert("foo".to_owned(), {
  236    237   
                    let mut ret = ::std::collections::HashMap::new();
  237    238   
                    ret.insert(
  238    239   
                        "bar".to_owned(),
  239    240   
                        "Bar".parse::<crate::types::FooEnum>().expect("static value validated to member"),
  240    241   
                    );
  241    242   
                    ret
  242    243   
                });
  243    244   
                ret
  244    245   
            }))
  245    246   
            .send()
  246    247   
            .await;
  247    248   
        let _ = dbg!(result);
  248    249   
        let http_request = request_receiver.expect_request();
  249    250   
        let expected_headers = [("Content-Type", "application/xml")];
  250    251   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  251    252   
        let body = http_request.body().bytes().expect("body should be strict");
  252    253   
        ::aws_smithy_protocol_test::assert_ok(
  253    254   
        ::aws_smithy_protocol_test::validate_body(body, "<NestedXmlMapsRequest>\n    <nestedMap>\n        <entry>\n            <key>foo</key>\n            <value>\n                <entry>\n                    <key>bar</key>\n                    <value>Bar</value>\n                </entry>\n            </value>\n        </entry>\n    </nestedMap>\n</NestedXmlMapsRequest>", ::aws_smithy_protocol_test::MediaType::from("application/xml"))
  254    255   
        );
  255    256   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  256    257   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  257    258   
        ::pretty_assertions::assert_eq!(uri.path(), "/NestedXmlMaps", "path was incorrect");
  258    259   
    }
  259    260   
    /// Tests requests with nested flat maps. Since maps can only be
  260    261   
    /// flattened when they're structure members, only the outer map is flat.
  261    262   
    /// Test ID: FlatNestedXmlMapRequest
  262    263   
    #[::tokio::test]
  263         -
    #[allow(unused_mut)]
         264  +
    #[::tracing_test::traced_test]
  264    265   
    async fn flat_nested_xml_map_request_request() {
  265    266   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  266    267   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  267    268   
  268    269   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  269    270   
        let result = client
  270    271   
            .nested_xml_maps()
  271    272   
            .set_flat_nested_map(::std::option::Option::Some({
  272    273   
                let mut ret = ::std::collections::HashMap::new();
  273    274   
                ret.insert("foo".to_owned(), {
  274    275   
                    let mut ret = ::std::collections::HashMap::new();
  275    276   
                    ret.insert(
  276    277   
                        "bar".to_owned(),
  277    278   
                        "Bar".parse::<crate::types::FooEnum>().expect("static value validated to member"),
  278    279   
                    );
  279    280   
                    ret
  280    281   
                });
  281    282   
                ret
  282    283   
            }))
  283    284   
            .send()
  284    285   
            .await;
  285    286   
        let _ = dbg!(result);
  286    287   
        let http_request = request_receiver.expect_request();
  287    288   
        let expected_headers = [("Content-Type", "application/xml")];
  288    289   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  289    290   
        let body = http_request.body().bytes().expect("body should be strict");
  290    291   
        ::aws_smithy_protocol_test::assert_ok(
  291    292   
        ::aws_smithy_protocol_test::validate_body(body, "<NestedXmlMapsRequest>\n    <flatNestedMap>\n        <key>foo</key>\n        <value>\n            <entry>\n                <key>bar</key>\n                <value>Bar</value>\n            </entry>\n        </value>\n    </flatNestedMap>\n</NestedXmlMapsRequest>", ::aws_smithy_protocol_test::MediaType::from("application/xml"))
  292    293   
        );
  293    294   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  294    295   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  295    296   
        ::pretty_assertions::assert_eq!(uri.path(), "/NestedXmlMaps", "path was incorrect");
  296    297   
    }
  297    298   
    /// Tests responses with nested maps.
  298    299   
    /// Test ID: NestedXmlMapResponse
  299    300   
    #[::tokio::test]
  300         -
    #[allow(unused_mut)]
         301  +
    #[::tracing_test::traced_test]
  301    302   
    async fn nested_xml_map_response_response() {
  302    303   
        let expected_output = crate::operation::nested_xml_maps::NestedXmlMapsOutput::builder()
  303    304   
            .set_nested_map(::std::option::Option::Some({
  304    305   
                let mut ret = ::std::collections::HashMap::new();
  305    306   
                ret.insert("foo".to_owned(), {
  306    307   
                    let mut ret = ::std::collections::HashMap::new();
  307    308   
                    ret.insert(
  308    309   
                        "bar".to_owned(),
  309    310   
                        "Bar".parse::<crate::types::FooEnum>().expect("static value validated to member"),
  310    311   
                    );
  311    312   
                    ret
  312    313   
                });
  313    314   
                ret
  314    315   
            }))
  315    316   
            .build();
  316    317   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
  317    318   
        .header("Content-Type", "application/xml")
  318    319   
        .status(200)
  319    320   
                    .body(::aws_smithy_types::body::SdkBody::from("<NestedXmlMapsResponse>\n    <nestedMap>\n        <entry>\n            <key>foo</key>\n            <value>\n                <entry>\n                    <key>bar</key>\n                    <value>Bar</value>\n                </entry>\n            </value>\n        </entry>\n    </nestedMap>\n</NestedXmlMapsResponse>"))
  320    321   
                    .unwrap()
  321    322   
                    ).unwrap();
  322    323   
        use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
  323    324   
        use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
  324    325   
  325    326   
        let op = crate::operation::nested_xml_maps::NestedXmlMaps::new();
  326    327   
        let config = op.config().expect("the operation has config");
  327    328   
        let de = config
  328    329   
            .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
  329    330   
            .expect("the config must have a deserializer");
  330    331   
  331    332   
        let parsed = de.deserialize_streaming(&mut http_response);
  332    333   
        let parsed = parsed.unwrap_or_else(|| {
  333    334   
            let http_response =
  334    335   
                http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
  335    336   
            de.deserialize_nonstreaming(&http_response)
  336    337   
        });
  337    338   
        let parsed = parsed
  338    339   
            .expect("should be successful response")
  339    340   
            .downcast::<crate::operation::nested_xml_maps::NestedXmlMapsOutput>()
  340    341   
            .unwrap();
  341    342   
        ::pretty_assertions::assert_eq!(parsed.nested_map, expected_output.nested_map, "Unexpected value for `nested_map`");
  342    343   
        ::pretty_assertions::assert_eq!(
  343    344   
            parsed.flat_nested_map,
  344    345   
            expected_output.flat_nested_map,
  345    346   
            "Unexpected value for `flat_nested_map`"
  346    347   
        );
  347    348   
    }
  348    349   
    /// Tests responses with nested flat maps. Since maps can only be
  349    350   
    /// flattened when they're structure members, only the outer map is flat.
  350    351   
    /// Test ID: FlatNestedXmlMapResponse
  351    352   
    #[::tokio::test]
  352         -
    #[allow(unused_mut)]
         353  +
    #[::tracing_test::traced_test]
  353    354   
    async fn flat_nested_xml_map_response_response() {
  354    355   
        let expected_output = crate::operation::nested_xml_maps::NestedXmlMapsOutput::builder()
  355    356   
            .set_flat_nested_map(::std::option::Option::Some({
  356    357   
                let mut ret = ::std::collections::HashMap::new();
  357    358   
                ret.insert("foo".to_owned(), {
  358    359   
                    let mut ret = ::std::collections::HashMap::new();
  359    360   
                    ret.insert(
  360    361   
                        "bar".to_owned(),
  361    362   
                        "Bar".parse::<crate::types::FooEnum>().expect("static value validated to member"),
  362    363   
                    );

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

@@ -193,193 +276,277 @@
  213    213   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  214    214   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  215    215   
        })?;
  216    216   
        cfg.interceptor_state()
  217    217   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  218    218   
        ::std::result::Result::Ok(())
  219    219   
    }
  220    220   
}
  221    221   
#[allow(unreachable_code, unused_variables)]
  222    222   
#[cfg(test)]
  223         -
mod no_input_and_no_output_request_test {
         223  +
mod no_input_and_no_output_test {
         224  +
  224    225   
    /// No input serializes no payload
  225    226   
    /// Test ID: NoInputAndNoOutput
  226    227   
    #[::tokio::test]
  227         -
    #[allow(unused_mut)]
         228  +
    #[::tracing_test::traced_test]
  228    229   
    async fn no_input_and_no_output_request() {
  229    230   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  230    231   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  231    232   
  232    233   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  233    234   
        let result = client.no_input_and_no_output().send().await;
  234    235   
        let _ = dbg!(result);
  235    236   
        let http_request = request_receiver.expect_request();
  236    237   
        let body = http_request.body().bytes().expect("body should be strict");
  237    238   
        // No body
  238    239   
        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
  239    240   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  240    241   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  241    242   
        ::pretty_assertions::assert_eq!(uri.path(), "/NoInputAndNoOutput", "path was incorrect");
  242    243   
    }
  243    244   
    /// No output serializes no payload
  244    245   
    /// Test ID: NoInputAndNoOutput
  245    246   
    #[::tokio::test]
  246         -
    #[allow(unused_mut)]
         247  +
    #[::tracing_test::traced_test]
  247    248   
    async fn no_input_and_no_output_response() {
  248    249   
        let expected_output = crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput::builder().build();
  249    250   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
  250    251   
            ::http::response::Builder::new()
  251    252   
                .status(200)
  252    253   
                .body(::aws_smithy_types::body::SdkBody::from(""))
  253    254   
                .unwrap(),
  254    255   
        )
  255    256   
        .unwrap();
  256    257   
        use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

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

@@ -187,187 +270,271 @@
  207    207   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  208    208   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  209    209   
        })?;
  210    210   
        cfg.interceptor_state()
  211    211   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  212    212   
        ::std::result::Result::Ok(())
  213    213   
    }
  214    214   
}
  215    215   
#[allow(unreachable_code, unused_variables)]
  216    216   
#[cfg(test)]
  217         -
mod no_input_and_output_request_test {
         217  +
mod no_input_and_output_test {
         218  +
  218    219   
    /// No input serializes no payload
  219    220   
    /// Test ID: NoInputAndOutput
  220    221   
    #[::tokio::test]
  221         -
    #[allow(unused_mut)]
         222  +
    #[::tracing_test::traced_test]
  222    223   
    async fn no_input_and_output_request() {
  223    224   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  224    225   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  225    226   
  226    227   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  227    228   
        let result = client.no_input_and_output().send().await;
  228    229   
        let _ = dbg!(result);
  229    230   
        let http_request = request_receiver.expect_request();
  230    231   
        let body = http_request.body().bytes().expect("body should be strict");
  231    232   
        // No body
  232    233   
        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
  233    234   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  234    235   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  235    236   
        ::pretty_assertions::assert_eq!(uri.path(), "/NoInputAndOutputOutput", "path was incorrect");
  236    237   
    }
  237    238   
    /// Empty output serializes no payload
  238    239   
    /// Test ID: NoInputAndOutput
  239    240   
    #[::tokio::test]
  240         -
    #[allow(unused_mut)]
         241  +
    #[::tracing_test::traced_test]
  241    242   
    async fn no_input_and_output_response() {
  242    243   
        let expected_output = crate::operation::no_input_and_output::NoInputAndOutputOutput::builder().build();
  243    244   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
  244    245   
            ::http::response::Builder::new()
  245    246   
                .status(200)
  246    247   
                .body(::aws_smithy_types::body::SdkBody::from(""))
  247    248   
                .unwrap(),
  248    249   
        )
  249    250   
        .unwrap();
  250    251   
        use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

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

@@ -194,194 +258,259 @@
  214    214   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  215    215   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  216    216   
        })?;
  217    217   
        cfg.interceptor_state()
  218    218   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  219    219   
        ::std::result::Result::Ok(())
  220    220   
    }
  221    221   
}
  222    222   
#[allow(unreachable_code, unused_variables)]
  223    223   
#[cfg(test)]
  224         -
mod null_and_empty_headers_client_request_test {
         224  +
mod null_and_empty_headers_client_test {
         225  +
  225    226   
    /// Do not send null values, empty strings, or empty lists over the wire in headers
  226    227   
    /// Test ID: NullAndEmptyHeaders
  227    228   
    #[::tokio::test]
  228         -
    #[allow(unused_mut)]
         229  +
    #[::tracing_test::traced_test]
  229    230   
    async fn null_and_empty_headers_request() {
  230    231   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  231    232   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  232    233   
  233    234   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  234    235   
        let result = client
  235    236   
            .null_and_empty_headers_client()
  236    237   
            .set_a(::std::option::Option::None)
  237    238   
            .set_b(::std::option::Option::Some("".to_owned()))
  238    239   
            .set_c(::std::option::Option::Some(vec![]))

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

@@ -213,213 +300,301 @@
  233    233   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  234    234   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  235    235   
        })?;
  236    236   
        cfg.interceptor_state()
  237    237   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  238    238   
        ::std::result::Result::Ok(())
  239    239   
    }
  240    240   
}
  241    241   
#[allow(unreachable_code, unused_variables)]
  242    242   
#[cfg(test)]
  243         -
mod omits_null_serializes_empty_string_request_test {
         243  +
mod omits_null_serializes_empty_string_test {
         244  +
  244    245   
    /// Omits null query values
  245    246   
    /// Test ID: RestXmlOmitsNullQuery
  246    247   
    #[::tokio::test]
  247         -
    #[allow(unused_mut)]
         248  +
    #[::tracing_test::traced_test]
  248    249   
    async fn rest_xml_omits_null_query_request() {
  249    250   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  250    251   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  251    252   
  252    253   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  253    254   
        let result = client
  254    255   
            .omits_null_serializes_empty_string()
  255    256   
            .set_null_value(::std::option::Option::None)
  256    257   
            .send()
  257    258   
            .await;
  258    259   
        let _ = dbg!(result);
  259    260   
        let http_request = request_receiver.expect_request();
  260    261   
        let body = http_request.body().bytes().expect("body should be strict");
  261    262   
        // No body
  262    263   
        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
  263    264   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  264    265   
        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
  265    266   
        ::pretty_assertions::assert_eq!(uri.path(), "/OmitsNullSerializesEmptyString", "path was incorrect");
  266    267   
    }
  267    268   
    /// Serializes empty query strings
  268    269   
    /// Test ID: RestXmlSerializesEmptyString
  269    270   
    #[::tokio::test]
  270         -
    #[allow(unused_mut)]
         271  +
    #[::tracing_test::traced_test]
  271    272   
    async fn rest_xml_serializes_empty_string_request() {
  272    273   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  273    274   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  274    275   
  275    276   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  276    277   
        let result = client
  277    278   
            .omits_null_serializes_empty_string()
  278    279   
            .set_empty_string(::std::option::Option::Some("".to_owned()))
  279    280   
            .send()
  280    281   
            .await;

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

@@ -202,202 +293,294 @@
  222    222   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  223    223   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  224    224   
        })?;
  225    225   
        cfg.interceptor_state()
  226    226   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  227    227   
        ::std::result::Result::Ok(())
  228    228   
    }
  229    229   
}
  230    230   
#[allow(unreachable_code, unused_variables)]
  231    231   
#[cfg(test)]
  232         -
mod put_with_content_encoding_request_test {
         232  +
mod put_with_content_encoding_test {
         233  +
  233    234   
    /// Compression algorithm encoding is appended to the Content-Encoding header.
  234    235   
    /// Test ID: SDKAppliedContentEncoding_restXml
  235    236   
    #[::tokio::test]
  236         -
    #[allow(unused_mut)]
         237  +
    #[::tracing_test::traced_test]
  237    238   
    async fn sdk_applied_content_encoding_rest_xml_request() {
  238    239   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  239    240   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  240    241   
  241    242   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  242    243   
        let result = client.put_with_content_encoding()
  243    244   
        .set_data(
  244    245   
            ::std::option::Option::Some(
  245    246   
                "RjCEL3kBwqPivZUXGiyA5JCujtWgJAkKRlnTEsNYfBRGOS0f7LT6R3bCSOXeJ4auSHzQ4BEZZTklUyj5\n1HEojihShQC2jkQJrNdGOZNSW49yRO0XbnGmeczUHbZqZRelLFKW4xjru9uTuB8lFCtwoGgciFsgqTF8\n5HYcoqINTRxuAwGuRUMoNO473QT0BtCQoKUkAyVaypG0hBZdGNoJhunBfW0d3HWTYlzz9pXElyZhq3C1\n2PDB17GEoOYXmTxDecysmPOdo5z6T0HFhujfeJFIQQ8dirmXcG4F3v0bZdf6AZ3jsiVh6RnEXIPxPbOi\ngIXDWTMUr4Pg3f2LdYCM01eAb2qTdgsEN0MUDhEIfn68I2tnWvcozyUFpg1ez6pyWP8ssWVfFrckREIM\nMb0cTUVqSVSM8bnFiF9SoXM6ZoGMKfX1mT708OYk7SqZ1JlCTkecDJDoR5ED2q2MWKUGR6jjnEV0GtD8\nWJO6AcF0DptY9Hk16Bav3z6c5FeBvrGDrxTFVgRUk8SychzjrcqJ4qskwN8rL3zslC0oqobQRnLFOvwJ\nprSzBIwdH2yAuxokXAdVRa1u9NGNRvfWJfKkwbbVz8yV76RUF9KNhAUmwyYDrLnxNj8ROl8B7dv8Gans\n7Bit52wcdiJyjBW1pAodB7zqqVwtBx5RaSpF7kEMXexYXp9N0J1jlXzdeg5Wgg4pO7TJNr2joiPVAiFf\nefwMMCNBkYx2z7cRxVxCJZMXXzxSKMGgdTN24bJ5UgE0TxyV52RC0wGWG49S1x5jGrvmxKCIgYPs0w3Z\n0I3XcdB0WEj4x4xRztB9Cx2Mc4qFYQdzS9kOioAgNBti1rBySZ8lFZM2zqxvBsJTTJsmcKPr1crqiXjM\noVWdM4ObOO6QA7Pu4c1hT68CrTmbcecjFcxHkgsqdixnFtN6keMGL9Z2YMjZOjYYzbUEwLJqUVWalkIB\nBkgBRqZpzxx5nB5t0qDH35KjsfKM5cinQaFoRq9y9Z82xdCoKZOsUbxZkk1kVmy1jPDCBhkhixkc5PKS\nFoSKTbeK7kuCEZCtR9OfF2k2MqbygGFsFu2sgb1Zn2YdDbaRwRGeaLhswta09UNSMUo8aTixgoYVHxwy\nvraLB6olPSPegeLOnmBeWyKmEfPdbpdGm4ev4vA2AUFuLIeFz0LkCSN0NgQMrr8ALEm1UNpJLReg1ZAX\nzZh7gtQTZUaBVdMJokaJpLk6FPxSA6zkwB5TegSqhrFIsmvpY3VNWmTUq7H0iADdh3dRQ8Is97bTsbwu\nvAEOjh4FQ9wPSFzEtcSJeYQft5GfWYPisDImjjvHVFshFFkNy2nN18pJmhVPoJc456tgbdfEIdGhIADC\n6UPcSSzE1FxlPpILqZrp3i4NvvKoiOa4a8tnALd2XRHHmsvALn2Wmfu07b86gZlu4yOyuUFNoWI6tFvd\nbHnqSJYNQlFESv13gJw609DBzNnrIgBGYBAcDRrIGAnflRKwVDUnDFrUQmE8xNG6jRlyb1p2Y2RrfBtG\ncKqhuGNiT2DfxpY89ektZ98waPhJrFEPJToNH8EADzBorh3T0h4YP1IeLmaI7SOxeuVrk1kjRqMK0rUB\nlUJgJNtCE35jCyoHMwPQlyi78ZaVv8COVQ24zcGpw0MTy6JUsDzAC3jLNY6xCb40SZV9XzG7nWvXA5Ej\nYC1gTXxF4AtFexIdDZ4RJbtYMyXt8LsEJerwwpkfqvDwsiFuqYC6vIn9RoZO5kI0F35XtUITDQYKZ4eq\nWBV0itxTyyR5Rp6g30pZEmEqOusDaIh96CEmHpOBYAQZ7u1QTfzRdysIGMpzbx5gj9Dxm2PO1glWzY7P\nlVqQiBlXSGDOkBkrB6SkiAxknt9zsPdTTsf3r3nid4hdiPrZmGWNgjOO1khSxZSzBdltrCESNnQmlnP5\nZOHA0eSYXwy8j4od5ZmjA3IpFOEPW2MutMbxIbJpg5dIx2x7WxespftenRLgl3CxcpPDcnb9w8LCHBg7\nSEjrEer6Y8wVLFWsQiv6nTdCPZz9cGqwgtCaiHRy8lTWFgdfWd397vw9rduGld3uUFeFRGjYrphqEmHi\nhiG0GhE6wRFVUsGJtvOCYkVREvbEdxPFeJvlAvOcs9HKbtptlTusvYB86vR2bNcIY4f5JZu2X6sGa354\n7LRk0ps2zqYjat3hMR7XDC8KiKceBteFsXoDjfVxTYKelpedTxqWAafrKhaoAVuNM98PSnkuIWGzjSUC\nNsDJTt6vt1D1afBVPWVmnQ7ZQdtEtLIEwAWYjemAztreELIr1E9fPEILm1Ke4KctP9I0I72Dh4eylNZD\n0DEr2Hg7cWFckuZ0Av5d0IPRARXikEGDHl8uh12TXL9v2Uh0ZVSJMEYvxGSbZvkWz8TjWSk3hKA2a7GL\nJm3Ho7e1C34gE1XRGcEthxvURxt4OKBqN3ZNaMIuDTWinoQAutMcUqtm4MoL7RGPiCHUrvTwQPSirsmA\nQmOEu8nOpnP77Fivh9jLGx5ta7nL6jrsWUsBqiN1lzpdPYLRR4mUIAj6sNWiDEk4pkbHSMEcqbWw6Zl7\npsEyPDHalCNhWMA3RSK3skURzQDZ0oBV5W7vjVIZ4d3uCKsk6zrzEI9u5mx7p9RdNKodXfzqYt0ULdtc\n3RW0hIfw2KvrO3BD2QrtgAkfrFBGVvlJSUoh0MvLz8DeXxfuiuq9Ttu7wvsqVI4Piah6WNEXtHHGPJO3\nGhc75Bnv2To4VS2v8rmyKAPIIVTuYBHZN6sZ4FhFzbrslCIdk0eadaU60naqiNWU3CsxplIYGyeThmJ7\n9u4h6Y2OmiPZjFPS2bAzwgAozYTVefII9aEaWZ0hxHZeu1FW7r79dkdO73ZqRfas9u8Z7LLBPCw5pV0F\n5I0pHDgNb6MogoxF4NZJfVtIX1vCHhhVLrXjrYNJU2fD9Fw8kT8Ie2HDBJnqAvYKmryQ1r9ulo3Me3rH\nq9s2Y5uCDxu9iQNhnpwIm57WYGFeqd2fnQeY2IziD3Jgx0KSrmOH0jgi0RwJyfGXaORPq3bQQqljuACo\nkO6io9t5VI8PbNxSHTRbtYiPciUslbT0g7SpCLrRPOBRJ4DDk56pjghpeoUagJ5xJ4wjBzBuXnAGkNnP\nTfpiuz2r3oSBAi8sB9wiYK2z9sp4gZyQsqdVNzAEgKatOxBRBmJCBYpjO98ZQrF83XApPpfFg0ujB2PW\n1iYF9NkgwIKB5oB6KVTOmSKJk11mVermPgeugHbzdd2zUP6fP8fWbhseqk2t8ahGvqjs2CDHFIWXl5jc\nfCknbykE3ANt7lnAfJQ2ddduLGiqrX4HWx6jcWw08Es6BkleO0IDbaWrb95d5isvFlzJsf0TyDIXF4uq\nbBDCi0XPWqtRJ2iqmnJa2GbBe9GmAOWMkBFSilMyC4sR395WSDpD56fx0NGoU6cHrRu9xF2Bgh7RGSfl\nch2GXEeE02fDpSHFNvJBlOEqqfkIX6oCa6KY9NThqeIjYsT184XR2ZI7akXRaw1gMOGpk4FmUxk6WIuX\n4ei1SLQgSdl7OEdRtJklZ76eFrMbkJQ2TDhu8f7mVuiy53GUMIvCrP9xYGZGmCIDm2e4U2BDi3F7C5xK\n3bDZXwlQp6z4BSqTy2OVEWxXUJfjPMOL5Mc7AvDeKtxAS73pVIv0HgHIa4NBAdC7uLG0zXuu1FF6z2XY\nyUhk03fMZhYe7vVxsul3WE7U01fuN8z2y0eKwBW1RFBE1eKIaR9Y01sIWQWbSrfHfDrdZiElhmhHehfs\n0EfrR4sLYdQshJuvhTeKGJDaEhtPQwwJ9mUYGtuCL9RozWx1XI4bHNlzBTW0BVokYiJGlPe7wdxNzJD7\nJgS7Lwv6jGKngVf86imGZyzqwiteWFPdNUoWdTvUPSMO5xIUK9mo5QpwbBOAmyYzVq42o3Qs90N9khEV\nU36LB99fw8PtGHH5wsCHshfauwnNPj0blGXzke0kQ4JNCVH7Jtn0Y0aeejkSxFtwtxoYs6zHl1Lxxpsd\nsw5vBy49CEtoltDW367lVAwDjWdx20msGB7qJCkEDrzu7EXSO22782QX9NBRcN9ppX0C25I0FMA4Wnhz\n9zIpiXRrsTH35jzM8Cjt4EVLGNU3O0HuEvAer3cENnMJtngdrT86ox3fihMQbiuy4Bh4DEcP5in2VjbT\n3qbnoCNvOi8Fmmf7KlGlWAOceL5OHVE5lljjQEMzEQOCEgrk5mDKgwSBJQBNauIDSC1a5iEQjB8Xxp4C\nqeKyyWY9IOntNrtU5ny4lNprHJd36dKFeBLKcGCOvgHBXdOZloMF0YTRExw7hreEO9IoTGVHJ4teWsNr\nHdtagUHjkeZkdMMfnUGNv5aBNtFMqhcZH6EitEa9lGPkKBbJpoom3u8D8EHSIF1H5EZqqx9TLY5hWAIG\nPwJ4qwkpCGw5rCLVrjw7ARKukIFzNULANqjHUMcJ002TlUosJM4xJ4aAgckpLVGOGuPDhGAAexEcQmbg\nUsZdmqQrtuVUyyLteLbLbqtR6CTlcAIwY3xyMCmPgyefE0FEUODBoxQtRUuYTL9RC5o1sYb2PvcxUQfb\niJFi2CAl99pAzcckU2qVCxniARslIxM5pmMRGsQX9ZzYAfZrbg6ce6S74I8UMlgRQ2QVyvUjKKOE6IrJ\nLng370emHfe5m6LZULD5YiZutkD5ipjL2Bz77DvTE5kNPUhuoKBcTJcUgytfXAKUTWOcRKNlq0GImrxM\nJfr7AWbLFFNKGLeTrVDBwpcokJCv0zcOKWe8fd2xkeXkZTdmM66IgM27cyYmtQ6YF26Kd0qrWJeVZJV9\n3fyLYYvKN5csbRY2BHoYE5ERARRW65IrpkXMf48OrCXMtDIP0Z7wxI9DiTeKKeH4uuguhCJnwzR3WxLA\nVU6eBJEd7ZjS6JA83w7decq8uDI7LGKjcz1FySp3B7fE9DkHRGXxbsL7Fjar6vW2mAv8CuvI20B6jctp\n2yLDs24sPfB3sSxrrlhbuT1m6DZqiN0dl6umKx7NGZhmOTVGr20jfcxhqPQwTJfd7kel4rvxip4BqkvT\n7STy8knJ2BXGyJeNgwo1PXUZRDVy0LCTsSF1RFuRZe8cktHl9lgw8ntdPn1pVFL0MwJkJfdXBNUp5gNv\n50FTkrpo1t6wq4CVbcfj2XOrOzvBUzNH26sXGABI1gGxCdp2jEZrHgqQaWIaTJVTuguZhxqDvdYsrwFW\nYN58uuNcKHIrGdRSigyZInwQDYk0pjcqdSeU0WVU3Y9htzZBR7XRaCJr5YTZvq7fwermb5tuwb37lPLq\nB2IGg0iftkVbXaSyfCwVaRbfLBb88so0QqpmJGirFu8FcDiXOV1zTr8yW9XLdYQuUjh43xrXLdgsuYff\nCagInUk1eU1aLjVZoJRsNmStmOEpAqlYMwTvx7w6j2f421Cxr5cNZBIVlAxlXN2QiDqJ9v3sHhHkTanc\nlQuH8ptUyX8qncpBuXXBn7cSez9N0EoxCBl1GHUagbjstgJo4gzLvTmVIY6MiWYOBitzNUHfyqKwtKUr\nVoSCdZcGeA9lHUPA7PUprRRaT3m1hGKPyshtVS2ikG48w3oVerln1N1qGdtz46gZCrndw3LZ1B362RfW\nzDPuXbpsyLsRMTt1Rz1oKHRXp3iE41hkhQH6pxlvyCW2INnHt5XU8zRamOB3oW0udOhMpQFDjRkOcy06\nb4t0QTHvoRqmBna3WXzIMZyeK3GChF5eF8oDXRbjhk7BB6YKCgqwWUzEJ5K47HMSlhFkBUjaPRjdGM0z\nzOMwhW6b1NvSwP7XM1P5yi1oPvOspts1vr29SXqrMMrBhVogeodWyd69NqrO4jkyBxKmlXifoTowpfiY\n2cUCE0XMZqxUN39LCP09JqZifaEcBEo3mgtm1tWu5QR2GNq7UyQf4RIPSDOpDCAtwoPhRgdT1lJdcj4U\nlnH0wrJ8Uwu7c08L7ErnIrDATqCrOjpSbzGP1xHENABYONC4TknFPrJ8pe40A8fzGT0qBw9mAM1SKcHO\nfoiLcMC9AjHTqJzDG3xplSLPG9or2rMeq7Fzp9r0y7uJRMxgg51EbjfvYlH466A3ggvL2WQlDXjJqPW3\nBJGWAWDNN9LK8f46bADKPxakpkx23S9O47rGSXfDhVSIZsDympxWX1UOzWwMZRHkofVeKqizgbKkGgUT\nWykE9gRoRAOd9wfHZDYKa9i0LaPDiaUMvnU1gdBIqIoiVsdJ9swX47oxvMtOxtcS0zlD6llDkBuIiU5g\nPwRCYmtkkb25c8iRJXwGFPjI1wJ34I1z1ENicPdosPiUe9ZC2jnXIKzEdv01x2ER7DNDF3yxOwOhxNxI\nGqsmC92j25UQQFu9ZstOZ28AoCkuOYs0Uycm5u8jR1T39dMBwrko09rC65ENLnsxM8oebmyFCPiGJ1ED\n5Xqc9qZ237f1OnETAoEOwqUSvrdPTv56U7hV91EMTyC812MLQpr2710E3VVpsUCUMNhIxdt7UXZ1UNFb\njgzpZLXnf4DHrv6B7kq6UI50KMxcw1HZE2GpODfUTzNFLaqdrvzxKe5eUWdcojBaRbD4fFdVYJTElYDH\nNNVh6ofkoeWcs9CWGFmSBe0T4K8phFeygQg0prKMELNEy6qENzVtG9ZDcqj3a7L6ZLtvq50anWp7fAVu\nfwz55g4iM2Z2fA0pnwHDL7tt67zTxGITvsnJsZSpeq1EQsZcwtkBV9liu7Rl7jiVT1IIRtchB8TsTiaA\nwVHIQQ9RIOTiPQdKNqi1kC9iGlUqWK93gblNWlBw1eYB9Wk8FQogutwTf0caNMx8D4nPbANcmOOlskIy\nzALh15OlTrWnhP95rf08AN2J026zDE2DUF9k0eCevYBQIDjqKNW4XCZnjbHoIcKzbY5VzPbMs3ZyMz8K\nSucBmgPg6wrSK5ykbkapS5vuqvXc9GbjQJ8bPNzoxoWGyjbZvDs2OBrIqBmcQb2DLJ8v38McQ4mC4UsS\njf4PyfSCtpk274QZjvLCZbLiCBxQegk7jUU0NmTFJAcYCxd9xMWdlFkiszcltT2YzwuFFz7iA6aa4n5L\nHpBNfUA01GcAi1aCMYhmooS4zSlYcSOZkovMz36U3Fd9WtqIEOJLi7HMgHQDgNMdK6DTzAdHQtxerxVF\nHJnPrfNVG7270r3bp0bPnLNYLhObbAn6zqSAUeLtI2Y4KJDjBKCAh2vvYGbu0e2REYJWRj7MkGevsSSy\nb1kCXLt6tKGWAb7lt5c0xyJgUIJW7pdtnwgT0ZCa24BecCAwNnG5U2EwQbcjZGsFxqNGfaemd3oFEhES\nBaE0Fxms9UKTnMafu8wvZ2xymMrUduuRzOjDeX7oD5YsLC88V8CGMLxbbxIpt94KGykbr6e7L0R4oZl1\ntKMgFwQ2p9Txdbp0Y293LcsJymKizqI0F2xEp7y4SmWOJqHZtsbz80wVV9nv41CvtfxuSoGZJ5cNB7pI\nBgzNcQCeH3Jt0RaGGwboxxpuFbzilmkMFXxJm87tD4WNgu01nHfGCKeQcySEBZpVfJgi6sDFJ8uWnvKm\n9mPLHurtWzEfKqUEa1iC71bXjw5wrvhv9BYW8JSUELHmDquftQyKdq0DZXhULMHGQLf4e95WIaoA14LL\nbThz77kuhKULPTu2MNrBUKGorurhGugo5gs4ZUezSsUOe3KxYdrFMdGgny1GgTxMSMTp2RAZytKjv4kQ\nVx7XgzvpQLIbDjUPAkJv6lScwIRq1W3Ne0Rh0V6Bmn6U5uIuWnJjULmbaQiSODj3z0mAZvak0mSWIGwT\nTX83HztcC4W7e1f6a1thmcc5K61Icehla2hBELWPpixTkyC4eEVmk9Rq0m0ZXtx0JX2ZQXqXDEyePyMe\nJ70sdSzXk72zusqhY4yuOMGgbYNHqxOToK6NxujR7e4dV3Wk5JnSUthym8scjcPeCiKDNY4cHfTMnDXJ\n9zLVy01LtNKYpJ1s8FxVxigmxQNKEbIamxhx6yqwGC4aiISVOOUEjvNOdaUfXfUsE6jEwtwxyGxjlRK1\ncLyxXttq4QWN6PehgHv7jXykzPjInbEysebFvvPOOMdunmJvcCNMSvjUda8fL6xfGo0FDrLg8XZipd6S\noPVdYtyIM1Dg40KbBA3JuumPYtXuJaHrZnjZmdnM5OVo4ZNxktfCVT0c6bnD4bAeyn4bYt1ZPaX6hQHh\nJtvNYfpD0ONYlmqKuToQAMlz52Fh6bj45EbX89L5eLlSpWeyBlGotzriB0EPlclrGi5l2B5oPb1aB1ag\nyyYuu44l0F1oOVYnBIZsxIsHVITxi9lEuVPFkWASOUNuVQXfM4n5hxWR9qtuKnIcPsvbJsv1U10XlKh3\nKisqPhHU15xrCLr5gwFxPUKiNTLUBrkzgBOHXPVsHcLCiSD0YU56TRGfvEom43TWUKPPfl9Z54tgVQuT\njCRlaljAzeniQIcbbHZnn3f0HxbDG3DFYqWSxNrXabHhRsIOhhUHSPENyhGSTVO5t0XX5CdMspJPCd02\n3Oqv32ccbUK4O3YH6LEvp0WO3kSl5n50odVkI9B0i0iq4UPFGMkM8bEQJbgJoOH71P10vtdevJFQE4g2\nyhimiM53ZJRWgSZveHtENZc0Gjo0F9eioak9BnPpY1QxAFPC817svuhEstcU69bLCA4D1rO5R8AuIIBq\nyQJcifFLvbpAEYTLKJqysZrU8EEl3TSdC13A9hZvk4NC8VGEDAxcNrKw313dZp17kZPO5HSd1y6sljAW\nA9M1d6FMYV5SlBWf3WZNCUPS7qKNlda2YBsC6IUVB363f5RLGQOQHwbaijBSRCkrVoRxBHtc0Bd5J9V9\nP5uMTXkpZOxRcCQvImGgcmGuxxLb5zTqfS2xu7v3Sf3IIesSt9tVzcEcdbEvLGVJkLk4mb3G30DbIbri\nPZ09JkweDvMaQ3bxT2nfkz3Ilihkw9jqikkCCCz7E8h6z6KbhQErEW9VzJZzMCgJsyPjFam6iNwpe07S\nhyOvNVw2t9wpzL5xM11DvVzQwDaWEytNRHzDBs4KwEtpI2IpjUyVZHSwA0UGqqkzoCgrJFlNOvPlXqcS\nIcREouUIBmuttkrhPWJtSxOOgpsdvBR3kTOzAXNzSKxoaBAb0c5SDMUc6FIyGA8x5wg5DkUgjFUUodEt\nOYaB2VHVePW9mxHeBTdKWLzJow4ZZvjnoBuVigXljKCNh137ckV2y3Yg3Xi4UzJEI2V5Rw9AfnMs7xUw\nVHOFCg189maD3bmZAe7b4eaGZhyy4HVKjqCXmIH7vsEjRvbnfB0SQxxpuqBDJbHNCtW4vM643ZQQBVPP\na7oXSQIq9w2dHp0A7dtkocCZdQp9FKR9XdJAFIbVSHzIF1ZogeZlc0pXuNE0tagvD57xwDRFkAuoQyMu\nYDdZasXrpSmEE5UjHVkyYsISn8QsfXurzDybX468aoRoks654jjmRY5zi1oB8TcMdC2c3sicNaqfeuhd\nH1nPX7l4RpdqWMR7gGx9slXtG8S3KxpOi4qCD7yg3saD66nun4dzksQURoTUdXyrJR5UpHsfIlTF1aJa\nMdXyQtQnrkl00TeghQd00rRFZsCnhi0qrCSKiBfB2EVrd9RPpbgwJGZHuIQecdBmNetc2ylSEClqVBPR\nGOPPIxrnswEZjmnS0jxKW9VSM1QVxSPJnPFswCqT95SoKD6CP4xdX28WIUGiNaIKodXXJHEIsXBCxLsr\nPwWPCtoplC6hhpKmW5dQo92iCTyY2KioKzO8XR6FKm6qonMKVEwQNtlYE9c97KMtEnp25VOdMP46SQXS\nYsSVp7vm8LP87VYI8SOKcW3s2oedYFtt45rvDzoTF0GmS6wELQ9uo98HhjQAI1Dt91cgjJOwygNmLoZE\nX5K2zQiNA163uMCl5xzaBqY4YTL0wgALg3IFdYSp0RFYLWdt6IxoGI1tnoxcjlUEPo5eGIc3mS3SmaLn\nOdumfUQQ4Jgmgaa5anUVQsfBDrlAN5oaX7O0JO71SSPSWiHBsT9WIPy2J1Cace9ZZLRxblFPSXcvsuHh\nhvnhWQltEDAe7MgvkFQ8lGVFa8jhzijoF9kLmMhMILSzYnfXnZPNP7TlAAwlLHK1RqlpHskJqb6CPpGP\nQvOAhEMsM3zJ2KejZx0esxkjxA0ZufVvGAMN3vTUMplQaF4RiQkp9fzBXf3CMk01dWjOMMIEXTeKzIQe\nEcffzjixWU9FpAyGp2rVl4ETRgqljOGw4UgK31r0ZIEGnH0xGz1FtbW1OcQM008JVujRqulCucEMmntr\n".to_owned()
  246    247   
            )
  247    248   
        )
  248    249   
        .send().await;
  249    250   
        let _ = dbg!(result);
  250    251   
        let http_request = request_receiver.expect_request();
  251    252   
        let expected_headers = [("Content-Encoding", "gzip")];
  252    253   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  253    254   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  254    255   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  255    256   
        ::pretty_assertions::assert_eq!(uri.path(), "/requestcompression/putcontentwithencoding", "path was incorrect");
  256    257   
    }
  257    258   
    /// Compression algorithm encoding is appended to the Content-Encoding header, and the
  258    259   
    /// user-provided content-encoding is in the Content-Encoding header before the
  259    260   
    /// request compression encoding from the HTTP binding.
  260    261   
    ///
  261    262   
    /// Test ID: SDKAppendedGzipAfterProvidedEncoding_restXml
  262    263   
    #[::tokio::test]
  263         -
    #[allow(unused_mut)]
         264  +
    #[::tracing_test::traced_test]
  264    265   
    async fn sdk_appended_gzip_after_provided_encoding_rest_xml_request() {
  265    266   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  266    267   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  267    268   
  268    269   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  269    270   
        let result = client.put_with_content_encoding()
  270    271   
        .set_encoding(
  271    272   
            ::std::option::Option::Some(
  272    273   
                "custom".to_owned()
  273    274   
            )

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

@@ -216,216 +301,302 @@
  236    236   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  237    237   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  238    238   
        })?;
  239    239   
        cfg.interceptor_state()
  240    240   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  241    241   
        ::std::result::Result::Ok(())
  242    242   
    }
  243    243   
}
  244    244   
#[allow(unreachable_code, unused_variables)]
  245    245   
#[cfg(test)]
  246         -
mod query_idempotency_token_auto_fill_request_test {
         246  +
mod query_idempotency_token_auto_fill_test {
         247  +
  247    248   
    /// Automatically adds idempotency token when not set
  248    249   
    /// Test ID: QueryIdempotencyTokenAutoFill
  249    250   
    #[::tokio::test]
  250         -
    #[allow(unused_mut)]
         251  +
    #[::tracing_test::traced_test]
  251    252   
    async fn query_idempotency_token_auto_fill_request() {
  252    253   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  253    254   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  254    255   
  255    256   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  256    257   
        let result = client.query_idempotency_token_auto_fill().send().await;
  257    258   
        let _ = dbg!(result);
  258    259   
        let http_request = request_receiver.expect_request();
  259    260   
        let expected_query_params = &["token=00000000-0000-4000-8000-000000000000"];
  260    261   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
  261    262   
        let body = http_request.body().bytes().expect("body should be strict");
  262    263   
        // No body
  263    264   
        ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
  264    265   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  265    266   
        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
  266    267   
        ::pretty_assertions::assert_eq!(uri.path(), "/QueryIdempotencyTokenAutoFill", "path was incorrect");
  267    268   
    }
  268    269   
    /// Uses the given idempotency token as-is
  269    270   
    /// Test ID: QueryIdempotencyTokenAutoFillIsSet
  270    271   
    #[::tokio::test]
  271         -
    #[allow(unused_mut)]
         272  +
    #[::tracing_test::traced_test]
  272    273   
    async fn query_idempotency_token_auto_fill_is_set_request() {
  273    274   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  274    275   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  275    276   
  276    277   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  277    278   
        let result = client
  278    279   
            .query_idempotency_token_auto_fill()
  279    280   
            .set_token(::std::option::Option::Some("00000000-0000-4000-8000-000000000000".to_owned()))
  280    281   
            .send()
  281    282   
            .await;

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

@@ -218,218 +282,283 @@
  238    238   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  239    239   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  240    240   
        })?;
  241    241   
        cfg.interceptor_state()
  242    242   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  243    243   
        ::std::result::Result::Ok(())
  244    244   
    }
  245    245   
}
  246    246   
#[allow(unreachable_code, unused_variables)]
  247    247   
#[cfg(test)]
  248         -
mod query_params_as_string_list_map_request_test {
         248  +
mod query_params_as_string_list_map_test {
         249  +
  249    250   
    /// Serialize query params from map of list strings
  250    251   
    /// Test ID: RestXmlQueryParamsStringListMap
  251    252   
    #[::tokio::test]
  252         -
    #[allow(unused_mut)]
         253  +
    #[::tracing_test::traced_test]
  253    254   
    async fn rest_xml_query_params_string_list_map_request() {
  254    255   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  255    256   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  256    257   
  257    258   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  258    259   
        let result = client
  259    260   
            .query_params_as_string_list_map()
  260    261   
            .set_qux(::std::option::Option::Some("named".to_owned()))
  261    262   
            .set_foo(::std::option::Option::Some({
  262    263   
                let mut ret = ::std::collections::HashMap::new();

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

@@ -210,210 +274,275 @@
  230    230   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  231    231   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  232    232   
        })?;
  233    233   
        cfg.interceptor_state()
  234    234   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  235    235   
        ::std::result::Result::Ok(())
  236    236   
    }
  237    237   
}
  238    238   
#[allow(unreachable_code, unused_variables)]
  239    239   
#[cfg(test)]
  240         -
mod query_precedence_request_test {
         240  +
mod query_precedence_test {
         241  +
  241    242   
    /// Prefer named query parameters when serializing
  242    243   
    /// Test ID: RestXmlQueryPrecedence
  243    244   
    #[::tokio::test]
  244         -
    #[allow(unused_mut)]
         245  +
    #[::tracing_test::traced_test]
  245    246   
    async fn rest_xml_query_precedence_request() {
  246    247   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  247    248   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  248    249   
  249    250   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  250    251   
        let result = client
  251    252   
            .query_precedence()
  252    253   
            .set_foo(::std::option::Option::Some("named".to_owned()))
  253    254   
            .set_baz(::std::option::Option::Some({
  254    255   
                let mut ret = ::std::collections::HashMap::new();

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

@@ -191,191 +300,301 @@
  211    211   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  212    212   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  213    213   
        })?;
  214    214   
        cfg.interceptor_state()
  215    215   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  216    216   
        ::std::result::Result::Ok(())
  217    217   
    }
  218    218   
}
  219    219   
#[allow(unreachable_code, unused_variables)]
  220    220   
#[cfg(test)]
  221         -
mod recursive_shapes_request_test {
         221  +
mod recursive_shapes_test {
         222  +
  222    223   
    /// Serializes recursive structures
  223    224   
    /// Test ID: RecursiveShapes
  224    225   
    #[::tokio::test]
  225         -
    #[allow(unused_mut)]
         226  +
    #[::tracing_test::traced_test]
  226    227   
    async fn recursive_shapes_request() {
  227    228   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  228    229   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  229    230   
  230    231   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  231    232   
        let result = client
  232    233   
            .recursive_shapes()
  233    234   
            .set_nested(::std::option::Option::Some(
  234    235   
                crate::types::RecursiveShapesInputOutputNested1::builder()
  235    236   
                    .set_foo(::std::option::Option::Some("Foo1".to_owned()))
  236    237   
                    .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
  237    238   
                        crate::types::RecursiveShapesInputOutputNested2::builder()
  238    239   
                            .set_bar(::std::option::Option::Some("Bar1".to_owned()))
  239    240   
                            .set_recursive_member(::std::option::Option::Some(
  240    241   
                                crate::types::RecursiveShapesInputOutputNested1::builder()
  241    242   
                                    .set_foo(::std::option::Option::Some("Foo2".to_owned()))
  242    243   
                                    .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
  243    244   
                                        crate::types::RecursiveShapesInputOutputNested2::builder()
  244    245   
                                            .set_bar(::std::option::Option::Some("Bar2".to_owned()))
  245    246   
                                            .build(),
  246    247   
                                    )))
  247    248   
                                    .build(),
  248    249   
                            ))
  249    250   
                            .build(),
  250    251   
                    )))
  251    252   
                    .build(),
  252    253   
            ))
  253    254   
            .send()
  254    255   
            .await;
  255    256   
        let _ = dbg!(result);
  256    257   
        let http_request = request_receiver.expect_request();
  257    258   
        let expected_headers = [("Content-Type", "application/xml")];
  258    259   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  259    260   
        let body = http_request.body().bytes().expect("body should be strict");
  260    261   
        ::aws_smithy_protocol_test::assert_ok(
  261    262   
        ::aws_smithy_protocol_test::validate_body(body, "<RecursiveShapesRequest>\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</RecursiveShapesRequest>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))
  262    263   
        );
  263    264   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  264    265   
        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
  265    266   
        ::pretty_assertions::assert_eq!(uri.path(), "/RecursiveShapes", "path was incorrect");
  266    267   
    }
  267    268   
    /// Serializes recursive structures
  268    269   
    /// Test ID: RecursiveShapes
  269    270   
    #[::tokio::test]
  270         -
    #[allow(unused_mut)]
         271  +
    #[::tracing_test::traced_test]
  271    272   
    async fn recursive_shapes_response() {
  272    273   
        let expected_output = crate::operation::recursive_shapes::RecursiveShapesOutput::builder()
  273    274   
            .set_nested(::std::option::Option::Some(
  274    275   
                crate::types::RecursiveShapesInputOutputNested1::builder()
  275    276   
                    .set_foo(::std::option::Option::Some("Foo1".to_owned()))
  276    277   
                    .set_nested(::std::option::Option::Some(::std::boxed::Box::new(
  277    278   
                        crate::types::RecursiveShapesInputOutputNested2::builder()
  278    279   
                            .set_bar(::std::option::Option::Some("Bar1".to_owned()))
  279    280   
                            .set_recursive_member(::std::option::Option::Some(
  280    281   
                                crate::types::RecursiveShapesInputOutputNested1::builder()

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

@@ -200,200 +480,481 @@
  220    220   
        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
  221    221   
            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  222    222   
        })?;
  223    223   
        cfg.interceptor_state()
  224    224   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  225    225   
        ::std::result::Result::Ok(())
  226    226   
    }
  227    227   
}
  228    228   
#[allow(unreachable_code, unused_variables)]
  229    229   
#[cfg(test)]
  230         -
mod simple_scalar_properties_request_test {
         230  +
mod simple_scalar_properties_test {
  231    231   
    use ::aws_smithy_protocol_test::FloatEquals;
         232  +
  232    233   
    /// Serializes simple scalar properties
  233    234   
    /// Test ID: SimpleScalarProperties
  234    235   
    #[::tokio::test]
  235         -
    #[allow(unused_mut)]
         236  +
    #[::tracing_test::traced_test]
  236    237   
    async fn simple_scalar_properties_request() {
  237    238   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  238    239   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  239    240   
  240    241   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  241    242   
        let result = client
  242    243   
            .simple_scalar_properties()
  243    244   
            .set_foo(::std::option::Option::Some("Foo".to_owned()))
  244    245   
            .set_string_value(::std::option::Option::Some("string".to_owned()))
  245    246   
            .set_true_boolean_value(::std::option::Option::Some(true))
  246    247   
            .set_false_boolean_value(::std::option::Option::Some(false))
  247    248   
            .set_byte_value(::std::option::Option::Some(1))
  248    249   
            .set_short_value(::std::option::Option::Some(2))
  249    250   
            .set_integer_value(::std::option::Option::Some(3))
  250    251   
            .set_long_value(::std::option::Option::Some(4))
  251    252   
            .set_float_value(::std::option::Option::Some(5.5_f32))
  252    253   
            .set_double_value(::std::option::Option::Some(6.5_f64))
  253    254   
            .send()
  254    255   
            .await;
  255    256   
        let _ = dbg!(result);
  256    257   
        let http_request = request_receiver.expect_request();
  257    258   
        let expected_headers = [("Content-Type", "application/xml"), ("X-Foo", "Foo")];
  258    259   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  259    260   
        let body = http_request.body().bytes().expect("body should be strict");
  260    261   
        ::aws_smithy_protocol_test::assert_ok(
  261    262   
        ::aws_smithy_protocol_test::validate_body(body, "<SimpleScalarPropertiesRequest>\n    <stringValue>string</stringValue>\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</SimpleScalarPropertiesRequest>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))
  262    263   
        );
  263    264   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  264    265   
        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
  265    266   
        ::pretty_assertions::assert_eq!(uri.path(), "/SimpleScalarProperties", "path was incorrect");
  266    267   
    }
  267    268   
    /// Serializes string with escaping
  268    269   
    /// Test ID: SimpleScalarPropertiesWithEscapedCharacter
  269    270   
    #[::tokio::test]
  270         -
    #[allow(unused_mut)]
         271  +
    #[::tracing_test::traced_test]
  271    272   
    async fn simple_scalar_properties_with_escaped_character_request() {
  272    273   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  273    274   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  274    275   
  275    276   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  276    277   
        let result = client
  277    278   
            .simple_scalar_properties()
  278    279   
            .set_foo(::std::option::Option::Some("Foo".to_owned()))
  279    280   
            .set_string_value(::std::option::Option::Some("<string>".to_owned()))
  280    281   
            .send()
  281    282   
            .await;
  282    283   
        let _ = dbg!(result);
  283    284   
        let http_request = request_receiver.expect_request();
  284    285   
        let expected_headers = [("Content-Type", "application/xml"), ("X-Foo", "Foo")];
  285    286   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  286    287   
        let body = http_request.body().bytes().expect("body should be strict");
  287    288   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
  288    289   
            body,
  289    290   
            "<SimpleScalarPropertiesRequest>\n    <stringValue>&lt;string&gt;</stringValue>\n</SimpleScalarPropertiesRequest>\n",
  290    291   
            ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  291    292   
        ));
  292    293   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  293    294   
        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
  294    295   
        ::pretty_assertions::assert_eq!(uri.path(), "/SimpleScalarProperties", "path was incorrect");
  295    296   
    }
  296    297   
    /// Serializes string containing white space
  297    298   
    /// Test ID: SimpleScalarPropertiesWithWhiteSpace
  298    299   
    #[::tokio::test]
  299         -
    #[allow(unused_mut)]
         300  +
    #[::tracing_test::traced_test]
  300    301   
    async fn simple_scalar_properties_with_white_space_request() {
  301    302   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  302    303   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  303    304   
  304    305   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  305    306   
        let result = client
  306    307   
            .simple_scalar_properties()
  307    308   
            .set_foo(::std::option::Option::Some("Foo".to_owned()))
  308    309   
            .set_string_value(::std::option::Option::Some("  string with white    space  ".to_owned()))
  309    310   
            .send()
  310    311   
            .await;
  311    312   
        let _ = dbg!(result);
  312    313   
        let http_request = request_receiver.expect_request();
  313    314   
        let expected_headers = [("Content-Type", "application/xml"), ("X-Foo", "Foo")];
  314    315   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  315    316   
        let body = http_request.body().bytes().expect("body should be strict");
  316    317   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
  317    318   
            body,
  318    319   
            "<SimpleScalarPropertiesRequest>\n    <stringValue>  string with white    space  </stringValue>\n</SimpleScalarPropertiesRequest>\n",
  319    320   
            ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  320    321   
        ));
  321    322   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  322    323   
        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
  323    324   
        ::pretty_assertions::assert_eq!(uri.path(), "/SimpleScalarProperties", "path was incorrect");
  324    325   
    }
  325    326   
    /// Serializes string containing exclusively whitespace
  326    327   
    /// Test ID: SimpleScalarPropertiesPureWhiteSpace
  327    328   
    #[::tokio::test]
  328         -
    #[allow(unused_mut)]
         329  +
    #[::tracing_test::traced_test]
  329    330   
    async fn simple_scalar_properties_pure_white_space_request() {
  330    331   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  331    332   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  332    333   
  333    334   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  334    335   
        let result = client
  335    336   
            .simple_scalar_properties()
  336    337   
            .set_foo(::std::option::Option::Some("Foo".to_owned()))
  337    338   
            .set_string_value(::std::option::Option::Some("   ".to_owned()))
  338    339   
            .send()
  339    340   
            .await;
  340    341   
        let _ = dbg!(result);
  341    342   
        let http_request = request_receiver.expect_request();
  342    343   
        let expected_headers = [("Content-Type", "application/xml"), ("X-Foo", "Foo")];
  343    344   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  344    345   
        let body = http_request.body().bytes().expect("body should be strict");
  345    346   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
  346    347   
            body,
  347    348   
            "<SimpleScalarPropertiesRequest>\n    <stringValue>   </stringValue>\n</SimpleScalarPropertiesRequest>\n",
  348    349   
            ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  349    350   
        ));
  350    351   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  351    352   
        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
  352    353   
        ::pretty_assertions::assert_eq!(uri.path(), "/SimpleScalarProperties", "path was incorrect");
  353    354   
    }
  354    355   
    /// Supports handling NaN float values.
  355    356   
    /// Test ID: RestXmlSupportsNaNFloatInputs
  356    357   
    #[::tokio::test]
  357         -
    #[allow(unused_mut)]
         358  +
    #[::tracing_test::traced_test]
  358    359   
    async fn rest_xml_supports_na_n_float_inputs_request() {
  359    360   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  360    361   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  361    362   
  362    363   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  363    364   
        let result = client
  364    365   
            .simple_scalar_properties()
  365    366   
            .set_float_value(::std::option::Option::Some(
  366    367   
                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
  367    368   
            ))
  368    369   
            .set_double_value(::std::option::Option::Some(
  369    370   
                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
  370    371   
            ))
  371    372   
            .send()
  372    373   
            .await;
  373    374   
        let _ = dbg!(result);
  374    375   
        let http_request = request_receiver.expect_request();
  375    376   
        let expected_headers = [("Content-Type", "application/xml")];
  376    377   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  377    378   
        let body = http_request.body().bytes().expect("body should be strict");
  378    379   
        ::aws_smithy_protocol_test::assert_ok(
  379    380   
        ::aws_smithy_protocol_test::validate_body(body, "<SimpleScalarPropertiesRequest>\n    <floatValue>NaN</floatValue>\n    <DoubleDribble>NaN</DoubleDribble>\n</SimpleScalarPropertiesRequest>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))
  380    381   
        );
  381    382   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  382    383   
        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
  383    384   
        ::pretty_assertions::assert_eq!(uri.path(), "/SimpleScalarProperties", "path was incorrect");
  384    385   
    }
  385    386   
    /// Supports handling Infinity float values.
  386    387   
    /// Test ID: RestXmlSupportsInfinityFloatInputs
  387    388   
    #[::tokio::test]
  388         -
    #[allow(unused_mut)]
         389  +
    #[::tracing_test::traced_test]
  389    390   
    async fn rest_xml_supports_infinity_float_inputs_request() {
  390    391   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  391    392   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  392    393   
  393    394   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  394    395   
        let result = client
  395    396   
            .simple_scalar_properties()
  396    397   
            .set_float_value(::std::option::Option::Some(
  397    398   
                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
  398    399   
            ))
  399    400   
            .set_double_value(::std::option::Option::Some(
  400    401   
                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
  401    402   
            ))
  402    403   
            .send()
  403    404   
            .await;
  404    405   
        let _ = dbg!(result);
  405    406   
        let http_request = request_receiver.expect_request();
  406    407   
        let expected_headers = [("Content-Type", "application/xml")];
  407    408   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  408    409   
        let body = http_request.body().bytes().expect("body should be strict");
  409    410   
        ::aws_smithy_protocol_test::assert_ok(
  410    411   
        ::aws_smithy_protocol_test::validate_body(body, "<SimpleScalarPropertiesRequest>\n    <floatValue>Infinity</floatValue>\n    <DoubleDribble>Infinity</DoubleDribble>\n</SimpleScalarPropertiesRequest>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))
  411    412   
        );
  412    413   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  413    414   
        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
  414    415   
        ::pretty_assertions::assert_eq!(uri.path(), "/SimpleScalarProperties", "path was incorrect");
  415    416   
    }
  416    417   
    /// Supports handling -Infinity float values.
  417    418   
    /// Test ID: RestXmlSupportsNegativeInfinityFloatInputs
  418    419   
    #[::tokio::test]
  419         -
    #[allow(unused_mut)]
         420  +
    #[::tracing_test::traced_test]
  420    421   
    async fn rest_xml_supports_negative_infinity_float_inputs_request() {
  421    422   
        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
  422    423   
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  423    424   
  424    425   
        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
  425    426   
        let result = client
  426    427   
            .simple_scalar_properties()
  427    428   
            .set_float_value(::std::option::Option::Some(
  428    429   
                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
  429    430   
            ))
  430    431   
            .set_double_value(::std::option::Option::Some(
  431    432   
                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
  432    433   
            ))
  433    434   
            .send()
  434    435   
            .await;
  435    436   
        let _ = dbg!(result);
  436    437   
        let http_request = request_receiver.expect_request();
  437    438   
        let expected_headers = [("Content-Type", "application/xml")];
  438    439   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  439    440   
        let body = http_request.body().bytes().expect("body should be strict");
  440    441   
        ::aws_smithy_protocol_test::assert_ok(
  441    442   
        ::aws_smithy_protocol_test::validate_body(body, "<SimpleScalarPropertiesRequest>\n    <floatValue>-Infinity</floatValue>\n    <DoubleDribble>-Infinity</DoubleDribble>\n</SimpleScalarPropertiesRequest>\n", ::aws_smithy_protocol_test::MediaType::from("application/xml"))
  442    443   
        );
  443    444   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  444    445   
        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
  445    446   
        ::pretty_assertions::assert_eq!(uri.path(), "/SimpleScalarProperties", "path was incorrect");
  446    447   
    }
  447    448   
    /// Serializes simple scalar properties
  448    449   
    /// Test ID: SimpleScalarProperties
  449    450   
    #[::tokio::test]
  450         -
    #[allow(unused_mut)]
         451  +
    #[::tracing_test::traced_test]
  451    452   
    async fn simple_scalar_properties_response() {
  452    453   
        let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
  453    454   
            .set_foo(::std::option::Option::Some("Foo".to_owned()))
  454    455   
            .set_string_value(::std::option::Option::Some("string".to_owned()))
  455    456   
            .set_true_boolean_value(::std::option::Option::Some(true))
  456    457   
            .set_false_boolean_value(::std::option::Option::Some(false))
  457    458   
            .set_byte_value(::std::option::Option::Some(1))
  458    459   
            .set_short_value(::std::option::Option::Some(2))
  459    460   
            .set_integer_value(::std::option::Option::Some(3))
  460    461   
            .set_long_value(::std::option::Option::Some(4))
@@ -502,503 +562,563 @@
  522    523   
    }
  523    524   
    /// Serializes string with escaping.
  524    525   
    ///
  525    526   
    /// This validates the three escape types: literal, decimal and hexadecimal. It also validates that unescaping properly
  526    527   
    /// handles the case where unescaping an & produces a newly formed escape sequence (this should not be re-unescaped).
  527    528   
    ///
  528    529   
    /// Servers may produce different output, this test is designed different unescapes clients must handle
  529    530   
    ///
  530    531   
    /// Test ID: SimpleScalarPropertiesComplexEscapes
  531    532   
    #[::tokio::test]
  532         -
    #[allow(unused_mut)]
         533  +
    #[::tracing_test::traced_test]
  533    534   
    async fn simple_scalar_properties_complex_escapes_response() {
  534    535   
        let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
  535    536   
            .set_foo(::std::option::Option::Some("Foo".to_owned()))
  536    537   
            .set_string_value(::std::option::Option::Some("escaped data: &lt;\r\n".to_owned()))
  537    538   
            .build();
  538    539   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
  539    540   
        .header("Content-Type", "application/xml")
  540    541   
        .header("X-Foo", "Foo")
  541    542   
        .status(200)
  542    543   
                    .body(::aws_smithy_types::body::SdkBody::from("<SimpleScalarPropertiesResponse>\n    <stringValue>escaped data: &amp;lt;&#xD;&#10;</stringValue>\n</SimpleScalarPropertiesResponse>\n"))
@@ -570,571 +630,631 @@
  590    591   
        assert!(
  591    592   
            parsed.double_value.float_equals(&expected_output.double_value),
  592    593   
            "Unexpected value for `double_value` {:?} vs. {:?}",
  593    594   
            expected_output.double_value,
  594    595   
            parsed.double_value
  595    596   
        );
  596    597   
    }
  597    598   
    /// Serializes string with escaping
  598    599   
    /// Test ID: SimpleScalarPropertiesWithEscapedCharacter
  599    600   
    #[::tokio::test]
  600         -
    #[allow(unused_mut)]
         601  +
    #[::tracing_test::traced_test]
  601    602   
    async fn simple_scalar_properties_with_escaped_character_response() {
  602    603   
        let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
  603    604   
            .set_foo(::std::option::Option::Some("Foo".to_owned()))
  604    605   
            .set_string_value(::std::option::Option::Some("<string>".to_owned()))
  605    606   
            .build();
  606    607   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
  607    608   
            ::http::response::Builder::new()
  608    609   
                .header("Content-Type", "application/xml")
  609    610   
                .header("X-Foo", "Foo")
  610    611   
                .status(200)
@@ -642,643 +702,703 @@
  662    663   
        assert!(
  663    664   
            parsed.double_value.float_equals(&expected_output.double_value),
  664    665   
            "Unexpected value for `double_value` {:?} vs. {:?}",
  665    666   
            expected_output.double_value,
  666    667   
            parsed.double_value
  667    668   
        );
  668    669   
    }
  669    670   
    /// Serializes simple scalar properties with xml preamble, comments and CDATA
  670    671   
    /// Test ID: SimpleScalarPropertiesWithXMLPreamble
  671    672   
    #[::tokio::test]
  672         -
    #[allow(unused_mut)]
         673  +
    #[::tracing_test::traced_test]
  673    674   
    async fn simple_scalar_properties_with_xml_preamble_response() {
  674    675   
        let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
  675    676   
            .set_foo(::std::option::Option::Some("Foo".to_owned()))
  676    677   
            .set_string_value(::std::option::Option::Some("string".to_owned()))
  677    678   
            .build();
  678    679   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
  679    680   
        .header("Content-Type", "application/xml")
  680    681   
        .header("X-Foo", "Foo")
  681    682   
        .status(200)
  682    683   
                    .body(::aws_smithy_types::body::SdkBody::from("<?xml version = \"1.0\" encoding = \"UTF-8\"?>\n<SimpleScalarPropertiesResponse>\n    <![CDATA[characters representing CDATA]]>\n    <stringValue>string</stringValue>\n    <!--xml comment-->\n</SimpleScalarPropertiesResponse>\n"))
@@ -710,711 +770,771 @@
  730    731   
        assert!(
  731    732   
            parsed.double_value.float_equals(&expected_output.double_value),
  732    733   
            "Unexpected value for `double_value` {:?} vs. {:?}",
  733    734   
            expected_output.double_value,
  734    735   
            parsed.double_value
  735    736   
        );
  736    737   
    }
  737    738   
    /// Serializes string containing white space
  738    739   
    /// Test ID: SimpleScalarPropertiesWithWhiteSpace
  739    740   
    #[::tokio::test]
  740         -
    #[allow(unused_mut)]
         741  +
    #[::tracing_test::traced_test]
  741    742   
    async fn simple_scalar_properties_with_white_space_response() {
  742    743   
        let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
  743    744   
            .set_foo(::std::option::Option::Some("Foo".to_owned()))
  744    745   
            .set_string_value(::std::option::Option::Some(" string with white    space ".to_owned()))
  745    746   
            .build();
  746    747   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
  747    748   
        .header("Content-Type", "application/xml")
  748    749   
        .header("X-Foo", "Foo")
  749    750   
        .status(200)
  750    751   
                    .body(::aws_smithy_types::body::SdkBody::from("<?xml version = \"1.0\" encoding = \"UTF-8\"?>\n<SimpleScalarPropertiesResponse>\n    <stringValue> string with white    space </stringValue>\n</SimpleScalarPropertiesResponse>\n"))
@@ -778,779 +838,839 @@
  798    799   
        assert!(
  799    800   
            parsed.double_value.float_equals(&expected_output.double_value),
  800    801   
            "Unexpected value for `double_value` {:?} vs. {:?}",
  801    802   
            expected_output.double_value,
  802    803   
            parsed.double_value
  803    804   
        );
  804    805   
    }
  805    806   
    /// Serializes string containing white space
  806    807   
    /// Test ID: SimpleScalarPropertiesPureWhiteSpace
  807    808   
    #[::tokio::test]
  808         -
    #[allow(unused_mut)]
         809  +
    #[::tracing_test::traced_test]
  809    810   
    async fn simple_scalar_properties_pure_white_space_response() {
  810    811   
        let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
  811    812   
            .set_foo(::std::option::Option::Some("Foo".to_owned()))
  812    813   
            .set_string_value(::std::option::Option::Some("  ".to_owned()))
  813    814   
            .build();
  814    815   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
  815    816   
        .header("Content-Type", "application/xml")
  816    817   
        .header("X-Foo", "Foo")
  817    818   
        .status(200)
  818    819   
                    .body(::aws_smithy_types::body::SdkBody::from("<?xml version = \"1.0\" encoding = \"UTF-8\"?>\n<SimpleScalarPropertiesResponse>\n    <stringValue>  </stringValue>\n</SimpleScalarPropertiesResponse>\n"))
@@ -846,847 +906,907 @@
  866    867   
        assert!(
  867    868   
            parsed.double_value.float_equals(&expected_output.double_value),
  868    869   
            "Unexpected value for `double_value` {:?} vs. {:?}",
  869    870   
            expected_output.double_value,
  870    871   
            parsed.double_value
  871    872   
        );
  872    873   
    }
  873    874   
    /// Supports handling NaN float values.
  874    875   
    /// Test ID: RestXmlSupportsNaNFloatOutputs
  875    876   
    #[::tokio::test]
  876         -
    #[allow(unused_mut)]
         877  +
    #[::tracing_test::traced_test]
  877    878   
    async fn rest_xml_supports_na_n_float_outputs_response() {
  878    879   
        let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
  879    880   
            .set_float_value(::std::option::Option::Some(
  880    881   
                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
  881    882   
            ))
  882    883   
            .set_double_value(::std::option::Option::Some(
  883    884   
                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
  884    885   
            ))
  885    886   
            .build();
  886    887   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
@@ -917,918 +977,978 @@
  937    938   
        assert!(
  938    939   
            parsed.double_value.float_equals(&expected_output.double_value),
  939    940   
            "Unexpected value for `double_value` {:?} vs. {:?}",
  940    941   
            expected_output.double_value,
  941    942   
            parsed.double_value
  942    943   
        );
  943    944   
    }
  944    945   
    /// Supports handling Infinity float values.
  945    946   
    /// Test ID: RestXmlSupportsInfinityFloatOutputs
  946    947   
    #[::tokio::test]
  947         -
    #[allow(unused_mut)]
         948  +
    #[::tracing_test::traced_test]
  948    949   
    async fn rest_xml_supports_infinity_float_outputs_response() {
  949    950   
        let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
  950    951   
            .set_float_value(::std::option::Option::Some(
  951    952   
                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
  952    953   
            ))
  953    954   
            .set_double_value(::std::option::Option::Some(
  954    955   
                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
  955    956   
            ))
  956    957   
            .build();
  957    958   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
@@ -988,989 +1048,1049 @@
 1008   1009   
        assert!(
 1009   1010   
            parsed.double_value.float_equals(&expected_output.double_value),
 1010   1011   
            "Unexpected value for `double_value` {:?} vs. {:?}",
 1011   1012   
            expected_output.double_value,
 1012   1013   
            parsed.double_value
 1013   1014   
        );
 1014   1015   
    }
 1015   1016   
    /// Supports handling -Infinity float values.
 1016   1017   
    /// Test ID: RestXmlSupportsNegativeInfinityFloatOutputs
 1017   1018   
    #[::tokio::test]
 1018         -
    #[allow(unused_mut)]
        1019  +
    #[::tracing_test::traced_test]
 1019   1020   
    async fn rest_xml_supports_negative_infinity_float_outputs_response() {
 1020   1021   
        let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
 1021   1022   
            .set_float_value(::std::option::Option::Some(
 1022   1023   
                <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
 1023   1024   
            ))
 1024   1025   
            .set_double_value(::std::option::Option::Some(
 1025   1026   
                <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
 1026   1027   
            ))
 1027   1028   
            .build();
 1028   1029   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()